gsd-pi 2.81.0 → 2.82.0-dev.20138ae42

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -18,18 +18,41 @@ import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
 import { readIntegrationBranch } from "./git-service.js";
 import { isClosedStatus } from "./status-guards.js";
-import { nativeConflictFiles, nativeCommit, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeRebaseAbort, nativeResetHard, } from "./native-git-bridge.js";
 import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { dirname, join } from "node:path";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { validateArtifact } from "./schemas/validate.js";
 import { getProjectResearchStatus } from "./project-research-policy.js";
+import { isGsdWorktreePath } from "./worktree-root.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
+// ─── Artifact Resolution & Verification ───────────────────────────────────────
+export function diagnoseWorktreeIntegrityFailure(basePath) {
+    if (!isGsdWorktreePath(basePath))
+        return null;
+    if (!existsSync(basePath)) {
+        return `Worktree integrity failure: ${basePath} does not exist. Repair or recreate the worktree before retrying.`;
+    }
+    const gitPath = join(basePath, ".git");
+    if (!existsSync(gitPath)) {
+        return `Worktree integrity failure: ${basePath} is not a valid git worktree (.git missing). Repair or recreate the worktree before retrying.`;
+    }
+    try {
+        execFileSync("git", ["rev-parse", "--git-dir"], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+        return null;
+    }
+    catch (err) {
+        return `Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${getErrorMessage(err).split("\n")[0]}). Repair or recreate the worktree before retrying.`;
+    }
+}
 export function refreshRecoveryDbForArtifact(unitType, unitId) {
     if (unitType !== "plan-slice" && unitType !== "execute-task")
         return { ok: true };
@@ -675,6 +698,11 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         return false;
     }
     if (!existsSync(absPath)) {
+        const worktreeFailure = diagnoseWorktreeIntegrityFailure(base);
+        if (worktreeFailure) {
+            logError("recovery", `${worktreeFailure} Unit: ${unitType} ${unitId}.`);
+            return false;
+        }
         logWarning("recovery", `verify-fail ${unitType} ${unitId}: existsSync false for ${absPath}`);
         return false;
     }
@@ -932,183 +960,10 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
     return diagnoseExpectedArtifact(unitType, unitId, base);
 }
 // ─── Merge State Reconciliation ───────────────────────────────────────────────
-/**
- * Best-effort abort of a pending merge/squash and hard-reset to HEAD.
- * Handles both real merges (MERGE_HEAD) and squash merges (SQUASH_MSG).
- */
-function abortAndResetMerge(basePath, hasMergeHead, squashMsgPath) {
-    if (hasMergeHead) {
-        try {
-            nativeMergeAbort(basePath);
-        }
-        catch (err) {
-            /* best-effort */
-            logWarning("recovery", `git merge-abort failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    else if (squashMsgPath) {
-        try {
-            unlinkSync(squashMsgPath);
-        }
-        catch (err) {
-            /* best-effort */
-            logWarning("recovery", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    try {
-        nativeResetHard(basePath);
-    }
-    catch (err) {
-        /* best-effort */
-        logError("recovery", `git reset failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-/**
- * Detect and abort other in-progress git operations left behind by a SIGKILL'd
- * worker (rebase, cherry-pick, revert). Without this, a killed worker mid-rebase
- * leaves `.git/rebase-merge/` or `.git/CHERRY_PICK_HEAD` and the worktree is
- * wedged until the user manually runs the matching `--abort`.
- *
- * Called before merge-state reconciliation because these states block any
- * subsequent merge/commit operation. (Issue #4980 HIGH-7)
- */
-function reconcileOtherInProgressGitOps(basePath, ctx) {
-    const gitDir = join(basePath, ".git");
-    const states = [
-        {
-            label: "rebase",
-            indicators: [join(gitDir, "rebase-merge"), join(gitDir, "rebase-apply")],
-            abort: () => nativeRebaseAbort(basePath),
-        },
-        {
-            label: "cherry-pick",
-            indicators: [join(gitDir, "CHERRY_PICK_HEAD")],
-            abort: () => {
-                // No native helper; fall back to git CLI.
-                try {
-                    execFileSync("git", ["cherry-pick", "--abort"], {
-                        cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8",
-                    });
-                }
-                catch (err) {
-                    logWarning("recovery", `cherry-pick --abort failed: ${getErrorMessage(err)}`);
-                }
-            },
-        },
-        {
-            label: "revert",
-            indicators: [join(gitDir, "REVERT_HEAD")],
-            abort: () => {
-                try {
-                    execFileSync("git", ["revert", "--abort"], {
-                        cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8",
-                    });
-                }
-                catch (err) {
-                    logWarning("recovery", `revert --abort failed: ${getErrorMessage(err)}`);
-                }
-            },
-        },
-    ];
-    let reconciled = false;
-    for (const s of states) {
-        const present = s.indicators.some((p) => existsSync(p));
-        if (!present)
-            continue;
-        try {
-            s.abort();
-            ctx.ui.notify(`Detected leftover ${s.label} state from prior session — aborted.`, "warning");
-            reconciled = true;
-        }
-        catch (err) {
-            logError("recovery", `${s.label} abort failed: ${getErrorMessage(err)}`);
-            ctx.ui.notify(`Detected leftover ${s.label} state but auto-abort failed. ` +
-                `Run \`git ${s.label} --abort\` manually before retrying.`, "error");
-            return "blocked";
-        }
-    }
-    return reconciled ? "reconciled" : "clean";
-}
-/**
- * Detect leftover merge state from a prior session and reconcile it.
- * If MERGE_HEAD or SQUASH_MSG exists, check whether conflicts are resolved.
- * If resolved: finalize the commit. If only .gsd conflicts remain: auto-resolve.
- * If code conflicts remain: fail safe without modifying the worktree.
- */
-export function reconcileMergeState(basePath, ctx) {
-    // First, abort any rebase/cherry-pick/revert left over from a SIGKILL'd
-    // worker. Doing this before the merge-state check unblocks any merge that
-    // would otherwise refuse with "you have unfinished operation". (HIGH-7)
-    const otherOpsResult = reconcileOtherInProgressGitOps(basePath, ctx);
-    if (otherOpsResult === "blocked")
-        return "blocked";
-    const mergeHeadPath = join(basePath, ".git", "MERGE_HEAD");
-    const squashMsgPath = join(basePath, ".git", "SQUASH_MSG");
-    const hasMergeHead = existsSync(mergeHeadPath);
-    const hasSquashMsg = existsSync(squashMsgPath);
-    if (!hasMergeHead && !hasSquashMsg) {
-        // If we cleaned up another op type, return "reconciled" so the caller
-        // re-derives state from a known-good baseline.
-        return otherOpsResult === "reconciled" ? "reconciled" : "clean";
-    }
-    const conflictedFiles = nativeConflictFiles(basePath);
-    if (conflictedFiles.length === 0) {
-        // All conflicts resolved — finalize the merge/squash commit
-        try {
-            const commitSha = nativeCommit(basePath, "chore(gsd): reconcile merge state");
-            if (commitSha) {
-                const mode = hasMergeHead ? "merge" : "squash commit";
-                ctx.ui.notify(`Finalized leftover ${mode} from prior session.`, "info");
-            }
-            else {
-                ctx.ui.notify("No new commit needed for leftover merge/squash state — already committed.", "info");
-            }
-        }
-        catch (err) {
-            const errorMessage = getErrorMessage(err);
-            ctx.ui.notify(`Failed to finalize leftover merge/squash commit: ${errorMessage}`, "error");
-            return "blocked";
-        }
-    }
-    else {
-        // Still conflicted — try auto-resolving .gsd/ state file conflicts (#530)
-        const gsdConflicts = conflictedFiles.filter((f) => f.startsWith(".gsd/"));
-        const codeConflicts = conflictedFiles.filter((f) => !f.startsWith(".gsd/"));
-        if (gsdConflicts.length > 0 && codeConflicts.length === 0) {
-            // All conflicts are in .gsd/ state files — auto-resolve by accepting theirs
-            let resolved = true;
-            try {
-                nativeCheckoutTheirs(basePath, gsdConflicts);
-                nativeAddPaths(basePath, gsdConflicts);
-            }
-            catch (e) {
-                logError("recovery", `auto-resolve .gsd/ conflicts failed: ${e.message}`);
-                resolved = false;
-            }
-            if (resolved) {
-                try {
-                    nativeCommit(basePath, "chore: auto-resolve .gsd/ state file conflicts");
-                    ctx.ui.notify(`Auto-resolved ${gsdConflicts.length} .gsd/ state file conflict(s) from prior merge.`, "info");
-                }
-                catch (e) {
-                    logError("recovery", `auto-commit .gsd/ conflict resolution failed: ${e.message}`);
-                    resolved = false;
-                }
-            }
-            if (!resolved) {
-                abortAndResetMerge(basePath, hasMergeHead, squashMsgPath);
-                ctx.ui.notify("Detected leftover merge state — auto-resolve failed, cleaned up. Re-deriving state.", "warning");
-            }
-        }
-        else {
-            // Code conflicts present — fail safe and preserve any manual resolution
-            // work instead of discarding it with merge --abort/reset --hard.
-            ctx.ui.notify("Detected leftover merge state with unresolved code conflicts. Auto-mode will pause without modifying the worktree so manual conflict resolution is preserved.", "error");
-            return "blocked";
-        }
-    }
-    return "reconciled";
-}
+// Body relocated to state-reconciliation/drift/merge-state.ts (ADR-017 #5701).
+// Re-exported here for backward compatibility with existing call sites:
+// auto.ts, auto/loop-deps.ts, tests/integration/auto-recovery.test.ts.
+export { reconcileMergeState, } from "./state-reconciliation/drift/merge-state.js";
 // ─── Loop Remediation ─────────────────────────────────────────────────────────
 /**
  * Build concrete, manual remediation steps for a loop-detected unit failure.

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -33,3 +33,8 @@ export function recordToolInvocationError(toolName, errorMsg) {
         autoSession.lastToolInvocationError = `${toolName}: ${errorMsg}`;
     }
 }
+export function clearToolInvocationError() {
+    if (!autoSession.active)
+        return;
+    autoSession.lastToolInvocationError = null;
+}

package/dist/resources/extensions/gsd/auto-start.js

@@ -21,7 +21,7 @@ import { invalidateAllCaches } from "./cache.js";
 import { writeLock, clearLock } from "./crash-recovery.js";
 import { acquireSessionLock, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
-import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeCheckoutBranch, nativeBranchList, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, nativeCommitCountBetween, } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeCheckoutBranch, nativeBranchList, nativeBranchExists, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, nativeCommitCountBetween, } from "./native-git-bridge.js";
 import { GitServiceImpl } from "./git-service.js";
 import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
@@ -33,7 +33,7 @@ import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable, getMilestone, openDatabase, getDbStatus } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, getAllMilestones, openDatabase, getDbStatus } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { auditOrphanedPreflightStashes } from "./orphan-stash-audit.js";
@@ -88,9 +88,11 @@ export function decideSurvivorAction(hasSurvivorBranch, phase) {
         return "finalize";
     return "none";
 }
-export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
+export function auditOrphanedMilestoneBranches(basePath, isolationMode, gitDeps = {}) {
     const recovered = [];
     const warnings = [];
+    const branchList = gitDeps.branchList ?? nativeBranchList;
+    const branchExists = gitDeps.branchExists ?? nativeBranchExists;
     // Skip in none mode — no milestone branches are created
     if (isolationMode === "none")
         return { recovered, warnings };
@@ -98,15 +100,16 @@ export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
     if (!isDbAvailable())
         return { recovered, warnings };
     let milestoneBranches;
+    let milestoneBranchListAvailable = true;
     try {
-        milestoneBranches = nativeBranchList(basePath, "milestone/*");
+        milestoneBranches = branchList(basePath, "milestone/*");
     }
     catch {
-        // git branch list failed — skip audit
-        return { recovered, warnings };
+        milestoneBranchListAvailable = false;
+        // git branch list failed — fall through with an empty branch set so the
+        // branch-less orphan pass can still run after per-milestone verification.
+        milestoneBranches = [];
     }
-    if (milestoneBranches.length === 0)
-        return { recovered, warnings };
     // Detect main branch for merge-check
     let mainBranch;
     try {
@@ -236,6 +239,71 @@ export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
             }
         }
     }
+    // Second pass (#5879): catch worktree directories stranded by a previous
+    // audit that deleted the milestone/* branch but failed to remove the
+    // directory (or the dir was orphaned by a separate path entirely, e.g.
+    // postflight-stash-restore-failed during closeout). The branch-keyed loop
+    // above is invisible to these cases — `nativeBranchList` returns nothing
+    // for the milestone, so the dir-cleanup block at line ~310 is never
+    // reached.
+    //
+    // Keyed on milestones whose DB status is `complete`. We do not iterate
+    // over arbitrary directories under .gsd/worktrees/ to avoid touching
+    // dirs that belong to an in-progress milestone whose branch was deleted
+    // separately — those are handled by the in-progress orphan path above
+    // when the branch is present, and by `/gsd doctor` when it is not.
+    const seenMilestoneIds = new Set(milestoneBranches.map((branch) => branch.replace(/^milestone\//, "")));
+    let completedMilestones = [];
+    try {
+        completedMilestones = getAllMilestones();
+    }
+    catch {
+        // DB read failure — skip the second pass; the first pass is still useful.
+        completedMilestones = [];
+    }
+    for (const m of completedMilestones) {
+        if (m.status !== "complete")
+            continue;
+        if (seenMilestoneIds.has(m.id))
+            continue; // already processed in the branch loop
+        if (!milestoneBranchListAvailable) {
+            try {
+                if (branchExists(basePath, `milestone/${m.id}`))
+                    continue;
+            }
+            catch (err) {
+                warnings.push(`Could not verify whether milestone/${m.id} still exists; skipping branch-less worktree cleanup for safety: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+        }
+        const wtDir = getWorktreeDir(basePath, m.id);
+        if (!existsSync(wtDir))
+            continue;
+        if (!isInsideWorktreesDir(basePath, wtDir)) {
+            warnings.push(`Orphaned worktree directory for ${m.id} is outside .gsd/worktrees/ — skipping removal for safety.`);
+            continue;
+        }
+        // Try `git worktree remove` first in case the dir is still registered
+        // (defensive — usually it is not when we reach this branch-less pass).
+        try {
+            nativeWorktreeRemove(basePath, wtDir, true);
+        }
+        catch (e) {
+            logWarning("engine", `worktree remove failed (expected for branch-less orphans): ${e instanceof Error ? e.message : String(e)}`);
+        }
+        if (existsSync(wtDir)) {
+            try {
+                rmSync(wtDir, { recursive: true, force: true });
+                recovered.push(`Removed orphaned worktree directory for ${m.id} (branch already deleted).`);
+            }
+            catch (err) {
+                warnings.push(`Failed to remove orphaned worktree directory for ${m.id}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        else {
+            recovered.push(`Removed orphaned worktree directory for ${m.id} (branch already deleted).`);
+        }
+    }
     return { recovered, warnings };
 }
 /**
@@ -368,7 +436,7 @@ export function _mergeOrphanCompletedMilestone(lifecycle, orphanId, ui) {
     return { merged: false, error: err };
 }
 export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, deps, interrupted) {
-    const { shouldUseWorktreeIsolation, registerSigtermHandler, lockBase, buildLifecycle, } = deps;
+    const { shouldUseWorktreeIsolation, registerSigtermHandler, registerAutoWorkerForSession, lockBase, buildLifecycle, } = deps;
     const dirCheck = validateDirectory(base);
     if (dirCheck.severity === "blocked") {
         ctx.ui.notify(dirCheck.reason, "error");
@@ -523,6 +591,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // consult DB status and avoid clearing runtime units for milestones that
         // only have a failure-path SUMMARY on disk (#4663).
         await openProjectDbIfPresent(base);
+        registerAutoWorkerForSession(base);
         // Clean stale runtime unit files for completed milestones (#887).
         // DB-authoritative: when DB is available, require DB status to be closed
         // before clearing runtime units. A SUMMARY file alone is no longer
@@ -606,12 +675,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // worktree cleanup) was never run — the survivor branch must be merged.
         // Applies to both worktree and branch isolation modes.
         let hasSurvivorBranch = false;
-        if (state.activeMilestone &&
+        let survivorMilestoneId = state.activeMilestone?.id ?? null;
+        if (!survivorMilestoneId && state.phase === "complete") {
+            survivorMilestoneId = findUnmergedCompletedMilestone(base, getIsolationMode(base));
+        }
+        if (survivorMilestoneId &&
             (state.phase === "pre-planning" || state.phase === "complete") &&
             getIsolationMode(base) !== "none" &&
             !detectWorktreeName(base) &&
             !base.includes(`${pathSep}.gsd${pathSep}worktrees${pathSep}`)) {
-            const milestoneBranch = `milestone/${state.activeMilestone.id}`;
+            const milestoneBranch = `milestone/${survivorMilestoneId}`;
             const { nativeBranchExists } = await import("./native-git-bridge.js");
             hasSurvivorBranch = nativeBranchExists(base, milestoneBranch);
             if (hasSurvivorBranch) {
@@ -645,7 +718,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // Re-evaluate via the helper — the discuss branch above may have cleared
         // hasSurvivorBranch after a successful promotion.
         if (decideSurvivorAction(hasSurvivorBranch, state.phase) === "finalize") {
-            const mid = state.activeMilestone.id;
+            const mid = survivorMilestoneId;
             // Commit 68ef58a3c made `_mergeBranchMode` throw on wrong-branch
             // instead of returning false silently. Wrap the call so the throw is
             // converted into an error notify + clean bootstrap abort, not an
@@ -679,30 +752,22 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         {
             const orphan = findUnmergedCompletedMilestone(base, getIsolationMode(base));
             if (orphan && orphan !== state.activeMilestone?.id) {
-                const priorBasePath = s.basePath;
-                const priorOriginalBasePath = s.originalBasePath;
-                s.originalBasePath = base;
-                s.basePath = getAutoWorktreePath(base, orphan) ?? base;
-                const result = _mergeOrphanCompletedMilestone(buildLifecycle(), orphan, ctx.ui);
+                // ADR-016 phase 2 / B4 (#5622): the swap-run-revert protocol for
+                // the orphan-merge dance is owned by `adoptOrphanWorktree`. The
+                // verb snapshots prior `s.basePath` / `s.originalBasePath`, swaps
+                // into the orphan worktree, runs the merge callback under the
+                // swap, and reverts (or holds the swap) based on the result.
+                // Callers can no longer forget the revert step on failure — the
+                // pattern that originally motivated this verb.
+                const lifecycle = buildLifecycle();
+                const result = lifecycle.adoptOrphanWorktree(orphan, base, () => _mergeOrphanCompletedMilestone(lifecycle, orphan, ctx.ui));
                 if (!result.merged) {
-                    s.basePath = base;
-                    s.originalBasePath = base;
-                    try {
-                        process.chdir(base);
-                    }
-                    catch (err) {
-                        logWarning("bootstrap", `could not restore cwd after orphan merge failure: ${err instanceof Error ? err.message : String(err)}`);
-                    }
+                    // Verb already restored basePath/originalBasePath to `base` and
+                    // chdir'd there. Return early.
                     return releaseLockAndReturn();
                 }
-                if (!s.active) {
-                    s.basePath = priorBasePath || base;
-                    s.originalBasePath = priorOriginalBasePath || base;
-                }
-                if (result.merged) {
-                    invalidateAllCaches();
-                    state = await deriveState(base);
-                }
+                invalidateAllCaches();
+                state = await deriveState(base);
             }
         }
         const effectivePrefs = loadEffectiveGSDPreferences(base)?.preferences;
@@ -792,7 +857,10 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         s.stepMode = requestedStepMode;
         s.verbose = verboseMode;
         s.cmdCtx = ctx;
-        s.basePath = base;
+        // ADR-016 phase 2 / B2 (#5620): single owner of bootstrap basePath
+        // mutation. Sets s.basePath = base and s.originalBasePath = base
+        // (originalBasePath is empty on a fresh bootstrap).
+        buildLifecycle().adoptSessionRoot(base);
         s.unitDispatchCount.clear();
         s.unitRecoveryCount.clear();
         s.lastBudgetAlertLevel = 0;
@@ -842,7 +910,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             }
         }
         // ── Auto-worktree setup ──
-        s.originalBasePath = base;
+        // s.originalBasePath was set to `base` by `adoptSessionRoot(base)` above
+        // (ADR-016 phase 2 / B2, #5620). The redundant assignment that used to
+        // live here is gone.
         const isUnderGsdWorktrees = (p) => {
             // Direct layout: /.gsd/worktrees/
             const marker = `${pathSep}.gsd${pathSep}worktrees${pathSep}`;

package/dist/resources/extensions/gsd/auto-unit-closeout.js

@@ -1,12 +1,40 @@
-/**
- * Unit closeout helper — consolidates the repeated pattern of
- * snapshotting metrics + saving activity log + extracting memories
- * that appears 6+ times in auto.ts.
- */
+// Project/App: GSD-2
+// File Purpose: Auto-mode unit closeout metrics, activity capture, and ghost-run detection.
 import { snapshotUnitMetrics } from "./metrics.js";
 import { saveActivityLog } from "./activity-log.js";
 import { logWarning } from "./workflow-logger.js";
 import { writeTurnGitTransaction } from "./uok/gitops.js";
+export const GHOST_COMPLETION_MAX_ELAPSED_MS = 500;
+export function snapshotUnitActivity(ctx, startedAt, now = Date.now()) {
+    let toolCalls = 0;
+    let assistantMessages = 0;
+    const entries = ctx.sessionManager.getEntries() ?? [];
+    for (const entry of entries) {
+        if (entry.type !== "message")
+            continue;
+        const msg = entry.message;
+        if (!msg || msg.role !== "assistant")
+            continue;
+        assistantMessages++;
+        if (!Array.isArray(msg.content))
+            continue;
+        for (const block of msg.content) {
+            if (block?.type === "toolCall")
+                toolCalls++;
+        }
+    }
+    return {
+        elapsedMs: Math.max(0, now - startedAt),
+        toolCalls,
+        assistantMessages,
+    };
+}
+export function isSuspiciousGhostCompletion(ctx, startedAt, maxElapsedMs = GHOST_COMPLETION_MAX_ELAPSED_MS) {
+    const activity = snapshotUnitActivity(ctx, startedAt);
+    return (activity.elapsedMs < maxElapsedMs &&
+        activity.toolCalls === 0 &&
+        activity.assistantMessages === 0);
+}
 /**
  * Snapshot metrics, save activity log, and fire-and-forget memory extraction
  * for a completed unit. Returns the activity log file path (if any).