CalvinBackup/gstack
1
0
Fork 0
mirror of https://github.com/garrytan/gstack.git synced 2026-08-05 13:58:37 +02:00
Code Issues Packages Projects Releases Wiki Activity

chore: trim verbose preamble + coverage audit prose

Browse Source 
Compress without removing behavior or voice. Three targeted cuts:

1. scripts/resolvers/testing.ts coverage diagram example: 40 lines → 14
   lines. Two-column ASCII layout instead of stacked sections.
   Preserves all required regression-guard phrases (processPayment,
   refundPayment, billing.test.ts, checkout.e2e.ts, COVERAGE, QUALITY,
   GAPS, Code paths, User flows, ASCII coverage diagram).

2. scripts/resolvers/preamble/generate-completion-status.ts Plan Status
   Footer: was 35 lines with embedded markdown table example, now 7
   lines that describe the table inline. The footer fires only at
   ExitPlanMode time — Claude can construct the placeholder table from
   the inline description without copying a literal example.

3. Same file's Plan Mode Safe Operations + Skill Invocation During Plan
   Mode sections compressed from ~25 lines combined to ~12. Preserves
   all required test phrases (precedence over generic plan mode behavior,
   Do not continue the workflow, cancel the skill or leave plan mode,
   PLAN MODE EXCEPTION).

NOT touched:
- Voice directive (Garry's voice — protected per CLAUDE.md)
- Office-hours Phase 6 Handoff (Garry's voice + YC pitch)
- Test bootstrap, review army, plan completion (carefully tuned behavior)

Token savings (per skill, system-wide):
  ship/SKILL.md           35474 → 34992 tokens (-482)
  plan-ceo-review         29436 → 28940 (-496)
  office-hours            26700 → 26204 (-496)

Still over the 25K ceiling. Bigger reduction requires restructure
(move large resolvers to externally-referenced docs, split /ship into
ship-quick + ship-full, or refactor the coverage audit + review army
into shorter prose). That's a follow-up — added to TODOS.

Tests: 420/420 pass on gen-skill-docs.test.ts + host-config.test.ts.
Goldens regenerated for claude/codex/factory ship.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Garry Tan
2026-04-17 14:33:07 +08:00
co-authored by Claude Opus 4.7
parent 1d0a6a0a59
commit e723576d70
37 changed files with 666 additions and 2634 deletions
Download Patch File Download Diff File Expand all files Collapse all files
SKILL.md
+16 -67
View File
@@ -405,80 +405,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
If `PROACTIVE` is `false`: do NOT proactively invoke or suggest other gstack skills during 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 this session. Only run skills the user explicitly invokes. This preference persists across
autoplan/SKILL.md
+16 -67
View File
@@ -614,80 +614,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## Step 0: Detect platform and base branch
benchmark/SKILL.md
+16 -67
View File
@@ -407,80 +407,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## SETUP (run this check BEFORE any browse command) ## SETUP (run this check BEFORE any browse command)
browse/SKILL.md
+16 -67
View File
@@ -406,80 +406,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# browse: QA Testing & Dogfooding # browse: QA Testing & Dogfooding
canary/SKILL.md
+16 -67
View File
@@ -588,80 +588,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## SETUP (run this check BEFORE any browse command) ## SETUP (run this check BEFORE any browse command)
checkpoint/SKILL.md
+16 -67
View File
@@ -591,80 +591,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# /checkpoint — Save and Resume Working State # /checkpoint — Save and Resume Working State
codex/SKILL.md
+16 -67
View File
@@ -608,80 +608,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## Step 0: Detect platform and base branch
cso/SKILL.md
+16 -67
View File
@@ -593,80 +593,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
design-consultation/SKILL.md
+16 -67
View File
@@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# /design-consultation: Your Design System, Built Together # /design-consultation: Your Design System, Built Together
design-html/SKILL.md
+16 -67
View File
@@ -595,80 +595,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# /design-html: Pretext-Native HTML Engine # /design-html: Pretext-Native HTML Engine
design-review/SKILL.md
+16 -67
View File
@@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
design-shotgun/SKILL.md
+16 -67
View File
@@ -590,80 +590,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# /design-shotgun: Visual Design Exploration # /design-shotgun: Visual Design Exploration
devex-review/SKILL.md
+16 -67
View File
@@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## Step 0: Detect platform and base branch
document-release/SKILL.md
+16 -67
View File
@@ -590,80 +590,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## Step 0: Detect platform and base branch
health/SKILL.md
+16 -67
View File
@@ -590,80 +590,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# /health -- Code Quality Dashboard # /health -- Code Quality Dashboard
investigate/SKILL.md
+16 -67
View File
@@ -607,80 +607,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# Systematic Debugging # Systematic Debugging
land-and-deploy/SKILL.md
+16 -67
View File
@@ -605,80 +605,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## SETUP (run this check BEFORE any browse command) ## SETUP (run this check BEFORE any browse command)
learn/SKILL.md
+16 -67
View File
@@ -590,80 +590,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# Project Learnings Manager # Project Learnings Manager
office-hours/SKILL.md
+16 -67
View File
@@ -616,80 +616,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## SETUP (run this check BEFORE any browse command) ## SETUP (run this check BEFORE any browse command)
open-gstack-browser/SKILL.md
+16 -67
View File
@@ -605,80 +605,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# /open-gstack-browser — Launch GStack Browser # /open-gstack-browser — Launch GStack Browser
pair-agent/SKILL.md
+16 -67
View File
@@ -606,80 +606,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# /pair-agent — Share Your Browser With Another AI Agent # /pair-agent — Share Your Browser With Another AI Agent
plan-ceo-review/SKILL.md
+16 -67
View File
@@ -612,80 +612,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## Step 0: Detect platform and base branch
plan-design-review/SKILL.md
+16 -67
View File
@@ -609,80 +609,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## Step 0: Detect platform and base branch
plan-devex-review/SKILL.md
+16 -67
View File
@@ -613,80 +613,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## Step 0: Detect platform and base branch
plan-eng-review/SKILL.md
+31 -104
View File
@@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
@@ -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: Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths:
``` ```
CODE PATH COVERAGE CODE PATHS USER FLOWS
=========================== [+] src/services/billing.ts [+] Payment checkout
[+] src/services/billing.ts ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15
│ │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit
├── processPayment() │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment
│ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 │ └── [GAP] Invalid currency
│ ├── [GAP] Network timeout — NO TEST └── refundPayment() [+] Error states
│ └── [GAP] Invalid currency — NO TEST ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message
│ └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX
└── refundPayment()
├── [★★ TESTED] Full refund — billing.test.ts:89
└── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101
USER FLOW COVERAGE LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test
===========================
[+] 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
[+] Error states 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)
├── [★★ 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)
─────────────────────────────────
``` ```
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. **Fast path:** All paths covered → "Test review: All new code paths have test coverage ✓" Continue.
**Step 5. Add missing tests to the plan:** **Step 5. Add missing tests to the plan:**
qa-only/SKILL.md
+16 -67
View File
@@ -607,80 +607,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# /qa-only: Report-Only QA Testing # /qa-only: Report-Only QA Testing
qa/SKILL.md
+16 -67
View File
@@ -613,80 +613,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## Step 0: Detect platform and base branch
retro/SKILL.md
+16 -67
View File
@@ -588,80 +588,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## Step 0: Detect platform and base branch
review/SKILL.md
+16 -67
View File
@@ -610,80 +610,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## Step 0: Detect platform and base branch
scripts/resolvers/preamble/generate-completion-status.ts
+16 -67
View File
@@ -83,79 +83,28 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: \`$B\` (browse), \`$D\` (design), \`codex exec\`/\`codex review\`, writes to \`~/.gstack/\`,
writes to the plan file, \`open\` for generated artifacts.
- \`$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).`;
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.`;
} }
scripts/resolvers/testing.ts
+15 -37
View File
@@ -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: Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths:
\`\`\` \`\`\`
CODE PATH COVERAGE CODE PATHS USER FLOWS
=========================== [+] src/services/billing.ts [+] Payment checkout
[+] src/services/billing.ts ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15
│ │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit
├── processPayment() │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment
│ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 │ └── [GAP] Invalid currency
│ ├── [GAP] Network timeout — NO TEST └── refundPayment() [+] Error states
│ └── [GAP] Invalid currency — NO TEST ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message
│ └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX
└── refundPayment()
├── [★★ TESTED] Full refund — billing.test.ts:89
└── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101
USER FLOW COVERAGE LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test
===========================
[+] 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
[+] Error states 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)
├── [★★ 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)
─────────────────────────────────
\`\`\` \`\`\`
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.`); **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 ── // ── Mode-specific action section ──
setup-browser-cookies/SKILL.md
+16 -67
View File
@@ -403,80 +403,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# Setup Browser Cookies # Setup Browser Cookies
setup-deploy/SKILL.md
+16 -67
View File
@@ -591,80 +591,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
# /setup-deploy — Configure Deployment for gstack # /setup-deploy — Configure Deployment for gstack
ship/SKILL.md
+31 -104
View File
@@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## 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: Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths:
``` ```
CODE PATH COVERAGE CODE PATHS USER FLOWS
=========================== [+] src/services/billing.ts [+] Payment checkout
[+] src/services/billing.ts ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15
│ │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit
├── processPayment() │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment
│ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 │ └── [GAP] Invalid currency
│ ├── [GAP] Network timeout — NO TEST └── refundPayment() [+] Error states
│ └── [GAP] Invalid currency — NO TEST ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message
│ └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX
└── refundPayment()
├── [★★ TESTED] Full refund — billing.test.ts:89
└── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101
USER FLOW COVERAGE LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test
===========================
[+] 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
[+] Error states 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)
├── [★★ 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)
─────────────────────────────────
``` ```
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. **Fast path:** All paths covered → "Step 7: All new code paths have test coverage ✓" Continue.
**5. Generate tests for uncovered paths:** **5. Generate tests for uncovered paths:**
test/fixtures/golden/claude-ship-SKILL.md
Vendored
+31 -104
View File
@@ -611,80 +611,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## 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: Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths:
``` ```
CODE PATH COVERAGE CODE PATHS USER FLOWS
=========================== [+] src/services/billing.ts [+] Payment checkout
[+] src/services/billing.ts ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15
│ │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit
├── processPayment() │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment
│ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 │ └── [GAP] Invalid currency
│ ├── [GAP] Network timeout — NO TEST └── refundPayment() [+] Error states
│ └── [GAP] Invalid currency — NO TEST ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message
│ └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX
└── refundPayment()
├── [★★ TESTED] Full refund — billing.test.ts:89
└── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101
USER FLOW COVERAGE LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test
===========================
[+] 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
[+] Error states 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)
├── [★★ 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)
─────────────────────────────────
``` ```
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. **Fast path:** All paths covered → "Step 7: All new code paths have test coverage ✓" Continue.
**5. Generate tests for uncovered paths:** **5. Generate tests for uncovered paths:**
test/fixtures/golden/codex-ship-SKILL.md
Vendored
+31 -104
View File
@@ -600,80 +600,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## 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: Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths:
``` ```
CODE PATH COVERAGE CODE PATHS USER FLOWS
=========================== [+] src/services/billing.ts [+] Payment checkout
[+] src/services/billing.ts ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15
│ │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit
├── processPayment() │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment
│ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 │ └── [GAP] Invalid currency
│ ├── [GAP] Network timeout — NO TEST └── refundPayment() [+] Error states
│ └── [GAP] Invalid currency — NO TEST ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message
│ └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX
└── refundPayment()
├── [★★ TESTED] Full refund — billing.test.ts:89
└── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101
USER FLOW COVERAGE LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test
===========================
[+] 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
[+] Error states 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)
├── [★★ 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)
─────────────────────────────────
``` ```
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. **Fast path:** All paths covered → "Step 7: All new code paths have test coverage ✓" Continue.
**5. Generate tests for uncovered paths:** **5. Generate tests for uncovered paths:**
test/fixtures/golden/factory-ship-SKILL.md
Vendored
+31 -104
View File
@@ -602,80 +602,29 @@ remote binary only runs if telemetry is not off and the binary exists.
## Plan Mode Safe Operations ## Plan Mode Safe Operations
When in plan mode, these operations are always allowed because they produce In plan mode, these are always allowed (they inform the plan, don't modify source):
artifacts that inform the plan, not code changes: `$B` (browse), `$D` (design), `codex exec`/`codex review`, writes to `~/.gstack/`,
writes to the plan file, `open` for generated artifacts.
- `$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.
## Skill Invocation During Plan Mode ## Skill Invocation During Plan Mode
If a user invokes a skill during plan mode, that invoked skill workflow takes 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
precedence over generic plan mode behavior until it finishes or the user explicitly by step. AskUserQuestion calls satisfy plan mode's end-of-turn requirement. At a STOP
cancels that skill. 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
Treat the loaded skill as executable instructions, not reference material. Follow above or explicitly exception-marked. Call ExitPlanMode only after the skill
it step by step. Do not summarize, skip, reorder, or shortcut its steps. workflow completes — only then call ExitPlanMode (or if the user tells you to cancel the skill or leave plan mode).
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.
## Plan Status Footer ## 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. PLAN MODE EXCEPTION — always allowed (it's the plan file).
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.
## Step 0: Detect platform and base branch ## 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: Include BOTH code paths and user flows in the same diagram. Mark E2E-worthy and eval-worthy paths:
``` ```
CODE PATH COVERAGE CODE PATHS USER FLOWS
=========================== [+] src/services/billing.ts [+] Payment checkout
[+] src/services/billing.ts ├── processPayment() ├── [★★★ TESTED] Complete purchase — checkout.e2e.ts:15
│ │ ├── [★★★ TESTED] happy + declined + timeout ├── [GAP] [→E2E] Double-click submit
├── processPayment() │ ├── [GAP] Network timeout └── [GAP] Navigate away mid-payment
│ ├── [★★★ TESTED] Happy path + card declined + timeout — billing.test.ts:42 │ └── [GAP] Invalid currency
│ ├── [GAP] Network timeout — NO TEST └── refundPayment() [+] Error states
│ └── [GAP] Invalid currency — NO TEST ├── [★★ TESTED] Full refund — :89 ├── [★★ TESTED] Card declined message
│ └── [★ TESTED] Partial (non-throw only) — :101 └── [GAP] Network timeout UX
└── refundPayment()
├── [★★ TESTED] Full refund — billing.test.ts:89
└── [★ TESTED] Partial refund (checks non-throw only) — billing.test.ts:101
USER FLOW COVERAGE LLM integration: [GAP] [→EVAL] Prompt template change — needs eval test
===========================
[+] 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
[+] Error states 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)
├── [★★ 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)
─────────────────────────────────
``` ```
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. **Fast path:** All paths covered → "Step 7: All new code paths have test coverage ✓" Continue.
**5. Generate tests for uncovered paths:** **5. Generate tests for uncovered paths:**