gsd-antigravity-kit 2.0.0 → 2.1.0

package/.agent/skills/gsd/references/workflows/audit-uat.md

@@ -1,109 +1,109 @@
-<purpose>
-Cross-phase audit of all UAT and verification files. Finds every outstanding item (pending, skipped, blocked, human_needed), optionally verifies against the codebase to detect stale docs, and produces a prioritized human test plan.
-</purpose>
-
-<process>
-
-<step name="initialize">
-Run the CLI audit:
-
-```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" audit-uat --raw)
-```
-
-Parse JSON for `results` array and `summary` object.
-
-If `summary.total_items` is 0:
-```
-## All Clear
-
-No outstanding UAT or verification items found across all phases.
-All tests are passing, resolved, or diagnosed with fix plans.
-```
-Stop here.
-</step>
-
-<step name="categorize">
-Group items by what's actionable NOW vs. what needs prerequisites:
-
-**Testable Now** (no external dependencies):
-- `pending` — tests never run
-- `human_uat` — human verification items
-- `skipped_unresolved` — skipped without clear blocking reason
-
-**Needs Prerequisites:**
-- `server_blocked` — needs external server running
-- `device_needed` — needs physical device (not simulator)
-- `build_needed` — needs release/preview build
-- `third_party` — needs external service configuration
-
-For each item in "Testable Now", use Grep/Read to check if the underlying feature still exists in the codebase:
-- If the test references a component/function that no longer exists → mark as `stale`
-- If the test references code that has been significantly rewritten → mark as `needs_update`
-- Otherwise → mark as `active`
-</step>
-
-<step name="present">
-Present the audit report:
-
-```
-## UAT Audit Report
-
-**{total_items} outstanding items across {total_files} files in {phase_count} phases**
-
-### Testable Now ({count})
-
-| # | Phase | Test | Description | Status |
-|---|-------|------|-------------|--------|
-| 1 | {phase} | {test_name} | {expected} | {active/stale/needs_update} |
-...
-
-### Needs Prerequisites ({count})
-
-| # | Phase | Test | Blocked By | Description |
-|---|-------|------|------------|-------------|
-| 1 | {phase} | {test_name} | {category} | {expected} |
-...
-
-### Stale (can be closed) ({count})
-
-| # | Phase | Test | Why Stale |
-|---|-------|------|-----------|
-| 1 | {phase} | {test_name} | {reason} |
-...
-
----
-
-## Recommended Actions
-
-1. **Close stale items:** `/gsd-verify-work {phase}` — mark stale tests as resolved
-2. **Run active tests:** Human UAT test plan below
-3. **When prerequisites met:** Retest blocked items with `/gsd-verify-work {phase}`
-```
-</step>
-
-<step name="test_plan">
-Generate a human UAT test plan for "Testable Now" + "active" items only:
-
-Group by what can be tested together (same screen, same feature, same prerequisite):
-
-```
-## Human UAT Test Plan
-
-### Group 1: {category — e.g., "Billing Flow"}
-Prerequisites: {what needs to be running/configured}
-
-1. **{Test name}** (Phase {N})
-   - Navigate to: {where}
-   - Do: {action}
-   - Expected: {expected behavior}
-
-2. **{Test name}** (Phase {N})
-   ...
-
-### Group 2: {category}
-...
-```
-</step>
-
-</process>
+<purpose>
+Cross-phase audit of all UAT and verification files. Finds every outstanding item (pending, skipped, blocked, human_needed), optionally verifies against the codebase to detect stale docs, and produces a prioritized human test plan.
+</purpose>
+
+<process>
+
+<step name="initialize">
+Run the CLI audit:
+
+```bash
+AUDIT=$(gsd-sdk query audit-uat --raw)
+```
+
+Parse JSON for `results` array and `summary` object.
+
+If `summary.total_items` is 0:
+```
+## All Clear
+
+No outstanding UAT or verification items found across all phases.
+All tests are passing, resolved, or diagnosed with fix plans.
+```
+Stop here.
+</step>
+
+<step name="categorize">
+Group items by what's actionable NOW vs. what needs prerequisites:
+
+**Testable Now** (no external dependencies):
+- `pending` — tests never run
+- `human_uat` — human verification items
+- `skipped_unresolved` — skipped without clear blocking reason
+
+**Needs Prerequisites:**
+- `server_blocked` — needs external server running
+- `device_needed` — needs physical device (not simulator)
+- `build_needed` — needs release/preview build
+- `third_party` — needs external service configuration
+
+For each item in "Testable Now", use Grep/Read to check if the underlying feature still exists in the codebase:
+- If the test references a component/function that no longer exists → mark as `stale`
+- If the test references code that has been significantly rewritten → mark as `needs_update`
+- Otherwise → mark as `active`
+</step>
+
+<step name="present">
+Present the audit report:
+
+```
+## UAT Audit Report
+
+**{total_items} outstanding items across {total_files} files in {phase_count} phases**
+
+### Testable Now ({count})
+
+| # | Phase | Test | Description | Status |
+|---|-------|------|-------------|--------|
+| 1 | {phase} | {test_name} | {expected} | {active/stale/needs_update} |
+...
+
+### Needs Prerequisites ({count})
+
+| # | Phase | Test | Blocked By | Description |
+|---|-------|------|------------|-------------|
+| 1 | {phase} | {test_name} | {category} | {expected} |
+...
+
+### Stale (can be closed) ({count})
+
+| # | Phase | Test | Why Stale |
+|---|-------|------|-----------|
+| 1 | {phase} | {test_name} | {reason} |
+...
+
+---
+
+## Recommended Actions
+
+1. **Close stale items:** `/gsd-verify-work {phase}` — mark stale tests as resolved
+2. **Run active tests:** Human UAT test plan below
+3. **When prerequisites met:** Retest blocked items with `/gsd-verify-work {phase}`
+```
+</step>
+
+<step name="test_plan">
+Generate a human UAT test plan for "Testable Now" + "active" items only:
+
+Group by what can be tested together (same screen, same feature, same prerequisite):
+
+```
+## Human UAT Test Plan
+
+### Group 1: {category — e.g., "Billing Flow"}
+Prerequisites: {what needs to be running/configured}
+
+1. **{Test name}** (Phase {N})
+   - Navigate to: {where}
+   - Do: {action}
+   - Expected: {expected behavior}
+
+2. **{Test name}** (Phase {N})
+   ...
+
+### Group 2: {category}
+...
+```
+</step>
+
+</process>

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

@@ -48,7 +48,7 @@ When `--interactive` is set, discuss runs inline with questions (not auto-answer
 Bootstrap via milestone-level init:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" init milestone-op)
+INIT=$(gsd-sdk query init.milestone-op)
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
 
@@ -82,7 +82,7 @@ If `INTERACTIVE` is set, display: `Mode: Interactive (discuss inline, plan+execu
 Run phase discovery:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" roadmap analyze)
+ROADMAP=$(gsd-sdk query roadmap.analyze)
 ```
 
 Parse the JSON `phases` array.
@@ -141,7 +141,7 @@ Exit cleanly.
 **Fetch details for each phase:**
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" roadmap get-phase ${PHASE_NUM})
+DETAIL=$(gsd-sdk query roadmap.get-phase ${PHASE_NUM})
 ```
 
 Extract `phase_name`, `goal`, `success_criteria` from each. Store for use in execute_phase and transition messages.
@@ -169,7 +169,7 @@ Where N = current phase number (from the ROADMAP, e.g., 63), T = total milestone
 Check if CONTEXT.md already exists for this phase:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" init phase-op ${PHASE_NUM})
+PHASE_STATE=$(gsd-sdk query init.phase-op ${PHASE_NUM})
 ```
 
 Parse `has_context` from JSON.
@@ -185,7 +185,7 @@ Proceed to 3b.
 **If has_context is false:** Check if discuss is disabled via settings:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" config-get workflow.skip_discuss 2>/dev/null || echo "false")
+SKIP_DISCUSS=$(gsd-sdk query config-get workflow.skip_discuss 2>/dev/null || echo "false")
 ```
 
 **If SKIP_DISCUSS is `true`:** Skip discuss entirely — the ROADMAP phase description is the spec. Display:
@@ -197,7 +197,7 @@ Phase ${PHASE_NUM}: Discuss skipped (workflow.skip_discuss=true) — using ROADM
 Write a minimal CONTEXT.md so downstream plan-phase has valid input. Get phase details:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" roadmap get-phase ${PHASE_NUM})
+DETAIL=$(gsd-sdk query roadmap.get-phase ${PHASE_NUM})
 ```
 
 Extract `goal` and `requirements` from JSON. Write `${phase_dir}/${padded_phase}-CONTEXT.md` with:
@@ -249,7 +249,7 @@ None — discuss phase skipped.
 Commit the minimal context:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" commit "docs(${PADDED_PHASE}): auto-generated context (discuss skipped)" --files "${phase_dir}/${padded_phase}-CONTEXT.md"
+gsd-sdk query commit "docs(${PADDED_PHASE}): auto-generated context (discuss skipped)" "${phase_dir}/${padded_phase}-CONTEXT.md"
 ```
 
 Proceed to 3b.
@@ -270,7 +270,7 @@ Skill(skill="gsd:discuss-phase", args="${PHASE_NUM}")
 After discuss completes (either mode), verify context was written:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" init phase-op ${PHASE_NUM})
+PHASE_STATE=$(gsd-sdk query init.phase-op ${PHASE_NUM})
 ```
 
 Check `has_context`. If false → go to handle_blocker: "Discuss for phase ${PHASE_NUM} did not produce CONTEXT.md."
@@ -280,7 +280,7 @@ Check `has_context`. If false → go to handle_blocker: "Discuss for phase ${PHA
 Check if this phase has frontend indicators and whether a UI-SPEC already exists:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" roadmap get-phase ${PHASE_NUM} 2>/dev/null)
+PHASE_SECTION=$(gsd-sdk query roadmap.get-phase ${PHASE_NUM} 2>/dev/null)
 echo "$PHASE_SECTION" | grep -iE "UI|interface|frontend|component|layout|page|screen|view|form|dashboard|widget" > /dev/null 2>&1
 HAS_UI=$?
 UI_SPEC_FILE=$(ls "${PHASE_DIR}"/*-UI-SPEC.md 2>/dev/null | head -1)
@@ -289,7 +289,7 @@ UI_SPEC_FILE=$(ls "${PHASE_DIR}"/*-UI-SPEC.md 2>/dev/null | head -1)
 Check if UI phase workflow is enabled:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" config-get workflow.ui_phase 2>/dev/null || echo "true")
+UI_PHASE_CFG=$(gsd-sdk query config-get workflow.ui_phase 2>/dev/null || echo "true")
 ```
 
 **If `HAS_UI` is 0 (frontend indicators found) AND `UI_SPEC_FILE` is empty (no UI-SPEC exists) AND `UI_PHASE_CFG` is not `false`:**
@@ -362,7 +362,7 @@ Auto-invoke code review and fix chain. Autonomous mode chains both review and fi
 
 **Config gate:**
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" config-get workflow.code_review 2>/dev/null || echo "true")
+CODE_REVIEW_ENABLED=$(gsd-sdk query config-get workflow.code_review 2>/dev/null || echo "true")
 ```
 If `"false"`: display "Code review skipped (workflow.code_review=false)" and proceed to 3d.
 
@@ -390,7 +390,7 @@ VERIFY_STATUS=$(grep "^status:" "${PHASE_DIR}"/*-VERIFICATION.md 2>/dev/null | h
 Where `PHASE_DIR` comes from the `init phase-op` call already made in step 3a. If the variable is not in scope, re-fetch:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" init phase-op ${PHASE_NUM})
+PHASE_STATE=$(gsd-sdk query init.phase-op ${PHASE_NUM})
 ```
 
 Parse `phase_dir` from the JSON.
@@ -412,6 +412,8 @@ Proceed to iterate step.
 
 Read the human_verification section from VERIFICATION.md to get the count and items requiring manual testing.
 
+
+**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.
 Display the items, then ask user via AskUserQuestion:
 - **question:** "Phase ${PHASE_NUM} has items needing manual verification. Validate now or continue to next phase?"
 - **options:** "Validate now" / "Continue without validation"
@@ -484,7 +486,7 @@ UI_SPEC_FILE=$(ls "${PHASE_DIR}"/*-UI-SPEC.md 2>/dev/null | head -1)
 Check if UI review is enabled:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" config-get workflow.ui_review 2>/dev/null || echo "true")
+UI_REVIEW_CFG=$(gsd-sdk query config-get workflow.ui_review 2>/dev/null || echo "true")
 ```
 
 **If `UI_SPEC_FILE` is not empty AND `UI_REVIEW_CFG` is not `false`:**
@@ -509,283 +511,13 @@ Display the review result summary (score from UI-REVIEW.md if produced). Continu
 
 ## Smart Discuss
 
-Run smart discuss for the current phase. Proposes grey area answers in batch tables — the user accepts or overrides per area. Produces identical CONTEXT.md output to regular discuss-phase.
-
-> **Note:** Smart discuss is an autonomous-optimized variant of the `gsd-discuss-phase` skill. It produces identical CONTEXT.md output but uses batch table proposals instead of sequential questioning. The original `gsd-discuss-phase` skill remains unchanged (per CTRL-03). Future milestones may extract this to a separate skill file.
-
-**Inputs:** `PHASE_NUM` from execute_phase. Run init to get phase paths:
-
-```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" init phase-op ${PHASE_NUM})
-```
-
-Parse from JSON: `phase_dir`, `phase_slug`, `padded_phase`, `phase_name`.
-
----
-
-### Sub-step 1: Load prior context
-
-Read project-level and prior phase context to avoid re-asking decided questions.
-
-**Read project files:**
-
-```bash
-cat .planning/PROJECT.md 2>/dev/null || true
-cat .planning/REQUIREMENTS.md 2>/dev/null || true
-cat .planning/STATE.md 2>/dev/null || true
-```
-
-Extract from these:
-- **PROJECT.md** — Vision, principles, non-negotiables, user preferences
-- **REQUIREMENTS.md** — Acceptance criteria, constraints, must-haves vs nice-to-haves
-- **STATE.md** — Current progress, decisions logged so far
-
-**Read all prior CONTEXT.md files:**
-
-```bash
-(find .planning/phases -name "*-CONTEXT.md" 2>/dev/null || true) | sort
-```
-
-For each CONTEXT.md where phase number < current phase:
-- Read the `<decisions>` section — these are locked preferences
-- Read `<specifics>` — particular references or "I want it like X" moments
-- Note patterns (e.g., "user consistently prefers minimal UI", "user rejected verbose output")
-
-**Build internal prior_decisions context** (do not write to file):
-
-```
-<prior_decisions>
-## Project-Level
-- [Key principle or constraint from PROJECT.md]
-- [Requirement affecting this phase from REQUIREMENTS.md]
-
-## From Prior Phases
-### Phase N: [Name]
-- [Decision relevant to current phase]
-- [Preference that establishes a pattern]
-</prior_decisions>
-```
-
-If no prior context exists, continue without — expected for early phases.
-
----
-
-### Sub-step 2: Scout Codebase
-
-Lightweight codebase scan to inform grey area identification and proposals. Keep under ~5% context.
-
-**Check for existing codebase maps:**
-
-```bash
-ls .planning/codebase/*.md 2>/dev/null || true
-```
-
-**If codebase maps exist:** Read the most relevant ones (CONVENTIONS.md, STRUCTURE.md, STACK.md based on phase type). Extract reusable components, established patterns, integration points. Skip to building context below.
-
-**If no codebase maps, do targeted grep:**
-
-Extract key terms from the phase goal. Search for related files:
-
-```bash
-grep -rl "{term1}\|{term2}" src/ app/ --include="*.ts" --include="*.tsx" --include="*.js" --include="*.jsx" 2>/dev/null | head -10 || true
-ls src/components/ src/hooks/ src/lib/ src/utils/ 2>/dev/null || true
-```
-
-Read the 3-5 most relevant files to understand existing patterns.
-
-**Build internal codebase_context** (do not write to file):
-- **Reusable assets** — existing components, hooks, utilities usable in this phase
-- **Established patterns** — how the codebase does state management, styling, data fetching
-- **Integration points** — where new code connects (routes, nav, providers)
-
----
-
-### Sub-step 3: Analyze Phase and Generate Proposals
-
-**Get phase details:**
-
-```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" roadmap get-phase ${PHASE_NUM})
-```
-
-Extract `goal`, `requirements`, `success_criteria` from the JSON response.
-
-**Infrastructure detection — check FIRST before generating grey areas:**
-
-A phase is pure infrastructure when ALL of these are true:
-1. Goal keywords match: "scaffolding", "plumbing", "setup", "configuration", "migration", "refactor", "rename", "restructure", "upgrade", "infrastructure"
-2. AND success criteria are all technical: "file exists", "test passes", "config valid", "command runs"
-3. AND no user-facing behavior is described (no "users can", "displays", "shows", "presents")
-
-**If infrastructure-only:** Skip Sub-step 4. Jump directly to Sub-step 5 with minimal CONTEXT.md. Display:
-
-```
-Phase ${PHASE_NUM}: Infrastructure phase — skipping discuss, writing minimal context.
-```
-
-Use these defaults for the CONTEXT.md:
-- `<domain>`: Phase boundary from ROADMAP goal
-- `<decisions>`: Single "### Antigravity's Discretion" subsection — "All implementation choices are at Antigravity's discretion — pure infrastructure phase"
-- `<code_context>`: Whatever the codebase scout found
-- `<specifics>`: "No specific requirements — infrastructure phase"
-- `<deferred>`: "None"
-
-**If NOT infrastructure — generate grey area proposals:**
-
-Determine domain type from the phase goal:
-- Something users **SEE** → visual: layout, interactions, states, density
-- Something users **CALL** → interface: contracts, responses, errors, auth
-- Something users **RUN** → execution: invocation, output, behavior modes, flags
-- Something users **READ** → content: structure, tone, depth, flow
-- Something being **ORGANIZED** → organization: criteria, grouping, exceptions, naming
-
-Check prior_decisions — skip grey areas already decided in prior phases.
-
-Generate **3-4 grey areas** with **~4 questions each**. For each question:
-- **Pre-select a recommended answer** based on: prior decisions (consistency), codebase patterns (reuse), domain conventions (standard approaches), ROADMAP success criteria
-- Generate **1-2 alternatives** per question
-- **Annotate** with prior decision context ("You decided X in Phase N") and code context ("Component Y exists with Z variants") where relevant
-
----
-
-### Sub-step 4: Present Proposals Per Area
-
-Present grey areas **one at a time**. For each area (M of N):
-
-Display a table:
-
-```
-### Grey Area {M}/{N}: {Area Name}
-
-| # | Question | ✅ Recommended | Alternative(s) |
-|---|----------|---------------|-----------------|
-| 1 | {question} | {answer} — {rationale} | {alt1}; {alt2} |
-| 2 | {question} | {answer} — {rationale} | {alt1} |
-| 3 | {question} | {answer} — {rationale} | {alt1}; {alt2} |
-| 4 | {question} | {answer} — {rationale} | {alt1} |
-```
+> Full instructions are in `get-shit-done/references/autonomous-smart-discuss.md`. Read that file now and follow it exactly.
 
-Then prompt the user via **AskUserQuestion**:
-- **header:** "Area {M}/{N}"
-- **question:** "Accept these answers for {Area Name}?"
-- **options:** Build dynamically — always "Accept all" first, then "Change Q1" through "Change QN" for each question (up to 4), then "Discuss deeper" last. Cap at 6 explicit options max (AskUserQuestion adds "Other" automatically).
+Smart discuss is an autonomous-optimized variant of `gsd-discuss-phase`. It proposes grey area answers in batch tables — the user accepts or overrides per area — and writes an identical CONTEXT.md to what discuss-phase produces.
 
-**On "Accept all":** Record all recommended answers for this area. Move to next area.
+**Inputs:** `PHASE_NUM` from execute_phase.
 
-**On "Change QN":** Use AskUserQuestion with the alternatives for that specific question:
-- **header:** "{Area Name}"
-- **question:** "Q{N}: {question text}"
-- **options:** List the 1-2 alternatives plus "You decide" (maps to Antigravity's Discretion)
-
-Record the user's choice. Re-display the updated table with the change reflected. Re-present the full acceptance prompt so the user can make additional changes or accept.
-
-**On "Discuss deeper":** Switch to interactive mode for this area only — ask questions one at a time using AskUserQuestion with 2-3 concrete options per question plus "You decide". After 4 questions, prompt:
-- **header:** "{Area Name}"
-- **question:** "More questions about {area name}, or move to next?"
-- **options:** "More questions" / "Next area"
-
-If "More questions", ask 4 more. If "Next area", display final summary table of captured answers for this area and move on.
-
-**On "Other" (free text):** Interpret as either a specific change request or general feedback. Incorporate into the area's decisions, re-display updated table, re-present acceptance prompt.
-
-**Scope creep handling:** If user mentions something outside the phase domain:
-
-```
-"{Feature} sounds like a new capability — that belongs in its own phase.
-I'll note it as a deferred idea.
-
-Back to {current area}: {return to current question}"
-```
-
-Track deferred ideas internally for inclusion in CONTEXT.md.
-
----
-
-### Sub-step 5: Write CONTEXT.md
-
-After all areas are resolved (or infrastructure skip), write the CONTEXT.md file.
-
-**File path:** `${phase_dir}/${padded_phase}-CONTEXT.md`
-
-Use **exactly** this structure (identical to discuss-phase output):
-
-```markdown
-# Phase {PHASE_NUM}: {Phase Name} - Context
-
-**Gathered:** {date}
-**Status:** Ready for planning
-
-<domain>
-## Phase Boundary
-
-{Domain boundary statement from analysis — what this phase delivers}
-
-</domain>
-
-<decisions>
-## Implementation Decisions
-
-### {Area 1 Name}
-- {Accepted/chosen answer for Q1}
-- {Accepted/chosen answer for Q2}
-- {Accepted/chosen answer for Q3}
-- {Accepted/chosen answer for Q4}
-
-### {Area 2 Name}
-- {Accepted/chosen answer for Q1}
-- {Accepted/chosen answer for Q2}
-...
-
-### Antigravity's Discretion
-{Any "You decide" answers collected — note Antigravity has flexibility here}
-
-</decisions>
-
-<code_context>
-## Existing Code Insights
-
-### Reusable Assets
-- {From codebase scout — components, hooks, utilities}
-
-### Established Patterns
-- {From codebase scout — state management, styling, data fetching}
-
-### Integration Points
-- {From codebase scout — where new code connects}
-
-</code_context>
-
-<specifics>
-## Specific Ideas
-
-{Any specific references or "I want it like X" from discussion}
-{If none: "No specific requirements — open to standard approaches"}
-
-</specifics>
-
-<deferred>
-## Deferred Ideas
-
-{Ideas captured but out of scope for this phase}
-{If none: "None — discussion stayed within phase scope"}
-
-</deferred>
-```
-
-Write the file.
-
-**Commit:**
-
-```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" commit "docs(${PADDED_PHASE}): smart discuss context" --files "${phase_dir}/${padded_phase}-CONTEXT.md"
-```
-
-Display confirmation:
-
-```
-Created: {path}
-Decisions captured: {count} across {area_count} areas
-```
+Read and execute: `C:/projects/GSD-Antigravity/.antigravity/get-shit-done/references/autonomous-smart-discuss.md`
 
 </step>
 
@@ -813,7 +545,7 @@ Proceed directly to lifecycle step (which handles partial completion — skips a
 **Otherwise:** After each phase completes, re-read ROADMAP.md to catch phases inserted mid-execution (decimal phases like 5.1):
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" roadmap analyze)
+ROADMAP=$(gsd-sdk query roadmap.analyze)
 ```
 
 Re-filter incomplete phases using the same logic as discover_phases:

package/.agent/skills/gsd/references/workflows/check-todos.md

@@ -12,7 +12,7 @@ Read all files referenced by the invoking prompt's execution_context before star
 Load todo context:
 
 ```bash
-.agent/skills/gsd/bin/gsd-tools.cjs" init todos)
+INIT=$(gsd-sdk query init.todos)
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 ```
 
@@ -102,6 +102,8 @@ If `.planning/ROADMAP.md` exists:
 <step name="offer_actions">
 **If todo maps to a roadmap phase:**
 
+
+**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.
 Use AskUserQuestion:
 - header: "Action"
 - question: "This todo relates to Phase [N]: [name]. What would you like to do?"
@@ -155,7 +157,7 @@ If todo was moved to done/, commit the change:
 
 ```bash
 git rm --cached .planning/todos/pending/[filename] 2>/dev/null || true
-.agent/skills/gsd/bin/gsd-tools.cjs" commit "docs: start work on todo - [title]" --files .planning/todos/completed/[filename] .planning/STATE.md
+gsd-sdk query commit "docs: start work on todo - [title]" .planning/todos/completed/[filename] .planning/STATE.md
 ```
 
 Tool respects `commit_docs` config and gitignore automatically.