gsd-pi 2.80.0 → 2.81.0-dev.72a81bdf3

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

@@ -12,15 +12,13 @@ import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk, getCompletedMilestoneTaskFileHints, getMilestoneCommitAttributionShas, recordMilestoneCommitAttribution } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
-import { getErrorMessage } from "./error-utils.js";
-import { logWarning, logError } from "./workflow-logger.js";
+import { logWarning } 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";
@@ -30,7 +28,49 @@ import { getProjectResearchStatus } from "./project-research-policy.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 refreshRecoveryDbForArtifact(unitType, unitId) {
+    if (unitType !== "plan-slice" && unitType !== "execute-task")
+        return { ok: true };
+    if (!isDbAvailable())
+        return { ok: true };
+    if (!refreshOpenDatabaseFromDisk()) {
+        return {
+            ok: false,
+            fatal: unitType === "execute-task",
+            reason: `${unitType}-db-refresh-failed`,
+            message: `Stuck recovery found ${unitType} ${unitId} artifacts, but the DB refresh failed.`,
+        };
+    }
+    if (unitType !== "execute-task")
+        return { ok: true };
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    if (!mid || !sid || !tid) {
+        return {
+            ok: false,
+            fatal: true,
+            reason: "execute-task-invalid-unit-id",
+            message: `Stuck recovery found execute-task ${unitId} artifacts, but the unit id could not be parsed for DB verification.`,
+        };
+    }
+    const task = getTask(mid, sid, tid);
+    if (!task) {
+        return {
+            ok: false,
+            fatal: true,
+            reason: "execute-task-artifact-db-missing",
+            message: `Stuck recovery found execute-task ${unitId} artifacts, but no matching DB task row exists after refresh.`,
+        };
+    }
+    if (!isClosedStatus(task.status)) {
+        return {
+            ok: false,
+            fatal: true,
+            reason: "execute-task-artifact-db-mismatch",
+            message: `Stuck recovery found execute-task ${unitId} artifacts, but the DB task status is still '${task.status}' after refresh.`,
+        };
+    }
+    return { ok: true };
+}
 function hasCapturedWorkflowPrefs(base) {
     const prefsPath = resolveExpectedArtifactPath("workflow-preferences", "WORKFLOW-PREFS", base);
     if (!prefsPath || !existsSync(prefsPath))
@@ -110,17 +150,32 @@ export function hasImplementationArtifacts(basePath, milestoneId) {
         // milestone commits instead of treating the self-diff as proof of no work.
         if (changedFiles.length === 0) {
             if (milestoneId && currentBranch === integrationBranch) {
-                const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
-                if (!tagged.ok)
+                const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+                if (!milestoneEvidence.ok)
                     return "unknown";
-                if (tagged.matched)
-                    return classifyImplementationFiles(tagged.files);
+                if (milestoneEvidence.matched)
+                    return classifyImplementationFiles(milestoneEvidence.files);
             }
             if (currentBranch && currentBranch !== "HEAD")
                 return "absent";
             return "unknown";
         }
-        return classifyImplementationFiles(changedFiles);
+        const branchClassification = classifyImplementationFiles(changedFiles);
+        if (branchClassification === "present")
+            return "present";
+        // A completing milestone branch can have a non-empty diff containing only
+        // .gsd/ closeout files after implementation commits already landed on the
+        // recorded integration branch. In that topology, the branch diff alone is
+        // insufficient; use the same milestone-tagged evidence fallback as the
+        // self-diff retry path before declaring the milestone implementation-free.
+        if (milestoneId) {
+            const milestoneEvidence = getChangedFilesFromMilestoneEvidence(basePath, milestoneId);
+            if (!milestoneEvidence.ok)
+                return "unknown";
+            if (milestoneEvidence.matched)
+                return classifyImplementationFiles(milestoneEvidence.files);
+        }
+        return "absent";
     }
     catch (e) {
         // Non-fatal — if git operations fail, return unknown so callers can decide
@@ -148,6 +203,9 @@ function classifyImplementationFiles(files) {
 function isImplementationPath(file) {
     return !file.startsWith(".gsd/") && !file.startsWith(".gsd\\");
 }
+function normalizeRepoPath(file) {
+    return file.trim().replace(/\\/g, "/").replace(/^\.\/+/, "");
+}
 /**
  * Detect the main/master branch name.
  */
@@ -217,7 +275,7 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     ]);
     if (!scoped.ok)
         return scoped;
-    if (scoped.matched)
+    if (scoped.matched && classifyImplementationFiles(scoped.files) === "present")
         return scoped;
     // Fallback (#5033): when .gsd/ is gitignored / external / untracked, the
     // path-scoped scan matches no commits even though GSD-tagged commits
@@ -228,9 +286,137 @@ function getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId) {
     // Intentionally unbounded — symmetric with the primary scan, and avoids
     // reintroducing the rolling-depth failure class removed in #4699 where
     // milestone evidence aged out behind unrelated activity.
-    return scanGsdTaggedCommits(basePath, milestoneId, [
+    const unscoped = scanGsdTaggedCommits(basePath, milestoneId, [
         "log", "--format=%H%x1f%B%x1e", "HEAD",
     ]);
+    if (!unscoped.ok)
+        return scoped.matched ? scoped : unscoped;
+    if (!unscoped.matched)
+        return scoped;
+    return {
+        ok: true,
+        matched: true,
+        files: [...new Set([...scoped.files, ...unscoped.files])],
+    };
+}
+function getChangedFilesFromMilestoneEvidence(basePath, milestoneId) {
+    const tagged = getChangedFilesFromMilestoneTaggedCommits(basePath, milestoneId);
+    if (!tagged.ok)
+        return tagged;
+    if (tagged.matched && classifyImplementationFiles(tagged.files) === "present")
+        return tagged;
+    const attributed = getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId);
+    if (!attributed.ok)
+        return tagged.matched ? tagged : attributed;
+    if (attributed.matched && classifyImplementationFiles(attributed.files) === "present")
+        return attributed;
+    const backfilled = backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId);
+    if (!backfilled.ok)
+        return tagged.matched ? tagged : attributed.matched ? attributed : backfilled;
+    if (!backfilled.matched) {
+        if (tagged.matched)
+            return tagged;
+        return attributed.matched ? attributed : backfilled;
+    }
+    return {
+        ok: true,
+        matched: true,
+        files: [...new Set([...tagged.files, ...attributed.files, ...backfilled.files])],
+    };
+}
+function getChangedFilesFromAttributedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const shas = getMilestoneCommitAttributionShas(milestoneId);
+        if (shas.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const files = new Set();
+        let matched = false;
+        for (const sha of shas) {
+            if (!isFullCommitSha(sha))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, sha);
+            if (commitFiles.length === 0)
+                continue;
+            matched = true;
+            for (const file of commitFiles)
+                files.add(file);
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution scan failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function backfillChangedFilesFromUntaggedMilestoneCommits(basePath, milestoneId) {
+    try {
+        const milestone = getMilestone(milestoneId);
+        const milestoneStartedAt = milestone?.created_at ? Math.floor(Date.parse(milestone.created_at) / 1000) * 1000 : NaN;
+        if (!Number.isFinite(milestoneStartedAt))
+            return { ok: true, matched: false, files: [] };
+        const taskFileHints = getCompletedMilestoneTaskFileHints(milestoneId);
+        if (taskFileHints.length === 0)
+            return { ok: true, matched: false, files: [] };
+        const hintSet = new Set(taskFileHints.map(normalizeRepoPath).filter(Boolean));
+        if (hintSet.size === 0)
+            return { ok: true, matched: false, files: [] };
+        const records = getCommitRecords(basePath);
+        const files = new Set();
+        let matched = false;
+        for (const record of records) {
+            if (!isFullCommitSha(record.hash))
+                continue;
+            if (Date.parse(record.committedAt) < milestoneStartedAt)
+                continue;
+            if (record.parents.trim().split(/\s+/).filter(Boolean).length > 1)
+                continue;
+            if (commitMessageHasGsdTrailer(record.message))
+                continue;
+            const commitFiles = getChangedFilesForCommit(basePath, record.hash);
+            const implementationFiles = commitFiles.map(normalizeRepoPath).filter(isImplementationPath);
+            if (implementationFiles.length === 0)
+                continue;
+            if (!implementationFiles.some((file) => hintSet.has(file)))
+                continue;
+            matched = true;
+            for (const file of implementationFiles)
+                files.add(file);
+            recordMilestoneCommitAttribution({
+                commitSha: record.hash,
+                milestoneId,
+                source: "backfill",
+                confidence: 0.8,
+                files: implementationFiles,
+                createdAt: new Date().toISOString(),
+            });
+        }
+        return { ok: true, matched, files: [...files] };
+    }
+    catch (e) {
+        logWarning("recovery", `milestone attribution backfill failed: ${e.message}`);
+        return { ok: false, matched: false, files: [] };
+    }
+}
+function getCommitRecords(basePath) {
+    const logOutput = execFileSync("git", ["log", "--format=%H%x1f%P%x1f%cI%x1f%B%x1e", "HEAD"], {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+    });
+    return logOutput
+        .split("\x1e")
+        .map((record) => record.trim())
+        .filter(Boolean)
+        .flatMap((record) => {
+        const parts = record.split("\x1f");
+        if (parts.length < 4)
+            return [];
+        const [hash, parents, committedAt, ...messageParts] = parts;
+        return [{ hash: hash.trim(), parents: parents.trim(), committedAt: committedAt.trim(), message: messageParts.join("\x1f") }];
+    });
+}
+function isFullCommitSha(value) {
+    return /^[0-9a-f]{40}$/i.test(value);
 }
 function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
     try {
@@ -744,183 +930,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;
+}