diff --git a/autoplan/SKILL.md b/autoplan/SKILL.md index a39b60bbd..ddf458fbb 100644 --- a/autoplan/SKILL.md +++ b/autoplan/SKILL.md @@ -324,7 +324,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -357,6 +386,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/canary/SKILL.md b/canary/SKILL.md index 1ba6ecec7..b3149ad7e 100644 --- a/canary/SKILL.md +++ b/canary/SKILL.md @@ -316,7 +316,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -349,6 +378,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/codex/SKILL.md b/codex/SKILL.md index dbc6bbcb6..5215dc6a9 100644 --- a/codex/SKILL.md +++ b/codex/SKILL.md @@ -318,7 +318,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -351,6 +380,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/context-restore/SKILL.md b/context-restore/SKILL.md index 92eb1cdd1..5b1588af1 100644 --- a/context-restore/SKILL.md +++ b/context-restore/SKILL.md @@ -320,7 +320,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -353,6 +382,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/context-save/SKILL.md b/context-save/SKILL.md index 5a7b0d60e..6a6c05732 100644 --- a/context-save/SKILL.md +++ b/context-save/SKILL.md @@ -320,7 +320,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -353,6 +382,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/cso/SKILL.md b/cso/SKILL.md index 64cb75306..0ffec24af 100644 --- a/cso/SKILL.md +++ b/cso/SKILL.md @@ -321,7 +321,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -354,6 +383,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/design-consultation/SKILL.md b/design-consultation/SKILL.md index 8cecaa3d6..5edb13eec 100644 --- a/design-consultation/SKILL.md +++ b/design-consultation/SKILL.md @@ -344,7 +344,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -377,6 +406,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/design-html/SKILL.md b/design-html/SKILL.md index 5c92f7703..48f1c8873 100644 --- a/design-html/SKILL.md +++ b/design-html/SKILL.md @@ -323,7 +323,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -356,6 +385,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/design-review/SKILL.md b/design-review/SKILL.md index b584ada8f..ca5f0f148 100644 --- a/design-review/SKILL.md +++ b/design-review/SKILL.md @@ -321,7 +321,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -354,6 +383,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/design-shotgun/SKILL.md b/design-shotgun/SKILL.md index 36cbcb498..af93ebabd 100644 --- a/design-shotgun/SKILL.md +++ b/design-shotgun/SKILL.md @@ -338,7 +338,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -371,6 +400,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/devex-review/SKILL.md b/devex-review/SKILL.md index 49d5ae212..945259f60 100644 --- a/devex-review/SKILL.md +++ b/devex-review/SKILL.md @@ -321,7 +321,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -354,6 +383,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/docs/askuserquestion-split.md b/docs/askuserquestion-split.md new file mode 100644 index 000000000..ec2f880ce --- /dev/null +++ b/docs/askuserquestion-split.md @@ -0,0 +1,216 @@ +# AskUserQuestion split rule — full reference + +Inline summary lives in the canonical preamble (`scripts/resolvers/preamble/generate-ask-user-format.ts`). +That subsection is intentionally compressed because it injects into every +tier-2+ skill's `SKILL.md`. This file is the deep reference the inline +guidance points to — load it when N>4 options come up and you need +worked examples or the full Hold / dependency / final-summary semantics. + +## The bug this prevents + +Pre-rule failure mode (transcript verbatim from the user complaint that +motivated this): + +> "I'm hitting Conductor's limit of 4 options in the AUQ, so I need to +> cut one. E4 (the detect-mappings codegen) is the biggest lift and +> probably beyond scope for v0.42 anyway — users can hand-author their +> mapping rules for the 9 clusters. I'll drop that and keep E1, E2, E3, +> and E5..." +> +> "Conductor caps at 4 options. Trimming: E4 (detect-mappings codegen) +> is the largest-effort item and a natural v0.43+ follow-up — moving it +> to TODOS.md without asking. Re-firing with 4." + +The agent unilaterally cut a real option without user input. The option +set is the user's decision space; shrinking it silently is the bug. + +## Which shape: batched vs. split + +Two compliant shapes. Pick by reading the options: + +1. **Batched into ≤4-groups** — the options are coherent alternatives, + one will be picked. Examples: "major / minor / patch / micro" for a + version bump, "5 layout variants where the user picks one", "which + framework: rspec / minitest / cucumber / none". Batch the top 4 into + one AskUserQuestion; surface the 5th as a follow-up if none of the + first 4 fit. This is the lower-friction path when applicable. + +2. **Split per-option** — the options are independent scope items, each + carrying its own include/defer/cut decision. Examples: "E1..E6, which + do we ship?", "5 candidate integrations for Q3", "8 TODOs surfaced by + the audit — which do we land?". Fire N sequential AskUserQuestion + calls, one per option. + +**Default to split per-option when unsure.** Batching wrong options +together — shoehorning orthogonal scope items into one question — is +the same failure mode as dropping. + +## Split per-option mechanics + +### Before the chain + +Check for dependencies between options. If E3 requires E1, or E5 +conflicts with E2, surface that in the per-option ELI10: + +> "Cutting this orphans E3 — they're linked." + +Without dependency surfacing, the chain produces incoherent picked sets +(user picks Include for E3 + Cut for E1, ships an unbuildable scope). + +### D-numbering + +- Parent decision: `D` where N is the global question counter. +- Each per-option call: `D.k` for k=1..K children. +- Final summary: `D.final`. +- Single-option revise: `D.revise-`. + +Example chain for 5 options at parent D3: + +``` +D3.1 → D3.2 → D3.3 → D3.4 → D3.5 → D3.final +``` + +### Per-option call shape + +For each option Eₖ, fire an AskUserQuestion with: + +- `D.k` header (e.g. D3.1, D3.2 ... D3.5) +- ELI10 of just this option's scope, cost, and any dependency it carries +- Recommendation: Include / Defer / Cut, with concrete reason +- 4 buckets per option: + - **A) Include** in this scope (recommended/not) + - **B) Defer** to follow-up (TODOs / next version) + - **C) Cut** entirely + - **D) Hold** — stop the chain, discuss before deciding +- Note: options differ in kind, not coverage — no completeness score. + (Include/Defer/Cut/Hold are decision actions, so the existing format + rule applies: omit `Completeness: N/10` and use the kind-note instead.) + +### Hold means stop, not queue + +When the user picks Hold on any per-option call, **stop the chain +immediately**. Do not continue asking later options behind the Hold — +the user wants to discuss the picked option first. After discussion, +the user resumes by saying "continue" or naming the next option to ask +about. + +Wrong behavior: queue E4 and E5 behind a Hold on E3, then fire them +later with stale context. Right behavior: stop, let the user reset the +parent decision, resume from where they left off. + +### Final summary + +After the chain resolves (without Hold), fire `D.final` to confirm +and validate the assembled set. + +**Step 1 — validate dependencies.** If the picked set is incoherent +(e.g. E3 picked Include but its required E1 was Cut), do NOT silently +accept. Re-prompt the conflict as a single AskUserQuestion: + +> "E3 needs E1 but you cut E1. Revise: +> A) keep E1 +> B) cut E3 too +> C) leave as-is and accept the broken state" + +**Step 2 — confirm the assembled set.** If coherent: + +> "Here's the assembled set: E1, E2, E5. Ship this scope? +> A) Ship this scope (recommended) +> B) Revise one option (you pick which) +> C) Cut more" + +**Step 3 — targeted revise.** If the user picks B, ask which option to +revise, then fire ONE per-option AskUserQuestion at `D.revise-` +to update just that option. Do **not** re-run the whole chain. + +## Sizing rules + +- **N ≤ 4**: use the normal single AskUserQuestion form. Don't split. +- **N = 5 or 6**: split (or batch if a clean grouping exists). +- **N > 6**: BEFORE the chain, fire a meta-AskUserQuestion at `D.0`: + + > "About to ask N per-option questions. Options: + > A) Proceed with the full split (recommended only if every option is + > independent) + > B) Narrow scope first — I'll propose a smaller set + > C) Batch into groups of 4 instead" + + This is itself an AskUserQuestion tool call, not prose — it counts as + the first prompt in the chain, not a violation of the "tool not prose" + rule. + +## question_id rules for split chains + +Each per-option AskUserQuestion emits a unique `question_id` of the +form `-split-` where `` is the option's +key kebab-cased (lowercase, hyphens, ASCII only). + +Examples: +- `plan-ceo-review-split-e4-detect-mappings` +- `ship-split-rspec` +- `plan-eng-review-split-add-coverage-test` + +**Collision handling.** If two options would produce the same slug, +suffix with `-2`, `-3`, etc. + +**Length.** Total length must be ≤64 chars (validated by +`bin/gstack-question-preference --write`). Truncate the option slug if +needed, preserving the `-split-` prefix. + +## AUTO_DECIDE behavior with split chains + +Two-layer defense. + +**Layer 1 — mechanism.** Each per-option `question_id` is unique to its +option, so preferences set on one option's id cannot leak across the +chain. A `never-ask` on `ship-split-rspec` does not silently approve +`ship-split-minitest`. + +**Layer 2 — runtime enforcement.** `bin/gstack-question-preference +--check` detects any id matching `*-split-*` (the canonical slug pattern +emitted by split chains) and forces `ASK_NORMALLY` even when a +`never-ask` or `ask-only-for-one-way` preference exists for that exact +id. The check emits an explanatory note when this override fires: + +> "split-chain per-option calls always ASK_NORMALLY; your never-ask +> preference does not apply to options inside a sequential split." + +**Result.** Split-chain per-option calls are NEVER AUTO_DECIDE-eligible. +This is a runtime contract, not just collision-resistance by id +uniqueness. The user's option set is sacred — restoring user +sovereignty over the decision space is the entire point of splitting. + +## Interaction with per-skill rules + +This rule **overrides any per-skill "batch decisions" guidance**. +Per-skill templates that explicitly require one-issue-per-call (e.g. +`plan-eng-review`) are already compatible — they're a stricter special +case of this rule. + +## Worked example: 5 platform integrations + +Fixture used by `test/skill-e2e-plan-ceo-split-overflow.test.ts`. A plan +has 5 independent chat-platform candidates: + +- E1) Slack DM bot (~2 weeks, ~40% of asks) +- E2) Discord guild bot (~3 weeks, ~15%) +- E3) Microsoft Teams (~4 weeks, ~5%) +- E4) Telegram (~1 week, ~8%) +- E5) Mattermost (~2 weeks, ~3%) + +User wants individual decisions per candidate, not a bundled pick. The +agent should: + +1. Recognize this is a 5-option independent-scope decision → split. +2. Check dependencies (none here — each platform is standalone). +3. Fire `D3.1` through `D3.5`, one per platform, with Include / Defer / + Cut / Hold buckets and an effort+demand-grounded recommendation per + option. +4. After the chain, fire `D3.final` summarizing the assembled scope + (e.g. "Ship E1 + E4 — Slack and Telegram pull most demand for least + build cost. Defer the rest. A) Ship / B) Revise / C) Cut more"). + +Pre-fix failure shape (the bug): agent constructs a single +AskUserQuestion with E1..E4 as four options, drops E5 with prose like +"E5 is the smallest revenue segment, moving to TODOs". The user never +got to weigh in on E5. Floor-of-4 in the E2E test catches this. diff --git a/document-generate/SKILL.md b/document-generate/SKILL.md index e6cf9965d..d48bf8b5d 100644 --- a/document-generate/SKILL.md +++ b/document-generate/SKILL.md @@ -323,7 +323,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -356,6 +385,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/document-release/SKILL.md b/document-release/SKILL.md index b49f4e89b..b4c5caa65 100644 --- a/document-release/SKILL.md +++ b/document-release/SKILL.md @@ -320,7 +320,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -353,6 +382,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/health/SKILL.md b/health/SKILL.md index 396c980b2..70ffb4b53 100644 --- a/health/SKILL.md +++ b/health/SKILL.md @@ -318,7 +318,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -351,6 +380,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/investigate/SKILL.md b/investigate/SKILL.md index 40525d63a..71dd355ec 100644 --- a/investigate/SKILL.md +++ b/investigate/SKILL.md @@ -357,7 +357,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -390,6 +419,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/ios-clean/SKILL.md b/ios-clean/SKILL.md index f1a458e1e..4a89e0a3e 100644 --- a/ios-clean/SKILL.md +++ b/ios-clean/SKILL.md @@ -320,7 +320,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -353,6 +382,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/ios-design-review/SKILL.md b/ios-design-review/SKILL.md index f03806f54..d6a8135ff 100644 --- a/ios-design-review/SKILL.md +++ b/ios-design-review/SKILL.md @@ -321,7 +321,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -354,6 +383,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/ios-fix/SKILL.md b/ios-fix/SKILL.md index cc7a172b1..0f2da0548 100644 --- a/ios-fix/SKILL.md +++ b/ios-fix/SKILL.md @@ -322,7 +322,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -355,6 +384,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/ios-qa/SKILL.md b/ios-qa/SKILL.md index 4d03a041b..1f03d1623 100644 --- a/ios-qa/SKILL.md +++ b/ios-qa/SKILL.md @@ -325,7 +325,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -358,6 +387,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/ios-sync/SKILL.md b/ios-sync/SKILL.md index c3449af7b..69d03a30b 100644 --- a/ios-sync/SKILL.md +++ b/ios-sync/SKILL.md @@ -320,7 +320,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -353,6 +382,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/land-and-deploy/SKILL.md b/land-and-deploy/SKILL.md index ef7497cd4..588467ebc 100644 --- a/land-and-deploy/SKILL.md +++ b/land-and-deploy/SKILL.md @@ -315,7 +315,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -348,6 +377,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/landing-report/SKILL.md b/landing-report/SKILL.md index be8aed5e1..8ea669181 100644 --- a/landing-report/SKILL.md +++ b/landing-report/SKILL.md @@ -316,7 +316,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -349,6 +378,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/learn/SKILL.md b/learn/SKILL.md index 3599115b8..8025868e6 100644 --- a/learn/SKILL.md +++ b/learn/SKILL.md @@ -318,7 +318,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -351,6 +380,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/office-hours/SKILL.md b/office-hours/SKILL.md index b54c7c791..66a5cb8f1 100644 --- a/office-hours/SKILL.md +++ b/office-hours/SKILL.md @@ -353,7 +353,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -386,6 +415,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/open-gstack-browser/SKILL.md b/open-gstack-browser/SKILL.md index 8b4b0c493..ce7f34d2b 100644 --- a/open-gstack-browser/SKILL.md +++ b/open-gstack-browser/SKILL.md @@ -315,7 +315,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -348,6 +377,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/pair-agent/SKILL.md b/pair-agent/SKILL.md index dd7a51ecd..23ed138c6 100644 --- a/pair-agent/SKILL.md +++ b/pair-agent/SKILL.md @@ -316,7 +316,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -349,6 +378,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/plan-ceo-review/SKILL.md b/plan-ceo-review/SKILL.md index a0b24ef99..5c9d77bd4 100644 --- a/plan-ceo-review/SKILL.md +++ b/plan-ceo-review/SKILL.md @@ -347,7 +347,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -380,6 +409,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/plan-design-review/SKILL.md b/plan-design-review/SKILL.md index 2c95c67e6..396abe175 100644 --- a/plan-design-review/SKILL.md +++ b/plan-design-review/SKILL.md @@ -320,7 +320,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -353,6 +382,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/plan-devex-review/SKILL.md b/plan-devex-review/SKILL.md index 371d07a75..3a005647c 100644 --- a/plan-devex-review/SKILL.md +++ b/plan-devex-review/SKILL.md @@ -324,7 +324,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -357,6 +386,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/plan-eng-review/SKILL.md b/plan-eng-review/SKILL.md index a3a064a32..6f0c8134c 100644 --- a/plan-eng-review/SKILL.md +++ b/plan-eng-review/SKILL.md @@ -322,7 +322,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -355,6 +384,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/plan-tune/SKILL.md b/plan-tune/SKILL.md index c575ef4f4..1002dc031 100644 --- a/plan-tune/SKILL.md +++ b/plan-tune/SKILL.md @@ -329,7 +329,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -362,6 +391,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/qa-only/SKILL.md b/qa-only/SKILL.md index 3e95cb032..1cf8ffd65 100644 --- a/qa-only/SKILL.md +++ b/qa-only/SKILL.md @@ -317,7 +317,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -350,6 +379,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/qa/SKILL.md b/qa/SKILL.md index aec716f95..9768b2d45 100644 --- a/qa/SKILL.md +++ b/qa/SKILL.md @@ -323,7 +323,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -356,6 +385,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/retro/SKILL.md b/retro/SKILL.md index f75097669..a3f719236 100644 --- a/retro/SKILL.md +++ b/retro/SKILL.md @@ -335,7 +335,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -368,6 +397,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/review/SKILL.md b/review/SKILL.md index ef9e439c5..51cb2d8e2 100644 --- a/review/SKILL.md +++ b/review/SKILL.md @@ -320,7 +320,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -353,6 +382,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/scrape/SKILL.md b/scrape/SKILL.md index 7fb04d3f6..1ccba0755 100644 --- a/scrape/SKILL.md +++ b/scrape/SKILL.md @@ -316,7 +316,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -349,6 +378,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/scripts/resolvers/preamble/generate-ask-user-format.ts b/scripts/resolvers/preamble/generate-ask-user-format.ts index 5a7d174db..e71b39e41 100644 --- a/scripts/resolvers/preamble/generate-ask-user-format.ts +++ b/scripts/resolvers/preamble/generate-ask-user-format.ts @@ -46,7 +46,36 @@ 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. -12. **Non-ASCII characters — write directly, never \\u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: \`D.k\` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire \`D.final\` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use \`D.revise-\` to +revise one option without re-running the chain. + +For N>6, fire a \`D.0\` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: \`-split-\` (kebab-case ASCII, +≤64 chars, \`-2\`/\`-3\` suffix on collision). The runtime checker +(\`bin/gstack-question-preference\`) refuses \`never-ask\` on any \`*-split-*\` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +\`docs/askuserquestion-split.md\` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \\u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -79,5 +108,8 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) `; } diff --git a/setup-deploy/SKILL.md b/setup-deploy/SKILL.md index 0e09cc491..0bed79734 100644 --- a/setup-deploy/SKILL.md +++ b/setup-deploy/SKILL.md @@ -319,7 +319,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -352,6 +381,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/setup-gbrain/SKILL.md b/setup-gbrain/SKILL.md index 6a3536d3b..861e4e7b9 100644 --- a/setup-gbrain/SKILL.md +++ b/setup-gbrain/SKILL.md @@ -320,7 +320,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -353,6 +382,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/ship/SKILL.md b/ship/SKILL.md index 38da52874..45898d4fc 100644 --- a/ship/SKILL.md +++ b/ship/SKILL.md @@ -321,7 +321,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -354,6 +383,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/skillify/SKILL.md b/skillify/SKILL.md index afef0e3a1..47a7e61da 100644 --- a/skillify/SKILL.md +++ b/skillify/SKILL.md @@ -317,7 +317,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -350,6 +379,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/sync-gbrain/SKILL.md b/sync-gbrain/SKILL.md index 7b7610ea6..dcdb4418d 100644 --- a/sync-gbrain/SKILL.md +++ b/sync-gbrain/SKILL.md @@ -320,7 +320,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -353,6 +382,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/test/fixtures/golden/claude-ship-SKILL.md b/test/fixtures/golden/claude-ship-SKILL.md index 38da52874..45898d4fc 100644 --- a/test/fixtures/golden/claude-ship-SKILL.md +++ b/test/fixtures/golden/claude-ship-SKILL.md @@ -321,7 +321,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -354,6 +383,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/test/fixtures/golden/codex-ship-SKILL.md b/test/fixtures/golden/codex-ship-SKILL.md index d0159842f..0cffeeb0a 100644 --- a/test/fixtures/golden/codex-ship-SKILL.md +++ b/test/fixtures/golden/codex-ship-SKILL.md @@ -310,7 +310,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -343,6 +372,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/test/fixtures/golden/factory-ship-SKILL.md b/test/fixtures/golden/factory-ship-SKILL.md index 9ccdfeeeb..0682d8ed5 100644 --- a/test/fixtures/golden/factory-ship-SKILL.md +++ b/test/fixtures/golden/factory-ship-SKILL.md @@ -312,7 +312,36 @@ 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. -12. **Non-ASCII characters — write directly, never \u-escape.** When any +### Handling 5+ options — split, never drop + +AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER +drop, merge, or silently defer one to fit. Pick a compliant shape: + +- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps, + layout variants). One call, 5th surfaced only if first 4 don't fit. +- **Split per-option** — for independent scope items (e.g. "ship E1..E6?"). + Fire N sequential calls, one per option. Default to this when unsure. + +Per-option call shape: `D.k` header (e.g. D3.1..D3.5), ELI10 per option, +Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are +decision actions), and 4 buckets: +**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss). + +After the chain, fire `D.final` to validate the assembled set (reprompt +dependency conflicts) and confirm shipping it. Use `D.revise-` to +revise one option without re-running the chain. + +For N>6, fire a `D.0` meta-AskUserQuestion first (proceed / narrow / batch). + +question_ids for split chains: `-split-` (kebab-case ASCII, +≤64 chars, `-2`/`-3` suffix on collision). The runtime checker +(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id, +so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred. + +**Full rule + worked examples + Hold/dependency semantics:** see +`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4. + +**Non-ASCII characters — write directly, never \u-escape.** When any string field (question, option label, option description) contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text, emit the literal UTF-8 characters in the JSON string. **Never escape them @@ -345,6 +374,9 @@ Before calling AskUserQuestion, verify: - [ ] Net line closes the decision - [ ] You are calling the tool, not writing prose - [ ] 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 +- [ ] If you split, you checked dependencies between options before firing the chain +- [ ] If a per-option Hold fires, you stopped the chain immediately (didn't queue) ## Artifacts Sync (skill start) diff --git a/test/resolver-ask-user-format.test.ts b/test/resolver-ask-user-format.test.ts index 37744f2bc..629780c4f 100644 --- a/test/resolver-ask-user-format.test.ts +++ b/test/resolver-ask-user-format.test.ts @@ -119,3 +119,45 @@ describe('generateAskUserFormat — v1.7.0.0 Pros/Cons format', () => { expect(out).toMatch(/Per-skill instructions may add/); }); }); + +describe('generateAskUserFormat — 5+ option split rule (slim inline + docs pointer)', () => { + const out = generateAskUserFormat(makeCtx()); + + // 5 highest-signal pins. The full rule lives in + // docs/askuserquestion-split.md; this contract only checks what the + // inline subsection MUST surface so the agent can act without + // reading the docs file for routine 5-option splits. + + test('forbids dropping options to fit the 4-option cap', () => { + expect(out).toMatch(/caps every call at \*\*4 options\*\*/); + expect(out).toMatch(/NEVER\s+drop, merge, or silently defer/); + }); + + test('names the Include / Defer / Cut / Hold buckets', () => { + expect(out).toMatch(/A\) Include/); + expect(out).toMatch(/B\) Defer/); + expect(out).toMatch(/C\) Cut/); + expect(out).toMatch(/D\) Hold/); + }); + + test('specifies D.k child numbering and D.final summary', () => { + expect(out).toContain('D.k'); + expect(out).toContain('D.final'); + }); + + test('AUTO_DECIDE is gated at runtime, not just collision-resistance', () => { + expect(out).toContain('bin/gstack-question-preference'); + expect(out).toContain('*-split-*'); + expect(out).toContain('never AUTO_DECIDE-eligible'); + }); + + test('points to docs/askuserquestion-split.md for the full rule', () => { + expect(out).toContain('docs/askuserquestion-split.md'); + expect(out).toMatch(/Read on demand when N>4/); + }); + + test('regression: orphan "12." prefix removed from CJK rule', () => { + expect(out).not.toContain('12. **Non-ASCII'); + expect(out).toContain('**Non-ASCII characters'); + }); +});