From a3343beef002dc67b5b3faecc68b9a1c39b7b69b Mon Sep 17 00:00:00 2001
From: Garry Tan <garrytan@gmail.com>
Date: Tue, 25 Aug 2026 16:09:08 +0000
Subject: [PATCH] =?UTF-8?q?chore(gen):=20regenerate=20all=20skills=20+=20g?=
 =?UTF-8?q?oldens=20=E2=80=94=20AUQ=20slim?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Mechanical regen: −1.3KB per tier-2+ skill (ship 69.9KB, learn 32.5KB).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 autoplan/SKILL.md                          | 57 ++++++++--------------
 canary/SKILL.md                            | 57 ++++++++--------------
 codex/SKILL.md                             | 57 ++++++++--------------
 context-restore/SKILL.md                   | 57 ++++++++--------------
 context-save/SKILL.md                      | 57 ++++++++--------------
 cso/SKILL.md                               | 57 ++++++++--------------
 design-consultation/SKILL.md               | 57 ++++++++--------------
 design-html/SKILL.md                       | 57 ++++++++--------------
 design-review/SKILL.md                     | 57 ++++++++--------------
 design-shotgun/SKILL.md                    | 57 ++++++++--------------
 devex-review/SKILL.md                      | 57 ++++++++--------------
 document-generate/SKILL.md                 | 57 ++++++++--------------
 document-release/SKILL.md                  | 57 ++++++++--------------
 health/SKILL.md                            | 57 ++++++++--------------
 investigate/SKILL.md                       | 57 ++++++++--------------
 ios-clean/SKILL.md                         | 57 ++++++++--------------
 ios-design-review/SKILL.md                 | 57 ++++++++--------------
 ios-fix/SKILL.md                           | 57 ++++++++--------------
 ios-qa/SKILL.md                            | 57 ++++++++--------------
 ios-sync/SKILL.md                          | 57 ++++++++--------------
 land-and-deploy/SKILL.md                   | 57 ++++++++--------------
 landing-report/SKILL.md                    | 57 ++++++++--------------
 learn/SKILL.md                             | 57 ++++++++--------------
 office-hours/SKILL.md                      | 57 ++++++++--------------
 pair-agent/SKILL.md                        | 57 ++++++++--------------
 plan-ceo-review/SKILL.md                   | 57 ++++++++--------------
 plan-design-review/SKILL.md                | 57 ++++++++--------------
 plan-devex-review/SKILL.md                 | 57 ++++++++--------------
 plan-eng-review/SKILL.md                   | 57 ++++++++--------------
 plan-tune/SKILL.md                         | 57 ++++++++--------------
 qa-only/SKILL.md                           | 57 ++++++++--------------
 qa/SKILL.md                                | 57 ++++++++--------------
 retro/SKILL.md                             | 57 ++++++++--------------
 review/SKILL.md                            | 57 ++++++++--------------
 setup-deploy/SKILL.md                      | 57 ++++++++--------------
 setup-gbrain/SKILL.md                      | 57 ++++++++--------------
 ship/SKILL.md                              | 57 ++++++++--------------
 skillify/SKILL.md                          | 57 ++++++++--------------
 spec/SKILL.md                              | 57 ++++++++--------------
 sync-gbrain/SKILL.md                       | 57 ++++++++--------------
 test/fixtures/golden/claude-ship-SKILL.md  | 57 ++++++++--------------
 test/fixtures/golden/codex-ship-SKILL.md   | 57 ++++++++--------------
 test/fixtures/golden/factory-ship-SKILL.md | 57 ++++++++--------------
 43 files changed, 903 insertions(+), 1548 deletions(-)

diff --git a/autoplan/SKILL.md b/autoplan/SKILL.md
index 5121f75fb..cce0953f4 100644
--- a/autoplan/SKILL.md
+++ b/autoplan/SKILL.md
@@ -77,13 +77,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -147,38 +145,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/canary/SKILL.md b/canary/SKILL.md
index 8981b5a29..6afe2cf1a 100644
--- a/canary/SKILL.md
+++ b/canary/SKILL.md
@@ -70,13 +70,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -140,38 +138,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/codex/SKILL.md b/codex/SKILL.md
index 215cc007b..4eb105ada 100644
--- a/codex/SKILL.md
+++ b/codex/SKILL.md
@@ -73,13 +73,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -143,38 +141,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/context-restore/SKILL.md b/context-restore/SKILL.md
index 6a7080812..5698510ac 100644
--- a/context-restore/SKILL.md
+++ b/context-restore/SKILL.md
@@ -74,13 +74,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -144,38 +142,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/context-save/SKILL.md b/context-save/SKILL.md
index 2c6e74694..364bb4e1a 100644
--- a/context-save/SKILL.md
+++ b/context-save/SKILL.md
@@ -73,13 +73,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -143,38 +141,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/cso/SKILL.md b/cso/SKILL.md
index 4ec779630..574f7b8ea 100644
--- a/cso/SKILL.md
+++ b/cso/SKILL.md
@@ -76,13 +76,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -146,38 +144,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/design-consultation/SKILL.md b/design-consultation/SKILL.md
index 0c0ff36c9..f9ec11ce4 100644
--- a/design-consultation/SKILL.md
+++ b/design-consultation/SKILL.md
@@ -96,13 +96,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -166,38 +164,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/design-html/SKILL.md b/design-html/SKILL.md
index 025bde7d2..dba83d9f8 100644
--- a/design-html/SKILL.md
+++ b/design-html/SKILL.md
@@ -77,13 +77,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -147,38 +145,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/design-review/SKILL.md b/design-review/SKILL.md
index 6e8852701..94948caab 100644
--- a/design-review/SKILL.md
+++ b/design-review/SKILL.md
@@ -74,13 +74,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -144,38 +142,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/design-shotgun/SKILL.md b/design-shotgun/SKILL.md
index 67e463d89..32804ed9c 100644
--- a/design-shotgun/SKILL.md
+++ b/design-shotgun/SKILL.md
@@ -91,13 +91,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -161,38 +159,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/devex-review/SKILL.md b/devex-review/SKILL.md
index 80599a6d4..9378041ed 100644
--- a/devex-review/SKILL.md
+++ b/devex-review/SKILL.md
@@ -76,13 +76,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -146,38 +144,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/document-generate/SKILL.md b/document-generate/SKILL.md
index 0e9320892..3aca27ef6 100644
--- a/document-generate/SKILL.md
+++ b/document-generate/SKILL.md
@@ -76,13 +76,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -146,38 +144,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/document-release/SKILL.md b/document-release/SKILL.md
index 930cb663d..533b87021 100644
--- a/document-release/SKILL.md
+++ b/document-release/SKILL.md
@@ -74,13 +74,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -144,38 +142,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/health/SKILL.md b/health/SKILL.md
index 3511cf152..ba0a83284 100644
--- a/health/SKILL.md
+++ b/health/SKILL.md
@@ -72,13 +72,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -142,38 +140,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/investigate/SKILL.md b/investigate/SKILL.md
index 9c7e5bb9e..91cbd4028 100644
--- a/investigate/SKILL.md
+++ b/investigate/SKILL.md
@@ -111,13 +111,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -181,38 +179,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/ios-clean/SKILL.md b/ios-clean/SKILL.md
index 68cbc1b4b..b5b86480c 100644
--- a/ios-clean/SKILL.md
+++ b/ios-clean/SKILL.md
@@ -74,13 +74,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -144,38 +142,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/ios-design-review/SKILL.md b/ios-design-review/SKILL.md
index ce0a6c98b..5ef4214eb 100644
--- a/ios-design-review/SKILL.md
+++ b/ios-design-review/SKILL.md
@@ -76,13 +76,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -146,38 +144,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/ios-fix/SKILL.md b/ios-fix/SKILL.md
index 573ef607e..b4ea612b0 100644
--- a/ios-fix/SKILL.md
+++ b/ios-fix/SKILL.md
@@ -77,13 +77,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -147,38 +145,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/ios-qa/SKILL.md b/ios-qa/SKILL.md
index c82ca1778..477e97c18 100644
--- a/ios-qa/SKILL.md
+++ b/ios-qa/SKILL.md
@@ -80,13 +80,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -150,38 +148,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/ios-sync/SKILL.md b/ios-sync/SKILL.md
index c0a8deb0e..51f37fc0f 100644
--- a/ios-sync/SKILL.md
+++ b/ios-sync/SKILL.md
@@ -74,13 +74,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -144,38 +142,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/land-and-deploy/SKILL.md b/land-and-deploy/SKILL.md
index 390b548e5..e94f0d13c 100644
--- a/land-and-deploy/SKILL.md
+++ b/land-and-deploy/SKILL.md
@@ -69,13 +69,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -139,38 +137,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/landing-report/SKILL.md b/landing-report/SKILL.md
index 73de02990..a54bf5463 100644
--- a/landing-report/SKILL.md
+++ b/landing-report/SKILL.md
@@ -71,13 +71,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -141,38 +139,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/learn/SKILL.md b/learn/SKILL.md
index 4897ccc9b..2c4fcff31 100644
--- a/learn/SKILL.md
+++ b/learn/SKILL.md
@@ -72,13 +72,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -142,38 +140,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/office-hours/SKILL.md b/office-hours/SKILL.md
index b07582719..7f697e20b 100644
--- a/office-hours/SKILL.md
+++ b/office-hours/SKILL.md
@@ -107,13 +107,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -177,38 +175,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/pair-agent/SKILL.md b/pair-agent/SKILL.md
index 357fe7e9e..0b7660775 100644
--- a/pair-agent/SKILL.md
+++ b/pair-agent/SKILL.md
@@ -73,13 +73,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -143,38 +141,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/plan-ceo-review/SKILL.md b/plan-ceo-review/SKILL.md
index 45179b311..56ebe623c 100644
--- a/plan-ceo-review/SKILL.md
+++ b/plan-ceo-review/SKILL.md
@@ -99,13 +99,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -169,38 +167,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/plan-design-review/SKILL.md b/plan-design-review/SKILL.md
index 0242b06f0..25230ee84 100644
--- a/plan-design-review/SKILL.md
+++ b/plan-design-review/SKILL.md
@@ -72,13 +72,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -142,38 +140,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/plan-devex-review/SKILL.md b/plan-devex-review/SKILL.md
index 954503d44..5fb64bad1 100644
--- a/plan-devex-review/SKILL.md
+++ b/plan-devex-review/SKILL.md
@@ -77,13 +77,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -147,38 +145,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/plan-eng-review/SKILL.md b/plan-eng-review/SKILL.md
index 04109060f..6a60f7e2b 100644
--- a/plan-eng-review/SKILL.md
+++ b/plan-eng-review/SKILL.md
@@ -75,13 +75,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -145,38 +143,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/plan-tune/SKILL.md b/plan-tune/SKILL.md
index 8d790987f..bffe95dd1 100644
--- a/plan-tune/SKILL.md
+++ b/plan-tune/SKILL.md
@@ -82,13 +82,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -152,38 +150,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/qa-only/SKILL.md b/qa-only/SKILL.md
index 02b5ff083..55f359532 100644
--- a/qa-only/SKILL.md
+++ b/qa-only/SKILL.md
@@ -72,13 +72,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -142,38 +140,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/qa/SKILL.md b/qa/SKILL.md
index 00dc0a114..b2ab09621 100644
--- a/qa/SKILL.md
+++ b/qa/SKILL.md
@@ -78,13 +78,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -148,38 +146,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/retro/SKILL.md b/retro/SKILL.md
index f6748151c..afb687aec 100644
--- a/retro/SKILL.md
+++ b/retro/SKILL.md
@@ -92,13 +92,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -162,38 +160,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/review/SKILL.md b/review/SKILL.md
index d9ce92f4a..dd6102b29 100644
--- a/review/SKILL.md
+++ b/review/SKILL.md
@@ -74,13 +74,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -144,38 +142,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/setup-deploy/SKILL.md b/setup-deploy/SKILL.md
index baeb30e96..0f5d5c7c7 100644
--- a/setup-deploy/SKILL.md
+++ b/setup-deploy/SKILL.md
@@ -73,13 +73,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -143,38 +141,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/setup-gbrain/SKILL.md b/setup-gbrain/SKILL.md
index 17a0bdb53..557f381e2 100644
--- a/setup-gbrain/SKILL.md
+++ b/setup-gbrain/SKILL.md
@@ -72,13 +72,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -142,38 +140,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/ship/SKILL.md b/ship/SKILL.md
index 27ff48c24..b1a61b877 100644
--- a/ship/SKILL.md
+++ b/ship/SKILL.md
@@ -74,13 +74,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -144,38 +142,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/skillify/SKILL.md b/skillify/SKILL.md
index 34e110084..0ccef072b 100644
--- a/skillify/SKILL.md
+++ b/skillify/SKILL.md
@@ -71,13 +71,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -141,38 +139,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/spec/SKILL.md b/spec/SKILL.md
index f3d8bd824..c3b2e3098 100644
--- a/spec/SKILL.md
+++ b/spec/SKILL.md
@@ -72,13 +72,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -142,38 +140,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/sync-gbrain/SKILL.md b/sync-gbrain/SKILL.md
index cacc0b74c..67e8079b3 100644
--- a/sync-gbrain/SKILL.md
+++ b/sync-gbrain/SKILL.md
@@ -73,13 +73,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -143,38 +141,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/test/fixtures/golden/claude-ship-SKILL.md b/test/fixtures/golden/claude-ship-SKILL.md
index 27ff48c24..b1a61b877 100644
--- a/test/fixtures/golden/claude-ship-SKILL.md
+++ b/test/fixtures/golden/claude-ship-SKILL.md
@@ -74,13 +74,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -144,38 +142,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`~/.claude/skills/gstack/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `~/.claude/skills/gstack/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/test/fixtures/golden/codex-ship-SKILL.md b/test/fixtures/golden/codex-ship-SKILL.md
index 3b28a1626..545a44812 100644
--- a/test/fixtures/golden/codex-ship-SKILL.md
+++ b/test/fixtures/golden/codex-ship-SKILL.md
@@ -60,13 +60,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -130,38 +128,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`$GSTACK_ROOT/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `$GSTACK_ROOT/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting
 
diff --git a/test/fixtures/golden/factory-ship-SKILL.md b/test/fixtures/golden/factory-ship-SKILL.md
index d48b6dd3a..b9f096cc8 100644
--- a/test/fixtures/golden/factory-ship-SKILL.md
+++ b/test/fixtures/golden/factory-ship-SKILL.md
@@ -62,13 +62,11 @@ If `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay
 
 ### Tool resolution (read first)
 
-"AskUserQuestion" can resolve to two tools at runtime: the **host MCP variant** (e.g. `mcp__conductor__AskUserQuestion` — appears in your tool list when the host registers it) or the **native** Claude Code tool.
+Branch on the skill-start STATUS lines, in this order:
 
-**Conductor rule (read before the MCP rule):** if `CONDUCTOR_SESSION: true` was echoed by the preamble, do NOT call AskUserQuestion at all — neither native nor any `mcp__*__AskUserQuestion` variant. Render EVERY decision brief as the **prose form** below and STOP. This is proactive, not a reaction to a failure: Conductor disables native AUQ and its MCP variant is flaky (it returns `[Tool result missing due to internal error]`), so prose is the reliable path. **Auto-decide preferences still apply first:** if a `[plan-tune auto-decide] <id> → <option>` result has already surfaced for a question, proceed with that option (no prose). Because in Conductor you go straight to prose without ever calling the tool, this auto-decide-first ordering is enforced HERE, not only by the PreToolUse hook. When you render a Conductor prose brief, also capture it with `bin/gstack-question-log` (the PostToolUse capture hook never fires on a prose path, so `/plan-tune` history/learning depends on this call).
-
-**Rule (non-Conductor):** if any `mcp__*__AskUserQuestion` variant is in your tool list, prefer it. Hosts may disable native AUQ via `--disallowedTools AskUserQuestion` (Conductor does, by default) and route through their MCP variant; calling native there silently fails. Same questions/options shape; same decision-brief format applies.
-
-If AskUserQuestion is unavailable (no variant in your tool list) OR a call to it fails, do NOT silently auto-decide or write the decision to the plan file as a substitute. Follow the **failure fallback** below.
+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:** a surfaced `[plan-tune auto-decide] <id> → <option>` result means proceed with that 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.
 
 ### When AskUserQuestion is unavailable or a call fails
 
@@ -132,38 +130,25 @@ Net line closes the tradeoff. Per-skill instructions may add stricter rules.
 ### Handling 5+ options — split, never drop
 
 AskUserQuestion caps every call at **4 options**. With 5+ real options, NEVER
-drop, merge, or silently defer one to fit. Pick a compliant shape:
+drop, merge, or silently defer one to fit: **batch into ≤4-groups** (coherent
+alternatives) or **split per-option** (independent scope items — the default
+when unsure): sequential `D<N>.k` calls, each with its ELI10, Recommendation,
+kind-note, and buckets **A) Include, B) Defer, C) Cut, D) Hold** (stop chain,
+discuss); a `D<N>.final` validates the assembled set; for N>6 fire a
+`D<N>.0` meta-question first. Split question_ids: `<skill>-split-<option-slug>`
+(kebab-case ASCII, ≤64 chars) — the runtime checker (`bin/gstack-question-preference`) refuses `never-ask` on
+any `*-split-*` id, so split chains are never AUTO_DECIDE-eligible: the
+user's option set is sacred.
 
-- **Batch into ≤4-groups** — for coherent alternatives (e.g. version bumps,
-  layout variants). One call, 5th surfaced only if first 4 don't fit.
-- **Split per-option** — for independent scope items (e.g. "ship E1..E6?").
-  Fire N sequential calls, one per option. Default to this when unsure.
+**Full rule + worked examples + Hold/dependency semantics:**
+`$GSTACK_ROOT/docs/askuserquestion-split.md`. Read on demand when N>4.
 
-Per-option call shape: `D<N>.k` header (e.g. D3.1..D3.5), ELI10 per option,
-Recommendation, kind-note (no completeness score — Include/Defer/Cut/Hold are
-decision actions), and 4 buckets:
-**A) Include**, **B) Defer**, **C) Cut**, **D) Hold** (stop chain, discuss).
-
-After the chain, fire `D<N>.final` to validate the assembled set (reprompt
-dependency conflicts) and confirm shipping it. Use `D<N>.revise-<k>` to
-revise one option without re-running the chain.
-
-For N>6, fire a `D<N>.0` meta-AskUserQuestion first (proceed / narrow / batch).
-
-question_ids for split chains: `<skill>-split-<option-slug>` (kebab-case ASCII,
-≤64 chars, `-2`/`-3` suffix on collision). The runtime checker
-(`bin/gstack-question-preference`) refuses `never-ask` on any `*-split-*` id,
-so split chains are never AUTO_DECIDE-eligible — the user's option set is sacred.
-
-**Full rule + worked examples + Hold/dependency semantics:** see
-`docs/askuserquestion-split.md` in the gstack repo. Read on demand when N>4.
-
-**Non-ASCII characters — write directly, never \u-escape.** When any string
-field contains Chinese (繁體/簡體), Japanese, Korean, or other non-ASCII text,
-emit the literal UTF-8 characters; never escape them as `\uXXXX` (the pipe is
-UTF-8 native, and manual escaping miscodes long CJK strings). Only `\n`,
-`\t`, `\"`, `\\` remain allowed. Full rationale + worked example: see
-`docs/askuserquestion-cjk.md`. Read on demand when a question contains CJK.
+**Non-ASCII characters — write directly, never \u-escape.** Emit literal
+UTF-8 for Chinese (繁體/簡體), Japanese, Korean, or any non-ASCII text; never
+`\uXXXX`-escape it (the pipe is UTF-8 native; manual escaping miscodes long
+CJK strings). Only `\n`, `\t`, `\"`, `\\` remain allowed. Full rationale +
+worked example: Read `$GSTACK_ROOT/docs/askuserquestion-cjk.md`
+on demand when a question contains CJK.
 
 ### Self-check before emitting