gsd-pi 2.58.0 → 2.59.0-dev.023bd39

package/dist/resources/extensions/gsd/db-writer.js

@@ -11,7 +11,7 @@ import { resolve } from 'node:path';
 import { readFileSync, existsSync, statSync } from 'node:fs';
 import { resolveGsdRootFile } from './paths.js';
 import { saveFile } from './files.js';
-import { GSDError, GSD_STALE_STATE, GSD_IO_ERROR } from './errors.js';
+import { GSDError, GSD_IO_ERROR } from './errors.js';
 import { logWarning, logError } from './workflow-logger.js';
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
@@ -205,6 +205,98 @@ export async function nextDecisionId() {
         return 'D001';
     }
 }
+// ─── Next Requirement ID ─────────────────────────────────────────────────
+/**
+ * Compute the next requirement ID from the current DB state.
+ * Queries MAX(CAST(SUBSTR(id, 2) AS INTEGER)) from requirements table.
+ * Returns R001 if no requirements exist. Zero-pads to 3 digits.
+ */
+export async function nextRequirementId() {
+    try {
+        const db = await import('./gsd-db.js');
+        const adapter = db._getAdapter();
+        if (!adapter)
+            return 'R001';
+        const row = adapter
+            .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM requirements')
+            .get();
+        const maxNum = row ? row['max_num'] : null;
+        if (maxNum == null || isNaN(maxNum))
+            return 'R001';
+        const next = maxNum + 1;
+        return `R${String(next).padStart(3, '0')}`;
+    }
+    catch (err) {
+        logError('manifest', 'nextRequirementId failed', { fn: 'nextRequirementId', error: String(err.message) });
+        return 'R001';
+    }
+}
+/**
+ * Save a new requirement to DB and regenerate REQUIREMENTS.md.
+ * Auto-assigns the next ID via nextRequirementId().
+ * Returns the assigned ID.
+ */
+export async function saveRequirementToDb(fields, basePath) {
+    try {
+        const db = await import('./gsd-db.js');
+        const id = await nextRequirementId();
+        const requirement = {
+            id,
+            class: fields.class,
+            status: fields.status ?? 'active',
+            description: fields.description,
+            why: fields.why,
+            source: fields.source,
+            primary_owner: fields.primary_owner ?? '',
+            supporting_slices: fields.supporting_slices ?? '',
+            validation: fields.validation ?? '',
+            notes: fields.notes ?? '',
+            full_content: '',
+            superseded_by: null,
+        };
+        db.upsertRequirement(requirement);
+        // Fetch all requirements for full file regeneration
+        const adapter = db._getAdapter();
+        let allRequirements = [];
+        if (adapter) {
+            const rows = adapter.prepare('SELECT * FROM requirements ORDER BY id').all();
+            allRequirements = rows.map(row => ({
+                id: row['id'],
+                class: row['class'],
+                status: row['status'],
+                description: row['description'],
+                why: row['why'],
+                source: row['source'],
+                primary_owner: row['primary_owner'],
+                supporting_slices: row['supporting_slices'],
+                validation: row['validation'],
+                notes: row['notes'],
+                full_content: row['full_content'],
+                superseded_by: row['superseded_by'] ?? null,
+            }));
+        }
+        const nonSuperseded = allRequirements.filter(r => r.superseded_by == null);
+        const md = generateRequirementsMd(nonSuperseded);
+        const filePath = resolveGsdRootFile(basePath, 'REQUIREMENTS');
+        try {
+            await saveFile(filePath, md);
+        }
+        catch (diskErr) {
+            logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveRequirementToDb', error: String(diskErr.message) });
+            const rollbackAdapter = db._getAdapter();
+            rollbackAdapter?.prepare('DELETE FROM requirements WHERE id = :id').run({ ':id': id });
+            throw diskErr;
+        }
+        invalidateStateCache();
+        clearPathCache();
+        clearParseCache();
+        return { id };
+    }
+    catch (err) {
+        logError('manifest', 'saveRequirementToDb failed', { fn: 'saveRequirementToDb', error: String(err.message) });
+        throw err;
+    }
+}
 /**
  * Save a new decision to DB and regenerate DECISIONS.md.
  * Auto-assigns the next ID via nextDecisionId().
@@ -295,14 +387,28 @@ export async function updateRequirementInDb(id, updates, basePath) {
     try {
         const db = await import('./gsd-db.js');
         const existing = db.getRequirementById(id);
-        if (!existing) {
-            throw new GSDError(GSD_STALE_STATE, `Requirement ${id} not found`);
-        }
-        // Merge updates into existing
+        // If requirement doesn't exist in DB, create a skeleton and merge updates.
+        // This handles the case where requirements were written to REQUIREMENTS.md
+        // but never imported into the database (see #2919).
+        const base = existing ?? {
+            id,
+            class: '',
+            status: 'active',
+            description: '',
+            why: '',
+            source: '',
+            primary_owner: '',
+            supporting_slices: '',
+            validation: '',
+            notes: '',
+            full_content: '',
+            superseded_by: null,
+        };
+        // Merge updates into existing (or skeleton)
         const merged = {
-            ...existing,
+            ...base,
             ...updates,
-            id: existing.id, // ID cannot be changed
+            id: base.id, // ID cannot be changed
         };
         db.upsertRequirement(merged);
         // Fetch ALL requirements (including superseded) for full file regeneration
@@ -335,7 +441,9 @@ export async function updateRequirementInDb(id, updates, basePath) {
         }
         catch (diskErr) {
             logError('manifest', 'disk write failed, reverting DB row', { fn: 'updateRequirementInDb', error: String(diskErr.message) });
-            db.upsertRequirement(existing);
+            if (existing) {
+                db.upsertRequirement(existing);
+            }
             throw diskErr;
         }
         // Invalidate file-read caches so deriveState() sees the updated markdown.

package/dist/resources/extensions/gsd/doctor-git-checks.js

@@ -8,9 +8,32 @@ import { deriveState, isMilestoneComplete } from "./state.js";
 import { listWorktrees, resolveGitDir, worktreesDir } from "./worktree-manager.js";
 import { abortAndReset } from "./git-self-heal.js";
 import { RUNTIME_EXCLUSION_PATHS, resolveMilestoneIntegrationBranch, writeIntegrationBranch } from "./git-service.js";
-import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchList, nativeBranchDelete, nativeLsFiles, nativeRmCached, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
 import { getAllWorktreeHealth } from "./worktree-health.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+/**
+ * Returns true if the directory contains only doctor artifacts
+ * (e.g. `.gsd/doctor-history.jsonl`). These dirs are created by
+ * appendDoctorHistory() writing to worktree-scoped paths during the audit
+ * and should not be flagged as orphaned worktrees (#3105).
+ */
+function isDoctorArtifactOnly(dirPath) {
+    try {
+        const entries = readdirSync(dirPath);
+        // Empty dir — not a doctor artifact, still orphaned
+        if (entries.length === 0)
+            return false;
+        // Only a .gsd subdirectory
+        if (entries.length === 1 && entries[0] === ".gsd") {
+            const gsdEntries = readdirSync(join(dirPath, ".gsd"));
+            return gsdEntries.length <= 1 && gsdEntries.every(e => e === "doctor-history.jsonl");
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode = "none") {
     // Degrade gracefully if not a git repo
     if (!nativeIsRepo(basePath)) {
@@ -307,6 +330,11 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
                 }
                 const normalizedFullPath = normalizePath(fullPath);
                 if (!registeredPaths.has(normalizedFullPath)) {
+                    // Skip directories that only contain doctor artifacts (.gsd/doctor-history.jsonl).
+                    // appendDoctorHistory() can recreate these dirs during the audit itself,
+                    // causing a circular false positive (#3105 Bug 1).
+                    if (isDoctorArtifactOnly(fullPath))
+                        continue;
                     issues.push({
                         severity: "warning",
                         code: "worktree_directory_orphaned",
@@ -331,6 +359,53 @@ export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix,
     catch {
         // Non-fatal — orphaned worktree directory check failed
     }
+    // ── Stale uncommitted changes ────────────────────────────────────────────
+    // If the working tree has uncommitted changes and the last commit was
+    // longer ago than the configured threshold, flag it and optionally
+    // auto-commit a safety snapshot so work isn't lost.
+    try {
+        const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
+        const thresholdMinutes = prefs.stale_commit_threshold_minutes ?? 30;
+        if (thresholdMinutes > 0) {
+            const dirty = nativeHasChanges(basePath);
+            if (dirty) {
+                const branch = nativeGetCurrentBranch(basePath);
+                const lastEpoch = nativeLastCommitEpoch(basePath, branch || "HEAD");
+                const nowEpoch = Math.floor(Date.now() / 1000);
+                const minutesSinceCommit = lastEpoch > 0 ? (nowEpoch - lastEpoch) / 60 : Infinity;
+                if (minutesSinceCommit >= thresholdMinutes) {
+                    const mins = Math.floor(minutesSinceCommit);
+                    issues.push({
+                        severity: "warning",
+                        code: "stale_uncommitted_changes",
+                        scope: "project",
+                        unitId: "project",
+                        message: `Uncommitted changes detected with no commit in ${mins} minute${mins === 1 ? "" : "s"} (threshold: ${thresholdMinutes}m). Snapshotting tracked files.`,
+                        fixable: true,
+                    });
+                    if (shouldFix("stale_uncommitted_changes")) {
+                        try {
+                            nativeAddTracked(basePath);
+                            const commitMsg = `gsd snapshot: uncommitted changes after ${mins}m inactivity`;
+                            const result = nativeCommit(basePath, commitMsg);
+                            if (result) {
+                                fixesApplied.push(`created gsd snapshot after ${mins}m of uncommitted changes`);
+                            }
+                            else {
+                                fixesApplied.push("gsd snapshot skipped — nothing to commit after staging tracked files");
+                            }
+                        }
+                        catch {
+                            fixesApplied.push("failed to create gsd snapshot commit");
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Non-fatal — stale commit check failed
+    }
     // ── Worktree lifecycle checks ──────────────────────────────────────────
     // Check GSD-managed worktrees for: merged branches, stale work, dirty
     // state, and unpushed commits. Only worktrees under .gsd/worktrees/.

package/dist/resources/extensions/gsd/doctor-proactive.js

@@ -21,7 +21,7 @@ import { abortAndReset } from "./git-self-heal.js";
 import { rebuildState } from "./doctor.js";
 import { deriveState } from "./state.js";
 import { resolveMilestoneIntegrationBranch } from "./git-service.js";
-import { nativeIsRepo } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeHasChanges, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeAddTracked, nativeCommit } from "./native-git-bridge.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 /** In-memory health history for the current auto-mode session. */
@@ -232,6 +232,39 @@ export async function preDispatchHealthGate(basePath) {
     catch {
         // Non-fatal — dispatch continues if state/branch check fails
     }
+    // ── Stale uncommitted changes — auto-snapshot before dispatch ──
+    // If the working tree is dirty and no commit has happened recently,
+    // create a safety snapshot so work isn't lost if the next unit crashes.
+    try {
+        if (nativeIsRepo(basePath)) {
+            const prefs = loadEffectiveGSDPreferences()?.preferences ?? {};
+            const thresholdMinutes = prefs.stale_commit_threshold_minutes ?? 30;
+            if (thresholdMinutes > 0 && nativeHasChanges(basePath)) {
+                const branch = nativeGetCurrentBranch(basePath);
+                const lastEpoch = nativeLastCommitEpoch(basePath, branch || "HEAD");
+                const nowEpoch = Math.floor(Date.now() / 1000);
+                const minutesSinceCommit = lastEpoch > 0 ? (nowEpoch - lastEpoch) / 60 : Infinity;
+                if (minutesSinceCommit >= thresholdMinutes) {
+                    const mins = Math.floor(minutesSinceCommit);
+                    try {
+                        nativeAddTracked(basePath);
+                        const commitMsg = `gsd snapshot: pre-dispatch, uncommitted changes after ${mins}m inactivity`;
+                        const result = nativeCommit(basePath, commitMsg);
+                        if (result) {
+                            fixesApplied.push(`pre-dispatch: created gsd snapshot after ${mins}m of uncommitted changes`);
+                        }
+                    }
+                    catch {
+                        // Non-blocking — snapshot failed but dispatch can continue
+                        fixesApplied.push("pre-dispatch: gsd snapshot failed");
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Non-fatal
+    }
     // ── Disk space check ──
     // Catches low-disk conditions before dispatch rather than letting the unit
     // fail mid-execution with ENOSPC (which wastes a full LLM turn).

package/dist/resources/extensions/gsd/doctor-providers.js

@@ -144,7 +144,8 @@ function resolveKey(providerId) {
  */
 const PROVIDER_ROUTES = {
     anthropic: ["github-copilot"],
-    openai: ["github-copilot"],
+    openai: ["github-copilot", "openai-codex"],
+    google: ["google-gemini-cli"],
 };
 function checkLlmProviders() {
     const required = collectConfiguredModelProviders();

package/dist/resources/extensions/gsd/doctor-runtime-checks.js

@@ -108,11 +108,12 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
             const orphaned = [];
             for (const key of keys) {
                 // Key format: "unitType/unitId" e.g. "execute-task/M001/S01/T01"
-                const slashIdx = key.indexOf("/");
-                if (slashIdx === -1)
+                // Hook units have compound types: "hook/<hookName>/unitId"
+                const { splitCompletedKey } = await import("./forensics.js");
+                const parsed = splitCompletedKey(key);
+                if (!parsed)
                     continue;
-                const unitType = key.slice(0, slashIdx);
-                const unitId = key.slice(slashIdx + 1);
+                const { unitType, unitId } = parsed;
                 // Only validate artifact-producing unit types
                 const { verifyExpectedArtifact } = await import("./auto-recovery.js");
                 if (!verifyExpectedArtifact(unitType, unitId, basePath)) {

package/dist/resources/extensions/gsd/doctor.js

@@ -689,8 +689,10 @@ export async function runGSDDoctor(basePath, options) {
                 allTasksDone = allTasksDone && task.done;
             }
             // Blocker-without-replan detection
+            // Skip when all tasks are done — the blocker was implicitly resolved
+            // within the task and the slice is not stuck (#3105 Bug 2).
             const replanPath = resolveSliceFile(basePath, milestoneId, slice.id, "REPLAN");
-            if (!replanPath) {
+            if (!replanPath && !allTasksDone) {
                 for (const task of plan.tasks) {
                     if (!task.done)
                         continue;

package/dist/resources/extensions/gsd/error-classifier.js

@@ -24,7 +24,9 @@ const NETWORK_RE = /network|ECONNRESET|ETIMEDOUT|ECONNREFUSED|socket hang up|fet
 const SERVER_RE = /internal server error|500|502|503|overloaded|server_error|api_error|service.?unavailable/i;
 // ECONNRESET/ECONNREFUSED are in NETWORK_RE (same-model retry first).
 const CONNECTION_RE = /terminated|connection.?refused|other side closed|EPIPE|network.?(?:is\s+)?unavailable|stream_exhausted(?:_without_result)?/i;
-const STREAM_RE = /Unexpected end of JSON|Unexpected token.*JSON|Expected double-quoted property name|SyntaxError.*JSON/i;
+// Catch-all for V8 JSON.parse errors: all modern variants end with "in JSON at position \d+".
+// This eliminates the need to enumerate every error message variant individually.
+const STREAM_RE = /in JSON at position \d+|Unexpected end of JSON|SyntaxError.*JSON/i;
 const RESET_DELAY_RE = /reset in (\d+)s/i;
 /**
  * Classify an error message into one of the ErrorClass kinds.
@@ -33,9 +35,9 @@ const RESET_DELAY_RE = /reset in (\d+)s/i;
  *  1. Permanent (auth/billing/quota) — unless also rate-limited
  *  2. Rate limit (429, rate.?limit, too many requests)
  *  3. Network (ECONNRESET, ETIMEDOUT, socket hang up, fetch failed, dns)
- *  4. Server (500/502/503, overloaded, server_error)
- *  5. Connection (terminated, ECONNREFUSED, EPIPE, other side closed)
- *  6. Stream truncation (malformed JSON from mid-stream cut)
+ *  4. Stream truncation (malformed JSON from mid-stream cut)
+ *  5. Server (500/502/503, overloaded, server_error)
+ *  6. Connection (terminated, ECONNREFUSED, EPIPE, other side closed)
  *  7. Unknown
  */
 export function classifyError(errorMsg, retryAfterMs) {
@@ -61,18 +63,18 @@ export function classifyError(errorMsg, retryAfterMs) {
         // "billing" appearing alongside "network").
         return { kind: "network", retryAfterMs: retryAfterMs ?? 3_000 };
     }
-    // 4. Server errors — try fallback model
+    // 4. Stream truncation — downstream symptom of connection drop
+    if (STREAM_RE.test(errorMsg)) {
+        return { kind: "stream", retryAfterMs: retryAfterMs ?? 15_000 };
+    }
+    // 5. Server errors — try fallback model
     if (SERVER_RE.test(errorMsg)) {
         return { kind: "server", retryAfterMs: retryAfterMs ?? 30_000 };
     }
-    // 5. Connection errors — try fallback model
+    // 6. Connection errors — try fallback model
     if (CONNECTION_RE.test(errorMsg)) {
         return { kind: "connection", retryAfterMs: retryAfterMs ?? 15_000 };
     }
-    // 6. Stream truncation — downstream symptom of connection drop
-    if (STREAM_RE.test(errorMsg)) {
-        return { kind: "stream", retryAfterMs: retryAfterMs ?? 15_000 };
-    }
     // 7. Unknown
     return { kind: "unknown" };
 }

package/dist/resources/extensions/gsd/extension-manifest.json

@@ -12,7 +12,22 @@
       "gsd_requirement_update", "gsd_milestone_generate_id"
     ],
     "commands": ["gsd", "kill", "worktree", "exit"],
-    "hooks": ["session_start", "session_switch"],
+    "hooks": [
+      "session_start",
+      "session_switch",
+      "bash_transform",
+      "session_fork",
+      "before_agent_start",
+      "agent_end",
+      "session_before_compact",
+      "session_shutdown",
+      "tool_call",
+      "tool_result",
+      "tool_execution_start",
+      "tool_execution_end",
+      "model_select",
+      "before_provider_request"
+    ],
     "shortcuts": ["Ctrl+Alt+G"]
   }
 }

package/dist/resources/extensions/gsd/forensics.js

@@ -22,6 +22,8 @@ import { deriveState } from "./state.js";
 import { isAutoActive } from "./auto.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
+import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
 import { formatDuration } from "../shared/format-utils.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
@@ -29,13 +31,15 @@ import { showNextAction } from "../shared/tui.js";
 import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
 // ─── Duplicate Detection ──────────────────────────────────────────────────────
 const DEDUP_PROMPT_SECTION = `
-## Duplicate Detection (REQUIRED before issue creation)
+## Pre-Investigation: Duplicate Check (REQUIRED)
 
-Before offering to create a GitHub issue, you MUST search for existing issues and PRs that may already address this bug. This step uses the user's AI tokens for analysis.
+Before reading GSD source code or performing deep analysis, you MUST search for existing issues and PRs that may already address this bug. This avoids wasting tokens on already-fixed bugs.
 
 ### Search Steps
 
-1. **Search closed issues** for similar keywords from your diagnosis:
+Use keywords from the user's problem description and the anomaly summaries in the forensic report above.
+
+1. **Search closed issues** for similar keywords:
    \`\`\`
    gh issue list --repo gsd-build/gsd-2 --state closed --search "<keywords from root cause>" --limit 20
    \`\`\`
@@ -52,20 +56,16 @@ Before offering to create a GitHub issue, you MUST search for existing issues an
 
 ### Analysis
 
-For each result, compare it against your root-cause diagnosis:
+For each result, compare it against the user's reported symptoms and the forensic anomalies:
 - Does the issue describe the same code path or file?
-- Does the PR modify the same file:line you identified?
+- Does the PR modify the area related to the reported symptoms?
 - Is the symptom description semantically similar even if keywords differ?
 
-### Present Findings
-
-If you find potential matches, present them to the user:
-
-1. **"Already fixed by PR #X — skip issue creation"** — when a merged PR or closed issue clearly addresses the same root cause. Explain why you believe it matches.
-2. **"Add my findings to existing issue #Y"** — when an open issue exists for the same bug. Use \`gh issue comment #Y --repo gsd-build/gsd-2\` to add forensic evidence.
-3. **"Create new issue anyway"** — when existing results do not cover this specific failure.
+### Decision Gate
 
-Only proceed to issue creation if no matches were found OR the user explicitly chooses "Create new issue anyway".
+- **Merged PR clearly fixes the described symptom** → Report "Already fixed by PR #X" with brief explanation. Skip full investigation.
+- **Open issue matches** → Report "Existing issue #Y covers this." Offer to add forensic evidence. Skip full investigation unless user asks for deeper analysis.
+- **No matches** → Proceed to full investigation below.
 `;
 async function writeForensicsDedupPref(ctx, enabled) {
     const prefsPath = getGlobalGSDPreferencesPath();
@@ -148,6 +148,8 @@ export async function handleForensics(args, ctx, pi) {
     });
     ctx.ui.notify(`Forensic report saved: ${relative(basePath, savedPath)}`, "info");
     pi.sendMessage({ customType: "gsd-forensics", content, display: false }, { triggerTurn: true });
+    // Persist forensics context so follow-up turns can re-inject it (#2941)
+    writeForensicsMarker(basePath, savedPath, content);
 }
 // ─── Report Builder ───────────────────────────────────────────────────────────
 export async function buildForensicReport(basePath) {
@@ -167,8 +169,9 @@ export async function buildForensicReport(basePath) {
     const unitTraces = scanActivityLogs(basePath, activeMilestone);
     // 3. Load metrics
     const metrics = loadLedgerFromDisk(basePath);
-    // 4. Load completed keys
+    // 4. Load completed keys (legacy) and DB completion counts
     const completedKeys = loadCompletedKeys(basePath);
+    const dbCompletionCounts = getDbCompletionCounts();
     // 5. Check crash lock
     const crashLock = readCrashLock(basePath);
     // 6. Run doctor
@@ -222,6 +225,7 @@ export async function buildForensicReport(basePath) {
         unitTraces,
         metrics,
         completedKeys,
+        dbCompletionCounts,
         crashLock,
         doctorIssues,
         anomalies,
@@ -458,6 +462,41 @@ function loadCompletedKeys(basePath) {
     catch { /* non-fatal */ }
     return [];
 }
+// ─── DB Completion Counts ────────────────────────────────────────────────────
+function getDbCompletionCounts() {
+    if (!isDbAvailable())
+        return null;
+    const milestones = getAllMilestones();
+    let completedMilestones = 0;
+    let totalSlices = 0;
+    let completedSlices = 0;
+    let totalTasks = 0;
+    let completedTasks = 0;
+    for (const m of milestones) {
+        if (isClosedStatus(m.status))
+            completedMilestones++;
+        const slices = getMilestoneSlices(m.id);
+        for (const s of slices) {
+            totalSlices++;
+            if (isClosedStatus(s.status))
+                completedSlices++;
+            const tasks = getSliceTasks(m.id, s.id);
+            for (const t of tasks) {
+                totalTasks++;
+                if (isClosedStatus(t.status))
+                    completedTasks++;
+            }
+        }
+    }
+    return {
+        milestones: completedMilestones,
+        milestonesTotal: milestones.length,
+        slices: completedSlices,
+        slicesTotal: totalSlices,
+        tasks: completedTasks,
+        tasksTotal: totalTasks,
+    };
+}
 // ─── Anomaly Detectors ───────────────────────────────────────────────────────
 function detectStuckLoops(units, anomalies) {
     const counts = new Map();
@@ -515,15 +554,42 @@ function detectTimeouts(traces, anomalies) {
         }
     }
 }
+/**
+ * Parse a completed-unit key into its unitType and unitId.
+ *
+ * Hook units use a compound slash-delimited type ("hook/<hookName>"), so a
+ * naive `key.indexOf("/")` would split "hook/telegram-progress/M007/S01" into
+ * unitType="hook" (wrong) instead of "hook/telegram-progress".
+ *
+ * Returns `null` for malformed keys that cannot be split.
+ */
+export function splitCompletedKey(key) {
+    if (key.startsWith("hook/")) {
+        // Hook unit types are two segments: "hook/<hookName>/<unitId...>"
+        const secondSlash = key.indexOf("/", 5); // skip past "hook/"
+        if (secondSlash === -1)
+            return null; // malformed — no unitId after hook name
+        return {
+            unitType: key.slice(0, secondSlash),
+            unitId: key.slice(secondSlash + 1),
+        };
+    }
+    const slashIdx = key.indexOf("/");
+    if (slashIdx === -1)
+        return null;
+    return {
+        unitType: key.slice(0, slashIdx),
+        unitId: key.slice(slashIdx + 1),
+    };
+}
 function detectMissingArtifacts(completedKeys, basePath, activeMilestone, anomalies) {
     // Also check the worktree path for artifacts — they may exist there but not at root
     const wtBasePath = activeMilestone ? getAutoWorktreePath(basePath, activeMilestone) : null;
     for (const key of completedKeys) {
-        const slashIdx = key.indexOf("/");
-        if (slashIdx === -1)
+        const parsed = splitCompletedKey(key);
+        if (!parsed)
             continue;
-        const unitType = key.slice(0, slashIdx);
-        const unitId = key.slice(slashIdx + 1);
+        const { unitType, unitId } = parsed;
         const rootHasArtifact = verifyExpectedArtifact(unitType, unitId, basePath);
         const wtHasArtifact = wtBasePath ? verifyExpectedArtifact(unitType, unitId, wtBasePath) : false;
         if (!rootHasArtifact && !wtHasArtifact) {
@@ -749,6 +815,34 @@ function saveForensicReport(basePath, report, problemDescription) {
     writeFileSync(filePath, sections.join("\n"), "utf-8");
     return filePath;
 }
+/**
+ * Write a marker file so that buildBeforeAgentStartResult() can re-inject
+ * the forensics prompt on follow-up turns.  (#2941)
+ */
+export function writeForensicsMarker(basePath, reportPath, promptContent) {
+    const dir = join(gsdRoot(basePath), "runtime");
+    mkdirSync(dir, { recursive: true });
+    const marker = {
+        reportPath,
+        promptContent,
+        createdAt: new Date().toISOString(),
+    };
+    writeFileSync(join(dir, "active-forensics.json"), JSON.stringify(marker), "utf-8");
+}
+/**
+ * Read the active forensics marker, or null if none exists.
+ */
+export function readForensicsMarker(basePath) {
+    const markerPath = join(gsdRoot(basePath), "runtime", "active-forensics.json");
+    if (!existsSync(markerPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(markerPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Prompt Formatter ─────────────────────────────────────────────────────────
 function formatReportForPrompt(report) {
     const MAX_BYTES = 30 * 1024;
@@ -856,8 +950,17 @@ function formatReportForPrompt(report) {
         }
         sections.push("");
     }
-    // Completed keys count
-    sections.push(`### Completed Keys: ${report.completedKeys.length}`);
+    // Completion status — prefer DB counts, fall back to legacy completed-units.json
+    if (report.dbCompletionCounts) {
+        const c = report.dbCompletionCounts;
+        sections.push(`### Completion Status (from DB)`);
+        sections.push(`- ${c.milestones}/${c.milestonesTotal} milestones complete`);
+        sections.push(`- ${c.slices}/${c.slicesTotal} slices complete`);
+        sections.push(`- ${c.tasks}/${c.tasksTotal} tasks complete`);
+    }
+    else {
+        sections.push(`### Completed Keys: ${report.completedKeys.length}`);
+    }
     sections.push(`### GSD Version: ${report.gsdVersion}`);
     sections.push(`### Active Milestone: ${report.activeMilestone ?? "none"}`);
     sections.push(`### Active Slice: ${report.activeSlice ?? "none"}`);