From 0c1b50441d67070a96730d86748a5cb12ad63da5 Mon Sep 17 00:00:00 2001 From: Garry Tan Date: Sun, 30 Aug 2026 23:49:47 +0000 Subject: [PATCH] feat(auq-format): proactive SESSION_KIND=spawned rule ordered above the Conductor rule (#2733) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The spawned classification previously existed only in the failure-fallback branch — a spawned session was invited to call AskUserQuestion and reach auto-choose via the deny/error detour, and a spawned session inside a Conductor workspace hit the Conductor prose-STOP rule first. The Tool resolution list now leads with the spawned rule (auto-choose recommended, never prose, never BLOCKED, destructive gates resolve conservative), the self-check carries the never-reach-this-checklist clause, and all tier>=2 SKILL.md renders are regenerated. Context-budget fixture refreshed in the same commit per the ratchet protocol (the AUQ section is eager in every tier>=2 skill). Co-Authored-By: Claude Fable 5 --- autoplan/SKILL.md | 9 ++- canary/SKILL.md | 9 ++- codex/SKILL.md | 9 ++- context-restore/SKILL.md | 9 ++- context-save/SKILL.md | 9 ++- cso/SKILL.md | 9 ++- design-consultation/SKILL.md | 9 ++- design-html/SKILL.md | 9 ++- design-review/SKILL.md | 9 ++- design-shotgun/SKILL.md | 9 ++- devex-review/SKILL.md | 9 ++- document-generate/SKILL.md | 9 ++- document-release/SKILL.md | 9 ++- health/SKILL.md | 9 ++- investigate/SKILL.md | 9 ++- ios-clean/SKILL.md | 9 ++- ios-design-review/SKILL.md | 9 ++- ios-fix/SKILL.md | 9 ++- ios-qa/SKILL.md | 9 ++- ios-sync/SKILL.md | 9 ++- land-and-deploy/SKILL.md | 9 ++- landing-report/SKILL.md | 9 ++- learn/SKILL.md | 9 ++- office-hours/SKILL.md | 9 ++- pair-agent/SKILL.md | 9 ++- plan-ceo-review/SKILL.md | 9 ++- plan-design-review/SKILL.md | 9 ++- plan-devex-review/SKILL.md | 9 ++- plan-eng-review/SKILL.md | 9 ++- plan-tune/SKILL.md | 9 ++- qa-only/SKILL.md | 9 ++- qa/SKILL.md | 9 ++- retro/SKILL.md | 9 ++- review/SKILL.md | 9 ++- .../preamble/generate-ask-user-format.ts | 9 ++- setup-deploy/SKILL.md | 9 ++- setup-gbrain/SKILL.md | 9 ++- ship/SKILL.md | 9 ++- skillify/SKILL.md | 9 ++- spec/SKILL.md | 9 ++- sync-gbrain/SKILL.md | 9 ++- test/fixtures/context-budget.json | 80 +++++++++---------- test/fixtures/golden/claude-ship-SKILL.md | 9 ++- test/fixtures/golden/codex-ship-SKILL.md | 9 ++- test/fixtures/golden/factory-ship-SKILL.md | 9 ++- test/helpers/carve-guards.ts | 38 ++++----- test/resolver-ask-user-format.test.ts | 21 +++++ 47 files changed, 300 insertions(+), 235 deletions(-) diff --git a/autoplan/SKILL.md b/autoplan/SKILL.md index 6e90fd372..b02a2f078 100644 --- a/autoplan/SKILL.md +++ b/autoplan/SKILL.md @@ -79,9 +79,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -178,7 +179,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/canary/SKILL.md b/canary/SKILL.md index 55a034c46..0a7762efa 100644 --- a/canary/SKILL.md +++ b/canary/SKILL.md @@ -72,9 +72,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -171,7 +172,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/codex/SKILL.md b/codex/SKILL.md index 2d95bb175..b2d58820c 100644 --- a/codex/SKILL.md +++ b/codex/SKILL.md @@ -75,9 +75,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -174,7 +175,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/context-restore/SKILL.md b/context-restore/SKILL.md index cef2d420e..3a99343f2 100644 --- a/context-restore/SKILL.md +++ b/context-restore/SKILL.md @@ -76,9 +76,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -175,7 +176,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/context-save/SKILL.md b/context-save/SKILL.md index 4af2114f0..987876876 100644 --- a/context-save/SKILL.md +++ b/context-save/SKILL.md @@ -75,9 +75,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -174,7 +175,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/cso/SKILL.md b/cso/SKILL.md index 483f770c6..1cef29854 100644 --- a/cso/SKILL.md +++ b/cso/SKILL.md @@ -78,9 +78,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -177,7 +178,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/design-consultation/SKILL.md b/design-consultation/SKILL.md index 9aa388786..9f6f226ac 100644 --- a/design-consultation/SKILL.md +++ b/design-consultation/SKILL.md @@ -98,9 +98,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -197,7 +198,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/design-html/SKILL.md b/design-html/SKILL.md index 6bcd2a317..6dd0a7020 100644 --- a/design-html/SKILL.md +++ b/design-html/SKILL.md @@ -79,9 +79,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -178,7 +179,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/design-review/SKILL.md b/design-review/SKILL.md index 60cfe9639..17c0a2894 100644 --- a/design-review/SKILL.md +++ b/design-review/SKILL.md @@ -76,9 +76,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -175,7 +176,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/design-shotgun/SKILL.md b/design-shotgun/SKILL.md index e545d8a04..14a5ba96b 100644 --- a/design-shotgun/SKILL.md +++ b/design-shotgun/SKILL.md @@ -93,9 +93,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -192,7 +193,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/devex-review/SKILL.md b/devex-review/SKILL.md index 50b42df84..27c4c56b5 100644 --- a/devex-review/SKILL.md +++ b/devex-review/SKILL.md @@ -78,9 +78,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -177,7 +178,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/document-generate/SKILL.md b/document-generate/SKILL.md index d0c54e8c7..b6a4daefd 100644 --- a/document-generate/SKILL.md +++ b/document-generate/SKILL.md @@ -78,9 +78,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -177,7 +178,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/document-release/SKILL.md b/document-release/SKILL.md index 7936ade24..01aa980f7 100644 --- a/document-release/SKILL.md +++ b/document-release/SKILL.md @@ -76,9 +76,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -175,7 +176,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/health/SKILL.md b/health/SKILL.md index 3027c67e3..7cdea5427 100644 --- a/health/SKILL.md +++ b/health/SKILL.md @@ -74,9 +74,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -173,7 +174,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/investigate/SKILL.md b/investigate/SKILL.md index 65d4a283f..da984a39b 100644 --- a/investigate/SKILL.md +++ b/investigate/SKILL.md @@ -113,9 +113,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -212,7 +213,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/ios-clean/SKILL.md b/ios-clean/SKILL.md index fe3df2977..fe339b288 100644 --- a/ios-clean/SKILL.md +++ b/ios-clean/SKILL.md @@ -76,9 +76,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -175,7 +176,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/ios-design-review/SKILL.md b/ios-design-review/SKILL.md index 93c73fa35..622bf2303 100644 --- a/ios-design-review/SKILL.md +++ b/ios-design-review/SKILL.md @@ -78,9 +78,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -177,7 +178,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/ios-fix/SKILL.md b/ios-fix/SKILL.md index c2d78c683..cbb4ea335 100644 --- a/ios-fix/SKILL.md +++ b/ios-fix/SKILL.md @@ -79,9 +79,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -178,7 +179,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/ios-qa/SKILL.md b/ios-qa/SKILL.md index 380dac958..1bcec1998 100644 --- a/ios-qa/SKILL.md +++ b/ios-qa/SKILL.md @@ -82,9 +82,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -181,7 +182,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/ios-sync/SKILL.md b/ios-sync/SKILL.md index 0bc5798e6..03372b386 100644 --- a/ios-sync/SKILL.md +++ b/ios-sync/SKILL.md @@ -76,9 +76,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -175,7 +176,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/land-and-deploy/SKILL.md b/land-and-deploy/SKILL.md index 2be5448fb..09a0a93fa 100644 --- a/land-and-deploy/SKILL.md +++ b/land-and-deploy/SKILL.md @@ -71,9 +71,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -170,7 +171,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/landing-report/SKILL.md b/landing-report/SKILL.md index b432b568b..8d5877ab6 100644 --- a/landing-report/SKILL.md +++ b/landing-report/SKILL.md @@ -73,9 +73,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -172,7 +173,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/learn/SKILL.md b/learn/SKILL.md index 66d2fbc6d..2812a3c85 100644 --- a/learn/SKILL.md +++ b/learn/SKILL.md @@ -74,9 +74,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -173,7 +174,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/office-hours/SKILL.md b/office-hours/SKILL.md index 5ee21e8b7..1a13fdfc7 100644 --- a/office-hours/SKILL.md +++ b/office-hours/SKILL.md @@ -109,9 +109,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -208,7 +209,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/pair-agent/SKILL.md b/pair-agent/SKILL.md index 4f57ffd25..232f458b1 100644 --- a/pair-agent/SKILL.md +++ b/pair-agent/SKILL.md @@ -75,9 +75,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -174,7 +175,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/plan-ceo-review/SKILL.md b/plan-ceo-review/SKILL.md index 5df11757a..153353ea4 100644 --- a/plan-ceo-review/SKILL.md +++ b/plan-ceo-review/SKILL.md @@ -101,9 +101,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -200,7 +201,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/plan-design-review/SKILL.md b/plan-design-review/SKILL.md index b2173ac0e..bdc020216 100644 --- a/plan-design-review/SKILL.md +++ b/plan-design-review/SKILL.md @@ -74,9 +74,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -173,7 +174,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/plan-devex-review/SKILL.md b/plan-devex-review/SKILL.md index 022855e7e..4c2fb97c5 100644 --- a/plan-devex-review/SKILL.md +++ b/plan-devex-review/SKILL.md @@ -79,9 +79,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -178,7 +179,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/plan-eng-review/SKILL.md b/plan-eng-review/SKILL.md index 38aefc1f3..fc3894ec4 100644 --- a/plan-eng-review/SKILL.md +++ b/plan-eng-review/SKILL.md @@ -77,9 +77,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -176,7 +177,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/plan-tune/SKILL.md b/plan-tune/SKILL.md index 825601e11..e616a8b5c 100644 --- a/plan-tune/SKILL.md +++ b/plan-tune/SKILL.md @@ -84,9 +84,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -183,7 +184,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/qa-only/SKILL.md b/qa-only/SKILL.md index e68934692..b113b2e2e 100644 --- a/qa-only/SKILL.md +++ b/qa-only/SKILL.md @@ -74,9 +74,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -173,7 +174,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/qa/SKILL.md b/qa/SKILL.md index e2a9a525f..c0c2be09d 100644 --- a/qa/SKILL.md +++ b/qa/SKILL.md @@ -80,9 +80,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -179,7 +180,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/retro/SKILL.md b/retro/SKILL.md index 90a7c1918..d43591e3f 100644 --- a/retro/SKILL.md +++ b/retro/SKILL.md @@ -94,9 +94,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -193,7 +194,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/review/SKILL.md b/review/SKILL.md index 8ca078428..55473204c 100644 --- a/review/SKILL.md +++ b/review/SKILL.md @@ -76,9 +76,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -175,7 +176,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/scripts/resolvers/preamble/generate-ask-user-format.ts b/scripts/resolvers/preamble/generate-ask-user-format.ts index d24df7d9a..b43d0724a 100644 --- a/scripts/resolvers/preamble/generate-ask-user-format.ts +++ b/scripts/resolvers/preamble/generate-ask-user-format.ts @@ -7,9 +7,10 @@ export function generateAskUserFormat(ctx: TemplateContext): string { Branch on the skill-start STATUS lines, in this order: -1. **\`CONDUCTOR_SESSION: true\` echoed** → do NOT call AskUserQuestion at all (neither native nor any \`mcp__*__AskUserQuestion\` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (\`[Tool result missing due to internal error]\`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with \`bin/gstack-question-log\` (the PostToolUse hook never fires on a prose path; \`/plan-tune\` learning depends on it). -2. **Any \`mcp__*__AskUserQuestion\` variant in your tool list** → prefer it (hosts may disable native via \`--disallowedTools\`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **\`SESSION_KIND: spawned\` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **\`CONDUCTOR_SESSION: true\` echoed** → do NOT call AskUserQuestion at all (neither native nor any \`mcp__*__AskUserQuestion\` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (\`[Tool result missing due to internal error]\`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with \`bin/gstack-question-log\` (the PostToolUse hook never fires on a prose path; \`/plan-tune\` learning depends on it). +3. **Any \`mcp__*__AskUserQuestion\` variant in your tool list** → prefer it (hosts may disable native via \`--disallowedTools\`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -106,7 +107,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless \`CONDUCTOR_SESSION: true\` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless \`CONDUCTOR_SESSION: true\` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in \`SESSION_KIND: spawned\` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/setup-deploy/SKILL.md b/setup-deploy/SKILL.md index ff7f06a1c..8b70b838c 100644 --- a/setup-deploy/SKILL.md +++ b/setup-deploy/SKILL.md @@ -75,9 +75,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -174,7 +175,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/setup-gbrain/SKILL.md b/setup-gbrain/SKILL.md index f56bc8d4a..11b60f008 100644 --- a/setup-gbrain/SKILL.md +++ b/setup-gbrain/SKILL.md @@ -74,9 +74,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -173,7 +174,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/ship/SKILL.md b/ship/SKILL.md index f010fd254..23ea540a7 100644 --- a/ship/SKILL.md +++ b/ship/SKILL.md @@ -76,9 +76,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -175,7 +176,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/skillify/SKILL.md b/skillify/SKILL.md index 0dd9330f0..9b64be91a 100644 --- a/skillify/SKILL.md +++ b/skillify/SKILL.md @@ -73,9 +73,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -172,7 +173,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/spec/SKILL.md b/spec/SKILL.md index 764b61620..b4ef73f97 100644 --- a/spec/SKILL.md +++ b/spec/SKILL.md @@ -74,9 +74,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -173,7 +174,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/sync-gbrain/SKILL.md b/sync-gbrain/SKILL.md index 38a7fb1d2..f229c437a 100644 --- a/sync-gbrain/SKILL.md +++ b/sync-gbrain/SKILL.md @@ -75,9 +75,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -174,7 +175,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/test/fixtures/context-budget.json b/test/fixtures/context-budget.json index df0271d7a..127b4b861 100644 --- a/test/fixtures/context-budget.json +++ b/test/fixtures/context-budget.json @@ -2,64 +2,64 @@ "_comment": "Context-budget ratchet ceilings (~tokens). Regenerate: bun test/helpers/capture-context-budget.ts. Headroom: alwaysOnTotal x1.05, eagerPerInvocation x1.1. Graded by test/context-budget-ratchet.test.ts via lib/context-bill.ts checkBudget.", "alwaysOnTotal": 6344, "eagerPerInvocation": { - "autoplan": 16321, + "autoplan": 16525, "benchmark": 4931, "benchmark-models": 3829, "browse": 7097, "browser-skills/hackernews-frontpage": 371, - "canary": 10365, + "canary": 10570, "careful": 919, - "codex": 14952, - "context-restore": 9304, - "context-save": 9921, - "cso": 14894, - "design-consultation": 13601, - "design-html": 13286, - "design-review": 24182, - "design-shotgun": 13397, - "devex-review": 15540, + "codex": 15156, + "context-restore": 9509, + "context-save": 10125, + "cso": 15098, + "design-consultation": 13805, + "design-html": 13491, + "design-review": 24387, + "design-shotgun": 13602, + "devex-review": 15744, "diagram": 3847, - "document-generate": 12049, - "document-release": 9846, + "document-generate": 12253, + "document-release": 10050, "freeze": 990, "gstack": 3548, "gstack-upgrade": 3981, "guard": 889, - "health": 10502, - "investigate": 11155, - "ios-clean": 8407, - "ios-design-review": 8588, - "ios-fix": 8360, - "ios-qa": 11100, - "ios-sync": 8531, - "land-and-deploy": 15776, - "landing-report": 9214, - "learn": 8884, + "health": 10707, + "investigate": 11360, + "ios-clean": 8612, + "ios-design-review": 8793, + "ios-fix": 8565, + "ios-qa": 11305, + "ios-sync": 8736, + "land-and-deploy": 15981, + "landing-report": 9418, + "learn": 9088, "make-pdf": 4957, - "office-hours": 18685, + "office-hours": 18890, "open-gstack-browser": 4504, "openclaw/skills/gstack-openclaw-ceo-review": 2764, "openclaw/skills/gstack-openclaw-investigate": 1429, "openclaw/skills/gstack-openclaw-office-hours": 4433, "openclaw/skills/gstack-openclaw-retro": 2542, - "pair-agent": 11309, - "plan-ceo-review": 19400, - "plan-design-review": 18841, - "plan-devex-review": 16681, - "plan-eng-review": 13621, - "plan-tune": 14458, - "qa": 13197, - "qa-only": 12970, - "retro": 18660, - "review": 14914, + "pair-agent": 11513, + "plan-ceo-review": 19604, + "plan-design-review": 19045, + "plan-devex-review": 16886, + "plan-eng-review": 13825, + "plan-tune": 14662, + "qa": 13401, + "qa-only": 13175, + "retro": 18865, + "review": 15119, "scrape": 3939, "setup-browser-cookies": 3194, - "setup-deploy": 10646, - "setup-gbrain": 15251, - "ship": 19751, - "skillify": 11889, - "spec": 14385, - "sync-gbrain": 13672, + "setup-deploy": 10851, + "setup-gbrain": 15456, + "ship": 19956, + "skillify": 12094, + "spec": 14589, + "sync-gbrain": 13876, "unfreeze": 393 } } diff --git a/test/fixtures/golden/claude-ship-SKILL.md b/test/fixtures/golden/claude-ship-SKILL.md index f010fd254..23ea540a7 100644 --- a/test/fixtures/golden/claude-ship-SKILL.md +++ b/test/fixtures/golden/claude-ship-SKILL.md @@ -76,9 +76,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -175,7 +176,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/test/fixtures/golden/codex-ship-SKILL.md b/test/fixtures/golden/codex-ship-SKILL.md index 3ec1da130..6b117c9e7 100644 --- a/test/fixtures/golden/codex-ship-SKILL.md +++ b/test/fixtures/golden/codex-ship-SKILL.md @@ -62,9 +62,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -161,7 +162,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/test/fixtures/golden/factory-ship-SKILL.md b/test/fixtures/golden/factory-ship-SKILL.md index 4a965c535..ccc2535da 100644 --- a/test/fixtures/golden/factory-ship-SKILL.md +++ b/test/fixtures/golden/factory-ship-SKILL.md @@ -64,9 +64,10 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay Branch on the skill-start STATUS lines, in this order: -1. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). -2. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. -3. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. +1. **`SESSION_KIND: spawned` echoed (or your dispatch prompt marks this session as spawned)** → do NOT call AskUserQuestion at all and do NOT render prose decision briefs: no human reads this session's output mid-run. Auto-choose the **recommended** option at every decision point per the Spawned session block — never prose, never BLOCKED — and record each auto-chosen decision in your completion report. Exception: never auto-choose a destructive or irreversible option — take the conservative non-destructive choice and record it. This rule outranks the Conductor rule below: a spawned session inside a Conductor workspace still auto-chooses. +2. **`CONDUCTOR_SESSION: true` echoed** → do NOT call AskUserQuestion at all (neither native nor any `mcp__*__AskUserQuestion` variant): render EVERY decision brief as the **prose form** below and STOP. Proactive, not a failure reaction — Conductor disables native AUQ and its MCP variant is flaky (`[Tool result missing due to internal error]`). **Auto-decide preferences still apply first** (failure-fallback item 1 below): proceed with a surfaced auto-decide option, no prose — enforced HERE since no tool call ever happens. Capture each Conductor prose brief with `bin/gstack-question-log` (the PostToolUse hook never fires on a prose path; `/plan-tune` learning depends on it). +3. **Any `mcp__*__AskUserQuestion` variant in your tool list** → prefer it (hosts may disable native via `--disallowedTools`; calling native there silently fails). Same shape, same decision-brief format. +4. **Unavailable (no variant) OR a call fails** → do NOT silently auto-decide or write the decision to the plan file as a substitute; follow the **failure fallback** below. ### When AskUserQuestion is unavailable or a call fails @@ -163,7 +164,7 @@ Before calling AskUserQuestion, verify: - [ ] (recommended) label on one option (even for neutral-posture) - [ ] Dual-scale effort labels on effort-bearing options (human / CC) - [ ] Net line closes the decision -- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP) +- [ ] You are calling the tool, not writing prose — unless `CONDUCTOR_SESSION: true` (then prose is the DEFAULT, not the tool) OR the documented failure fallback applies (then: the prose fallback's mandatory triad + a "reply with a letter" instruction, then STOP); in `SESSION_KIND: spawned` you should never reach this checklist — auto-choose the recommended option, no tool call, no 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 diff --git a/test/helpers/carve-guards.ts b/test/helpers/carve-guards.ts index 23b2fade5..cbb24833c 100644 --- a/test/helpers/carve-guards.ts +++ b/test/helpers/carve-guards.ts @@ -150,7 +150,7 @@ export const CARVE_GUARDS: Record = { }, behavioral: 'external', externalTest: 'test/skill-e2e-ship-section-loading.test.ts', - maxSkeletonBytes: 76_200, // + v1.73 --regen-digest trust-envelope + evidence-gate digest prose; measured 75_592 + maxSkeletonBytes: 76_800, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 76_375 minUnionBytes: 181_000, // token-reduction Phases 1-2 (v1.69.x branch); measured union 201,464 mustContain: ['VERSION', 'CHANGELOG', 'review', 'merge', 'PR'], // v1.58.5.0: pre-push-guard install (#2077) stacks on the shared first-run-guidance preamble. @@ -181,7 +181,7 @@ export const CARVE_GUARDS: Record = { // v1.65 merge: provisional larger-of-both-waves budget; re-measured below. // Fork port wave 2 (#703): the repo-doc-preference block in the design // check grew every plan-review skeleton ~0.7KB. Measured values noted. - maxSkeletonBytes: 74_830, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 74_221 + maxSkeletonBytes: 75_450, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 75_029 minUnionBytes: 123_600, // token-reduction Phases 1-2 (v1.69.x branch): preamble bash -> bin/gstack-skill-start, onboarding -> gated emission; measured union 137,346 mustContain: ['SCOPE EXPANSION', 'SELECTIVE EXPANSION', 'HOLD SCOPE', 'SCOPE REDUCTION'], // Default-on Codex outside-voice (codexPreflight block + CODEX_MODE branch @@ -207,7 +207,7 @@ export const CARVE_GUARDS: Record = { // check grew every plan-review skeleton ~0.7KB. Measured values noted. // #2499 project-scope MCP jq in the brain-sync block grew every tier-2+ // skeleton ~1.5KB (entry resolution emitted once per SKILL.md). - maxSkeletonBytes: 52_710, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 52_104 + maxSkeletonBytes: 53_350, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 52_912 minUnionBytes: 99_800, // token-reduction Phases 1-2 (v1.69.x branch); measured union 110,910 mustContain: ['Architecture', 'Code Quality', 'Test', 'Performance'], // Cross-cutting preamble growth (v1.57.2.0 AUQ-failure prose fallback + the @@ -240,7 +240,7 @@ export const CARVE_GUARDS: Record = { // tier-2+ skeleton (measured 89,184). Main's v1.64.0.0 adds ~340 B more // (telemetry --error-message/--failed-step preamble prose, PR #769). // Budget covers the sum of both waves. - maxSkeletonBytes: 72_690, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 72_082 + maxSkeletonBytes: 73_300, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 72_890 minUnionBytes: 99_200, // token-reduction Phases 1-2 (v1.69.x branch); measured union 110,293 mustContain: ['design', 'visual'], maxSizeRatio: 1.12, // D1 1.104 + main's ~0.008 @@ -264,7 +264,7 @@ export const CARVE_GUARDS: Record = { // check grew every plan-review skeleton ~0.7KB. Measured values noted. // #2499 project-scope MCP jq in the brain-sync block grew every tier-2+ // skeleton ~1.5KB (entry resolution emitted once per SKILL.md). - maxSkeletonBytes: 64_420, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 63_817 + maxSkeletonBytes: 65_050, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 64_625 minUnionBytes: 99_700, // token-reduction Phases 1-2 (v1.69.x branch); measured union 110,833 mustContain: ['developer experience', 'Getting Started'], // Default-on Codex outside-voice (codexPreflight block + CODEX_MODE branch @@ -295,7 +295,7 @@ export const CARVE_GUARDS: Record = { // the #538 opt-out + D1 evidence directive — ratio 1.104 measured. // #2499 project-scope MCP jq in the brain-sync block grew every tier-2+ // skeleton ~1.5KB (entry resolution emitted once per SKILL.md). - maxSkeletonBytes: 72_120, // ponytail-import wave + v1.72 Aside third-party-actions contract (merged); measured 71_511 + maxSkeletonBytes: 72_700, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 72_294 minUnionBytes: 115_800, // Phase 4 wave 4; measured union 118,175 mustContain: ['design doc', 'problem statement'], maxSizeRatio: 1.12, @@ -316,7 +316,7 @@ export const CARVE_GUARDS: Record = { // +Conductor AUQ-default-prose rule + one-way/continuation safety in the // always-loaded AskUserQuestion Format section. // v1.2.0 activation lift: first-run-guidance section in the shared preamble. - maxSkeletonBytes: 38_070, // token-reduction Phases 1-2 (v1.69.x branch): preamble bash -> bin/gstack-skill-start, onboarding -> gated emission; measured 37,469 + maxSkeletonBytes: 38_900, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 38_464 minUnionBytes: 56_700, // token-reduction Phases 1-2 (v1.69.x branch): preamble bash -> bin/gstack-skill-start, onboarding -> gated emission; measured union 63,018 mustContain: ['CHANGELOG', 'Diataxis', 'coverage'], // Two intentional additions stack on this small skill: the AUQ-failure prose @@ -347,7 +347,7 @@ export const CARVE_GUARDS: Record = { // v1.65 merge: provisional larger-of-both-waves budget; re-measured below. // v1.64.1.0: shared-preamble prose from the two parallel v1.64 waves lands // the skeleton at 69,022 B; +~1 KB headroom. - maxSkeletonBytes: 52_340, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 51_739 + maxSkeletonBytes: 53_250, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 52_834 minUnionBytes: 65_000, // token-reduction Phases 1-2 (v1.69.x branch): preamble bash -> bin/gstack-skill-start, onboarding -> gated emission; measured union 72,252 mustContain: ['Typography', 'Color', 'Aesthetic Direction'], // Cross-cutting preamble growth (v1.57.2.0 AUQ-failure prose fallback ~2KB + @@ -387,7 +387,7 @@ export const CARVE_GUARDS: Record = { // +Conductor AUQ-default-prose rule + one-way/continuation safety in the // always-loaded AskUserQuestion Format section. // v1.2.0 activation lift: first-run-guidance section in the shared preamble. - maxSkeletonBytes: 57_390, // token-reduction Phases 1-2 (v1.69.x branch); measured 56,789 + maxSkeletonBytes: 58_200, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 57_784 minUnionBytes: 64_200, // token-reduction Phases 1-2 (v1.69.x branch); measured union 71,379 mustContain: ['OWASP', 'STRIDE', 'daily', 'comprehensive', 'verif'], // cso keeps its mode-dispatch + FP-filtering phases always-loaded, so the @@ -424,7 +424,7 @@ export const CARVE_GUARDS: Record = { gateAfterStop: undefined, // operational multi-STOP skill, like ship }, behavioral: 'plan', - maxSkeletonBytes: 57_660, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 57_053 + maxSkeletonBytes: 58_300, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 57_861 minUnionBytes: 89_000, // Phase 4 wave 1; measured union 93,357 mustContain: ['confidence', 'P1', 'P2', 'Review Army', 'adversarial'], }, @@ -451,7 +451,7 @@ export const CARVE_GUARDS: Record = { gateAfterStop: 'EXIT PLAN MODE GATE', }, behavioral: 'prompt', - maxSkeletonBytes: 57_800, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 57_198 + maxSkeletonBytes: 58_400, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 58_006 minUnionBytes: 83_400, // Phase 4 wave 1; measured union 84,304 mustContain: ['GATE: PASS', 'CROSS-MODEL ANALYSIS', 'codex exec resume', 'sandbox_mode="read-only"', 'mktemp'], maxSizeRatio: 1.06, // measured 1.040 vs the v1.64.1.0 parity baseline @@ -477,7 +477,7 @@ export const CARVE_GUARDS: Record = { gateAfterStop: undefined, // operational skill }, behavioral: 'prompt', - maxSkeletonBytes: 60_980, // ponytail-import wave + v1.72 Aside third-party-actions contract (merged); measured 60_377 + maxSkeletonBytes: 61_600, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 61_160 minUnionBytes: 91_000, // Phase 4 wave 1; estimated union ~94.9KB mustContain: ['readiness', 'merge', 'canary', 'revert', 'staging'], }, @@ -512,7 +512,7 @@ export const CARVE_GUARDS: Record = { }, behavioral: 'external', externalTest: 'test/skill-e2e-autoplan-chain.test.ts', // phase-complete markers live ONLY in sections — its assertions ARE section-read proof - maxSkeletonBytes: 62_610, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 62_006 + maxSkeletonBytes: 63_650, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 63_245 minUnionBytes: 85_000, // measured union 86,926 mustContain: ['6 Decision Principles', 'TASTE DECISION', 'USER CHALLENGE', 'consensus', 'Restore Point'], }, @@ -541,7 +541,7 @@ export const CARVE_GUARDS: Record = { gateAfterStop: undefined, }, behavioral: 'prompt', - maxSkeletonBytes: 55_660, // ponytail-import wave + v1.72 Aside third-party-actions contract (merged); measured 55_053 + maxSkeletonBytes: 56_250, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 55_836 minUnionBytes: 64_500, // measured union 67,430 mustContain: ['HARD GATE', 'dedupe', 'quality gate', 'acceptance criteria', 'archive'], }, @@ -570,7 +570,7 @@ export const CARVE_GUARDS: Record = { gateAfterStop: undefined, }, behavioral: 'prompt', - maxSkeletonBytes: 58_950, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 58_344 + maxSkeletonBytes: 59_550, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 59_152 minUnionBytes: 78_300, // measured union 79,139 mustContain: ['PGLite', 'Supabase', 'claude mcp add', 'read_secret_to_env', 'pooler'], maxSizeRatio: 1.07, // measured 1.051 vs the branch monolith: index + stubs + 4 STOP pointers @@ -605,7 +605,7 @@ export const CARVE_GUARDS: Record = { gateAfterStop: undefined, }, behavioral: 'prompt', - maxSkeletonBytes: 50_800, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 50_194 + maxSkeletonBytes: 51_700, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 51_289 minUnionBytes: 69_500, // measured union 70,385 mustContain: ['bug', 'browse', 'fix', 'Health Score Rubric', 'regression'], }, @@ -642,7 +642,7 @@ export const CARVE_GUARDS: Record = { gateAfterStop: undefined, }, behavioral: 'prompt', - maxSkeletonBytes: 71_620, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 71_020 (retro also gained the Step 11.5 shortcut-debt harvest) + maxSkeletonBytes: 72_600, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 72_198 minUnionBytes: 66_000, // measured union 73,496 mustContain: ['retrospective', '45-minute gap', 'Ship of the week', 'Praise'], }, @@ -674,7 +674,7 @@ export const CARVE_GUARDS: Record = { gateAfterStop: undefined, // operational skill, no plan-mode gate }, behavioral: 'prompt', - maxSkeletonBytes: 51_140, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 50_536 + maxSkeletonBytes: 52_050, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 51_631 minUnionBytes: 57_500, // Phase 4 wave 4; measured union 58,682 mustContain: ["Don't make me think", "Users scan, they don't read", 'The Goodwill Reservoir', 'PRETEXT API CHEATSHEET', 'Pattern 3: Text around obstacles'], }, @@ -701,7 +701,7 @@ export const CARVE_GUARDS: Record = { gateAfterStop: undefined, }, behavioral: 'prompt', - maxSkeletonBytes: 51_850, // ponytail-import wave: reuse ladder + bounded closer + shortcut trail (AUQ repetition cut netted -236B, gated); measured 51_248 + maxSkeletonBytes: 52_500, // + v1.76 AUQ proactive SESSION_KIND=spawned rule (#2733); measured 52_056 minUnionBytes: 53_200, // Phase 4 wave 4; measured union 54,290 mustContain: ["Don't make me think", "Users scan, they don't read", 'trunk test', '44px minimum'], }, diff --git a/test/resolver-ask-user-format.test.ts b/test/resolver-ask-user-format.test.ts index 0b498af0a..1deadb444 100644 --- a/test/resolver-ask-user-format.test.ts +++ b/test/resolver-ask-user-format.test.ts @@ -231,6 +231,27 @@ describe('generateAskUserFormat — runtime-failure prose fallback', () => { expect(out).toMatch(/not writing prose — unless `CONDUCTOR_SESSION: true`[\s\S]*OR the documented failure fallback applies/); }); + // #2733: proactive spawned rule — spawned outranks Conductor. Without it a + // spawned session's AUQ handling exists only as a failure-reaction path, and + // a spawned subagent inside a Conductor workspace prose-STOPs with no reader. + test('Spawned: proactive do-not-call rule present and ordered ABOVE the Conductor rule', () => { + const spawnedRule = out.indexOf('`SESSION_KIND: spawned` echoed'); + const conductorRule = out.indexOf('`CONDUCTOR_SESSION: true` echoed'); + expect(spawnedRule).toBeGreaterThan(0); + expect(conductorRule).toBeGreaterThan(0); + expect(spawnedRule, 'spawned rule must outrank (precede) the Conductor rule').toBeLessThan(conductorRule); + expect(out).toMatch(/never prose, never BLOCKED/); + expect(out).toMatch(/outranks the Conductor rule/); + }); + + test('Spawned: destructive-gate carve-out present (conservative-continue, never prose-STOP)', () => { + expect(out).toMatch(/never auto-choose a destructive or irreversible option[\s\S]{0,80}conservative/); + }); + + test('Spawned: self-check carries the never-reach-this-checklist clause', () => { + expect(out).toMatch(/in `SESSION_KIND: spawned` you should never reach this checklist/); + }); + // Conductor-default-prose contract (the proactive path, distinct from the // failure fallback). Guards the Tool-resolution rule + self-check wording. test('Conductor: do-not-call rule present in Tool resolution', () => {