diff --git a/autoplan/SKILL.md b/autoplan/SKILL.md index c64e6e8bd..463018e03 100644 --- a/autoplan/SKILL.md +++ b/autoplan/SKILL.md @@ -283,15 +283,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -324,6 +324,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -348,13 +354,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/canary/SKILL.md b/canary/SKILL.md index a211c386a..1fd299b69 100644 --- a/canary/SKILL.md +++ b/canary/SKILL.md @@ -275,15 +275,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -316,6 +316,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -340,13 +346,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/codex/SKILL.md b/codex/SKILL.md index 0ff1e3e55..c50ffa4d1 100644 --- a/codex/SKILL.md +++ b/codex/SKILL.md @@ -277,15 +277,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -318,6 +318,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -342,13 +348,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/context-restore/SKILL.md b/context-restore/SKILL.md index 4f0cd70eb..94ed86720 100644 --- a/context-restore/SKILL.md +++ b/context-restore/SKILL.md @@ -279,15 +279,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -320,6 +320,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -344,13 +350,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/context-save/SKILL.md b/context-save/SKILL.md index b083b039f..3c8a2efb7 100644 --- a/context-save/SKILL.md +++ b/context-save/SKILL.md @@ -279,15 +279,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -320,6 +320,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -344,13 +350,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/cso/SKILL.md b/cso/SKILL.md index fe12df74e..ef477f87a 100644 --- a/cso/SKILL.md +++ b/cso/SKILL.md @@ -280,15 +280,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -321,6 +321,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -345,13 +351,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/design-consultation/SKILL.md b/design-consultation/SKILL.md index ed4d3811b..230ff3a41 100644 --- a/design-consultation/SKILL.md +++ b/design-consultation/SKILL.md @@ -303,15 +303,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -344,6 +344,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -368,13 +374,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/design-html/SKILL.md b/design-html/SKILL.md index 2337af721..7ea63dd46 100644 --- a/design-html/SKILL.md +++ b/design-html/SKILL.md @@ -282,15 +282,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -323,6 +323,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -347,13 +353,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/design-review/SKILL.md b/design-review/SKILL.md index d17c07678..626317045 100644 --- a/design-review/SKILL.md +++ b/design-review/SKILL.md @@ -280,15 +280,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -321,6 +321,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -345,13 +351,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/design-shotgun/SKILL.md b/design-shotgun/SKILL.md index 2f8ac7abb..821af7396 100644 --- a/design-shotgun/SKILL.md +++ b/design-shotgun/SKILL.md @@ -297,15 +297,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -338,6 +338,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -362,13 +368,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/devex-review/SKILL.md b/devex-review/SKILL.md index fd8dbf908..2deb0a2e6 100644 --- a/devex-review/SKILL.md +++ b/devex-review/SKILL.md @@ -280,15 +280,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -321,6 +321,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -345,13 +351,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/document-release/SKILL.md b/document-release/SKILL.md index 79edb7c49..ce5ec3ca7 100644 --- a/document-release/SKILL.md +++ b/document-release/SKILL.md @@ -277,15 +277,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -318,6 +318,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -342,13 +348,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/health/SKILL.md b/health/SKILL.md index b5471c0e8..de55054a3 100644 --- a/health/SKILL.md +++ b/health/SKILL.md @@ -277,15 +277,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -318,6 +318,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -342,13 +348,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/investigate/SKILL.md b/investigate/SKILL.md index f69aefe17..fc6b25e40 100644 --- a/investigate/SKILL.md +++ b/investigate/SKILL.md @@ -316,15 +316,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -357,6 +357,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -381,13 +387,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/land-and-deploy/SKILL.md b/land-and-deploy/SKILL.md index 1c19c98b0..4b17da326 100644 --- a/land-and-deploy/SKILL.md +++ b/land-and-deploy/SKILL.md @@ -274,15 +274,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -315,6 +315,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -339,13 +345,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/landing-report/SKILL.md b/landing-report/SKILL.md index e14817cfa..4bf417731 100644 --- a/landing-report/SKILL.md +++ b/landing-report/SKILL.md @@ -275,15 +275,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -316,6 +316,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -340,13 +346,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/learn/SKILL.md b/learn/SKILL.md index 899ad42c1..163c3892e 100644 --- a/learn/SKILL.md +++ b/learn/SKILL.md @@ -277,15 +277,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -318,6 +318,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -342,13 +348,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/office-hours/SKILL.md b/office-hours/SKILL.md index 6170f0e5f..2b6496893 100644 --- a/office-hours/SKILL.md +++ b/office-hours/SKILL.md @@ -312,15 +312,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -353,6 +353,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -377,13 +383,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/open-gstack-browser/SKILL.md b/open-gstack-browser/SKILL.md index b510d9d7b..2773b58ca 100644 --- a/open-gstack-browser/SKILL.md +++ b/open-gstack-browser/SKILL.md @@ -274,15 +274,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -315,6 +315,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -339,13 +345,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/pair-agent/SKILL.md b/pair-agent/SKILL.md index 8ddaf5e1a..9cb9467f1 100644 --- a/pair-agent/SKILL.md +++ b/pair-agent/SKILL.md @@ -275,15 +275,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -316,6 +316,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -340,13 +346,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/plan-ceo-review/SKILL.md b/plan-ceo-review/SKILL.md index 0f1738aec..6f75f8329 100644 --- a/plan-ceo-review/SKILL.md +++ b/plan-ceo-review/SKILL.md @@ -306,15 +306,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -347,6 +347,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -371,13 +377,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/plan-design-review/SKILL.md b/plan-design-review/SKILL.md index 699bacf69..74e08fb9d 100644 --- a/plan-design-review/SKILL.md +++ b/plan-design-review/SKILL.md @@ -279,15 +279,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -320,6 +320,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -344,13 +350,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/plan-devex-review/SKILL.md b/plan-devex-review/SKILL.md index 886964a58..12fa0eea7 100644 --- a/plan-devex-review/SKILL.md +++ b/plan-devex-review/SKILL.md @@ -283,15 +283,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -324,6 +324,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -348,13 +354,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/plan-eng-review/SKILL.md b/plan-eng-review/SKILL.md index 881455550..1567e30c2 100644 --- a/plan-eng-review/SKILL.md +++ b/plan-eng-review/SKILL.md @@ -281,15 +281,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -322,6 +322,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -346,13 +352,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/plan-tune/SKILL.md b/plan-tune/SKILL.md index 471fbe517..7d80434eb 100644 --- a/plan-tune/SKILL.md +++ b/plan-tune/SKILL.md @@ -288,15 +288,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -329,6 +329,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -353,13 +359,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/qa-only/SKILL.md b/qa-only/SKILL.md index 77dcc4d23..ef65bb1bf 100644 --- a/qa-only/SKILL.md +++ b/qa-only/SKILL.md @@ -276,15 +276,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -317,6 +317,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -341,13 +347,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/qa/SKILL.md b/qa/SKILL.md index 41f84fccc..395d0223d 100644 --- a/qa/SKILL.md +++ b/qa/SKILL.md @@ -282,15 +282,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -323,6 +323,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -347,13 +353,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/retro/SKILL.md b/retro/SKILL.md index 2d2684afe..8a5fcec39 100644 --- a/retro/SKILL.md +++ b/retro/SKILL.md @@ -294,15 +294,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -335,6 +335,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -359,13 +365,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/review/SKILL.md b/review/SKILL.md index 4d134d175..568434427 100644 --- a/review/SKILL.md +++ b/review/SKILL.md @@ -279,15 +279,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -320,6 +320,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -344,13 +350,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/scrape/SKILL.md b/scrape/SKILL.md index b255abe08..ed94a6ca4 100644 --- a/scrape/SKILL.md +++ b/scrape/SKILL.md @@ -275,15 +275,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -316,6 +316,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -340,13 +346,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/scripts/resolvers/preamble/generate-ask-user-format.ts b/scripts/resolvers/preamble/generate-ask-user-format.ts index 5a7d174db..d41e63adb 100644 --- a/scripts/resolvers/preamble/generate-ask-user-format.ts +++ b/scripts/resolvers/preamble/generate-ask-user-format.ts @@ -5,15 +5,15 @@ export function generateAskUserFormat(_ctx: TemplateContext): string { ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. \`mcp__conductor__AskUserQuestion\` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. \`mcp__conductor__AskUserQuestion\`) or native. -**Rule:** if any \`mcp__*__AskUserQuestion\` variant is in your tool list, prefer it. Hosts may disable native AUQ via \`--disallowedTools AskUserQuestion\` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any \`mcp__*__AskUserQuestion\` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report \`BLOCKED — AskUserQuestion unavailable\`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only \`/plan-tune\` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's \`question\` string. Every AskUserQuestion must be sent as tool_use, not prose. \`\`\` D — @@ -46,6 +46,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- \`question\` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both \`question\` and \`options[].description\`. Prefer putting option-specific trade-offs in \`options[].description\`. + 12. **Non-ASCII characters — write directly, never \\u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -70,13 +76,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] \`question\` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between \`question\` and \`options[].description\` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \\u-escaped `; diff --git a/setup-deploy/SKILL.md b/setup-deploy/SKILL.md index 2731365c5..c3ee94bc2 100644 --- a/setup-deploy/SKILL.md +++ b/setup-deploy/SKILL.md @@ -278,15 +278,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -319,6 +319,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -343,13 +349,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/setup-gbrain/SKILL.md b/setup-gbrain/SKILL.md index 19d18afb7..0fe586787 100644 --- a/setup-gbrain/SKILL.md +++ b/setup-gbrain/SKILL.md @@ -279,15 +279,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -320,6 +320,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -344,13 +350,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/ship/SKILL.md b/ship/SKILL.md index c1b25c95a..8ff64b8ea 100644 --- a/ship/SKILL.md +++ b/ship/SKILL.md @@ -280,15 +280,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -321,6 +321,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -345,13 +351,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/skillify/SKILL.md b/skillify/SKILL.md index 503f8262b..b420f715b 100644 --- a/skillify/SKILL.md +++ b/skillify/SKILL.md @@ -276,15 +276,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -317,6 +317,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -341,13 +347,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/sync-gbrain/SKILL.md b/sync-gbrain/SKILL.md index afebd31f1..dcc590224 100644 --- a/sync-gbrain/SKILL.md +++ b/sync-gbrain/SKILL.md @@ -279,15 +279,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -320,6 +320,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -344,13 +350,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/test/fixtures/golden/claude-ship-SKILL.md b/test/fixtures/golden/claude-ship-SKILL.md index c1b25c95a..8ff64b8ea 100644 --- a/test/fixtures/golden/claude-ship-SKILL.md +++ b/test/fixtures/golden/claude-ship-SKILL.md @@ -280,15 +280,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -321,6 +321,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -345,13 +351,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/test/fixtures/golden/codex-ship-SKILL.md b/test/fixtures/golden/codex-ship-SKILL.md index 3db6ae823..a15eeb3a0 100644 --- a/test/fixtures/golden/codex-ship-SKILL.md +++ b/test/fixtures/golden/codex-ship-SKILL.md @@ -269,15 +269,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -310,6 +310,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -334,13 +340,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/test/fixtures/golden/factory-ship-SKILL.md b/test/fixtures/golden/factory-ship-SKILL.md index 675fde3bf..0a7621bbf 100644 --- a/test/fixtures/golden/factory-ship-SKILL.md +++ b/test/fixtures/golden/factory-ship-SKILL.md @@ -271,15 +271,15 @@ AI orchestrator (e.g., OpenClaw). In spawned sessions: ### Tool resolution (read first) -"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool. +"AskUserQuestion" may be host MCP (e.g. `mcp__conductor__AskUserQuestion`) or native. -**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies. +**Rule:** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ and route through MCP; same shape and brief. **If no AskUserQuestion variant appears in your tool list, this skill is BLOCKED.** Stop, report `BLOCKED — AskUserQuestion unavailable`, and wait for the user. Do not write decisions to the plan file as a substitute, do not emit them as prose and stop, and do not silently auto-decide (only `/plan-tune` AUTO_DECIDE opt-ins authorize auto-picking). ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose. +Every AskUserQuestion decision has two parts: a markdown decision brief before the call, then a compact tool_use payload. Do not pack the full brief into the tool's `question` string. Every AskUserQuestion must be sent as tool_use, not prose. ``` D — @@ -312,6 +312,12 @@ Effort both-scales: when an option involves effort, label both human-team and CC Net line closes the tradeoff. Per-skill instructions may add stricter rules. +Tool payload rules: +- `question` is only the decision prompt: one sentence, no newlines, <=80 chars. +- Background, regrounding, ELI10, stakes, recommendation, pros/cons, and trade-off tables stay in the markdown brief before the tool call. +- Ask one decision per tool call when possible; batch at most two related questions/tabs. Sequence independent decisions instead of sending 3+ tabs. +- Do not duplicate the same trade-off text in both `question` and `options[].description`. Prefer putting option-specific trade-offs in `options[].description`. + 12. **Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit @@ -336,13 +342,17 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules. Before calling AskUserQuestion, verify: - [ ] D header present -- [ ] ELI10 paragraph present (stakes line too) -- [ ] Recommendation line present with concrete reason -- [ ] Completeness scored (coverage) OR kind-note present (kind) +- [ ] ELI10 paragraph and stakes line present +- [ ] Recommendation line present with reason +- [ ] Completeness scored OR kind-note present - [ ] Every option has ≥2 ✅ and ≥1 ❌, each ≥40 chars (or hard-stop escape) - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision +- [ ] `question` is one sentence, no newlines, <=80 chars +- [ ] Tool call has no more than two related questions/tabs +- [ ] No duplicated trade-off text between `question` and `options[].description` +- [ ] You wrote the brief, then called the tool_use payload - [ ] You are calling the tool, not writing prose - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped diff --git a/test/gen-skill-docs.test.ts b/test/gen-skill-docs.test.ts index b30a32464..9dbfa0869 100644 --- a/test/gen-skill-docs.test.ts +++ b/test/gen-skill-docs.test.ts @@ -287,6 +287,15 @@ describe('gen-skill-docs', () => { expect(content).toContain('not function names'); }); + test('tier 2+ skills keep AskUserQuestion panel payloads compact', () => { + const content = fs.readFileSync(path.join(ROOT, 'cso', 'SKILL.md'), 'utf-8'); + expect(content).toContain("Do not pack the full brief into the tool's `question` string"); + expect(content).toContain('`question` is only the decision prompt'); + expect(content).toContain('<=80 chars'); + expect(content).toContain('batch at most two related questions/tabs'); + expect(content).toContain('No duplicated trade-off text'); + }); + test('tier 1 skills do NOT contain AskUserQuestion format', () => { // Use benchmark (tier 1) instead of root — root SKILL.md gets overwritten by Codex test setup const content = fs.readFileSync(path.join(ROOT, 'benchmark', 'SKILL.md'), 'utf-8'); diff --git a/test/resolver-ask-user-format.test.ts b/test/resolver-ask-user-format.test.ts index 37744f2bc..79703fb71 100644 --- a/test/resolver-ask-user-format.test.ts +++ b/test/resolver-ask-user-format.test.ts @@ -97,16 +97,35 @@ describe('generateAskUserFormat — v1.7.0.0 Pros/Cons format', () => { expect(out).toMatch(/options differ in kind, not coverage/); }); - test('documents tool_use mandate (rule 11)', () => { + test('documents tool_use mandate', () => { expect(out).toMatch(/tool_use/); - // "not a question" spans a newline in the rendered text - expect(out).toMatch(/not a[\s\S]*question|not[\s\S]*interactive/i); + expect(out).toMatch(/brief, then called the tool_use payload/i); + }); + + test('keeps long decision briefs out of the tool question field', () => { + expect(out).toMatch(/Do not pack the full brief into the tool's `question` string/); + expect(out).toMatch(/`question` is only the decision prompt/); + expect(out).toMatch(/<=80 chars/); + expect(out).toMatch(/no newlines/); + }); + + test('limits batched AskUserQuestion tabs for panel readability', () => { + expect(out).toMatch(/batch at most two related questions\/tabs/i); + expect(out).toMatch(/Sequence independent decisions/i); + }); + + test('forbids duplicate trade-off text in question and option descriptions', () => { + expect(out).toMatch(/Do not duplicate the same trade-off text/); + expect(out).toMatch(/options\[\]\.description/); }); test('includes self-check before emitting', () => { expect(out).toContain('Self-check before emitting'); expect(out).toMatch(/D header present/); expect(out).toMatch(/Net line closes/); + expect(out).toMatch(/`question` is one sentence/); + expect(out).toMatch(/no more than two related questions\/tabs/); + expect(out).toMatch(/No duplicated trade-off text/); }); test('documents D-numbering as model-level not runtime state', () => {