From 8d79caf178e80a7d9bf382964cccc43dbfbc6ab4 Mon Sep 17 00:00:00 2001 From: Jayesh Betala Date: Wed, 17 Jun 2026 12:34:05 +0530 Subject: [PATCH] fix(ask-user): keep question payloads compact (#1208) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Long decision-brief bodies packed into AskUserQuestion's `question` field and multi-tab batches make the question card unreadable in panel hosts (VSCode). The brief belongs in markdown before the call; the tool payload should stay compact. generate-ask-user-format.ts now documents, in the Format section: - the two-part contract (markdown brief, then a compact tool_use payload); - "Tool payload rules": `question` is one sentence / no newlines / <=80 chars, brief content stays in markdown, batch at most two related questions/tabs (sequence the rest), and no duplicated trade-off text between `question` and `options[].description`; - four matching self-check items. This grafts only the compact-payload guidance onto the current resolver — it preserves the Conductor / runtime-failure-fallback content that landed on main since this PR was first opened. Regenerated all host SKILL.md variants (--host all) and refreshed the claude/codex/factory ship golden fixtures so the generated docs carry the new rules. Tests: new resolver assertions (compact-question, tab-batching, no-duplicate-tradeoff, self-check items) and a gen-skill-docs assertion that the rules reach generated tier 2+ SKILL.md. Affected suites (resolver-ask-user-format, gen-skill-docs, host-config) green. Fixes #1208 Co-Authored-By: Claude Opus 4.8 (1M context) --- autoplan/SKILL.md | 12 ++++++++- canary/SKILL.md | 12 ++++++++- codex/SKILL.md | 12 ++++++++- context-restore/SKILL.md | 12 ++++++++- context-save/SKILL.md | 12 ++++++++- cso/SKILL.md | 12 ++++++++- design-consultation/SKILL.md | 12 ++++++++- design-html/SKILL.md | 12 ++++++++- design-review/SKILL.md | 12 ++++++++- design-shotgun/SKILL.md | 12 ++++++++- devex-review/SKILL.md | 12 ++++++++- diagram/SKILL.md | 12 ++++++++- document-generate/SKILL.md | 12 ++++++++- document-release/SKILL.md | 12 ++++++++- health/SKILL.md | 12 ++++++++- investigate/SKILL.md | 12 ++++++++- ios-clean/SKILL.md | 12 ++++++++- ios-design-review/SKILL.md | 12 ++++++++- ios-fix/SKILL.md | 12 ++++++++- ios-qa/SKILL.md | 12 ++++++++- ios-sync/SKILL.md | 12 ++++++++- land-and-deploy/SKILL.md | 12 ++++++++- landing-report/SKILL.md | 12 ++++++++- learn/SKILL.md | 12 ++++++++- office-hours/SKILL.md | 12 ++++++++- open-gstack-browser/SKILL.md | 12 ++++++++- pair-agent/SKILL.md | 12 ++++++++- plan-ceo-review/SKILL.md | 12 ++++++++- plan-design-review/SKILL.md | 12 ++++++++- plan-devex-review/SKILL.md | 12 ++++++++- plan-eng-review/SKILL.md | 12 ++++++++- plan-tune/SKILL.md | 12 ++++++++- qa-only/SKILL.md | 12 ++++++++- qa/SKILL.md | 12 ++++++++- retro/SKILL.md | 12 ++++++++- review/SKILL.md | 12 ++++++++- scrape/SKILL.md | 12 ++++++++- .../preamble/generate-ask-user-format.ts | 12 ++++++++- setup-deploy/SKILL.md | 12 ++++++++- setup-gbrain/SKILL.md | 12 ++++++++- ship/SKILL.md | 12 ++++++++- skillify/SKILL.md | 12 ++++++++- spec/SKILL.md | 24 ++++++++++++++++-- sync-gbrain/SKILL.md | 12 ++++++++- test/fixtures/golden/claude-ship-SKILL.md | 12 ++++++++- test/fixtures/golden/codex-ship-SKILL.md | 12 ++++++++- test/fixtures/golden/factory-ship-SKILL.md | 12 ++++++++- test/gen-skill-docs.test.ts | 11 ++++++++ test/resolver-ask-user-format.test.ts | 25 +++++++++++++++++++ 49 files changed, 564 insertions(+), 48 deletions(-) diff --git a/autoplan/SKILL.md b/autoplan/SKILL.md index 49db38ff9..97d36b298 100644 --- a/autoplan/SKILL.md +++ b/autoplan/SKILL.md @@ -345,7 +345,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -378,6 +378,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -425,6 +431,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/canary/SKILL.md b/canary/SKILL.md index b72b99364..9f6b03f4e 100644 --- a/canary/SKILL.md +++ b/canary/SKILL.md @@ -337,7 +337,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -370,6 +370,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -417,6 +423,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/codex/SKILL.md b/codex/SKILL.md index cd40e075d..7a4282e09 100644 --- a/codex/SKILL.md +++ b/codex/SKILL.md @@ -340,7 +340,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -373,6 +373,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -420,6 +426,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/context-restore/SKILL.md b/context-restore/SKILL.md index 11b95b4e2..a2620d6c0 100644 --- a/context-restore/SKILL.md +++ b/context-restore/SKILL.md @@ -341,7 +341,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -374,6 +374,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -421,6 +427,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/context-save/SKILL.md b/context-save/SKILL.md index c135352ed..b6bfd3d16 100644 --- a/context-save/SKILL.md +++ b/context-save/SKILL.md @@ -340,7 +340,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -373,6 +373,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -420,6 +426,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/cso/SKILL.md b/cso/SKILL.md index 9843d26ca..de9df90e4 100644 --- a/cso/SKILL.md +++ b/cso/SKILL.md @@ -343,7 +343,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -376,6 +376,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -423,6 +429,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/design-consultation/SKILL.md b/design-consultation/SKILL.md index 2ecca91c0..02bb2fc4c 100644 --- a/design-consultation/SKILL.md +++ b/design-consultation/SKILL.md @@ -363,7 +363,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -396,6 +396,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -443,6 +449,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/design-html/SKILL.md b/design-html/SKILL.md index 78a0bc926..fdca76238 100644 --- a/design-html/SKILL.md +++ b/design-html/SKILL.md @@ -344,7 +344,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -377,6 +377,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -424,6 +430,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/design-review/SKILL.md b/design-review/SKILL.md index 6aa627271..63b07abc4 100644 --- a/design-review/SKILL.md +++ b/design-review/SKILL.md @@ -341,7 +341,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -374,6 +374,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -421,6 +427,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/design-shotgun/SKILL.md b/design-shotgun/SKILL.md index 18506be7d..9befde919 100644 --- a/design-shotgun/SKILL.md +++ b/design-shotgun/SKILL.md @@ -358,7 +358,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -391,6 +391,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -438,6 +444,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/devex-review/SKILL.md b/devex-review/SKILL.md index 990755b50..cc761affa 100644 --- a/devex-review/SKILL.md +++ b/devex-review/SKILL.md @@ -343,7 +343,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -376,6 +376,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -423,6 +429,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/diagram/SKILL.md b/diagram/SKILL.md index 345a81140..f70f2e95a 100644 --- a/diagram/SKILL.md +++ b/diagram/SKILL.md @@ -338,7 +338,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -371,6 +371,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -418,6 +424,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/document-generate/SKILL.md b/document-generate/SKILL.md index b257ad76d..ce01f7861 100644 --- a/document-generate/SKILL.md +++ b/document-generate/SKILL.md @@ -343,7 +343,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -376,6 +376,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -423,6 +429,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/document-release/SKILL.md b/document-release/SKILL.md index f6aef206c..ddba95a24 100644 --- a/document-release/SKILL.md +++ b/document-release/SKILL.md @@ -341,7 +341,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -374,6 +374,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -421,6 +427,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/health/SKILL.md b/health/SKILL.md index 9ba9bbbb3..37d767182 100644 --- a/health/SKILL.md +++ b/health/SKILL.md @@ -339,7 +339,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -372,6 +372,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -419,6 +425,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/investigate/SKILL.md b/investigate/SKILL.md index 0e27f4d34..5f570b9b7 100644 --- a/investigate/SKILL.md +++ b/investigate/SKILL.md @@ -378,7 +378,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -411,6 +411,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -458,6 +464,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/ios-clean/SKILL.md b/ios-clean/SKILL.md index d969640a2..eb472b5ff 100644 --- a/ios-clean/SKILL.md +++ b/ios-clean/SKILL.md @@ -341,7 +341,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -374,6 +374,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -421,6 +427,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/ios-design-review/SKILL.md b/ios-design-review/SKILL.md index 6a890f26a..972c698ce 100644 --- a/ios-design-review/SKILL.md +++ b/ios-design-review/SKILL.md @@ -343,7 +343,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -376,6 +376,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -423,6 +429,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/ios-fix/SKILL.md b/ios-fix/SKILL.md index 464691bc8..a5de7397c 100644 --- a/ios-fix/SKILL.md +++ b/ios-fix/SKILL.md @@ -344,7 +344,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -377,6 +377,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -424,6 +430,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/ios-qa/SKILL.md b/ios-qa/SKILL.md index a57421d3c..06a339d2c 100644 --- a/ios-qa/SKILL.md +++ b/ios-qa/SKILL.md @@ -347,7 +347,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -380,6 +380,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -427,6 +433,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/ios-sync/SKILL.md b/ios-sync/SKILL.md index a55b2a426..a14602bee 100644 --- a/ios-sync/SKILL.md +++ b/ios-sync/SKILL.md @@ -341,7 +341,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -374,6 +374,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -421,6 +427,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/land-and-deploy/SKILL.md b/land-and-deploy/SKILL.md index f2c3e75c7..e6ac20554 100644 --- a/land-and-deploy/SKILL.md +++ b/land-and-deploy/SKILL.md @@ -336,7 +336,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -369,6 +369,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -416,6 +422,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/landing-report/SKILL.md b/landing-report/SKILL.md index 3d33ab3ad..ccc240bde 100644 --- a/landing-report/SKILL.md +++ b/landing-report/SKILL.md @@ -337,7 +337,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -370,6 +370,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -417,6 +423,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/learn/SKILL.md b/learn/SKILL.md index 4266c1e36..7e2b338aa 100644 --- a/learn/SKILL.md +++ b/learn/SKILL.md @@ -339,7 +339,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -372,6 +372,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -419,6 +425,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/office-hours/SKILL.md b/office-hours/SKILL.md index b02ec8fa6..1a1d5b979 100644 --- a/office-hours/SKILL.md +++ b/office-hours/SKILL.md @@ -374,7 +374,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -407,6 +407,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -454,6 +460,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/open-gstack-browser/SKILL.md b/open-gstack-browser/SKILL.md index 09ed56123..da9dd0bea 100644 --- a/open-gstack-browser/SKILL.md +++ b/open-gstack-browser/SKILL.md @@ -336,7 +336,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -369,6 +369,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -416,6 +422,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/pair-agent/SKILL.md b/pair-agent/SKILL.md index b6e192070..58fddb382 100644 --- a/pair-agent/SKILL.md +++ b/pair-agent/SKILL.md @@ -338,7 +338,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -371,6 +371,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -418,6 +424,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/plan-ceo-review/SKILL.md b/plan-ceo-review/SKILL.md index 126c9282c..8197bccb9 100644 --- a/plan-ceo-review/SKILL.md +++ b/plan-ceo-review/SKILL.md @@ -368,7 +368,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -401,6 +401,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -448,6 +454,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/plan-design-review/SKILL.md b/plan-design-review/SKILL.md index baaba9568..b7cd707dd 100644 --- a/plan-design-review/SKILL.md +++ b/plan-design-review/SKILL.md @@ -340,7 +340,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -373,6 +373,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -420,6 +426,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/plan-devex-review/SKILL.md b/plan-devex-review/SKILL.md index 3492fd51d..85caf8f13 100644 --- a/plan-devex-review/SKILL.md +++ b/plan-devex-review/SKILL.md @@ -346,7 +346,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -379,6 +379,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -426,6 +432,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/plan-eng-review/SKILL.md b/plan-eng-review/SKILL.md index 5a20a2295..627f2e5fc 100644 --- a/plan-eng-review/SKILL.md +++ b/plan-eng-review/SKILL.md @@ -344,7 +344,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -377,6 +377,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -424,6 +430,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/plan-tune/SKILL.md b/plan-tune/SKILL.md index ecd2c8d71..a083beb6c 100644 --- a/plan-tune/SKILL.md +++ b/plan-tune/SKILL.md @@ -349,7 +349,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -382,6 +382,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -429,6 +435,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/qa-only/SKILL.md b/qa-only/SKILL.md index ec2cea40d..80e36ce93 100644 --- a/qa-only/SKILL.md +++ b/qa-only/SKILL.md @@ -339,7 +339,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -372,6 +372,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -419,6 +425,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/qa/SKILL.md b/qa/SKILL.md index 4108212ea..74862bcb9 100644 --- a/qa/SKILL.md +++ b/qa/SKILL.md @@ -345,7 +345,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -378,6 +378,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -425,6 +431,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/retro/SKILL.md b/retro/SKILL.md index cb65e98cf..722581dc4 100644 --- a/retro/SKILL.md +++ b/retro/SKILL.md @@ -356,7 +356,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -389,6 +389,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -436,6 +442,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/review/SKILL.md b/review/SKILL.md index 9ce97c052..65cf9e89a 100644 --- a/review/SKILL.md +++ b/review/SKILL.md @@ -341,7 +341,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -374,6 +374,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -421,6 +427,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/scrape/SKILL.md b/scrape/SKILL.md index 54e1187c6..1c61b9e2b 100644 --- a/scrape/SKILL.md +++ b/scrape/SKILL.md @@ -337,7 +337,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -370,6 +370,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -417,6 +423,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/scripts/resolvers/preamble/generate-ask-user-format.ts b/scripts/resolvers/preamble/generate-ask-user-format.ts index 533c002c0..933f5f181 100644 --- a/scripts/resolvers/preamble/generate-ask-user-format.ts +++ b/scripts/resolvers/preamble/generate-ask-user-format.ts @@ -39,7 +39,7 @@ Layout: a \`D\` title + a one-line note to reply with a letter (in Conductor ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. \`\`\` D — @@ -72,6 +72,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\`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -119,6 +125,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless \`CONDUCTOR_SESSION: true\` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + \`(recommended)\` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \\u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/setup-deploy/SKILL.md b/setup-deploy/SKILL.md index 9765c3798..eff30fe04 100644 --- a/setup-deploy/SKILL.md +++ b/setup-deploy/SKILL.md @@ -340,7 +340,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -373,6 +373,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -420,6 +426,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/setup-gbrain/SKILL.md b/setup-gbrain/SKILL.md index e6a041710..f8e631576 100644 --- a/setup-gbrain/SKILL.md +++ b/setup-gbrain/SKILL.md @@ -339,7 +339,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -372,6 +372,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -419,6 +425,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/ship/SKILL.md b/ship/SKILL.md index a8ebb77d7..422093a20 100644 --- a/ship/SKILL.md +++ b/ship/SKILL.md @@ -341,7 +341,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -374,6 +374,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -421,6 +427,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/skillify/SKILL.md b/skillify/SKILL.md index c3db38b4d..3f52ba3ee 100644 --- a/skillify/SKILL.md +++ b/skillify/SKILL.md @@ -337,7 +337,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -370,6 +370,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -417,6 +423,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/spec/SKILL.md b/spec/SKILL.md index 89198cb91..26589d56d 100644 --- a/spec/SKILL.md +++ b/spec/SKILL.md @@ -338,7 +338,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -371,6 +371,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -418,6 +424,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any @@ -1379,7 +1389,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -1412,6 +1422,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -1459,6 +1475,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/sync-gbrain/SKILL.md b/sync-gbrain/SKILL.md index eba49d403..fc7c79b84 100644 --- a/sync-gbrain/SKILL.md +++ b/sync-gbrain/SKILL.md @@ -339,7 +339,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -372,6 +372,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -419,6 +425,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/test/fixtures/golden/claude-ship-SKILL.md b/test/fixtures/golden/claude-ship-SKILL.md index a8ebb77d7..422093a20 100644 --- a/test/fixtures/golden/claude-ship-SKILL.md +++ b/test/fixtures/golden/claude-ship-SKILL.md @@ -341,7 +341,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -374,6 +374,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -421,6 +427,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/test/fixtures/golden/codex-ship-SKILL.md b/test/fixtures/golden/codex-ship-SKILL.md index 347e1ff81..399ff28ed 100644 --- a/test/fixtures/golden/codex-ship-SKILL.md +++ b/test/fixtures/golden/codex-ship-SKILL.md @@ -327,7 +327,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -360,6 +360,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -407,6 +413,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/test/fixtures/golden/factory-ship-SKILL.md b/test/fixtures/golden/factory-ship-SKILL.md index ee0ee83a2..2b90d2f32 100644 --- a/test/fixtures/golden/factory-ship-SKILL.md +++ b/test/fixtures/golden/factory-ship-SKILL.md @@ -329,7 +329,7 @@ Layout: a `D` title + a one-line note to reply with a letter (in Conductor th ### Format -Every AskUserQuestion is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. +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 is a decision brief and must be sent as tool_use, not prose — unless the documented failure fallback above applies (interactive session + the call is unavailable/erroring), in which case the prose fallback is the correct output. ``` D — @@ -362,6 +362,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`. + ### Handling 5+ options — split, never drop AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER @@ -409,6 +415,10 @@ Before calling AskUserQuestion, verify: - [ ] (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 — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: prose with the mandatory triad — issue ELI10, per-choice Completeness, Recommendation + `(recommended)` — and a "reply with a letter" instruction, then STOP) - [ ] Non-ASCII characters (CJK / accents) written directly, NOT \u-escaped - [ ] If you had 5+ options, you split (or batched into ≤4-groups) — did NOT drop any diff --git a/test/gen-skill-docs.test.ts b/test/gen-skill-docs.test.ts index 431209a7f..714d939b3 100644 --- a/test/gen-skill-docs.test.ts +++ b/test/gen-skill-docs.test.ts @@ -332,6 +332,17 @@ describe('gen-skill-docs', () => { expect(content).toContain('not function names'); }); + // #1208: the compact-payload rules must reach generated tier 2+ SKILL.md so + // panel hosts (VSCode) render readable question cards. + 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 0b498af0a..e0013c635 100644 --- a/test/resolver-ask-user-format.test.ts +++ b/test/resolver-ask-user-format.test.ts @@ -105,10 +105,35 @@ describe('generateAskUserFormat — v1.7.0.0 Pros/Cons format', () => { expect(out).toMatch(/not a[\s\S]*question|not[\s\S]*interactive/i); }); + // #1208: keep the tool_use payload compact so the question card stays + // readable in panel hosts (VSCode). The full brief belongs in markdown + // before the call, not inside the tool's `question` string. + 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/); + // #1208 self-check items for compact payloads. + 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/); + expect(out).toMatch(/wrote the brief, then called the tool_use payload/); }); test('documents D-numbering as model-level not runtime state', () => {