gsd-pi 2.57.0 → 2.58.0-dev.394cb18

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"}`);

package/dist/resources/extensions/gsd/git-service.js

@@ -8,14 +8,14 @@
  * paths, commit type inference, and the runGit shell helper.
  */
 import { execFileSync, execSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { detectWorktreeName, } from "./worktree.js";
 import { SLICE_BRANCH_RE, QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
-import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeResetSoft, nativeCommitSubject, } from "./native-git-bridge.js";
 import { GSDError, GSD_MERGE_CONFLICT, GSD_GIT_ERROR } from "./errors.js";
 import { getErrorMessage } from "./error-utils.js";
 export const VALID_BRANCH_NAME = /^[a-zA-Z0-9_\-\/.]+$/;
@@ -348,6 +348,28 @@ export class GitServiceImpl {
         // If .gsd/ IS in .gitignore (the default for external state projects),
         // git add -A already skips it and the exclusions are harmless no-ops.
         const allExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
+        // ── Parallel worker milestone scope (#1991) ──
+        // When GSD_MILESTONE_LOCK is set, this process is a parallel worker that
+        // must only commit files belonging to its own milestone. Exclude all other
+        // milestone directories from staging to prevent cross-milestone pollution
+        // (e.g., an M033 worker fabricating M032 artifacts in the same commit).
+        const milestoneLock = process.env.GSD_MILESTONE_LOCK;
+        if (milestoneLock) {
+            const msDir = join(gsdRoot(this.basePath), "milestones");
+            if (existsSync(msDir)) {
+                try {
+                    const entries = readdirSync(msDir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.isDirectory() && entry.name !== milestoneLock) {
+                            allExclusions.push(`.gsd/milestones/${entry.name}/`);
+                        }
+                    }
+                }
+                catch {
+                    // Best-effort — if we can't read the milestones dir, proceed without scoping
+                }
+            }
+        }
         nativeAddAllWithExclusions(this.basePath, allExclusions);
     }
     /** Tracks whether runtime file cleanup has run this session. */
@@ -390,8 +412,89 @@ export class GitServiceImpl {
             ? buildTaskCommitMessage(taskContext)
             : `chore: auto-commit after ${unitType}\n\nGSD-Unit: ${unitId}`;
         nativeCommit(this.basePath, message, { allowEmpty: false });
+        // Absorb any preceding gsd snapshot commits into this real commit.
+        // Walk backwards from HEAD~1 counting consecutive snapshot subjects,
+        // then soft-reset to before them and re-commit with the same message.
+        this.absorbSnapshotCommits(message);
         return message;
     }
+    /**
+     * Squash consecutive `gsd snapshot:` commits that sit immediately below
+     * HEAD into the current HEAD commit. This keeps the git history clean
+     * after automated snapshot commits are superseded by real work.
+     *
+     * Guards:
+     * - Opt-in via `absorb_snapshot_commits` preference (default: true).
+     * - Refuses to rewrite commits that have been pushed to the remote
+     *   tracking branch (checks merge-base ancestry).
+     * - Saves HEAD SHA before reset; restores it if the re-commit fails.
+     *
+     * Does nothing if there are no snapshot commits to absorb.
+     */
+    absorbSnapshotCommits(headMessage) {
+        try {
+            // Opt-in guard — users can disable to keep snapshot commits for forensics
+            if (this.prefs.absorb_snapshot_commits === false)
+                return;
+            const GSD_SNAPSHOT_PREFIX = "gsd snapshot:";
+            let count = 0;
+            // Walk back from HEAD~1 counting consecutive snapshot commits (cap at 10)
+            for (let i = 1; i <= 10; i++) {
+                const subject = nativeCommitSubject(this.basePath, `HEAD~${i}`);
+                if (!subject.startsWith(GSD_SNAPSHOT_PREFIX))
+                    break;
+                count = i;
+            }
+            if (count === 0)
+                return;
+            // Guard: don't rewrite history that has been pushed to the remote.
+            // Check whether the newest snapshot commit (HEAD~1) is already
+            // reachable from the remote tracking branch. If it is, the snapshots
+            // have been pushed and must not be squashed via local history rewrite.
+            // (Checking resetTarget instead would false-positive when the remote
+            // is at the pre-snapshot base but the snapshots themselves are local.)
+            const resetTarget = `HEAD~${count + 1}`;
+            try {
+                const branch = nativeGetCurrentBranch(this.basePath);
+                if (branch) {
+                    const remoteBranch = `origin/${branch}`;
+                    // merge-base --is-ancestor exits 0 if HEAD~1 is ancestor of remote
+                    execFileSync("git", ["merge-base", "--is-ancestor", "HEAD~1", remoteBranch], {
+                        cwd: this.basePath,
+                        stdio: ["ignore", "pipe", "pipe"],
+                    });
+                    // If we get here, newest snapshot IS reachable from remote — already pushed
+                    return;
+                }
+            }
+            catch {
+                // Not an ancestor or remote doesn't exist — safe to proceed
+            }
+            // Save HEAD SHA so we can restore if the re-commit fails
+            const savedHead = execFileSync("git", ["rev-parse", "HEAD"], {
+                cwd: this.basePath,
+                stdio: ["ignore", "pipe", "pipe"],
+                encoding: "utf-8",
+            }).trim();
+            nativeResetSoft(this.basePath, resetTarget);
+            // Re-run smartStage so the same RUNTIME_EXCLUSION_PATHS apply.
+            // Snapshot commits used nativeAddTracked (git add -u) which stages
+            // ALL tracked modifications including .gsd/ state files. Without
+            // re-staging, those .gsd/ changes leak into the absorbed commit.
+            this.smartStage();
+            try {
+                nativeCommit(this.basePath, headMessage, { allowEmpty: false });
+            }
+            catch {
+                // Re-commit failed — restore original HEAD to avoid leaving the
+                // repo in a partially-reset state with no commit
+                nativeResetSoft(this.basePath, savedHead);
+            }
+        }
+        catch {
+            // Non-fatal — if squash fails, the commits remain unsquashed
+        }
+    }
     // ─── Branch Queries ────────────────────────────────────────────────────
     /**
      * Get the integration branch for this repo — the branch that slice

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

@@ -38,6 +38,7 @@ const GSD_RUNTIME_PATTERNS = [
 const BASELINE_PATTERNS = [
     // ── GSD state directory (symlink to external storage) ──
     ".gsd",
+    ".gsd-id",
     // ── OS junk ──
     ".DS_Store",
     "Thumbs.db",
@@ -72,6 +73,38 @@ const BASELINE_PATTERNS = [
     ".cache/",
     "tmp/",
 ];
+/**
+ * Check whether `.gsd` is covered by the project's `.gitignore`.
+ *
+ * Uses `git check-ignore` for accurate evaluation — this respects nested
+ * .gitignore files, global gitignore, and negation patterns. Returns true
+ * only when git would actually ignore `.gsd/`.
+ *
+ * Returns false (not ignored) if:
+ *   - No `.gitignore` exists
+ *   - `.gsd` is not listed in any active ignore rule
+ *   - Not a git repo or git is unavailable
+ */
+export function isGsdGitignored(basePath) {
+    // Check both `.gsd` and `.gsd/` because `.gsd/` in .gitignore (trailing
+    // slash = directory-only pattern) only matches the directory form. Using
+    // both paths covers all gitignore pattern variants.
+    for (const path of [".gsd", ".gsd/"]) {
+        try {
+            // git check-ignore exits 0 when the path IS ignored, 1 when it is NOT.
+            execFileSync("git", ["check-ignore", "-q", path], {
+                cwd: basePath,
+                stdio: "pipe",
+                env: GIT_NO_PROMPT_ENV,
+            });
+            return true; // exit 0 → .gsd is ignored
+        }
+        catch {
+            // exit 1 → this form is NOT ignored, try the other
+        }
+    }
+    return false; // neither form is ignored (or git unavailable)
+}
 /**
  * Check whether `.gsd/` contains files tracked by git.
  * If so, the project intentionally keeps `.gsd/` in version control

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

@@ -5,9 +5,10 @@
 // Exposes a unified sync API for decisions and requirements storage.
 // Schema is initialized on first open with WAL mode for file-backed DBs.
 import { createRequire } from "node:module";
-import { existsSync, copyFileSync, mkdirSync } from "node:fs";
+import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
 import { dirname } from "node:path";
 import { GSDError, GSD_STALE_STATE } from "./errors.js";
+import { logError } from "./workflow-logger.js";
 const _require = createRequire(import.meta.url);
 let providerName = null;
 let providerModule = null;
@@ -697,11 +698,29 @@ export function openDatabase(path) {
         initSchema(adapter, fileBacked);
     }
     catch (err) {
-        try {
-            adapter.close();
+        // Corrupt freelist: DDL fails with "malformed" but VACUUM can rebuild.
+        // Attempt VACUUM recovery before giving up (see #2519).
+        if (fileBacked && err instanceof Error && err.message?.includes("malformed")) {
+            try {
+                adapter.exec("VACUUM");
+                initSchema(adapter, fileBacked);
+                process.stderr.write("gsd-db: recovered corrupt database via VACUUM\n");
+            }
+            catch (retryErr) {
+                try {
+                    adapter.close();
+                }
+                catch { /* swallow */ }
+                throw retryErr;
+            }
+        }
+        else {
+            try {
+                adapter.close();
+            }
+            catch { /* swallow */ }
+            throw err;
         }
-        catch { /* swallow */ }
-        throw err;
     }
     currentDb = adapter;
     currentPath = path;
@@ -990,10 +1009,11 @@ export function insertMilestone(m) {
         ":boundary_map_markdown": m.planning?.boundaryMapMarkdown ?? "",
     });
 }
-export function upsertMilestonePlanning(milestoneId, planning) {
+export function upsertMilestonePlanning(milestoneId, planning, title) {
     if (!currentDb)
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     currentDb.prepare(`UPDATE milestones SET
+      title = COALESCE(:title, title),
       vision = COALESCE(:vision, vision),
       success_criteria = COALESCE(:success_criteria, success_criteria),
       key_risks = COALESCE(:key_risks, key_risks),
@@ -1007,6 +1027,7 @@ export function upsertMilestonePlanning(milestoneId, planning) {
       boundary_map_markdown = COALESCE(:boundary_map_markdown, boundary_map_markdown)
      WHERE id = :id`).run({
         ":id": milestoneId,
+        ":title": title ?? null,
         ":vision": planning.vision ?? null,
         ":success_criteria": planning.successCriteria ? JSON.stringify(planning.successCriteria) : null,
         ":key_risks": planning.keyRisks ? JSON.stringify(planning.keyRisks) : null,
@@ -1276,6 +1297,12 @@ export function insertVerificationEvidence(e) {
         ":created_at": new Date().toISOString(),
     });
 }
+export function getVerificationEvidence(milestoneId, sliceId, taskId) {
+    if (!currentDb)
+        return [];
+    const rows = currentDb.prepare("SELECT * FROM verification_evidence WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid ORDER BY id").all({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+    return rows;
+}
 function rowToMilestone(row) {
     return {
         id: row["id"],
@@ -1447,7 +1474,7 @@ export function copyWorktreeDb(srcDbPath, destDbPath) {
         return true;
     }
     catch (err) {
-        process.stderr.write(`gsd-db: failed to copy DB to worktree: ${err.message}\n`);
+        logError("db", "failed to copy DB to worktree", { error: err.message });
         return false;
     }
 }
@@ -1455,17 +1482,24 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
     const zero = { decisions: 0, requirements: 0, artifacts: 0, milestones: 0, slices: 0, tasks: 0, memories: 0, verification_evidence: 0, conflicts: [] };
     if (!existsSync(worktreeDbPath))
         return zero;
+    // Guard: bail when both paths resolve to the same physical file.
+    // ATTACHing a WAL-mode DB to itself corrupts the WAL (#2823).
+    try {
+        if (realpathSync(mainDbPath) === realpathSync(worktreeDbPath))
+            return zero;
+    }
+    catch { /* path resolution failed — fall through to existing checks */ }
     // Sanitize path: reject any characters that could break ATTACH syntax.
     // ATTACH DATABASE doesn't support parameterized paths in all providers,
     // so we use strict allowlist validation instead.
     if (/['";\x00]/.test(worktreeDbPath)) {
-        process.stderr.write("gsd-db: worktree DB reconciliation failed: path contains unsafe characters\n");
+        logError("db", "worktree DB reconciliation failed: path contains unsafe characters");
         return zero;
     }
     if (!currentDb) {
         const opened = openDatabase(mainDbPath);
         if (!opened) {
-            process.stderr.write("gsd-db: worktree DB reconciliation failed: cannot open main DB\n");
+            logError("db", "worktree DB reconciliation failed: cannot open main DB");
             return zero;
         }
     }
@@ -1589,7 +1623,7 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
         }
     }
     catch (err) {
-        process.stderr.write(`gsd-db: worktree DB reconciliation failed: ${err.message}\n`);
+        logError("db", "worktree DB reconciliation failed", { error: err.message });
         return { ...zero, conflicts };
     }
 }