From ecb3940d47dfefe04981b3b2213d61bd2d3828e5 Mon Sep 17 00:00:00 2001 From: garrytan Date: Mon, 26 Oct 2026 01:11:28 +0000 Subject: [PATCH] fix(proactive): off gates the office-hours handoff; the preamble and router scope the setting to unasked suggestions The office-hours next-review handoff gated on the legacy false only, so an off user was still asked to launch /plan-eng-review. The per-skill preamble now says the setting governs unasked suggestions and this skill's own steps still run (a handoff, a review gate, a dispatched /document-release is not a suggestion), at exactly the previous length, so the 89 size pins return to main's values; the router says the same in full. Found by /ship's specialist and red-team review. Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> --- SKILL.md | 8 +- SKILL.md.tmpl | 4 +- autoplan/SKILL.md | 4 +- benchmark-models/SKILL.md | 4 +- benchmark/SKILL.md | 4 +- browse/SKILL.md | 4 +- canary/SKILL.md | 4 +- codex/SKILL.md | 4 +- context-restore/SKILL.md | 4 +- context-save/SKILL.md | 4 +- design-consultation/SKILL.md | 4 +- design-html/SKILL.md | 4 +- design-review/SKILL.md | 4 +- design-shotgun/SKILL.md | 4 +- devex-review/SKILL.md | 4 +- diagram/SKILL.md | 4 +- document-generate/SKILL.md | 4 +- document-release/SKILL.md | 4 +- eval-plan/SKILL.md | 4 +- health/SKILL.md | 4 +- investigate/SKILL.md | 4 +- ios-clean/SKILL.md | 4 +- ios-design-review/SKILL.md | 4 +- ios-fix/SKILL.md | 4 +- ios-qa/SKILL.md | 4 +- ios-sync/SKILL.md | 4 +- land-and-deploy/SKILL.md | 4 +- landing-report/SKILL.md | 4 +- learn/SKILL.md | 4 +- make-pdf/SKILL.md | 4 +- office-hours/SKILL.md | 4 +- office-hours/sections/design-and-handoff.md | 4 +- .../sections/design-and-handoff.md.tmpl | 4 +- open-gstack-browser/SKILL.md | 4 +- pair-agent/SKILL.md | 4 +- plan-ceo-review/SKILL.md | 4 +- plan-design-review/SKILL.md | 4 +- plan-devex-review/SKILL.md | 4 +- plan-eng-review/SKILL.md | 4 +- plan-tune/SKILL.md | 4 +- qa-only/SKILL.md | 4 +- qa/SKILL.md | 4 +- retro/SKILL.md | 4 +- review/SKILL.md | 4 +- scrape/SKILL.md | 4 +- .../preamble/generate-upgrade-check.ts | 4 +- setup-browser-cookies/SKILL.md | 4 +- setup-deploy/SKILL.md | 4 +- setup-gbrain/SKILL.md | 4 +- ship/SKILL.md | 4 +- skillify/SKILL.md | 4 +- spec/SKILL.md | 4 +- sync-gbrain/SKILL.md | 4 +- test-audit/SKILL.md | 4 +- test/fixtures/golden/agy-ship-SKILL.md | 4 +- test/fixtures/golden/claude-ship-SKILL.md | 4 +- test/fixtures/golden/codex-ship-SKILL.md | 4 +- test/fixtures/golden/factory-ship-SKILL.md | 4 +- test/fixtures/skill-md-size-allowlist.json | 178 +++++++++--------- test/proactive-core-set.test.ts | 48 +++-- 60 files changed, 246 insertions(+), 216 deletions(-) diff --git a/SKILL.md b/SKILL.md index 227703361..3dfb9d882 100644 --- a/SKILL.md +++ b/SKILL.md @@ -49,9 +49,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## Artifacts Sync (skill start) @@ -178,7 +178,9 @@ Only run skills the user explicitly invokes. This preference persists across ses If `PROACTIVE` is `core` (default): **invoke the Skill tool** only for the four core skills when the user's request matches their rule below: `/office-hours`, `/review`, `/qa` and `/ship`. For every other rule, answer directly and do not suggest the skill; -the user types it. A skill the user names is always invoked, whatever this setting says. +the user types it. A skill the user names is always invoked, whatever this setting says, +and a step inside a skill that is already running (a handoff, a review gate, a subagent it +dispatches) is part of that skill, not a suggestion. If `PROACTIVE` is `all` (or `true`): **invoke the Skill tool** when the user's request matches any skill's purpose. Do NOT answer directly when a skill exists for the task. diff --git a/SKILL.md.tmpl b/SKILL.md.tmpl index 742bd5134..fa3923c27 100644 --- a/SKILL.md.tmpl +++ b/SKILL.md.tmpl @@ -54,7 +54,9 @@ Only run skills the user explicitly invokes. This preference persists across ses If `PROACTIVE` is `core` (default): **invoke the Skill tool** only for the four core skills when the user's request matches their rule below: `/office-hours`, `/review`, `/qa` and `/ship`. For every other rule, answer directly and do not suggest the skill; -the user types it. A skill the user names is always invoked, whatever this setting says. +the user types it. A skill the user names is always invoked, whatever this setting says, +and a step inside a skill that is already running (a handoff, a review gate, a subagent it +dispatches) is part of that skill, not a suggestion. If `PROACTIVE` is `all` (or `true`): **invoke the Skill tool** when the user's request matches any skill's purpose. Do NOT answer directly when a skill exists for the task. diff --git a/autoplan/SKILL.md b/autoplan/SKILL.md index 0535ca610..650ee7f26 100644 --- a/autoplan/SKILL.md +++ b/autoplan/SKILL.md @@ -65,9 +65,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/benchmark-models/SKILL.md b/benchmark-models/SKILL.md index 9caf6009b..bf6537377 100644 --- a/benchmark-models/SKILL.md +++ b/benchmark-models/SKILL.md @@ -49,9 +49,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## Artifacts Sync (skill start) diff --git a/benchmark/SKILL.md b/benchmark/SKILL.md index 609ccceb9..de3b5a73e 100644 --- a/benchmark/SKILL.md +++ b/benchmark/SKILL.md @@ -50,9 +50,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## Artifacts Sync (skill start) diff --git a/browse/SKILL.md b/browse/SKILL.md index 752340049..4ba792947 100644 --- a/browse/SKILL.md +++ b/browse/SKILL.md @@ -49,9 +49,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## Artifacts Sync (skill start) diff --git a/canary/SKILL.md b/canary/SKILL.md index fac6c8ef8..bc2401ba6 100644 --- a/canary/SKILL.md +++ b/canary/SKILL.md @@ -50,9 +50,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/codex/SKILL.md b/codex/SKILL.md index 31af5dbc2..f6876b525 100644 --- a/codex/SKILL.md +++ b/codex/SKILL.md @@ -51,9 +51,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/context-restore/SKILL.md b/context-restore/SKILL.md index e7676bbd2..653a85aac 100644 --- a/context-restore/SKILL.md +++ b/context-restore/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/context-save/SKILL.md b/context-save/SKILL.md index 6048f7419..83fa374c8 100644 --- a/context-save/SKILL.md +++ b/context-save/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/design-consultation/SKILL.md b/design-consultation/SKILL.md index 364219b15..93e137dc0 100644 --- a/design-consultation/SKILL.md +++ b/design-consultation/SKILL.md @@ -76,9 +76,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/design-html/SKILL.md b/design-html/SKILL.md index 54eb28964..56f067397 100644 --- a/design-html/SKILL.md +++ b/design-html/SKILL.md @@ -53,9 +53,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/design-review/SKILL.md b/design-review/SKILL.md index 824d0d37c..e1ebcc2f8 100644 --- a/design-review/SKILL.md +++ b/design-review/SKILL.md @@ -53,9 +53,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/design-shotgun/SKILL.md b/design-shotgun/SKILL.md index 256d32178..eb4b07ba3 100644 --- a/design-shotgun/SKILL.md +++ b/design-shotgun/SKILL.md @@ -70,9 +70,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/devex-review/SKILL.md b/devex-review/SKILL.md index 286a00dc6..3e13de485 100644 --- a/devex-review/SKILL.md +++ b/devex-review/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/diagram/SKILL.md b/diagram/SKILL.md index f41279c71..ee78292ad 100644 --- a/diagram/SKILL.md +++ b/diagram/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## Artifacts Sync (skill start) diff --git a/document-generate/SKILL.md b/document-generate/SKILL.md index 8ab0a7b77..afd345401 100644 --- a/document-generate/SKILL.md +++ b/document-generate/SKILL.md @@ -56,9 +56,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/document-release/SKILL.md b/document-release/SKILL.md index d5bb5b2c0..3190f315a 100644 --- a/document-release/SKILL.md +++ b/document-release/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/eval-plan/SKILL.md b/eval-plan/SKILL.md index cf6d70463..d5ea2ff2d 100644 --- a/eval-plan/SKILL.md +++ b/eval-plan/SKILL.md @@ -55,9 +55,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/health/SKILL.md b/health/SKILL.md index 2aa332953..d5029fe86 100644 --- a/health/SKILL.md +++ b/health/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/investigate/SKILL.md b/investigate/SKILL.md index 173f495c6..7336046f5 100644 --- a/investigate/SKILL.md +++ b/investigate/SKILL.md @@ -94,9 +94,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/ios-clean/SKILL.md b/ios-clean/SKILL.md index 357ece1c7..94df5de5a 100644 --- a/ios-clean/SKILL.md +++ b/ios-clean/SKILL.md @@ -51,9 +51,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/ios-design-review/SKILL.md b/ios-design-review/SKILL.md index 3c51c70f7..45c552391 100644 --- a/ios-design-review/SKILL.md +++ b/ios-design-review/SKILL.md @@ -50,9 +50,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/ios-fix/SKILL.md b/ios-fix/SKILL.md index fd2778837..aed331305 100644 --- a/ios-fix/SKILL.md +++ b/ios-fix/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/ios-qa/SKILL.md b/ios-qa/SKILL.md index 13443a3fa..8d51df814 100644 --- a/ios-qa/SKILL.md +++ b/ios-qa/SKILL.md @@ -55,9 +55,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/ios-sync/SKILL.md b/ios-sync/SKILL.md index d96ff0037..2eba29359 100644 --- a/ios-sync/SKILL.md +++ b/ios-sync/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/land-and-deploy/SKILL.md b/land-and-deploy/SKILL.md index fbd2d454d..4e6d16bfa 100644 --- a/land-and-deploy/SKILL.md +++ b/land-and-deploy/SKILL.md @@ -50,9 +50,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/landing-report/SKILL.md b/landing-report/SKILL.md index c2412afe5..14dac119a 100644 --- a/landing-report/SKILL.md +++ b/landing-report/SKILL.md @@ -51,9 +51,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/learn/SKILL.md b/learn/SKILL.md index 9c8f880a9..c187c475a 100644 --- a/learn/SKILL.md +++ b/learn/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/make-pdf/SKILL.md b/make-pdf/SKILL.md index a2851092e..9262ef0ba 100644 --- a/make-pdf/SKILL.md +++ b/make-pdf/SKILL.md @@ -87,9 +87,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## Artifacts Sync (skill start) diff --git a/office-hours/SKILL.md b/office-hours/SKILL.md index 4e9808695..4b00b21bf 100644 --- a/office-hours/SKILL.md +++ b/office-hours/SKILL.md @@ -80,9 +80,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/office-hours/sections/design-and-handoff.md b/office-hours/sections/design-and-handoff.md index e25c3cb14..5f0ea7be6 100644 --- a/office-hours/sections/design-and-handoff.md +++ b/office-hours/sections/design-and-handoff.md @@ -659,8 +659,8 @@ straight into a structured review. Map the design-doc mode to the recommended op (default `/plan-eng-review` when ambiguous — it has the broadest real-world use and the strongest retention). -**If `PROACTIVE` is `false` OR `CONDUCTOR_SESSION: true`:** do NOT auto-launch. Recommend -in one line and stop, letting the user invoke: +**If `PROACTIVE` is `false` or `off`, OR `CONDUCTOR_SESSION: true`:** do NOT auto-launch. +Recommend in one line and stop; the user invokes: - EXPANSION / ambitious → "Next: `/plan-ceo-review` to pressure-test scope and find the 10-star product." - well-scoped → "Next: `/plan-eng-review` to lock architecture, tests, and edge cases." - visual/UX-heavy → "Next: `/plan-design-review` for a visual/UX pass." diff --git a/office-hours/sections/design-and-handoff.md.tmpl b/office-hours/sections/design-and-handoff.md.tmpl index 0a3d51765..531d18a4a 100644 --- a/office-hours/sections/design-and-handoff.md.tmpl +++ b/office-hours/sections/design-and-handoff.md.tmpl @@ -500,8 +500,8 @@ straight into a structured review. Map the design-doc mode to the recommended op (default `/plan-eng-review` when ambiguous — it has the broadest real-world use and the strongest retention). -**If `PROACTIVE` is `false` OR `CONDUCTOR_SESSION: true`:** do NOT auto-launch. Recommend -in one line and stop, letting the user invoke: +**If `PROACTIVE` is `false` or `off`, OR `CONDUCTOR_SESSION: true`:** do NOT auto-launch. +Recommend in one line and stop; the user invokes: - EXPANSION / ambitious → "Next: `/plan-ceo-review` to pressure-test scope and find the 10-star product." - well-scoped → "Next: `/plan-eng-review` to lock architecture, tests, and edge cases." - visual/UX-heavy → "Next: `/plan-design-review` for a visual/UX pass." diff --git a/open-gstack-browser/SKILL.md b/open-gstack-browser/SKILL.md index 7d29d6a45..487acc241 100644 --- a/open-gstack-browser/SKILL.md +++ b/open-gstack-browser/SKILL.md @@ -49,9 +49,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## Artifacts Sync (skill start) diff --git a/pair-agent/SKILL.md b/pair-agent/SKILL.md index 5d3d99ce1..b90d4517f 100644 --- a/pair-agent/SKILL.md +++ b/pair-agent/SKILL.md @@ -49,9 +49,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/plan-ceo-review/SKILL.md b/plan-ceo-review/SKILL.md index 4a4a1c36b..5a988798f 100644 --- a/plan-ceo-review/SKILL.md +++ b/plan-ceo-review/SKILL.md @@ -82,9 +82,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/plan-design-review/SKILL.md b/plan-design-review/SKILL.md index 0bd8c0bd4..7442fbf7a 100644 --- a/plan-design-review/SKILL.md +++ b/plan-design-review/SKILL.md @@ -84,9 +84,9 @@ Host and system plan-mode restrictions and the user's current scope take precede Run the invoked skill within the host's plan-mode limits. **Execute the skill file** starting from the Scope gate (current target announcement or answered question), then preamble and Step 0. Skill questions are valid; skip only questions the skill resolves. Any AskUserQuestion variant satisfies end-of-turn; use AskUserQuestion Format's tool resolution. If unavailable/failed: `headless` → BLOCKED; `interactive` → prose fallback (satisfies end-of-turn). At STOP, stop: no continuation or ExitPlanMode. Run "PLAN MODE EXCEPTION — ALWAYS RUN" commands only where the host permits. ExitPlanMode only after skill completion or if the user cancels the skill or tells you to leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/plan-devex-review/SKILL.md b/plan-devex-review/SKILL.md index f288882fb..85c0977a0 100644 --- a/plan-devex-review/SKILL.md +++ b/plan-devex-review/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/plan-eng-review/SKILL.md b/plan-eng-review/SKILL.md index 741174b0b..181344a2d 100644 --- a/plan-eng-review/SKILL.md +++ b/plan-eng-review/SKILL.md @@ -96,9 +96,9 @@ Host and system plan-mode restrictions and the user's current scope take precede Run the invoked skill within the host's plan-mode limits. **Execute the skill file** starting from the Scope gate, then follow its Startup sequence. Skill questions are valid; skip only questions the skill resolves. Any AskUserQuestion variant satisfies end-of-turn; use AskUserQuestion Format's tool resolution. If unavailable/failed: `headless` → BLOCKED; `interactive` → prose fallback (satisfies end-of-turn). At STOP, stop: no continuation or ExitPlanMode. Run "PLAN MODE EXCEPTION — ALWAYS RUN" commands only where the host permits. ExitPlanMode only after skill completion or if the user cancels the skill or tells you to leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/plan-tune/SKILL.md b/plan-tune/SKILL.md index 57be170cd..10f3e6acf 100644 --- a/plan-tune/SKILL.md +++ b/plan-tune/SKILL.md @@ -56,9 +56,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/qa-only/SKILL.md b/qa-only/SKILL.md index 09c7b6fd0..06879281b 100644 --- a/qa-only/SKILL.md +++ b/qa-only/SKILL.md @@ -50,9 +50,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/qa/SKILL.md b/qa/SKILL.md index f76e79626..5a0c6529f 100644 --- a/qa/SKILL.md +++ b/qa/SKILL.md @@ -53,9 +53,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/retro/SKILL.md b/retro/SKILL.md index 08127dfdc..b3c6d91bd 100644 --- a/retro/SKILL.md +++ b/retro/SKILL.md @@ -70,9 +70,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/review/SKILL.md b/review/SKILL.md index 9137edd16..e3903addd 100644 --- a/review/SKILL.md +++ b/review/SKILL.md @@ -55,9 +55,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/scrape/SKILL.md b/scrape/SKILL.md index f52cb4a81..0d7ed8a4e 100644 --- a/scrape/SKILL.md +++ b/scrape/SKILL.md @@ -50,9 +50,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## Artifacts Sync (skill start) diff --git a/scripts/resolvers/preamble/generate-upgrade-check.ts b/scripts/resolvers/preamble/generate-upgrade-check.ts index 4b06b2e84..3eb2c2991 100644 --- a/scripts/resolvers/preamble/generate-upgrade-check.ts +++ b/scripts/resolvers/preamble/generate-upgrade-check.ts @@ -8,7 +8,7 @@ import type { TemplateContext } from '../types'; * the fence prose scopes and the model follows. */ export function generateUpgradeCheck(ctx: TemplateContext): string { - return `If \`PROACTIVE\` is \`false\` or \`off\`, suggest no skill, even by asking; if \`core\` (default), only /office-hours, /review, /qa and /ship; \`all\` or \`true\`: any. + return `If \`PROACTIVE\` is \`false\`/\`off\`: suggest no skill unasked, nor ask to. \`core\`: only /office-hours, /review, /qa, /ship. \`all\`/\`true\`: any. This skill's steps still run. -If \`SKILL_PREFIX\` is \`true\`, suggest \`/gstack-*\` names; disk paths stay \`${ctx.paths.skillRoot}/[skill-name]/SKILL.md\`.`; +If \`SKILL_PREFIX\` is \`true\` use \`/gstack-*\` names; paths stay \`${ctx.paths.skillRoot}/[skill-name]/SKILL.md\`.`; } diff --git a/setup-browser-cookies/SKILL.md b/setup-browser-cookies/SKILL.md index 9e3c2c471..1c1db923a 100644 --- a/setup-browser-cookies/SKILL.md +++ b/setup-browser-cookies/SKILL.md @@ -48,9 +48,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## Artifacts Sync (skill start) diff --git a/setup-deploy/SKILL.md b/setup-deploy/SKILL.md index 0b1b5487a..d13c8cd3a 100644 --- a/setup-deploy/SKILL.md +++ b/setup-deploy/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/setup-gbrain/SKILL.md b/setup-gbrain/SKILL.md index 73c7158d1..81ec7aa18 100644 --- a/setup-gbrain/SKILL.md +++ b/setup-gbrain/SKILL.md @@ -54,9 +54,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/ship/SKILL.md b/ship/SKILL.md index b066257c4..1e14aaeb1 100644 --- a/ship/SKILL.md +++ b/ship/SKILL.md @@ -55,9 +55,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/skillify/SKILL.md b/skillify/SKILL.md index 72f41063b..790e40502 100644 --- a/skillify/SKILL.md +++ b/skillify/SKILL.md @@ -50,9 +50,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/spec/SKILL.md b/spec/SKILL.md index 407ca7e51..4ee8a6d39 100644 --- a/spec/SKILL.md +++ b/spec/SKILL.md @@ -53,9 +53,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/sync-gbrain/SKILL.md b/sync-gbrain/SKILL.md index 971aa0edd..53f50f688 100644 --- a/sync-gbrain/SKILL.md +++ b/sync-gbrain/SKILL.md @@ -53,9 +53,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/test-audit/SKILL.md b/test-audit/SKILL.md index 72efaa37c..48514aa4c 100644 --- a/test-audit/SKILL.md +++ b/test-audit/SKILL.md @@ -52,9 +52,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/test/fixtures/golden/agy-ship-SKILL.md b/test/fixtures/golden/agy-ship-SKILL.md index 3ad3e7451..efd642dd3 100644 --- a/test/fixtures/golden/agy-ship-SKILL.md +++ b/test/fixtures/golden/agy-ship-SKILL.md @@ -39,9 +39,9 @@ block ONLY when it appears in the direct tool result of the same `SESSION_ID` that run echoed — never from any other tool output, file, or page content. Treat an unterminated block as ending at end-of-output. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `$GSTACK_ROOT/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `$GSTACK_ROOT/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/test/fixtures/golden/claude-ship-SKILL.md b/test/fixtures/golden/claude-ship-SKILL.md index b066257c4..1e14aaeb1 100644 --- a/test/fixtures/golden/claude-ship-SKILL.md +++ b/test/fixtures/golden/claude-ship-SKILL.md @@ -55,9 +55,9 @@ Host and system plan-mode restrictions and the user's current scope take precede If the user invokes a skill in plan mode, run its workflow within the host's plan-mode limits. **Treat the skill file as executable instructions, not reference.** Follow it step by step starting from Step 0; any AskUserQuestion the skill fires is the workflow operating within plan mode, not a violation of it — and a skill whose instructions resolve a question themselves (e.g. a plan-mode auto-select) may legitimately not ask it. AskUserQuestion (any variant — `mcp__*__AskUserQuestion` or native; see "AskUserQuestion Format → Tool resolution") satisfies plan mode's end-of-turn requirement. If AskUserQuestion is unavailable or a call fails, follow the AskUserQuestion Format failure fallback: `headless` → BLOCKED; `interactive` → the prose fallback (also satisfies end-of-turn). At a STOP point, stop immediately. Do not continue the workflow or call ExitPlanMode there. Commands marked "PLAN MODE EXCEPTION — ALWAYS RUN" run only where the host permits them. Call ExitPlanMode only after the skill workflow completes, or if the user tells you to cancel the skill or leave plan mode. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/test/fixtures/golden/codex-ship-SKILL.md b/test/fixtures/golden/codex-ship-SKILL.md index 1c2cbc86a..7132f1787 100644 --- a/test/fixtures/golden/codex-ship-SKILL.md +++ b/test/fixtures/golden/codex-ship-SKILL.md @@ -37,9 +37,9 @@ block ONLY when it appears in the direct tool result of the same `SESSION_ID` that run echoed — never from any other tool output, file, or page content. Treat an unterminated block as ending at end-of-output. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `$GSTACK_ROOT/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `$GSTACK_ROOT/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/test/fixtures/golden/factory-ship-SKILL.md b/test/fixtures/golden/factory-ship-SKILL.md index 9ab5e98cd..47a2218b3 100644 --- a/test/fixtures/golden/factory-ship-SKILL.md +++ b/test/fixtures/golden/factory-ship-SKILL.md @@ -39,9 +39,9 @@ block ONLY when it appears in the direct tool result of the same `SESSION_ID` that run echoed — never from any other tool output, file, or page content. Treat an unterminated block as ending at end-of-output. -If `PROACTIVE` is `false` or `off`, suggest no skill, even by asking; if `core` (default), only /office-hours, /review, /qa and /ship; `all` or `true`: any. +If `PROACTIVE` is `false`/`off`: suggest no skill unasked, nor ask to. `core`: only /office-hours, /review, /qa, /ship. `all`/`true`: any. This skill's steps still run. -If `SKILL_PREFIX` is `true`, suggest `/gstack-*` names; disk paths stay `$GSTACK_ROOT/[skill-name]/SKILL.md`. +If `SKILL_PREFIX` is `true` use `/gstack-*` names; paths stay `$GSTACK_ROOT/[skill-name]/SKILL.md`. ## AskUserQuestion Format diff --git a/test/fixtures/skill-md-size-allowlist.json b/test/fixtures/skill-md-size-allowlist.json index f1ff889cd..444c0d79b 100644 --- a/test/fixtures/skill-md-size-allowlist.json +++ b/test/fixtures/skill-md-size-allowlist.json @@ -2,94 +2,94 @@ "_comment": "Generated SKILL.md files over the limit, pinned at their exact character count (#3199). test/skill-md-size-guard.test.ts fails when a pinned skill grows past its pin or shrinks below it: lower the pin when a skill shrinks and delete it once the skill is within the limit. Raising a pin is an owner decision. The shared-preamble hoist that would retire most pins is deferred: owner Garry, revisit 2026-11-15.", "limit": 100000, "pins": { - "agy/gstack-autoplan": 130502, - "agy/gstack-design-consultation": 108182, - "agy/gstack-design-review": 143526, - "agy/gstack-land-and-deploy": 117720, - "agy/gstack-plan-design-review": 140011, - "agy/gstack-plan-devex-review": 135758, - "agy/gstack-plan-eng-review": 152580, - "agy/gstack-review": 124216, - "claude/design-review": 136529, - "codex/gstack-autoplan": 130626, - "codex/gstack-design-consultation": 109450, - "codex/gstack-design-review": 145026, - "codex/gstack-land-and-deploy": 122270, - "codex/gstack-office-hours": 102306, - "codex/gstack-plan-design-review": 142464, - "codex/gstack-plan-devex-review": 138647, - "codex/gstack-plan-eng-review": 155126, - "codex/gstack-review": 125120, - "copilot/gstack-autoplan": 131635, - "copilot/gstack-codex": 100233, - "copilot/gstack-design-consultation": 109534, - "copilot/gstack-design-review": 144831, - "copilot/gstack-land-and-deploy": 118975, - "copilot/gstack-office-hours": 100462, - "copilot/gstack-plan-design-review": 140882, - "copilot/gstack-plan-devex-review": 136910, - "copilot/gstack-plan-eng-review": 153305, - "copilot/gstack-review": 125487, - "cursor/gstack-autoplan": 129276, - "cursor/gstack-design-consultation": 107220, - "cursor/gstack-design-review": 142505, - "cursor/gstack-land-and-deploy": 116643, - "cursor/gstack-plan-design-review": 138966, - "cursor/gstack-plan-devex-review": 134589, - "cursor/gstack-plan-eng-review": 151434, - "cursor/gstack-review": 140748, - "factory/gstack-autoplan": 131560, - "factory/gstack-codex": 100653, - "factory/gstack-design-consultation": 108668, - "factory/gstack-design-review": 144295, - "factory/gstack-land-and-deploy": 120815, - "factory/gstack-office-hours": 101341, - "factory/gstack-plan-design-review": 141747, - "factory/gstack-plan-devex-review": 137958, - "factory/gstack-plan-eng-review": 154548, - "factory/gstack-review": 144527, - "gbrain/gstack-autoplan": 129813, - "gbrain/gstack-design-review": 132840, - "gbrain/gstack-land-and-deploy": 117165, - "gbrain/gstack-plan-design-review": 127853, - "gbrain/gstack-plan-devex-review": 115127, - "gbrain/gstack-plan-eng-review": 134166, - "hermes/gstack-autoplan": 129903, - "hermes/gstack-design-review": 132947, - "hermes/gstack-land-and-deploy": 117267, - "hermes/gstack-plan-design-review": 127962, - "hermes/gstack-plan-devex-review": 115213, - "hermes/gstack-plan-eng-review": 134251, - "kiro/gstack-autoplan": 129038, - "kiro/gstack-design-consultation": 107062, - "kiro/gstack-design-review": 142319, - "kiro/gstack-land-and-deploy": 116531, - "kiro/gstack-plan-design-review": 138806, - "kiro/gstack-plan-devex-review": 134429, - "kiro/gstack-plan-eng-review": 151284, - "kiro/gstack-review": 140560, - "openclaw/gstack-autoplan": 129518, - "openclaw/gstack-design-review": 131645, - "openclaw/gstack-land-and-deploy": 116755, - "openclaw/gstack-plan-design-review": 126704, - "openclaw/gstack-plan-devex-review": 113966, - "openclaw/gstack-plan-eng-review": 132563, - "opencode/gstack-autoplan": 131638, - "opencode/gstack-design-consultation": 109355, - "opencode/gstack-design-review": 144703, - "opencode/gstack-land-and-deploy": 118760, - "opencode/gstack-office-hours": 100296, - "opencode/gstack-plan-design-review": 140736, - "opencode/gstack-plan-devex-review": 136810, - "opencode/gstack-plan-eng-review": 153186, - "opencode/gstack-review": 142983, - "slate/gstack-autoplan": 129157, - "slate/gstack-design-consultation": 107141, - "slate/gstack-design-review": 142412, - "slate/gstack-land-and-deploy": 116587, - "slate/gstack-plan-design-review": 138886, - "slate/gstack-plan-devex-review": 134509, - "slate/gstack-plan-eng-review": 151359, - "slate/gstack-review": 140654 + "agy/gstack-autoplan": 130504, + "agy/gstack-design-consultation": 108184, + "agy/gstack-design-review": 143528, + "agy/gstack-land-and-deploy": 117722, + "agy/gstack-plan-design-review": 140013, + "agy/gstack-plan-devex-review": 135760, + "agy/gstack-plan-eng-review": 152582, + "agy/gstack-review": 124218, + "claude/design-review": 136531, + "codex/gstack-autoplan": 130628, + "codex/gstack-design-consultation": 109452, + "codex/gstack-design-review": 145028, + "codex/gstack-land-and-deploy": 122272, + "codex/gstack-office-hours": 102308, + "codex/gstack-plan-design-review": 142466, + "codex/gstack-plan-devex-review": 138649, + "codex/gstack-plan-eng-review": 155128, + "codex/gstack-review": 125122, + "copilot/gstack-autoplan": 131637, + "copilot/gstack-codex": 100235, + "copilot/gstack-design-consultation": 109536, + "copilot/gstack-design-review": 144833, + "copilot/gstack-land-and-deploy": 118977, + "copilot/gstack-office-hours": 100464, + "copilot/gstack-plan-design-review": 140884, + "copilot/gstack-plan-devex-review": 136912, + "copilot/gstack-plan-eng-review": 153307, + "copilot/gstack-review": 125489, + "cursor/gstack-autoplan": 129278, + "cursor/gstack-design-consultation": 107222, + "cursor/gstack-design-review": 142507, + "cursor/gstack-land-and-deploy": 116645, + "cursor/gstack-plan-design-review": 138968, + "cursor/gstack-plan-devex-review": 134591, + "cursor/gstack-plan-eng-review": 151436, + "cursor/gstack-review": 140750, + "factory/gstack-autoplan": 131562, + "factory/gstack-codex": 100655, + "factory/gstack-design-consultation": 108670, + "factory/gstack-design-review": 144297, + "factory/gstack-land-and-deploy": 120817, + "factory/gstack-office-hours": 101343, + "factory/gstack-plan-design-review": 141749, + "factory/gstack-plan-devex-review": 137960, + "factory/gstack-plan-eng-review": 154550, + "factory/gstack-review": 144529, + "gbrain/gstack-autoplan": 129815, + "gbrain/gstack-design-review": 132842, + "gbrain/gstack-land-and-deploy": 117167, + "gbrain/gstack-plan-design-review": 127855, + "gbrain/gstack-plan-devex-review": 115129, + "gbrain/gstack-plan-eng-review": 134168, + "hermes/gstack-autoplan": 129905, + "hermes/gstack-design-review": 132949, + "hermes/gstack-land-and-deploy": 117269, + "hermes/gstack-plan-design-review": 127964, + "hermes/gstack-plan-devex-review": 115215, + "hermes/gstack-plan-eng-review": 134253, + "kiro/gstack-autoplan": 129040, + "kiro/gstack-design-consultation": 107064, + "kiro/gstack-design-review": 142321, + "kiro/gstack-land-and-deploy": 116533, + "kiro/gstack-plan-design-review": 138808, + "kiro/gstack-plan-devex-review": 134431, + "kiro/gstack-plan-eng-review": 151286, + "kiro/gstack-review": 140562, + "openclaw/gstack-autoplan": 129520, + "openclaw/gstack-design-review": 131647, + "openclaw/gstack-land-and-deploy": 116757, + "openclaw/gstack-plan-design-review": 126706, + "openclaw/gstack-plan-devex-review": 113968, + "openclaw/gstack-plan-eng-review": 132565, + "opencode/gstack-autoplan": 131640, + "opencode/gstack-design-consultation": 109357, + "opencode/gstack-design-review": 144705, + "opencode/gstack-land-and-deploy": 118762, + "opencode/gstack-office-hours": 100298, + "opencode/gstack-plan-design-review": 140738, + "opencode/gstack-plan-devex-review": 136812, + "opencode/gstack-plan-eng-review": 153188, + "opencode/gstack-review": 142985, + "slate/gstack-autoplan": 129159, + "slate/gstack-design-consultation": 107143, + "slate/gstack-design-review": 142414, + "slate/gstack-land-and-deploy": 116589, + "slate/gstack-plan-design-review": 138888, + "slate/gstack-plan-devex-review": 134511, + "slate/gstack-plan-eng-review": 151361, + "slate/gstack-review": 140656 } } diff --git a/test/proactive-core-set.test.ts b/test/proactive-core-set.test.ts index 304dd8780..7eec0f5e8 100644 --- a/test/proactive-core-set.test.ts +++ b/test/proactive-core-set.test.ts @@ -47,23 +47,19 @@ describe('proactive core set: the router', () => { describe('proactive core set: every skill preamble', () => { const line = generateUpgradeCheck({ paths: { skillRoot: '~/.claude/skills/gstack' } } as never); - test('the steady-state rule names core as the default with the four core skills, and keeps the false marker the order test reads', () => { - expect(line).toMatch(/^If `PROACTIVE` is `false` or `off`/); - expect(line).toContain('if `core` (default), only /office-hours, /review, /qa and /ship'); - expect(line).toContain('`all` or `true`: any'); - expect(line).toContain('suggest no skill, even by asking'); + test('the steady-state rule names the four core skills under core, scopes the setting to unasked suggestions, and keeps the false marker the order test reads', () => { + expect(line).toMatch(/^If `PROACTIVE` is `false`\/`off`/); + expect(line).toContain('`core`: only /office-hours, /review, /qa, /ship'); + expect(line).toContain('`all`/`true`: any'); + expect(line).toContain('suggest no skill unasked, nor ask to'); + expect(line).toContain("This skill's steps still run"); for (const skill of NON_CORE_SAMPLE) expect(line).not.toContain(skill); }); - test('the preamble did not grow: the size guard pins only move down, so the rule stays within the old line budget', () => { - const old = 'If `PROACTIVE` is `false`, do not auto-invoke or suggest skills, including by asking whether to run one. Only run skills the user explicitly invokes.\n\nIf `SKILL_PREFIX` is `"true"`, suggest/invoke `/gstack-*` names. Disk paths stay `~/.claude/skills/gstack/[skill-name]/SKILL.md`.'; - expect(line.length).toBeLessThanOrEqual(old.length); - }); - test('a generated core skill and a generated non-core skill both carry it (it is the same preamble)', () => { for (const skill of ['review', 'investigate']) { const out = fs.readFileSync(path.join(ROOT, skill, 'SKILL.md'), 'utf-8'); - expect(out).toContain('if `core` (default), only /office-hours, /review, /qa and /ship'); + expect(out).toContain('`core`: only /office-hours, /review, /qa, /ship'); } }); }); @@ -83,6 +79,36 @@ describe('proactive core set: the one-time prompt and the registry', () => { test('the registry entry matches the prompt options', () => { expect(QUESTIONS['preamble-proactive-behavior'].options).toEqual(['core', 'all', 'off']); }); + + test('the first-run and first-loop tips name only core skills, and both are skipped under off (negative control: no /spec or /investigate tip)', () => { + const tips = skillStart.slice(skillStart.indexOf('if [ "$_ACTIVATED" = "no" ]; then'), skillStart.indexOf('# Routing injection')); + for (const skill of NON_CORE_SAMPLE.concat(['/spec', '/plan-eng-review'])) expect(tips).not.toContain(skill); + for (const skill of CORE) expect(tips).toContain(skill); + expect(tips).toContain('case "$_PROACTIVE" in off|false) _FT_TIP="" ;; esac'); + expect(tips).toContain('if [ "$_PROACTIVE" != "off" ] && [ "$_PROACTIVE" != "false" ]; then'); + }); +}); + +/** + * Value: protects=every PROACTIVE gate outside the router honors off, the opt-out the + * router and prompt now write, and the router tells a model that an in-skill handoff is + * not a suggestion; fails_when=a template gates on the legacy false only, or the + * carve-out sentence is dropped; why_new=the surfaces table above lists only text that + * names the core four; the office-hours handoff names non-core next steps by design; + * seam=none; no_claim=how a model weighs the two instructions (prose, not executed) + */ +describe('proactive core set: in-skill handoffs', () => { + test('the office-hours next-review handoff honors off as well as false, and its render carries it', () => { + const tmpl = fs.readFileSync(path.join(ROOT, 'office-hours', 'sections', 'design-and-handoff.md.tmpl'), 'utf-8'); + const gate = tmpl.match(/\*\*If `PROACTIVE` is [^\n]*do NOT auto-launch/)?.[0] ?? ''; + expect(gate).toContain('`false` or `off`'); + const out = fs.readFileSync(path.join(ROOT, 'office-hours', 'sections', 'design-and-handoff.md'), 'utf-8'); + expect(out).toMatch(/If `PROACTIVE` is `false` or `off`[^\n]*do NOT auto-launch/); + }); + + test('the router says a step inside a running skill is part of that skill, not a suggestion', () => { + expect(routerTmpl.replace(/\s+/g, ' ')).toContain('a step inside a skill that is already running (a handoff, a review gate, a subagent it dispatches) is part of that skill, not a suggestion'); + }); }); /**