@undeemed/get-shit-done-codex 1.23.2 → 1.24.2

package/get-shit-done/bin/lib/state.cjs

@@ -4,7 +4,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { loadConfig, getMilestoneInfo, output, error } = require('./core.cjs');
+const { loadConfig, getMilestoneInfo, getMilestonePhaseFilter, output, error } = require('./core.cjs');
 const { extractFrontmatter, reconstructFrontmatter } = require('./frontmatter.cjs');
 
 function cmdStateLoad(cwd, raw) {
@@ -65,11 +65,19 @@ function cmdStateGet(cwd, section, raw) {
     // Try to find markdown section or field
     const fieldEscaped = section.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 
-    // Check for **field:** value
-    const fieldPattern = new RegExp(`\\*\\*${fieldEscaped}:\\*\\*\\s*(.*)`, 'i');
-    const fieldMatch = content.match(fieldPattern);
-    if (fieldMatch) {
-      output({ [section]: fieldMatch[1].trim() }, raw, fieldMatch[1].trim());
+    // Check for **field:** value (bold format)
+    const boldPattern = new RegExp(`\\*\\*${fieldEscaped}:\\*\\*\\s*(.*)`, 'i');
+    const boldMatch = content.match(boldPattern);
+    if (boldMatch) {
+      output({ [section]: boldMatch[1].trim() }, raw, boldMatch[1].trim());
+      return;
+    }
+
+    // Check for field: value (plain format)
+    const plainPattern = new RegExp(`^${fieldEscaped}:\\s*(.*)`, 'im');
+    const plainMatch = content.match(plainPattern);
+    if (plainMatch) {
+      output({ [section]: plainMatch[1].trim() }, raw, plainMatch[1].trim());
       return;
     }
 
@@ -106,10 +114,15 @@ function cmdStatePatch(cwd, patches, raw) {
 
     for (const [field, value] of Object.entries(patches)) {
       const fieldEscaped = field.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      const pattern = new RegExp(`(\\*\\*${fieldEscaped}:\\*\\*\\s*)(.*)`, 'i');
+      // Try **Field:** bold format first, then plain Field: format
+      const boldPattern = new RegExp(`(\\*\\*${fieldEscaped}:\\*\\*\\s*)(.*)`, 'i');
+      const plainPattern = new RegExp(`(^${fieldEscaped}:\\s*)(.*)`, 'im');
 
-      if (pattern.test(content)) {
-        content = content.replace(pattern, (_match, prefix) => `${prefix}${value}`);
+      if (boldPattern.test(content)) {
+        content = content.replace(boldPattern, (_match, prefix) => `${prefix}${value}`);
+        results.updated.push(field);
+      } else if (plainPattern.test(content)) {
+        content = content.replace(plainPattern, (_match, prefix) => `${prefix}${value}`);
         results.updated.push(field);
       } else {
         results.failed.push(field);
@@ -135,9 +148,15 @@ function cmdStateUpdate(cwd, field, value) {
   try {
     let content = fs.readFileSync(statePath, 'utf-8');
     const fieldEscaped = field.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const pattern = new RegExp(`(\\*\\*${fieldEscaped}:\\*\\*\\s*)(.*)`, 'i');
-    if (pattern.test(content)) {
-      content = content.replace(pattern, (_match, prefix) => `${prefix}${value}`);
+    // Try **Field:** bold format first, then plain Field: format
+    const boldPattern = new RegExp(`(\\*\\*${fieldEscaped}:\\*\\*\\s*)(.*)`, 'i');
+    const plainPattern = new RegExp(`(^${fieldEscaped}:\\s*)(.*)`, 'im');
+    if (boldPattern.test(content)) {
+      content = content.replace(boldPattern, (_match, prefix) => `${prefix}${value}`);
+      writeStateMd(statePath, content, cwd);
+      output({ updated: true });
+    } else if (plainPattern.test(content)) {
+      content = content.replace(plainPattern, (_match, prefix) => `${prefix}${value}`);
       writeStateMd(statePath, content, cwd);
       output({ updated: true });
     } else {
@@ -151,16 +170,27 @@ function cmdStateUpdate(cwd, field, value) {
 // ─── State Progression Engine ────────────────────────────────────────────────
 
 function stateExtractField(content, fieldName) {
-  const pattern = new RegExp(`\\*\\*${fieldName}:\\*\\*\\s*(.+)`, 'i');
-  const match = content.match(pattern);
-  return match ? match[1].trim() : null;
+  const escaped = fieldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  // Try **Field:** bold format first
+  const boldPattern = new RegExp(`\\*\\*${escaped}:\\*\\*\\s*(.+)`, 'i');
+  const boldMatch = content.match(boldPattern);
+  if (boldMatch) return boldMatch[1].trim();
+  // Fall back to plain Field: format
+  const plainPattern = new RegExp(`^${escaped}:\\s*(.+)`, 'im');
+  const plainMatch = content.match(plainPattern);
+  return plainMatch ? plainMatch[1].trim() : null;
 }
 
 function stateReplaceField(content, fieldName, newValue) {
   const escaped = fieldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const pattern = new RegExp(`(\\*\\*${escaped}:\\*\\*\\s*)(.*)`, 'i');
-  if (pattern.test(content)) {
-    return content.replace(pattern, (_match, prefix) => `${prefix}${newValue}`);
+  // Try **Field:** bold format first, then plain Field: format
+  const boldPattern = new RegExp(`(\\*\\*${escaped}:\\*\\*\\s*)(.*)`, 'i');
+  if (boldPattern.test(content)) {
+    return content.replace(boldPattern, (_match, prefix) => `${prefix}${newValue}`);
+  }
+  const plainPattern = new RegExp(`(^${escaped}:\\s*)(.*)`, 'im');
+  if (plainPattern.test(content)) {
+    return content.replace(plainPattern, (_match, prefix) => `${prefix}${newValue}`);
   }
   return null;
 }
@@ -255,9 +285,15 @@ function cmdStateUpdateProgress(cwd, raw) {
   const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(barWidth - filled);
   const progressStr = `[${bar}] ${percent}%`;
 
-  const progressPattern = /(\*\*Progress:\*\*\s*).*/i;
-  if (progressPattern.test(content)) {
-    content = content.replace(progressPattern, (_match, prefix) => `${prefix}${progressStr}`);
+  // Try **Progress:** bold format first, then plain Progress: format
+  const boldProgressPattern = /(\*\*Progress:\*\*\s*).*/i;
+  const plainProgressPattern = /^(Progress:\s*).*/im;
+  if (boldProgressPattern.test(content)) {
+    content = content.replace(boldProgressPattern, (_match, prefix) => `${prefix}${progressStr}`);
+    writeStateMd(statePath, content, cwd);
+    output({ updated: true, percent, completed: totalSummaries, total: totalPlans, bar: progressStr }, raw, progressStr);
+  } else if (plainProgressPattern.test(content)) {
+    content = content.replace(plainProgressPattern, (_match, prefix) => `${prefix}${progressStr}`);
     writeStateMd(statePath, content, cwd);
     output({ updated: true, percent, completed: totalSummaries, total: totalPlans, bar: progressStr }, raw, progressStr);
   } else {
@@ -413,11 +449,17 @@ function cmdStateSnapshot(cwd, raw) {
 
   const content = fs.readFileSync(statePath, 'utf-8');
 
-  // Helper to extract **Field:** value patterns
+  // Helper to extract field values — supports both **Field:** bold format
+  // and plain Field: format (STATE.md may use either depending on version)
   const extractField = (fieldName) => {
-    const pattern = new RegExp(`\\*\\*${fieldName}:\\*\\*\\s*(.+)`, 'i');
-    const match = content.match(pattern);
-    return match ? match[1].trim() : null;
+    // Try **Field:** format first (bold markdown)
+    const boldPattern = new RegExp(`\\*\\*${fieldName}:\\*\\*\\s*(.+)`, 'i');
+    const boldMatch = content.match(boldPattern);
+    if (boldMatch) return boldMatch[1].trim();
+    // Fall back to plain Field: format
+    const plainPattern = new RegExp(`^${fieldName}:\\s*(.+)`, 'im');
+    const plainMatch = content.match(plainPattern);
+    return plainMatch ? plainMatch[1].trim() : null;
   };
 
   // Extract basic fields
@@ -476,9 +518,12 @@ function cmdStateSnapshot(cwd, raw) {
   const sessionMatch = content.match(/##\s*Session\s*\n([\s\S]*?)(?=\n##|$)/i);
   if (sessionMatch) {
     const sessionSection = sessionMatch[1];
-    const lastDateMatch = sessionSection.match(/\*\*Last Date:\*\*\s*(.+)/i);
-    const stoppedAtMatch = sessionSection.match(/\*\*Stopped At:\*\*\s*(.+)/i);
-    const resumeFileMatch = sessionSection.match(/\*\*Resume File:\*\*\s*(.+)/i);
+    const lastDateMatch = sessionSection.match(/\*\*Last Date:\*\*\s*(.+)/i)
+      || sessionSection.match(/^Last Date:\s*(.+)/im);
+    const stoppedAtMatch = sessionSection.match(/\*\*Stopped At:\*\*\s*(.+)/i)
+      || sessionSection.match(/^Stopped At:\s*(.+)/im);
+    const resumeFileMatch = sessionSection.match(/\*\*Resume File:\*\*\s*(.+)/i)
+      || sessionSection.match(/^Resume File:\s*(.+)/im);
 
     if (lastDateMatch) session.last_date = lastDateMatch[1].trim();
     if (stoppedAtMatch) session.stopped_at = stoppedAtMatch[1].trim();
@@ -512,10 +557,14 @@ function cmdStateSnapshot(cwd, raw) {
  * reliably via `state json` instead of fragile regex parsing.
  */
 function buildStateFrontmatter(bodyContent, cwd) {
+  // Supports both **Field:** bold and plain Field: format (see state-snapshot)
   const extractField = (fieldName) => {
-    const pattern = new RegExp(`\\*\\*${fieldName}:\\*\\*\\s*(.+)`, 'i');
-    const match = bodyContent.match(pattern);
-    return match ? match[1].trim() : null;
+    const boldPattern = new RegExp(`\\*\\*${fieldName}:\\*\\*\\s*(.+)`, 'i');
+    const boldMatch = bodyContent.match(boldPattern);
+    if (boldMatch) return boldMatch[1].trim();
+    const plainPattern = new RegExp(`^${fieldName}:\\s*(.+)`, 'im');
+    const plainMatch = bodyContent.match(plainPattern);
+    return plainMatch ? plainMatch[1].trim() : null;
   };
 
   const currentPhase = extractField('Current Phase');
@@ -548,8 +597,10 @@ function buildStateFrontmatter(bodyContent, cwd) {
     try {
       const phasesDir = path.join(cwd, '.planning', 'phases');
       if (fs.existsSync(phasesDir)) {
+        const isDirInMilestone = getMilestonePhaseFilter(cwd);
         const phaseDirs = fs.readdirSync(phasesDir, { withFileTypes: true })
-          .filter(e => e.isDirectory()).map(e => e.name);
+          .filter(e => e.isDirectory()).map(e => e.name)
+          .filter(isDirInMilestone);
         let diskTotalPlans = 0;
         let diskTotalSummaries = 0;
         let diskCompletedPhases = 0;
@@ -562,7 +613,9 @@ function buildStateFrontmatter(bodyContent, cwd) {
           diskTotalSummaries += summaries;
           if (plans > 0 && summaries >= plans) diskCompletedPhases++;
         }
-        if (totalPhases === null) totalPhases = phaseDirs.length;
+        totalPhases = isDirInMilestone.phaseCount > 0
+          ? Math.max(phaseDirs.length, isDirInMilestone.phaseCount)
+          : phaseDirs.length;
         completedPhases = diskCompletedPhases;
         totalPlans = diskTotalPlans;
         completedPlans = diskTotalSummaries;

package/get-shit-done/references/checkpoints.md

@@ -8,7 +8,6 @@ Plans execute autonomously. Checkpoints formalize interaction points where human
 2. **Codex sets up the verification environment** - Start dev servers, seed databases, configure env vars
 3. **User only does what requires human judgment** - Visual checks, UX evaluation, "does this feel right?"
 4. **Secrets come from user, automation comes from Codex** - Ask for API keys, then Codex uses them via CLI
-5. **Auto-mode bypasses verification/decision checkpoints** — When `workflow.auto_advance` is true in config: human-verify auto-approves, decision auto-selects first option, human-action still stops (auth gates cannot be automated)
 </overview>
 
 <checkpoint_types>

package/get-shit-done/references/model-profile-resolution.md

@@ -14,21 +14,28 @@ Default: `balanced` if not set or config missing.
 
 @~/.codex/get-shit-done/references/model-profiles.md
 
-Look up the agent in the table for the resolved profile. Pass the model parameter to Task calls:
+Look up the agent in the table for the resolved profile. Each entry returns:
+
+```json
+{ "model": "inherit", "thinking": "xhigh" }
+```
+
+All agents use `gpt-5.3-codex` (via `"inherit"`). The `thinking` field controls reasoning effort.
+
+Pass both parameters to Task calls:
 
 ```
 Task(
   prompt="...",
   subagent_type="gsd-planner",
-  model="{resolved_model}"  # "inherit", "sonnet", or "haiku"
+  model="inherit",
+  thinking="{resolved_thinking}"  # "xhigh", "high", "medium", or "low"
 )
 ```
 
-**Note:** Opus-tier agents resolve to `"inherit"` (not `"opus"`). This causes the agent to use the parent session's model, avoiding conflicts with organization policies that may block specific opus versions.
-
 ## Usage
 
 1. Resolve once at orchestration start
 2. Store the profile value
-3. Look up each agent's model from the table when spawning
-4. Pass model parameter to each Task call (values: `"inherit"`, `"sonnet"`, `"haiku"`)
+3. Look up each agent's `{ model, thinking }` from the table
+4. Pass both model and thinking parameters to each Task call

package/get-shit-done/references/model-profiles.md

@@ -1,92 +1,101 @@
 # Model Profiles
 
-Model profiles control which Codex model each GSD agent uses. This allows balancing quality vs token spend.
+Model profiles control the reasoning effort level for each GSD agent. All agents use `gpt-5.3-codex` (Codex-optimized for agentic coding); what varies is the **thinking level** — how much reasoning budget each agent gets based on its role.
 
 ## Profile Definitions
 
-| Agent | `quality` | `balanced` | `budget` |
-|-------|-----------|------------|----------|
-| gsd-planner | opus | opus | sonnet |
-| gsd-roadmapper | opus | sonnet | sonnet |
-| gsd-executor | opus | sonnet | sonnet |
-| gsd-phase-researcher | opus | sonnet | haiku |
-| gsd-project-researcher | opus | sonnet | haiku |
-| gsd-research-synthesizer | sonnet | sonnet | haiku |
-| gsd-debugger | opus | sonnet | sonnet |
-| gsd-codebase-mapper | sonnet | haiku | haiku |
-| gsd-verifier | sonnet | sonnet | haiku |
-| gsd-plan-checker | sonnet | sonnet | haiku |
-| gsd-integration-checker | sonnet | sonnet | haiku |
+| Agent                    | `quality` | `balanced` | `budget`  |
+| ------------------------ | --------- | ---------- | --------- |
+| gsd-planner              | 🔴 xhigh  | 🔴 xhigh   | 🟢 high   |
+| gsd-roadmapper           | 🔴 xhigh  | 🟢 high    | 🟡 medium |
+| gsd-executor             | 🔴 xhigh  | 🟢 high    | 🟡 medium |
+| gsd-phase-researcher     | 🟢 high   | 🟡 medium  | 🟡 medium |
+| gsd-project-researcher   | 🟢 high   | 🟡 medium  | 🟡 medium |
+| gsd-research-synthesizer | 🟢 high   | 🟡 medium  | 🟡 medium |
+| gsd-debugger             | 🔴 xhigh  | 🔴 xhigh   | 🟢 high   |
+| gsd-codebase-mapper      | 🟡 medium | 🟡 medium  | 🟡 medium |
+| gsd-verifier             | 🟢 high   | 🟢 high    | 🟡 medium |
+| gsd-plan-checker         | 🟢 high   | 🟡 medium  | 🟡 medium |
+| gsd-integration-checker  | 🟢 high   | 🟡 medium  | 🟡 medium |
+
+All entries resolve to `model: "inherit"` (uses the session's gpt-5.3-codex). The `thinking` field controls reasoning effort.
 
 ## Profile Philosophy
 
-**quality** - Maximum reasoning power
-- Opus for all decision-making agents
-- Sonnet for read-only verification
-- Use when: quota available, critical architecture work
+**quality** - Maximum reasoning for every role
 
-**balanced** (default) - Smart allocation
-- Opus only for planning (where architecture decisions happen)
-- Sonnet for execution and research (follows explicit instructions)
-- Sonnet for verification (needs reasoning, not just pattern matching)
-- Use when: normal development, good balance of quality and cost
+- 🔴 **xhigh** for decision-makers: planner, roadmapper, executor, debugger
+- 🟢 **high** for analysis: researchers, verifiers, checkers
+- 🟡 **medium** for read-only mapping
+- Use when: critical architecture work, complex debugging
 
-**budget** - Minimal Opus usage
-- Sonnet for anything that writes code
-- Haiku for research and verification
-- Use when: conserving quota, high-volume work, less critical phases
+**balanced** (default) - Smart thinking allocation
+
+- 🔴 **xhigh** only for planner and debugger (highest-impact decisions)
+- 🟢 **high** for executor and verifier (needs reasoning but follows plans)
+- 🟡 **medium** for everything else (structured output, scanning)
+- Use when: normal development
+
+**budget** - Minimal reasoning budget
+
+- 🟢 **high** for planner and debugger (always need some reasoning)
+- 🟡 **medium** for everything else
+- Use when: high-volume work, less critical phases
+
+## Role-Based Thinking Rationale
+
+**Why xhigh thinking for gsd-planner?**
+Planning involves architecture decisions, goal decomposition, and task design. These decisions cascade through the entire phase — worth the extra reasoning budget.
+
+**Why xhigh thinking for gsd-debugger even in balanced?**
+Root cause analysis requires deep reasoning. A debugger that misdiagnoses wastes more tokens in re-runs than the reasoning cost.
+
+**Why medium thinking for gsd-codebase-mapper?**
+Read-only file scanning and pattern extraction. No decisions to make — just structured output from file contents.
+
+**Why high thinking for gsd-verifier in balanced?**
+Verification requires goal-backward reasoning — checking if code _delivers_ what the phase promised. Medium thinking may miss subtle gaps.
+
+**Why medium thinking for researchers in balanced?**
+Research agents scan and collect information. The synthesis happens elsewhere. They don't need deep reasoning for reading files.
 
 ## Resolution Logic
 
-Orchestrators resolve model before spawning:
+Orchestrators resolve model and thinking before spawning:
 
 ```
 1. Read .planning/config.json
 2. Check model_overrides for agent-specific override
 3. If no override, look up agent in profile table
-4. Pass model parameter to Task call
+4. Pass model + thinking to Task call
 ```
 
+Returns: `{ model: "inherit", thinking: "xhigh"|"high"|"medium"|"low" }`
+
 ## Per-Agent Overrides
 
-Override specific agents without changing the entire profile:
+Override thinking level for specific agents:
 
 ```json
 {
   "model_profile": "balanced",
   "model_overrides": {
-    "gsd-executor": "opus",
-    "gsd-planner": "haiku"
+    "gsd-executor": "xhigh",
+    "gsd-codebase-mapper": "high"
   }
 }
 ```
 
-Overrides take precedence over the profile. Valid values: `opus`, `sonnet`, `haiku`.
+Valid override values: `"xhigh"`, `"high"`, `"medium"`, `"low"`.
 
 ## Switching Profiles
 
 Runtime: `$gsd-set-profile <profile>`
 
-Per-project default: Set in `.planning/config.json`:
+Per-project default in `.planning/config.json`:
+
 ```json
 {
   "model_profile": "balanced"
 }
 ```
-
-## Design Rationale
-
-**Why Opus for gsd-planner?**
-Planning involves architecture decisions, goal decomposition, and task design. This is where model quality has the highest impact.
-
-**Why Sonnet for gsd-executor?**
-Executors follow explicit PLAN.md instructions. The plan already contains the reasoning; execution is implementation.
-
-**Why Sonnet (not Haiku) for verifiers in balanced?**
-Verification requires goal-backward reasoning - checking if code *delivers* what the phase promised, not just pattern matching. Sonnet handles this well; Haiku may miss subtle gaps.
-
-**Why Haiku for gsd-codebase-mapper?**
-Read-only exploration and pattern extraction. No reasoning required, just structured output from file contents.
-
-**Why `inherit` instead of passing `opus` directly?**
-Codex CLI's `"opus"` alias maps to a specific model version. Organizations may block older opus versions while allowing newer ones. GSD returns `"inherit"` for opus-tier agents, causing them to use whatever opus version the user has configured in their session. This avoids version conflicts and silent fallbacks to Sonnet.

package/get-shit-done/templates/context.md

@@ -54,6 +54,20 @@ Template for `.planning/phases/XX-name/{phase_num}-CONTEXT.md` - captures implem
 
 </specifics>
 
+<code_context>
+## Existing Code Insights
+
+### Reusable Assets
+- [Component/hook/utility]: [How it could be used in this phase]
+
+### Established Patterns
+- [Pattern]: [How it constrains/enables this phase]
+
+### Integration Points
+- [Where new code connects to existing system]
+
+</code_context>
+
 <deferred>
 ## Deferred Ideas
 

package/get-shit-done/templates/phase-prompt.md

@@ -20,7 +20,6 @@ wave: N                     # Execution wave (1, 2, 3...). Pre-computed at plan
 depends_on: []              # Plan IDs this plan requires (e.g., ["01-01"]).
 files_modified: []          # Files this plan modifies.
 autonomous: true            # false if plan has checkpoints requiring user interaction
-requirements: []            # REQUIRED — Requirement IDs from ROADMAP this plan addresses. MUST NOT be empty.
 user_setup: []              # Human-required setup Codex cannot automate (see below)
 
 # Goal-backward verification (derived during planning, verified after execution)
@@ -130,7 +129,6 @@ After completion, create `.planning/phases/XX-name/{phase}-{plan}-SUMMARY.md`
 | `depends_on` | Yes | Array of plan IDs this plan requires. |
 | `files_modified` | Yes | Files this plan touches. |
 | `autonomous` | Yes | `true` if no checkpoints, `false` if has checkpoints |
-| `requirements` | Yes | **MUST** list requirement IDs from ROADMAP. Every roadmap requirement MUST appear in at least one plan. |
 | `user_setup` | No | Array of human-required setup items (external services) |
 | `must_haves` | Yes | Goal-backward verification criteria (see below) |
 

package/get-shit-done/workflows/audit-milestone.md

@@ -57,8 +57,6 @@ If a phase is missing VERIFICATION.md, flag it as "unverified phase" — this is
 
 With phase context collected:
 
-Extract `MILESTONE_REQ_IDS` from REQUIREMENTS.md traceability table — all REQ-IDs assigned to phases in this milestone.
-
 ```
 Task(
   prompt="Check cross-phase integration and E2E flows.
@@ -67,11 +65,6 @@ Phases: {phase_dirs}
 Phase exports: {from SUMMARYs}
 API routes: {routes created}
 
-Milestone Requirements:
-{MILESTONE_REQ_IDS — list each REQ-ID with description and assigned phase}
-
-MUST map each integration finding to affected requirement IDs where applicable.
-
 Verify cross-phase wiring and E2E user flows.",
   subagent_type="gsd-integration-checker",
   model="{integration_checker_model}"
@@ -84,48 +77,12 @@ Combine:
 - Phase-level gaps and tech debt (from step 2)
 - Integration checker's report (wiring gaps, broken flows)
 
-## 5. Check Requirements Coverage (3-Source Cross-Reference)
-
-MUST cross-reference three independent sources for each requirement:
-
-### 5a. Parse REQUIREMENTS.md Traceability Table
-
-Extract all REQ-IDs mapped to milestone phases from the traceability table:
-- Requirement ID, description, assigned phase, current status, checked-off state (`[x]` vs `[ ]`)
-
-### 5b. Parse Phase VERIFICATION.md Requirements Tables
-
-For each phase's VERIFICATION.md, extract the expanded requirements table:
-- Requirement | Source Plan | Description | Status | Evidence
-- Map each entry back to its REQ-ID
-
-### 5c. Extract SUMMARY.md Frontmatter Cross-Check
-
-For each phase's SUMMARY.md, extract `requirements-completed` from YAML frontmatter:
-```bash
-for summary in .planning/phases/*-*/*-SUMMARY.md; do
-  node ~/.codex/get-shit-done/bin/gsd-tools.cjs summary-extract "$summary" --fields requirements_completed | jq -r '.requirements_completed'
-done
-```
-
-### 5d. Status Determination Matrix
-
-For each REQ-ID, determine status using all three sources:
-
-| VERIFICATION.md Status | SUMMARY Frontmatter | REQUIREMENTS.md | → Final Status |
-|------------------------|---------------------|-----------------|----------------|
-| passed                 | listed              | `[x]`           | **satisfied**  |
-| passed                 | listed              | `[ ]`           | **satisfied** (update checkbox) |
-| passed                 | missing             | any             | **partial** (verify manually) |
-| gaps_found             | any                 | any             | **unsatisfied** |
-| missing                | listed              | any             | **partial** (verification gap) |
-| missing                | missing             | any             | **unsatisfied** |
-
-### 5e. FAIL Gate and Orphan Detection
-
-**REQUIRED:** Any `unsatisfied` requirement MUST force `gaps_found` status on the milestone audit.
+## 5. Check Requirements Coverage
 
-**Orphan detection:** Requirements present in REQUIREMENTS.md traceability table but absent from ALL phase VERIFICATION.md files MUST be flagged as orphaned. Orphaned requirements are treated as `unsatisfied` — they were assigned but never verified by any phase.
+For each requirement in REQUIREMENTS.md mapped to this milestone:
+- Find owning phase
+- Check phase verification status
+- Determine: satisfied | partial | unsatisfied
 
 ## 6. Aggregate into v{version}-MILESTONE-AUDIT.md
 
@@ -142,14 +99,7 @@ scores:
   integration: N/M
   flows: N/M
 gaps:  # Critical blockers
-  requirements:
-    - id: "{REQ-ID}"
-      status: "unsatisfied | partial | orphaned"
-      phase: "{assigned phase}"
-      claimed_by_plans: ["{plan files that reference this requirement}"]
-      completed_by_plans: ["{plan files whose SUMMARY marks it complete}"]
-      verification_status: "passed | gaps_found | missing | orphaned"
-      evidence: "{specific evidence or lack thereof}"
+  requirements: [...]
   integration: [...]
   flows: [...]
 tech_debt:  # Non-critical, deferred
@@ -285,13 +235,8 @@ $gsd-plan-milestone-gaps
 <success_criteria>
 - [ ] Milestone scope identified
 - [ ] All phase VERIFICATION.md files read
-- [ ] SUMMARY.md `requirements-completed` frontmatter extracted for each phase
-- [ ] REQUIREMENTS.md traceability table parsed for all milestone REQ-IDs
-- [ ] 3-source cross-reference completed (VERIFICATION + SUMMARY + traceability)
-- [ ] Orphaned requirements detected (in traceability but absent from all VERIFICATIONs)
 - [ ] Tech debt and deferred gaps aggregated
-- [ ] Integration checker spawned with milestone requirement IDs
-- [ ] v{version}-MILESTONE-AUDIT.md created with structured requirement gap objects
-- [ ] FAIL gate enforced — any unsatisfied requirement forces gaps_found status
+- [ ] Integration checker spawned for cross-phase wiring
+- [ ] v{version}-MILESTONE-AUDIT.md created
 - [ ] Results presented with actionable next steps
 </success_criteria>

package/get-shit-done/workflows/diagnose-issues.md

@@ -79,7 +79,7 @@ For each gap, fill the debug-subagent-prompt template and spawn:
 
 ```
 Task(
-  prompt=filled_debug_subagent_prompt + "\n\n<files_to_read>\n- {phase_dir}/{phase_num}-UAT.md\n- .planning/STATE.md\n</files_to_read>",
+  prompt=filled_debug_subagent_prompt,
   subagent_type="general-purpose",
   description="Debug: {truth_short}"
 )