gsd-remix 1.0.2 → 1.1.0

package/get-shit-done/workflows/ingest-docs.md

@@ -1,328 +0,0 @@
-# Ingest Docs Workflow
-
-Scan a repo for mixed planning documents (ADR, PRD, SPEC, DOC), synthesize them into a consolidated context, and bootstrap or merge into `.planning/`.
-
-- `[path]` — optional target directory to scan (defaults to repo root)
-- `--mode new|merge` — override auto-detect (defaults: `new` if `.planning/` absent, `merge` if present)
-- `--manifest <file>` — YAML file listing `{path, type, precedence?}` per doc; overrides heuristic classification
-- `--resolve auto|interactive` — conflict resolution (v1: only `auto` is supported; `interactive` is reserved)
-
----
-
-<step name="banner">
-
-Display the stage banner:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- GSD ► INGEST DOCS
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-</step>
-
-<step name="parse_arguments">
-
-Parse `$ARGUMENTS`:
-
-- First positional token (if not a flag) → `SCAN_PATH` (default: `.`)
-- `--mode new|merge` → `MODE` (default: auto-detect)
-- `--manifest <file>` → `MANIFEST_PATH` (optional)
-- `--resolve auto|interactive` → `RESOLVE_MODE` (default: `auto`; reject `interactive` in v1 with message "interactive resolution is planned for a future release")
-
-**Validate paths:**
-
-```bash
-case "{SCAN_PATH}" in *..*) echo "SECURITY_ERROR: path contains traversal sequence"; exit 1 ;; esac
-test -d "{SCAN_PATH}" || echo "PATH_NOT_FOUND"
-if [ -n "{MANIFEST_PATH}" ]; then
-  case "{MANIFEST_PATH}" in *..*) echo "SECURITY_ERROR: manifest path contains traversal"; exit 1 ;; esac
-  test -f "{MANIFEST_PATH}" || echo "MANIFEST_NOT_FOUND"
-fi
-```
-
-**Containment (required):** After resolving `SCAN_PATH` and `MANIFEST_PATH` relative to the repo root, canonicalize each with `realpath` (or platform equivalent) and assert the result is under `realpath("$REPO_ROOT")`. Reject absolute paths outside the repo (e.g. `/tmp`, `C:\Windows`) even when they do not contain `..`.
-
-If `PATH_NOT_FOUND` or `MANIFEST_NOT_FOUND`: display error and exit.
-
-</step>
-
-<step name="init_and_mode_detect">
-
-Run the init query:
-
-```bash
-INIT=$(gsd-remix-sdk query init.ingest-docs)
-```
-
-Parse `project_exists`, `planning_exists`, `has_git`, `project_path` from INIT.
-
-**Auto-detect MODE** if not set:
-- `planning_exists: true` → `MODE=merge`
-- `planning_exists: false` → `MODE=new`
-
-If user passed `--mode new` but `.planning/` already exists: display warning and require explicit confirm via `AskUserQuestion` (approve-revise-abort from `references/gate-prompts.md`) before overwriting.
-
-If `has_git: false` and `MODE=new`: initialize git:
-```bash
-git init
-```
-
-**Detect runtime** using the same pattern as `new-project.md`:
-- execution_context path `/.codex/` → `RUNTIME=codex`
-- `/.gemini/` → `RUNTIME=gemini`
-- `/.opencode/` or `/.config/opencode/` → `RUNTIME=opencode`
-- else → `RUNTIME=claude`
-
-Fall back to env vars (`CODEX_HOME`, `GEMINI_CONFIG_DIR`, `OPENCODE_CONFIG_DIR`) if execution_context is unavailable.
-
-</step>
-
-<step name="discover_docs">
-
-Build the doc list from three sources, in order:
-
-**1. Manifest (if provided)** — authoritative:
-
-Read `MANIFEST_PATH`. Expected YAML shape:
-
-```yaml
-docs:
-  - path: docs/adr/0001-db.md
-    type: ADR
-    precedence: 0   # optional, lower = higher precedence
-  - path: docs/prd/auth.md
-    type: PRD
-```
-
-Each entry provides `path` (required, relative to repo root) + `type` (required, one of ADR|PRD|SPEC|DOC) + `precedence` (optional integer).
-
-**2. Directory conventions** (skipped when manifest is provided):
-
-```bash
-# ADRs
-find {SCAN_PATH} -type f \( -path '*/adr/*' -o -path '*/adrs/*' -o -name 'ADR-*.md' -o -regex '.*/[0-9]\{4\}-.*\.md' \) 2>/dev/null
-
-# PRDs
-find {SCAN_PATH} -type f \( -path '*/prd/*' -o -path '*/prds/*' -o -name 'PRD-*.md' \) 2>/dev/null
-
-# SPECs / RFCs
-find {SCAN_PATH} -type f \( -path '*/spec/*' -o -path '*/specs/*' -o -path '*/rfc/*' -o -path '*/rfcs/*' -o -name 'SPEC-*.md' -o -name 'RFC-*.md' \) 2>/dev/null
-
-# Generic docs (fall-through candidates)
-find {SCAN_PATH} -type f -path '*/docs/*' -name '*.md' 2>/dev/null
-```
-
-De-duplicate the union (a file matched by multiple patterns is one doc).
-
-**3. Content heuristics** (run during classification, not here) — the classifier handles frontmatter `type:` and H1 inspection for docs that didn't match a convention.
-
-**Cap:** hard limit of 50 docs per invocation (documented v1 constraint). If the discovered set exceeds 50:
-
-```
-GSD > Discovered {N} docs, which exceeds the v1 cap of 50.
-      Use --manifest to narrow the set to ≤ 50 files, or run
-      /gsd-ingest-docs again with a narrower <path>.
-```
-
-Exit without proceeding.
-
-**Display discovered set** and request approval (see `references/gate-prompts.md` — `yes-no-pick` pattern works; or `approve-revise-abort`):
-
-```
-Discovered {N} documents:
-  {N} ADR | {N} PRD | {N} SPEC | {N} DOC | {N} unclassified
-
-  docs/adr/0001-architecture.md       [ADR]    (from manifest|directory|heuristic)
-  docs/adr/0002-database.md           [ADR]    (directory)
-  docs/prd/auth.md                    [PRD]    (manifest)
-  ...
-```
-
-**Text mode:** apply the same `--text`/`text_mode` rule as other workflows — replace `AskUserQuestion` with a numbered list.
-
-Use `AskUserQuestion` (approve-revise-abort):
-- question: "Proceed with classification of these {N} documents?"
-- header: "Approve?"
-- options: Approve | Revise | Abort
-
-On Abort: exit cleanly with "Ingest cancelled."
-On Revise: exit with guidance to re-run with `--manifest` or a narrower path.
-
-</step>
-
-<step name="classify_parallel">
-
-Create staging directory:
-
-```bash
-mkdir -p .planning/intel/classifications/
-```
-
-For each discovered doc, spawn `gsd-doc-classifier` in parallel. In Claude Code, issue all Task calls in a single message with multiple tool uses so the harness runs them concurrently. For Copilot / sequential runtimes, fall back to sequential dispatch.
-
-Per-spawn prompt fields:
-- `FILEPATH` — absolute path to the doc
-- `OUTPUT_DIR` — `.planning/intel/classifications/`
-- `MANIFEST_TYPE` — the type from the manifest if present, else omit
-- `MANIFEST_PRECEDENCE` — the precedence integer from the manifest if present, else omit
-- `<required_reading>` — `agents/gsd-doc-classifier.md` (the agent definition itself)
-
-Collect the one-line confirmations from each classifier. If any classifier errors out, surface the error and abort without touching `.planning/` further.
-
-</step>
-
-<step name="synthesize">
-
-Spawn `gsd-doc-synthesizer` once:
-
-```
-Task({
-  subagent_type: "gsd-doc-synthesizer",
-  prompt: "
-    CLASSIFICATIONS_DIR: .planning/intel/classifications/
-    INTEL_DIR: .planning/intel/
-    CONFLICTS_PATH: .planning/INGEST-CONFLICTS.md
-    MODE: {MODE}
-    EXISTING_CONTEXT: {paths to existing .planning files if MODE=merge, else empty}
-    PRECEDENCE: {array from manifest defaults or default ['ADR','SPEC','PRD','DOC']}
-
-    <required_reading>
-    - agents/gsd-doc-synthesizer.md
-    - get-shit-done/references/doc-conflict-engine.md
-    </required_reading>
-  "
-})
-```
-
-The synthesizer writes:
-- `.planning/intel/decisions.md`, `.planning/intel/requirements.md`, `.planning/intel/constraints.md`, `.planning/intel/context.md`
-- `.planning/intel/SYNTHESIS.md`
-- `.planning/INGEST-CONFLICTS.md`
-
-</step>
-
-<step name="conflict_gate">
-
-Read `.planning/INGEST-CONFLICTS.md`. Count entries in each bucket (the synthesizer always writes the three-bucket header; parse the `### BLOCKERS ({N})`, `### WARNINGS ({N})`, `### INFO ({N})` lines).
-
-Apply the safety semantics from `references/doc-conflict-engine.md`. Operation noun: `ingest`.
-
-**If BLOCKERS > 0:**
-
-Render the report to the user, then display:
-
-```
-GSD > BLOCKED: {N} blockers must be resolved before ingest can proceed.
-```
-
-Exit WITHOUT writing PROJECT.md, REQUIREMENTS.md, ROADMAP.md, or STATE.md. The staging intel files remain for inspection. The safety gate holds — no destination files are written when blockers exist.
-
-**If WARNINGS > 0 and BLOCKERS = 0:**
-
-Render the report, then ask via AskUserQuestion (approve-revise-abort):
-- question: "Review the competing variants above. Resolve manually and proceed, or abort?"
-- header: "Approve?"
-- options: Approve | Abort
-
-On Abort: exit cleanly with "Ingest cancelled. Staged intel preserved at `.planning/intel/`."
-
-**If BLOCKERS = 0 and WARNINGS = 0:**
-
-Proceed to routing silently, or optionally display `GSD > No conflicts. Auto-resolved: {N}.`
-
-</step>
-
-<step name="route_new_mode">
-
-**Applies only when MODE=new.**
-
-Audit PROJECT.md field requirements that `gsd-roadmapper` expects. For fields derivable from `.planning/intel/SYNTHESIS.md` (project scope, goals/non-goals, constraints, locked decisions), synthesize from the intel. For fields NOT derivable (project name, developer-facing success metric, target runtime), prompt via `AskUserQuestion` one at a time — minimal question set, no interrogation.
-
-Delegate to `gsd-roadmapper`:
-
-```
-Task({
-  subagent_type: "gsd-roadmapper",
-  prompt: "
-    Mode: new-project-from-ingest
-    Intel: .planning/intel/SYNTHESIS.md (entry point)
-    Per-type intel: .planning/intel/{decisions,requirements,constraints,context}.md
-    User-supplied fields: {collected in previous step}
-
-    Produce:
-    - .planning/PROJECT.md
-    - .planning/REQUIREMENTS.md
-    - .planning/ROADMAP.md
-    - .planning/STATE.md
-
-    Treat ADR-locked decisions as locked in PROJECT.md <decisions> blocks.
-  "
-})
-```
-
-</step>
-
-<step name="route_merge_mode">
-
-**Applies only when MODE=merge.**
-
-Load existing `.planning/ROADMAP.md`, `.planning/PROJECT.md`, `.planning/REQUIREMENTS.md`, all `CONTEXT.md` files under `.planning/phases/`.
-
-The synthesizer has already hard-blocked on any LOCKED-in-ingest vs LOCKED-in-existing contradiction; if we reach this step, no such blockers remain.
-
-Plan the merge:
-- **New requirements** from synthesized `.planning/intel/requirements.md` that do not overlap existing REQUIREMENTS.md entries → append to REQUIREMENTS.md
-- **New decisions** from synthesized `.planning/intel/decisions.md` that do not overlap existing CONTEXT.md `<decisions>` blocks → write to a new phase's CONTEXT.md or append to the next milestone's requirements
-- **New scope** → derive phase additions following the `new-milestone.md` pattern; append phases to `.planning/ROADMAP.md`
-
-Preview the merge diff to the user and gate via approve-revise-abort before writing.
-
-</step>
-
-<step name="finalize">
-
-Commit the ingest results:
-
-```bash
-gsd-remix-sdk query commit "docs: ingest {N} docs from {SCAN_PATH} (#2387)" \
-  .planning/PROJECT.md \
-  .planning/REQUIREMENTS.md \
-  .planning/ROADMAP.md \
-  .planning/STATE.md \
-  .planning/intel/ \
-  .planning/INGEST-CONFLICTS.md
-```
-
-(For merge mode, substitute the actual set of modified files.)
-
-Display completion:
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- GSD ► INGEST DOCS COMPLETE
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-Show:
-- Mode ran (new or merge)
-- Docs ingested (count + type breakdown)
-- Decisions locked, requirements created, constraints captured
-- Conflict report path (`.planning/INGEST-CONFLICTS.md`)
-- Next step: `/gsd-plan-phase 1` (new mode) or `/gsd-plan-phase N` (merge, pointing at the first newly-added phase)
-
-</step>
-
----
-
-## Anti-Patterns
-
-Do NOT:
-- Violate the shared conflict-engine contract in `references/doc-conflict-engine.md` (no markdown tables, no new severity labels, no bypass of the BLOCKER gate)
-- Write PROJECT.md, REQUIREMENTS.md, ROADMAP.md, or STATE.md when BLOCKERs exist in the conflict report
-- Skip the 50-doc cap — larger sets must use `--manifest` to narrow the scope
-- Auto-resolve LOCKED-vs-LOCKED ADR contradictions — those are BLOCKERs in both modes
-- Merge competing PRD acceptance variants into a combined criterion — preserve all variants for user resolution
-- Bypass the discovery approval gate — users must see the classified doc list before classifiers spawn
-- Skip path validation on `SCAN_PATH` or `MANIFEST_PATH`
-- Implement `--resolve interactive` in this v1 — the flag is reserved; reject with a future-release message

package/get-shit-done/workflows/list-phase-assumptions.md

@@ -1,178 +0,0 @@
-<purpose>
-Surface Claude's assumptions about a phase before planning, enabling users to correct misconceptions early.
-
-Key difference from discuss-phase: This is ANALYSIS of what Claude thinks, not INTAKE of what user knows. No file output - purely conversational to prompt discussion.
-</purpose>
-
-<process>
-
-<step name="validate_phase" priority="first">
-Phase number: $ARGUMENTS (required)
-
-**If argument missing:**
-
-```
-Error: Phase number required.
-
-Usage: /gsd-list-phase-assumptions [phase-number]
-Example: /gsd-list-phase-assumptions 3
-```
-
-Exit workflow.
-
-**If argument provided:**
-Validate phase exists in roadmap:
-
-```bash
-cat .planning/ROADMAP.md | grep -i "Phase ${PHASE}"
-```
-
-**If phase not found:**
-
-```
-Error: Phase ${PHASE} not found in roadmap.
-
-Available phases:
-[list phases from roadmap]
-```
-
-Exit workflow.
-
-**If phase found:**
-Parse phase details from roadmap:
-
-- Phase number
-- Phase name
-- Phase description/goal
-- Any scope details mentioned
-
-Continue to analyze_phase.
-</step>
-
-<step name="analyze_phase">
-Based on roadmap description and project context, identify assumptions across five areas:
-
-**1. Technical Approach:**
-What libraries, frameworks, patterns, or tools would Claude use?
-- "I'd use X library because..."
-- "I'd follow Y pattern because..."
-- "I'd structure this as Z because..."
-
-**2. Implementation Order:**
-What would Claude build first, second, third?
-- "I'd start with X because it's foundational"
-- "Then Y because it depends on X"
-- "Finally Z because..."
-
-**3. Scope Boundaries:**
-What's included vs excluded in Claude's interpretation?
-- "This phase includes: A, B, C"
-- "This phase does NOT include: D, E, F"
-- "Boundary ambiguities: G could go either way"
-
-**4. Risk Areas:**
-Where does Claude expect complexity or challenges?
-- "The tricky part is X because..."
-- "Potential issues: Y, Z"
-- "I'd watch out for..."
-
-**5. Dependencies:**
-What does Claude assume exists or needs to be in place?
-- "This assumes X from previous phases"
-- "External dependencies: Y, Z"
-- "This will be consumed by..."
-
-Be honest about uncertainty. Mark assumptions with confidence levels:
-- "Fairly confident: ..." (clear from roadmap)
-- "Assuming: ..." (reasonable inference)
-- "Unclear: ..." (could go multiple ways)
-</step>
-
-<step name="present_assumptions">
-Present assumptions in a clear, scannable format:
-
-```
-## My Assumptions for Phase ${PHASE}: ${PHASE_NAME}
-
-### Technical Approach
-[List assumptions about how to implement]
-
-### Implementation Order
-[List assumptions about sequencing]
-
-### Scope Boundaries
-**In scope:** [what's included]
-**Out of scope:** [what's excluded]
-**Ambiguous:** [what could go either way]
-
-### Risk Areas
-[List anticipated challenges]
-
-### Dependencies
-**From prior phases:** [what's needed]
-**External:** [third-party needs]
-**Feeds into:** [what future phases need from this]
-
----
-
-**What do you think?**
-
-Are these assumptions accurate? Let me know:
-- What I got right
-- What I got wrong
-- What I'm missing
-```
-
-Wait for user response.
-</step>
-
-<step name="gather_feedback">
-**If user provides corrections:**
-
-Acknowledge the corrections:
-
-```
-Key corrections:
-- [correction 1]
-- [correction 2]
-
-This changes my understanding significantly. [Summarize new understanding]
-```
-
-**If user confirms assumptions:**
-
-```
-Assumptions validated.
-```
-
-Continue to offer_next.
-</step>
-
-<step name="offer_next">
-Present next steps:
-
-```
-What's next?
-1. Discuss context (/gsd-discuss-phase ${PHASE}) - Let me ask you questions to build comprehensive context
-2. Plan this phase (/gsd-plan-phase ${PHASE}) - Create detailed execution plans
-3. Re-examine assumptions - I'll analyze again with your corrections
-4. Done for now
-```
-
-Wait for user selection.
-
-If "Discuss context": Note that CONTEXT.md will incorporate any corrections discussed here
-If "Plan this phase": Proceed knowing assumptions are understood
-If "Re-examine": Return to analyze_phase with updated understanding
-</step>
-
-</process>
-
-<success_criteria>
-- Phase number validated against roadmap
-- Assumptions surfaced across five areas: technical approach, implementation order, scope, risks, dependencies
-- Confidence levels marked where appropriate
-- "What do you think?" prompt presented
-- User feedback acknowledged
-- Clear next steps offered
-</success_criteria>

package/get-shit-done/workflows/list-workspaces.md

@@ -1,56 +0,0 @@
-<purpose>
-List all GSD workspaces found in ~/gsd-workspaces/ with their status.
-</purpose>
-
-<required_reading>
-Read all files referenced by the invoking prompt's execution_context before starting.
-</required_reading>
-
-<process>
-
-## 1. Setup
-
-```bash
-INIT=$(gsd-remix-sdk query init.list-workspaces)
-if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
-```
-
-Parse JSON for: `workspace_base`, `workspaces`, `workspace_count`.
-
-## 2. Display
-
-**If `workspace_count` is 0:**
-
-```
-No workspaces found in ~/gsd-workspaces/
-
-Create one with:
-  /gsd-new-workspace --name my-workspace --repos repo1,repo2
-```
-
-Done.
-
-**If workspaces exist:**
-
-Display a table:
-
-```
-GSD Workspaces (~/gsd-workspaces/)
-
-| Name | Repos | Strategy | GSD Project |
-|------|-------|----------|-------------|
-| feature-a | 3 | worktree | Yes |
-| feature-b | 2 | clone | No |
-
-Manage:
-  cd ~/gsd-workspaces/<name>     # Enter a workspace
-  /gsd-remove-workspace <name>   # Remove a workspace
-```
-
-For each workspace, show:
-- **Name** — directory name
-- **Repos** — count from init data
-- **Strategy** — from WORKSPACE.md
-- **GSD Project** — whether `.planning/PROJECT.md` exists (Yes/No)
-
-</process>