diff --git a/SKILL.md b/SKILL.md index 21828cd6..7b489e99 100644 --- a/SKILL.md +++ b/SKILL.md @@ -405,80 +405,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). If `PROACTIVE` is `false`: do NOT proactively invoke or suggest other gstack skills during this session. Only run skills the user explicitly invokes. This preference persists across diff --git a/autoplan/SKILL.md b/autoplan/SKILL.md index 2c27f972..a0b60a7f 100644 --- a/autoplan/SKILL.md +++ b/autoplan/SKILL.md @@ -614,80 +614,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch diff --git a/benchmark/SKILL.md b/benchmark/SKILL.md index 562baea8..699b3746 100644 --- a/benchmark/SKILL.md +++ b/benchmark/SKILL.md @@ -407,80 +407,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## SETUP (run this check BEFORE any browse command) diff --git a/browse/SKILL.md b/browse/SKILL.md index 418413bf..c4035f2c 100644 --- a/browse/SKILL.md +++ b/browse/SKILL.md @@ -406,80 +406,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # browse: QA Testing & Dogfooding diff --git a/canary/SKILL.md b/canary/SKILL.md index 40c8cedf..c82d122c 100644 --- a/canary/SKILL.md +++ b/canary/SKILL.md @@ -588,80 +588,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## SETUP (run this check BEFORE any browse command) diff --git a/checkpoint/SKILL.md b/checkpoint/SKILL.md index b6d12905..bc3cd7d2 100644 --- a/checkpoint/SKILL.md +++ b/checkpoint/SKILL.md @@ -591,80 +591,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # /checkpoint — Save and Resume Working State diff --git a/codex/SKILL.md b/codex/SKILL.md index 11d221f6..bd7f83e7 100644 --- a/codex/SKILL.md +++ b/codex/SKILL.md @@ -608,80 +608,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch diff --git a/cso/SKILL.md b/cso/SKILL.md index d4efc250..98fa8b7e 100644 --- a/cso/SKILL.md +++ b/cso/SKILL.md @@ -593,80 +593,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). diff --git a/design-consultation/SKILL.md b/design-consultation/SKILL.md index ee3218d6..072a0dfb 100644 --- a/design-consultation/SKILL.md +++ b/design-consultation/SKILL.md @@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # /design-consultation: Your Design System, Built Together diff --git a/design-html/SKILL.md b/design-html/SKILL.md index bf3243b8..dabcee7b 100644 --- a/design-html/SKILL.md +++ b/design-html/SKILL.md @@ -595,80 +595,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # /design-html: Pretext-Native HTML Engine diff --git a/design-review/SKILL.md b/design-review/SKILL.md index 58815ab5..5860d3cc 100644 --- a/design-review/SKILL.md +++ b/design-review/SKILL.md @@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). diff --git a/design-shotgun/SKILL.md b/design-shotgun/SKILL.md index b191e2cc..ad8e490d 100644 --- a/design-shotgun/SKILL.md +++ b/design-shotgun/SKILL.md @@ -590,80 +590,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # /design-shotgun: Visual Design Exploration diff --git a/devex-review/SKILL.md b/devex-review/SKILL.md index dc573b6e..72b4aa51 100644 --- a/devex-review/SKILL.md +++ b/devex-review/SKILL.md @@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch diff --git a/document-release/SKILL.md b/document-release/SKILL.md index 80ca9a3a..1671dce3 100644 --- a/document-release/SKILL.md +++ b/document-release/SKILL.md @@ -590,80 +590,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch diff --git a/health/SKILL.md b/health/SKILL.md index 62f5d726..d82f8a23 100644 --- a/health/SKILL.md +++ b/health/SKILL.md @@ -590,80 +590,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # /health -- Code Quality Dashboard diff --git a/investigate/SKILL.md b/investigate/SKILL.md index 2555753b..f0fe3ad9 100644 --- a/investigate/SKILL.md +++ b/investigate/SKILL.md @@ -607,80 +607,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # Systematic Debugging diff --git a/land-and-deploy/SKILL.md b/land-and-deploy/SKILL.md index cc2be610..85c68d58 100644 --- a/land-and-deploy/SKILL.md +++ b/land-and-deploy/SKILL.md @@ -605,80 +605,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## SETUP (run this check BEFORE any browse command) diff --git a/learn/SKILL.md b/learn/SKILL.md index d19e8847..0f1065b9 100644 --- a/learn/SKILL.md +++ b/learn/SKILL.md @@ -590,80 +590,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # Project Learnings Manager diff --git a/office-hours/SKILL.md b/office-hours/SKILL.md index b84e200e..2c540399 100644 --- a/office-hours/SKILL.md +++ b/office-hours/SKILL.md @@ -616,80 +616,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## SETUP (run this check BEFORE any browse command) diff --git a/open-gstack-browser/SKILL.md b/open-gstack-browser/SKILL.md index 07ca1532..04084035 100644 --- a/open-gstack-browser/SKILL.md +++ b/open-gstack-browser/SKILL.md @@ -605,80 +605,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # /open-gstack-browser — Launch GStack Browser diff --git a/pair-agent/SKILL.md b/pair-agent/SKILL.md index ea051c6f..27bbd708 100644 --- a/pair-agent/SKILL.md +++ b/pair-agent/SKILL.md @@ -606,80 +606,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # /pair-agent — Share Your Browser With Another AI Agent diff --git a/plan-ceo-review/SKILL.md b/plan-ceo-review/SKILL.md index edb289c0..deabcdd5 100644 --- a/plan-ceo-review/SKILL.md +++ b/plan-ceo-review/SKILL.md @@ -612,80 +612,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch diff --git a/plan-design-review/SKILL.md b/plan-design-review/SKILL.md index 6cebe183..9df91abe 100644 --- a/plan-design-review/SKILL.md +++ b/plan-design-review/SKILL.md @@ -609,80 +609,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch diff --git a/plan-devex-review/SKILL.md b/plan-devex-review/SKILL.md index c30bf216..2d9b6984 100644 --- a/plan-devex-review/SKILL.md +++ b/plan-devex-review/SKILL.md @@ -613,80 +613,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch diff --git a/plan-eng-review/SKILL.md b/plan-eng-review/SKILL.md index 7c03749f..bcd244ad 100644 --- a/plan-eng-review/SKILL.md +++ b/plan-eng-review/SKILL.md @@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). @@ -1034,47 +983,25 @@ When uncertain whether a change is a regression, err on the side of writing the Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths: ``` -CODE PATH COVERAGE -=========================== -[+] src/services/billing.ts - │ - ├── processPayment() - │ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 - │ ├── [GAP] Network timeout — NO TEST - │ └── [GAP] Invalid currency — NO TEST - │ - └── refundPayment() - ├── [★★ TESTED] Full refund — billing.test.ts:89 - └── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101 +CODE PATHS USER FLOWS +[+] src/services/billing.ts [+] Payment checkout + ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 + │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit + │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment + │ └── [GAP] Invalid currency + └── refundPayment() [+] Error states + ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message + └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX -USER FLOW COVERAGE -=========================== -[+] Payment checkout flow - │ - ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 - ├── [GAP] [→E2E] Double-click submit — needs E2E, not just unit - ├── [GAP] Navigate away during payment — unit test sufficient - └── [★ TESTED] Form validation errors (checks render only) — checkout.test.ts:40 +LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test -[+] Error states - │ - ├── [★★ TESTED] Card declined message — billing.test.ts:58 - ├── [GAP] Network timeout UX (what does user see?) — NO TEST - └── [GAP] Empty cart submission — NO TEST - -[+] LLM integration - │ - └── [GAP] [→EVAL] Prompt template change — needs eval test - -───────────────────────────────── -COVERAGE: 5/13 paths tested (38%) - Code paths: 3/5 (60%) - User flows: 2/8 (25%) -QUALITY: ★★★: 2 ★★: 2 ★: 1 -GAPS: 8 paths need tests (2 need E2E, 1 needs eval) -───────────────────────────────── +COVERAGE: 5/13 paths tested (38%) | Code paths: 3/5 (60%) | User flows: 2/8 (25%) +QUALITY: ★★★:2 ★★:2 ★:1 | GAPS: 8 (2 E2E, 1 eval) ``` +Legend: ★★★ behavior + edge + error | ★★ happy path | ★ smoke check +[→E2E] = needs integration test | [→EVAL] = needs LLM eval + **Fast path:** All paths covered → "Test review: All new code paths have test coverage ✓" Continue. **Step 5. Add missing tests to the plan:** diff --git a/qa-only/SKILL.md b/qa-only/SKILL.md index bbe1c3d8..466ed7da 100644 --- a/qa-only/SKILL.md +++ b/qa-only/SKILL.md @@ -607,80 +607,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # /qa-only: Report-Only QA Testing diff --git a/qa/SKILL.md b/qa/SKILL.md index da718548..aa51744e 100644 --- a/qa/SKILL.md +++ b/qa/SKILL.md @@ -613,80 +613,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch diff --git a/retro/SKILL.md b/retro/SKILL.md index 5c576250..2d4c0d62 100644 --- a/retro/SKILL.md +++ b/retro/SKILL.md @@ -588,80 +588,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch diff --git a/review/SKILL.md b/review/SKILL.md index ca4fdb94..d8e86f1b 100644 --- a/review/SKILL.md +++ b/review/SKILL.md @@ -610,80 +610,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch diff --git a/scripts/resolvers/preamble/generate-completion-status.ts b/scripts/resolvers/preamble/generate-completion-status.ts index 71a1c945..bbaac9c9 100644 --- a/scripts/resolvers/preamble/generate-completion-status.ts +++ b/scripts/resolvers/preamble/generate-completion-status.ts @@ -83,79 +83,28 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- \`$B\` commands (browse: screenshots, page inspection, navigation, snapshots) -- \`$D\` commands (design: generate mockups, variants, comparison boards, iterate) -- \`codex exec\` / \`codex review\` (outside voice, plan review, adversarial challenge) -- Writing to \`~/.gstack/\` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- \`open\` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +\`$B\` (browse), \`$D\` (design), \`codex exec\`/\`codex review\`, writes to \`~/.gstack/\`, +writes to the plan file, \`open\` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a \`## GSTACK REVIEW REPORT\` +section, run \`~/.claude/skills/gstack/bin/gstack-review-read\` and append a report. +With JSONL entries (before \`---CONFIG---\`), format the standard runs/status/findings +table. With \`NO_REVIEWS\` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run \`/autoplan\`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a \`## GSTACK REVIEW REPORT\` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\\\`\\\`\\\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\\\`\\\`\\\` - -Then write a \`## GSTACK REVIEW REPORT\` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before \`---CONFIG---\`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is \`NO_REVIEWS\` or empty: write this placeholder table: - -\\\`\\\`\\\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \\\`/plan-ceo-review\\\` | Scope & strategy | 0 | — | — | -| Codex Review | \\\`/codex review\\\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \\\`/plan-eng-review\\\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \\\`/plan-design-review\\\` | UI/UX gaps | 0 | — | — | -| DX Review | \\\`/plan-devex-review\\\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \\\`/autoplan\\\` for full review pipeline, or individual reviews above. -\\\`\\\`\\\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status.`; +PLAN MODE EXCEPTION — always allowed (it's the plan file).`; } diff --git a/scripts/resolvers/testing.ts b/scripts/resolvers/testing.ts index f372aee1..592382bd 100644 --- a/scripts/resolvers/testing.ts +++ b/scripts/resolvers/testing.ts @@ -338,47 +338,25 @@ When uncertain whether a change is a regression, err on the side of writing the Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths: \`\`\` -CODE PATH COVERAGE -=========================== -[+] src/services/billing.ts - │ - ├── processPayment() - │ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 - │ ├── [GAP] Network timeout — NO TEST - │ └── [GAP] Invalid currency — NO TEST - │ - └── refundPayment() - ├── [★★ TESTED] Full refund — billing.test.ts:89 - └── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101 +CODE PATHS USER FLOWS +[+] src/services/billing.ts [+] Payment checkout + ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 + │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit + │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment + │ └── [GAP] Invalid currency + └── refundPayment() [+] Error states + ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message + └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX -USER FLOW COVERAGE -=========================== -[+] Payment checkout flow - │ - ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 - ├── [GAP] [→E2E] Double-click submit — needs E2E, not just unit - ├── [GAP] Navigate away during payment — unit test sufficient - └── [★ TESTED] Form validation errors (checks render only) — checkout.test.ts:40 +LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test -[+] Error states - │ - ├── [★★ TESTED] Card declined message — billing.test.ts:58 - ├── [GAP] Network timeout UX (what does user see?) — NO TEST - └── [GAP] Empty cart submission — NO TEST - -[+] LLM integration - │ - └── [GAP] [→EVAL] Prompt template change — needs eval test - -───────────────────────────────── -COVERAGE: 5/13 paths tested (38%) - Code paths: 3/5 (60%) - User flows: 2/8 (25%) -QUALITY: ★★★: 2 ★★: 2 ★: 1 -GAPS: 8 paths need tests (2 need E2E, 1 needs eval) -───────────────────────────────── +COVERAGE: 5/13 paths tested (38%) | Code paths: 3/5 (60%) | User flows: 2/8 (25%) +QUALITY: ★★★:2 ★★:2 ★:1 | GAPS: 8 (2 E2E, 1 eval) \`\`\` +Legend: ★★★ behavior + edge + error | ★★ happy path | ★ smoke check +[→E2E] = needs integration test | [→EVAL] = needs LLM eval + **Fast path:** All paths covered → "${mode === 'ship' ? 'Step 7' : mode === 'review' ? 'Step 4.75' : 'Test review'}: All new code paths have test coverage ✓" Continue.`); // ── Mode-specific action section ── diff --git a/setup-browser-cookies/SKILL.md b/setup-browser-cookies/SKILL.md index d15cc24a..c2e2c394 100644 --- a/setup-browser-cookies/SKILL.md +++ b/setup-browser-cookies/SKILL.md @@ -403,80 +403,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # Setup Browser Cookies diff --git a/setup-deploy/SKILL.md b/setup-deploy/SKILL.md index eb3c4176..0086e8d5 100644 --- a/setup-deploy/SKILL.md +++ b/setup-deploy/SKILL.md @@ -591,80 +591,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). # /setup-deploy — Configure Deployment for gstack diff --git a/ship/SKILL.md b/ship/SKILL.md index c3a83346..9e6efc71 100644 --- a/ship/SKILL.md +++ b/ship/SKILL.md @@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch @@ -1362,47 +1311,25 @@ Format: commit as `test: regression test for {what broke}` Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths: ``` -CODE PATH COVERAGE -=========================== -[+] src/services/billing.ts - │ - ├── processPayment() - │ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 - │ ├── [GAP] Network timeout — NO TEST - │ └── [GAP] Invalid currency — NO TEST - │ - └── refundPayment() - ├── [★★ TESTED] Full refund — billing.test.ts:89 - └── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101 +CODE PATHS USER FLOWS +[+] src/services/billing.ts [+] Payment checkout + ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 + │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit + │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment + │ └── [GAP] Invalid currency + └── refundPayment() [+] Error states + ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message + └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX -USER FLOW COVERAGE -=========================== -[+] Payment checkout flow - │ - ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 - ├── [GAP] [→E2E] Double-click submit — needs E2E, not just unit - ├── [GAP] Navigate away during payment — unit test sufficient - └── [★ TESTED] Form validation errors (checks render only) — checkout.test.ts:40 +LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test -[+] Error states - │ - ├── [★★ TESTED] Card declined message — billing.test.ts:58 - ├── [GAP] Network timeout UX (what does user see?) — NO TEST - └── [GAP] Empty cart submission — NO TEST - -[+] LLM integration - │ - └── [GAP] [→EVAL] Prompt template change — needs eval test - -───────────────────────────────── -COVERAGE: 5/13 paths tested (38%) - Code paths: 3/5 (60%) - User flows: 2/8 (25%) -QUALITY: ★★★: 2 ★★: 2 ★: 1 -GAPS: 8 paths need tests (2 need E2E, 1 needs eval) -───────────────────────────────── +COVERAGE: 5/13 paths tested (38%) | Code paths: 3/5 (60%) | User flows: 2/8 (25%) +QUALITY: ★★★:2 ★★:2 ★:1 | GAPS: 8 (2 E2E, 1 eval) ``` +Legend: ★★★ behavior + edge + error | ★★ happy path | ★ smoke check +[→E2E] = needs integration test | [→EVAL] = needs LLM eval + **Fast path:** All paths covered → "Step 7: All new code paths have test coverage ✓" Continue. **5. Generate tests for uncovered paths:** diff --git a/test/fixtures/golden/claude-ship-SKILL.md b/test/fixtures/golden/claude-ship-SKILL.md index c3a83346..9e6efc71 100644 --- a/test/fixtures/golden/claude-ship-SKILL.md +++ b/test/fixtures/golden/claude-ship-SKILL.md @@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `~/.claude/skills/gstack/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -~/.claude/skills/gstack/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch @@ -1362,47 +1311,25 @@ Format: commit as `test: regression test for {what broke}` Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths: ``` -CODE PATH COVERAGE -=========================== -[+] src/services/billing.ts - │ - ├── processPayment() - │ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 - │ ├── [GAP] Network timeout — NO TEST - │ └── [GAP] Invalid currency — NO TEST - │ - └── refundPayment() - ├── [★★ TESTED] Full refund — billing.test.ts:89 - └── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101 +CODE PATHS USER FLOWS +[+] src/services/billing.ts [+] Payment checkout + ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 + │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit + │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment + │ └── [GAP] Invalid currency + └── refundPayment() [+] Error states + ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message + └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX -USER FLOW COVERAGE -=========================== -[+] Payment checkout flow - │ - ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 - ├── [GAP] [→E2E] Double-click submit — needs E2E, not just unit - ├── [GAP] Navigate away during payment — unit test sufficient - └── [★ TESTED] Form validation errors (checks render only) — checkout.test.ts:40 +LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test -[+] Error states - │ - ├── [★★ TESTED] Card declined message — billing.test.ts:58 - ├── [GAP] Network timeout UX (what does user see?) — NO TEST - └── [GAP] Empty cart submission — NO TEST - -[+] LLM integration - │ - └── [GAP] [→EVAL] Prompt template change — needs eval test - -───────────────────────────────── -COVERAGE: 5/13 paths tested (38%) - Code paths: 3/5 (60%) - User flows: 2/8 (25%) -QUALITY: ★★★: 2 ★★: 2 ★: 1 -GAPS: 8 paths need tests (2 need E2E, 1 needs eval) -───────────────────────────────── +COVERAGE: 5/13 paths tested (38%) | Code paths: 3/5 (60%) | User flows: 2/8 (25%) +QUALITY: ★★★:2 ★★:2 ★:1 | GAPS: 8 (2 E2E, 1 eval) ``` +Legend: ★★★ behavior + edge + error | ★★ happy path | ★ smoke check +[→E2E] = needs integration test | [→EVAL] = needs LLM eval + **Fast path:** All paths covered → "Step 7: All new code paths have test coverage ✓" Continue. **5. Generate tests for uncovered paths:** diff --git a/test/fixtures/golden/codex-ship-SKILL.md b/test/fixtures/golden/codex-ship-SKILL.md index b9f8a935..04f80598 100644 --- a/test/fixtures/golden/codex-ship-SKILL.md +++ b/test/fixtures/golden/codex-ship-SKILL.md @@ -600,80 +600,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `$GSTACK_ROOT/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -$GSTACK_ROOT/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch @@ -1351,47 +1300,25 @@ Format: commit as `test: regression test for {what broke}` Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths: ``` -CODE PATH COVERAGE -=========================== -[+] src/services/billing.ts - │ - ├── processPayment() - │ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 - │ ├── [GAP] Network timeout — NO TEST - │ └── [GAP] Invalid currency — NO TEST - │ - └── refundPayment() - ├── [★★ TESTED] Full refund — billing.test.ts:89 - └── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101 +CODE PATHS USER FLOWS +[+] src/services/billing.ts [+] Payment checkout + ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 + │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit + │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment + │ └── [GAP] Invalid currency + └── refundPayment() [+] Error states + ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message + └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX -USER FLOW COVERAGE -=========================== -[+] Payment checkout flow - │ - ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 - ├── [GAP] [→E2E] Double-click submit — needs E2E, not just unit - ├── [GAP] Navigate away during payment — unit test sufficient - └── [★ TESTED] Form validation errors (checks render only) — checkout.test.ts:40 +LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test -[+] Error states - │ - ├── [★★ TESTED] Card declined message — billing.test.ts:58 - ├── [GAP] Network timeout UX (what does user see?) — NO TEST - └── [GAP] Empty cart submission — NO TEST - -[+] LLM integration - │ - └── [GAP] [→EVAL] Prompt template change — needs eval test - -───────────────────────────────── -COVERAGE: 5/13 paths tested (38%) - Code paths: 3/5 (60%) - User flows: 2/8 (25%) -QUALITY: ★★★: 2 ★★: 2 ★: 1 -GAPS: 8 paths need tests (2 need E2E, 1 needs eval) -───────────────────────────────── +COVERAGE: 5/13 paths tested (38%) | Code paths: 3/5 (60%) | User flows: 2/8 (25%) +QUALITY: ★★★:2 ★★:2 ★:1 | GAPS: 8 (2 E2E, 1 eval) ``` +Legend: ★★★ behavior + edge + error | ★★ happy path | ★ smoke check +[→E2E] = needs integration test | [→EVAL] = needs LLM eval + **Fast path:** All paths covered → "Step 7: All new code paths have test coverage ✓" Continue. **5. Generate tests for uncovered paths:** diff --git a/test/fixtures/golden/factory-ship-SKILL.md b/test/fixtures/golden/factory-ship-SKILL.md index 674ce104..78bd2041 100644 --- a/test/fixtures/golden/factory-ship-SKILL.md +++ b/test/fixtures/golden/factory-ship-SKILL.md @@ -602,80 +602,29 @@ remote binary only runs if telemetry is not off and the binary exists. ## Plan Mode Safe Operations -When in plan mode, these operations are always allowed because they produce -artifacts that inform the plan, not code changes: - -- `$B` commands (browse: screenshots, page inspection, navigation, snapshots) -- `$D` commands (design: generate mockups, variants, comparison boards, iterate) -- `codex exec` / `codex review` (outside voice, plan review, adversarial challenge) -- Writing to `~/.gstack/` (config, analytics, review logs, design artifacts, learnings) -- Writing to the plan file (already allowed by plan mode) -- `open` commands for viewing generated artifacts (comparison boards, HTML previews) - -These are read-only in spirit — they inspect the live site, generate visual artifacts, -or get independent opinions. They do NOT modify project source files. +In plan mode, these are always allowed (they inform the plan, don't modify source): +`$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`, +writes to the plan file, `open` for generated artifacts. ## Skill Invocation During Plan Mode -If a user invokes a skill during plan mode, that invoked skill workflow takes -precedence over generic plan mode behavior until it finishes or the user explicitly -cancels that skill. - -Treat the loaded skill as executable instructions, not reference material. Follow -it step by step. Do not summarize, skip, reorder, or shortcut its steps. - -If the skill says to use AskUserQuestion, do that. Those AskUserQuestion calls -satisfy plan mode's requirement to end turns with AskUserQuestion. - -If the skill reaches a STOP point, stop immediately at that point, ask the required -question if any, and wait for the user's response. Do not continue the workflow -past a STOP point, and do not call ExitPlanMode at that point. - -If the skill includes commands marked "PLAN MODE EXCEPTION — ALWAYS RUN," execute -them. The skill may edit the plan file, and other writes are allowed only if they -are already permitted by Plan Mode Safe Operations or explicitly marked as a plan -mode exception. - -Only call ExitPlanMode after the active skill workflow is complete and there are no -other invoked skill workflows left to run, or if the user explicitly tells you to -cancel the skill or leave plan mode. +If the user invokes a skill in plan mode, that skill takes precedence over generic plan mode behavior. Treat it as executable instructions, not reference. Follow step +by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP +point, stop immediately. Do not continue the workflow past a STOP point and do not call ExitPlanMode there. Commands marked "PLAN +MODE EXCEPTION — ALWAYS RUN" execute. Other writes need to be already permitted +above or explicitly exception-marked. Call ExitPlanMode only after the skill +workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode). ## Plan Status Footer -When you are in plan mode and about to call ExitPlanMode: +In plan mode, before ExitPlanMode: if the plan file lacks a `## GSTACK REVIEW REPORT` +section, run `$GSTACK_ROOT/bin/gstack-review-read` and append a report. +With JSONL entries (before `---CONFIG---`), format the standard runs/status/findings +table. With `NO_REVIEWS` or empty, append a 5-row placeholder table (CEO/Codex/Eng/ +Design/DX Review) with all zeros and verdict "NO REVIEWS YET — run `/autoplan`". +If a richer review report already exists, skip — review skills wrote it. -1. Check if the plan file already has a `## GSTACK REVIEW REPORT` section. -2. If it DOES — skip (a review skill already wrote a richer report). -3. If it does NOT — run this command: - -\`\`\`bash -$GSTACK_ROOT/bin/gstack-review-read -\`\`\` - -Then write a `## GSTACK REVIEW REPORT` section to the end of the plan file: - -- If the output contains review entries (JSONL lines before `---CONFIG---`): format the - standard report table with runs/status/findings per skill, same format as the review - skills use. -- If the output is `NO_REVIEWS` or empty: write this placeholder table: - -\`\`\`markdown -## GSTACK REVIEW REPORT - -| Review | Trigger | Why | Runs | Status | Findings | -|--------|---------|-----|------|--------|----------| -| CEO Review | \`/plan-ceo-review\` | Scope & strategy | 0 | — | — | -| Codex Review | \`/codex review\` | Independent 2nd opinion | 0 | — | — | -| Eng Review | \`/plan-eng-review\` | Architecture & tests (required) | 0 | — | — | -| Design Review | \`/plan-design-review\` | UI/UX gaps | 0 | — | — | -| DX Review | \`/plan-devex-review\` | Developer experience gaps | 0 | — | — | - -**VERDICT:** NO REVIEWS YET — run \`/autoplan\` for full review pipeline, or individual reviews above. -\`\`\` - -**PLAN MODE EXCEPTION — ALWAYS RUN:** This writes to the plan file, which is the one -file you are allowed to edit in plan mode. The plan file review report is part of the -plan's living status. +PLAN MODE EXCEPTION — always allowed (it's the plan file). ## Step 0: Detect platform and base branch @@ -1353,47 +1302,25 @@ Format: commit as `test: regression test for {what broke}` Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths: ``` -CODE PATH COVERAGE -=========================== -[+] src/services/billing.ts - │ - ├── processPayment() - │ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 - │ ├── [GAP] Network timeout — NO TEST - │ └── [GAP] Invalid currency — NO TEST - │ - └── refundPayment() - ├── [★★ TESTED] Full refund — billing.test.ts:89 - └── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101 +CODE PATHS USER FLOWS +[+] src/services/billing.ts [+] Payment checkout + ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 + │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit + │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment + │ └── [GAP] Invalid currency + └── refundPayment() [+] Error states + ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message + └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX -USER FLOW COVERAGE -=========================== -[+] Payment checkout flow - │ - ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15 - ├── [GAP] [→E2E] Double-click submit — needs E2E, not just unit - ├── [GAP] Navigate away during payment — unit test sufficient - └── [★ TESTED] Form validation errors (checks render only) — checkout.test.ts:40 +LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test -[+] Error states - │ - ├── [★★ TESTED] Card declined message — billing.test.ts:58 - ├── [GAP] Network timeout UX (what does user see?) — NO TEST - └── [GAP] Empty cart submission — NO TEST - -[+] LLM integration - │ - └── [GAP] [→EVAL] Prompt template change — needs eval test - -───────────────────────────────── -COVERAGE: 5/13 paths tested (38%) - Code paths: 3/5 (60%) - User flows: 2/8 (25%) -QUALITY: ★★★: 2 ★★: 2 ★: 1 -GAPS: 8 paths need tests (2 need E2E, 1 needs eval) -───────────────────────────────── +COVERAGE: 5/13 paths tested (38%) | Code paths: 3/5 (60%) | User flows: 2/8 (25%) +QUALITY: ★★★:2 ★★:2 ★:1 | GAPS: 8 (2 E2E, 1 eval) ``` +Legend: ★★★ behavior + edge + error | ★★ happy path | ★ smoke check +[→E2E] = needs integration test | [→EVAL] = needs LLM eval + **Fast path:** All paths covered → "Step 7: All new code paths have test coverage ✓" Continue. **5. Generate tests for uncovered paths:**