gsd-antigravity-kit 2.0.1 → 2.1.0

package/.agent/skills/gsd/references/workflows/next.md

@@ -1,153 +1,220 @@
-<purpose>
-Detect current project state and automatically advance to the next logical GSD workflow step.
-Reads project state to determine: discuss → plan → execute → verify → complete progression.
-</purpose>
-
-<required_reading>
-Read all files referenced by the invoking prompt's execution_context before starting.
-</required_reading>
-
-<process>
-
-<step name="detect_state">
-Read project state to determine current position:
-
-```bash
-# Get state snapshot
-.agent/skills/gsd/bin/gsd-tools.cjs" state json 2>/dev/null || echo "{}"
-```
-
-Also read:
-- `.planning/STATE.md` — current phase, progress, plan counts
-- `.planning/ROADMAP.md` — milestone structure and phase list
-
-Extract:
-- `current_phase` — which phase is active
-- `plan_of` / `plans_total` — plan execution progress
-- `progress` — overall percentage
-- `status` — active, paused, etc.
-
-If no `.planning/` directory exists:
-```
-No GSD project detected. Run `/gsd-new-project` to get started.
-```
-Exit.
-</step>
-
-<step name="safety_gates">
-Run hard-stop checks before routing. Exit on first hit unless `--force` was passed.
-
-If `--force` flag was passed, skip all gates and the consecutive guard.
-Print a one-line warning: `⚠ --force: skipping safety gates`
-Then proceed directly to `determine_next_action`.
-
-**Gate 1: Unresolved checkpoint**
-Check if `.planning/.continue-here.md` exists:
-```bash
-[ -f .planning/.continue-here.md ]
-```
-If found:
-```
-⛔ Hard stop: Unresolved checkpoint
-
-`.planning/.continue-here.md` exists — a previous session left
-unfinished work that needs manual review before advancing.
-
-Read the file, resolve the issue, then delete it to continue.
-Use `--force` to bypass this check.
-```
-Exit (do not route).
-
-**Gate 2: Error state**
-Check if STATE.md contains `status: error` or `status: failed`:
-If found:
-```
-⛔ Hard stop: Project in error state
-
-STATE.md shows status: {status}. Resolve the error before advancing.
-Run `/gsd-health` to diagnose, or manually fix STATE.md.
-Use `--force` to bypass this check.
-```
-Exit.
-
-**Gate 3: Unchecked verification**
-Check if the current phase has a VERIFICATION.md with any `FAIL` items that don't have overrides:
-If found:
-```
-⛔ Hard stop: Unchecked verification failures
-
-VERIFICATION.md for phase {N} has {count} unresolved FAIL items.
-Address the failures or add overrides before advancing to the next phase.
-Use `--force` to bypass this check.
-```
-Exit.
-
-**Consecutive-call guard:**
-After passing all gates, check a counter file `.planning/.next-call-count`:
-- If file exists and count >= 6: prompt "You've called /gsd-next {N} times consecutively. Continue? [y/N]"
-- If user says no, exit
-- Increment the counter
-- The counter file is deleted by any non-`/gsd-next` command (convention — other workflows don't need to implement this, the note here is sufficient)
-</step>
-
-<step name="determine_next_action">
-Apply routing rules based on state:
-
-**Route 1: No phases exist yet → discuss**
-If ROADMAP has phases but no phase directories exist on disk:
-→ Next action: `/gsd-discuss-phase <first-phase>`
-
-**Route 2: Phase exists but has no CONTEXT.md or RESEARCH.md → discuss**
-If the current phase directory exists but has neither CONTEXT.md nor RESEARCH.md:
-→ Next action: `/gsd-discuss-phase <current-phase>`
-
-**Route 3: Phase has context but no plans → plan**
-If the current phase has CONTEXT.md (or RESEARCH.md) but no PLAN.md files:
-→ Next action: `/gsd-plan-phase <current-phase>`
-
-**Route 4: Phase has plans but incomplete summaries → execute**
-If plans exist but not all have matching summaries:
-→ Next action: `/gsd-execute-phase <current-phase>`
-
-**Route 5: All plans have summaries → verify and complete**
-If all plans in the current phase have summaries:
-→ Next action: `/gsd-verify-work`
-
-**Route 6: Phase complete, next phase exists → advance**
-If the current phase is complete and the next phase exists in ROADMAP:
-→ Next action: `/gsd-discuss-phase <next-phase>`
-
-**Route 7: All phases complete → complete milestone**
-If all phases are complete:
-→ Next action: `/gsd-complete-milestone`
-
-**Route 8: Paused → resume**
-If STATE.md shows paused_at:
-→ Next action: `/gsd-resume-work`
-</step>
-
-<step name="show_and_execute">
-Display the determination:
-
-```
-## GSD Next
-
-**Current:** Phase [N] — [name] | [progress]%
-**Status:** [status description]
-
-▶ **Next step:** `/gsd-[command] [args]`
-  [One-line explanation of why this is the next step]
-```
-
-Then immediately invoke the determined command via SlashCommand.
-Do not ask for confirmation — the whole point of `/gsd-next` is zero-friction advancement.
-</step>
-
-</process>
-
-<success_criteria>
-- [ ] Project state correctly detected
-- [ ] Next action correctly determined from routing rules
-- [ ] Command invoked immediately without user confirmation
-- [ ] Clear status shown before invoking
-</success_criteria>
+<purpose>
+Detect current project state and automatically advance to the next logical GSD workflow step.
+Reads project state to determine: discuss → plan → execute → verify → complete progression.
+</purpose>
+
+<required_reading>
+Read all files referenced by the invoking prompt's execution_context before starting.
+</required_reading>
+
+<process>
+
+<step name="detect_state">
+Read project state to determine current position:
+
+```bash
+# Get state snapshot
+gsd-sdk query state.json 2>/dev/null || echo "{}"
+```
+
+Also read:
+- `.planning/STATE.md` — current phase, progress, plan counts
+- `.planning/ROADMAP.md` — milestone structure and phase list
+
+Extract:
+- `current_phase` — which phase is active
+- `plan_of` / `plans_total` — plan execution progress
+- `progress` — overall percentage
+- `status` — active, paused, etc.
+
+If no `.planning/` directory exists:
+```
+No GSD project detected. Run `/gsd-new-project` to get started.
+```
+Exit.
+</step>
+
+<step name="safety_gates">
+Run hard-stop checks before routing. Exit on first hit unless `--force` was passed.
+
+If `--force` flag was passed, skip all gates and the consecutive guard.
+Print a one-line warning: `⚠ --force: skipping safety gates`
+Then proceed directly to `determine_next_action`.
+
+**Gate 1: Unresolved checkpoint**
+Check if `.planning/.continue-here.md` exists:
+```bash
+[ -f .planning/.continue-here.md ]
+```
+If found:
+```
+⛔ Hard stop: Unresolved checkpoint
+
+`.planning/.continue-here.md` exists — a previous session left
+unfinished work that needs manual review before advancing.
+
+Read the file, resolve the issue, then delete it to continue.
+Use `--force` to bypass this check.
+```
+Exit (do not route).
+
+**Gate 2: Error state**
+Check if STATE.md contains `status: error` or `status: failed`:
+If found:
+```
+⛔ Hard stop: Project in error state
+
+STATE.md shows status: {status}. Resolve the error before advancing.
+Run `/gsd-health` to diagnose, or manually fix STATE.md.
+Use `--force` to bypass this check.
+```
+Exit.
+
+**Gate 3: Unchecked verification**
+Check if the current phase has a VERIFICATION.md with any `FAIL` items that don't have overrides:
+If found:
+```
+⛔ Hard stop: Unchecked verification failures
+
+VERIFICATION.md for phase {N} has {count} unresolved FAIL items.
+Address the failures or add overrides before advancing to the next phase.
+Use `--force` to bypass this check.
+```
+Exit.
+
+**Prior-phase completeness scan:**
+After passing all three hard-stop gates, scan all phases that precede the current phase in ROADMAP.md order for incomplete work. For each prior phase number `N`, use `gsd-sdk query find-phase <N>` JSON (plans, summaries, incomplete_plans, etc.) to inspect that phase.
+
+Detect three categories of incomplete work:
+1. **Plans without summaries** — a PLAN.md exists in a prior phase directory but no matching SUMMARY.md exists (execution started but not completed).
+2. **Verification failures not overridden** — a prior phase has a VERIFICATION.md with `FAIL` items that have no override annotation.
+3. **CONTEXT.md without plans** — a prior phase directory has a CONTEXT.md but no PLAN.md files (discussion happened, planning never ran).
+
+If no incomplete prior work is found, continue to `determine_next_action` silently with no interruption.
+
+If incomplete prior work is found, show a structured completeness report:
+```
+⚠ Prior phase has incomplete work
+
+Phase {N} — "{name}" has unresolved items:
+  • Plan {N}-{M} ({slug}): executed but no SUMMARY.md
+  [... additional items ...]
+
+Advancing before resolving these may cause:
+  • Verification gaps — future phase verification won't have visibility into what prior phases shipped
+  • Context loss — plans that ran without summaries leave no record for future agents
+
+Options:
+  [C] Continue and defer these items to backlog
+  [S] Stop and resolve manually (recommended)
+  [F] Force advance without recording deferral
+
+Choice [S]:
+```
+
+**If the user chooses "Stop" (S or Enter/default):** Exit without routing.
+
+**If the user chooses "Continue and defer" (C):**
+1. For each incomplete item, create a backlog entry in `ROADMAP.md` under `## Backlog` using the existing `999.x` numbering scheme:
+```markdown
+### Phase 999.{N}: Follow-up — Phase {src} incomplete plans (BACKLOG)
+
+**Goal:** Resolve plans that ran without producing summaries during Phase {src} execution
+**Source phase:** {src}
+**Deferred at:** {date} during /gsd-next advancement to Phase {dest}
+**Plans:**
+- [ ] {N}-{M}: {slug} (ran, no SUMMARY.md)
+```
+2. Commit the deferral record:
+```bash
+gsd-sdk query commit "docs: defer incomplete Phase {src} items to backlog"
+```
+3. Continue routing to `determine_next_action` immediately — no second prompt.
+
+**If the user chooses "Force" (F):** Continue to `determine_next_action` without recording deferral.
+</step>
+
+<step name="spike_sketch_notice">
+Check for pending spike/sketch work and surface a notice (does not change routing):
+
+```bash
+# Check for pending spikes (verdict: PENDING in any README)
+PENDING_SPIKES=$(grep -rl 'verdict: PENDING' .planning/spikes/*/README.md 2>/dev/null | wc -l | tr -d ' ')
+
+# Check for pending sketches (winner: null in any README)
+PENDING_SKETCHES=$(grep -rl 'winner: null' .planning/sketches/*/README.md 2>/dev/null | wc -l | tr -d ' ')
+```
+
+If either count is > 0, display before routing:
+```
+⚠ Pending exploratory work:
+  {PENDING_SPIKES} spike(s) with unresolved verdicts in .planning/spikes/
+  {PENDING_SKETCHES} sketch(es) without a winning variant in .planning/sketches/
+
+  Resume with `/gsd-spike` or `/gsd-sketch`, or continue with phase work below.
+```
+
+Only show lines for non-zero counts. If both are 0, skip this notice entirely.
+</step>
+
+<step name="determine_next_action">
+Apply routing rules based on state:
+
+**Route 1: No phases exist yet → discuss**
+If ROADMAP has phases but no phase directories exist on disk:
+→ Next action: `/gsd-discuss-phase <first-phase>`
+
+**Route 2: Phase exists but has no CONTEXT.md or RESEARCH.md → discuss**
+If the current phase directory exists but has neither CONTEXT.md nor RESEARCH.md:
+→ Next action: `/gsd-discuss-phase <current-phase>`
+
+**Route 3: Phase has context but no plans → plan**
+If the current phase has CONTEXT.md (or RESEARCH.md) but no PLAN.md files:
+→ Next action: `/gsd-plan-phase <current-phase>`
+
+**Route 4: Phase has plans but incomplete summaries → execute**
+If plans exist but not all have matching summaries:
+→ Next action: `/gsd-execute-phase <current-phase>`
+
+**Route 5: All plans have summaries → verify and complete**
+If all plans in the current phase have summaries:
+→ Next action: `/gsd-verify-work`
+
+**Route 6: Phase complete, next phase exists → advance**
+If the current phase is complete and the next phase exists in ROADMAP:
+→ Next action: `/gsd-discuss-phase <next-phase>`
+
+**Route 7: All phases complete → complete milestone**
+If all phases are complete:
+→ Next action: `/gsd-complete-milestone`
+
+**Route 8: Paused → resume**
+If STATE.md shows paused_at:
+→ Next action: `/gsd-resume-work`
+</step>
+
+<step name="show_and_execute">
+Display the determination:
+
+```
+## GSD Next
+
+**Current:** Phase [N] — [name] | [progress]%
+**Status:** [status description]
+
+▶ **Next step:** `/gsd-[command] [args]`
+  [One-line explanation of why this is the next step]
+```
+
+Then immediately invoke the determined command via SlashCommand.
+Do not ask for confirmation — the whole point of `/gsd-next` is zero-friction advancement.
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] Project state correctly detected
+- [ ] Next action correctly determined from routing rules
+- [ ] Command invoked immediately without user confirmation
+- [ ] Clear status shown before invoking
+</success_criteria>

package/.agent/skills/gsd/references/workflows/note.md

@@ -1,5 +1,7 @@
 <purpose>
 Zero-friction idea capture. One Write call, one confirmation line. No questions, no prompts.
+
+**Text mode (`workflow.text_mode: true` in config or `--text` flag):** Set `TEXT_MODE=true` if `--text` is present in `$ARGUMENTS` OR `text_mode` from init JSON is `true`. When TEXT_MODE is active, replace every `AskUserQuestion` call with a plain-text numbered list and ask the user to type their choice number. This is required for non-Antigravity runtimes (OpenAI Codex, Gemini CLI, etc.) where `AskUserQuestion` is not available.
 Runs inline — no Task, no AskUserQuestion, no Bash.
 </purpose>
 

package/.agent/skills/gsd/references/workflows/pause-work.md

@@ -18,7 +18,10 @@ Determine what kind of work is being paused and set the handoff destination acco
 phase=$(( ls -lt .planning/phases/*/PLAN.md 2>/dev/null || true ) | head -1 | grep -oP 'phases/\K[^/]+' || true)
 
 # Check for active spike
-spike=$(( ls -lt .planning/spikes/*/SPIKE.md .planning/spikes/*/DESIGN.md 2>/dev/null || true ) | head -1 | grep -oP 'spikes/\K[^/]+' || true)
+spike=$(( ls -lt .planning/spikes/*/SPIKE.md .planning/spikes/*/DESIGN.md .planning/spikes/*/README.md 2>/dev/null || true ) | head -1 | grep -oP 'spikes/\K[^/]+' || true)
+
+# Check for active sketch
+sketch=$(( ls -lt .planning/sketches/*/README.md .planning/sketches/*/index.html 2>/dev/null || true ) | head -1 | grep -oP 'sketches/\K[^/]+' || true)
 
 # Check for active deliberation
 deliberation=$(ls .planning/deliberations/*.md 2>/dev/null | head -1 || true)
@@ -26,8 +29,9 @@ deliberation=$(ls .planning/deliberations/*.md 2>/dev/null | head -1 || true)
 
 - **Phase work**: active phase directory → handoff to `.planning/phases/XX-name/.continue-here.md`
 - **Spike work**: active spike directory or spike-related files (no active phase) → handoff to `.planning/spikes/SPIKE-NNN/.continue-here.md` (create directory if needed)
-- **Deliberation work**: active deliberation file (no phase/spike) → handoff to `.planning/deliberations/.continue-here.md`
-- **Research work**: research notes exist but no phase/spike/deliberation → handoff to `.planning/.continue-here.md`
+- **Sketch work**: active sketch directory (no active phase/spike) → handoff to `.planning/sketches/.continue-here.md`
+- **Deliberation work**: active deliberation file (no phase/spike/sketch) → handoff to `.planning/deliberations/.continue-here.md`
+- **Research work**: research notes exist but no phase/spike/sketch/deliberation → handoff to `.planning/.continue-here.md`
 - **Default**: no detectable context → handoff to `.planning/.continue-here.md`, note the ambiguity in `<current_state>`
 
 If phase is detected, proceed with phase handoff path. Otherwise use the first matching non-phase path above.
@@ -62,7 +66,7 @@ Report any summaries with placeholder content as incomplete items.
 **Write structured handoff to `.planning/HANDOFF.json`:**
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" current-timestamp full --raw)
+timestamp=$(gsd-sdk query current-timestamp full --raw)
 ```
 
 ```json
@@ -106,7 +110,7 @@ Report any summaries with placeholder content as incomplete items.
 
 ```markdown
 ---
-context: [phase|spike|deliberation|research|default]
+context: [phase|spike|sketch|deliberation|research|default]
 phase: XX-name
 task: 3
 total_tasks: 7
@@ -197,13 +201,13 @@ Be specific enough for a fresh Antigravity to understand immediately.
 
 Use `current-timestamp` for last_updated field. You can use init todos (which provides timestamps) or call directly:
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" current-timestamp full --raw)
+timestamp=$(gsd-sdk query current-timestamp full --raw)
 ```
 </step>
 
 <step name="commit">
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" commit "wip: [context-name] paused at [X]/[Y]" --files [handoff-path] .planning/HANDOFF.json
+gsd-sdk query commit "wip: [context-name] paused at [X]/[Y]" [handoff-path] .planning/HANDOFF.json
 ```
 </step>