gsd-pi 2.74.0-dev.703eabc → 2.74.0-dev.ffbcc03

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

@@ -215,20 +215,28 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
     // For unit types with no verifiable artifact (null path), the parent directory
     // is missing on disk — treat as stale completion state so the key gets evicted (#313).
-    if (!absPath)
+    if (!absPath) {
+        logWarning("recovery", `verify-fail ${unitType} ${unitId}: resolveExpectedArtifactPath returned null (parent dir missing)`);
         return false;
-    if (!existsSync(absPath))
+    }
+    if (!existsSync(absPath)) {
+        logWarning("recovery", `verify-fail ${unitType} ${unitId}: existsSync false for ${absPath}`);
         return false;
+    }
     if (unitType === "validate-milestone") {
         const validationContent = readFileSync(absPath, "utf-8");
-        if (!isValidationTerminal(validationContent))
+        if (!isValidationTerminal(validationContent)) {
+            logWarning("recovery", `verify-fail ${unitType} ${unitId}: validation not terminal (len=${validationContent.length}) at ${absPath}`);
             return false;
+        }
     }
     if (unitType === "plan-milestone") {
         try {
             const roadmap = parseLegacyRoadmap(readFileSync(absPath, "utf-8"));
-            if (roadmap.slices.length === 0)
+            if (roadmap.slices.length === 0) {
+                logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap has zero slices at ${absPath}`);
                 return false;
+            }
         }
         catch (err) {
             logWarning("recovery", `plan-milestone roadmap verification failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -245,8 +253,10 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         // Accept checkbox-style (- [x] **T01: ...) or heading-style (### T01 -- / ### T01: / ### T01 —)
         const hasCheckboxTask = /^- \[[xX ]\] \*\*T\d+:/m.test(planContent);
         const hasHeadingTask = /^#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
-        if (!hasCheckboxTask && !hasHeadingTask)
+        if (!hasCheckboxTask && !hasHeadingTask) {
+            logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
             return false;
+        }
     }
     // execute-task: DB status is authoritative. Fall back to checked-checkbox
     // detection when the DB is unavailable (unmigrated projects).
@@ -306,11 +316,15 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                 }
                 if (taskIds && taskIds.length > 0) {
                     const tasksDir = resolveTasksDir(base, mid, sid);
-                    if (tasksDir) {
-                        for (const tid of taskIds) {
-                            const taskPlanFile = join(tasksDir, `${tid}-PLAN.md`);
-                            if (!existsSync(taskPlanFile))
-                                return false;
+                    if (!tasksDir) {
+                        logWarning("recovery", `verify-fail ${unitType} ${unitId}: resolveTasksDir returned null for ${mid}/${sid}`);
+                        return false;
+                    }
+                    for (const tid of taskIds) {
+                        const taskPlanFile = join(tasksDir, `${tid}-PLAN.md`);
+                        if (!existsSync(taskPlanFile)) {
+                            logWarning("recovery", `verify-fail ${unitType} ${unitId}: task plan missing ${taskPlanFile}`);
+                            return false;
                         }
                     }
                 }

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -41,8 +41,12 @@ export function registerHooks(pi, ecosystemHandlers) {
         resetToolCallLoopGuard();
         resetAskUserQuestionsCache();
         await syncServiceTierStatus(ctx);
-        const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-        prepareWorkflowMcpForProject(ctx, process.cwd());
+        // Skip MCP auto-prep when running inside an auto-worktree (see session_switch below).
+        const { isInAutoWorktree } = await import("../auto-worktree.js");
+        if (!isInAutoWorktree(process.cwd())) {
+            const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+            prepareWorkflowMcpForProject(ctx, process.cwd());
+        }
         // Apply show_token_cost preference (#1515)
         try {
             const { loadEffectiveGSDPreferences } = await import("../preferences.js");
@@ -82,8 +86,15 @@ export function registerHooks(pi, ecosystemHandlers) {
         resetAskUserQuestionsCache();
         clearDiscussionFlowState();
         await syncServiceTierStatus(ctx);
-        const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
-        prepareWorkflowMcpForProject(ctx, process.cwd());
+        // Skip MCP auto-prep when running inside an auto-worktree. The worktree
+        // already has .mcp.json from createAutoWorktree, and re-running the writer
+        // post-chdir rewrites the file mid-run (non-idempotent due to cwd-relative
+        // CLI path resolution), dirtying the tree and breaking the milestone merge.
+        const { isInAutoWorktree } = await import("../auto-worktree.js");
+        if (!isInAutoWorktree(process.cwd())) {
+            const { prepareWorkflowMcpForProject } = await import("../workflow-mcp-auto-prep.js");
+            prepareWorkflowMcpForProject(ctx, process.cwd());
+        }
         loadToolApiKeys();
     });
     pi.on("before_agent_start", async (event, ctx) => {
@@ -281,7 +292,7 @@ export function registerHooks(pi, ecosystemHandlers) {
     pi.on("tool_call", async (event, ctx) => {
         if (!isAutoActive())
             return;
-        safetyRecordToolCall(event.toolName, event.input);
+        safetyRecordToolCall(event.toolCallId, event.toolName, event.input);
         // Destructive command classification (warn only, never block)
         if (isToolCallEventType("bash", event)) {
             const classification = classifyCommand(event.input.command);

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

@@ -1,6 +1,6 @@
 // GSD Extension — Unified Cache Invalidation
 //
-// Three module-scoped caches exist across the GSD extension:
+// Three module-scoped read caches exist across the GSD extension:
 //   1. State cache (state.ts)  — memoized deriveState() result
 //   2. Path cache  (paths.ts)  — directory listing results (readdirSync)
 //   3. Parse cache (files.ts)  — parsed markdown file results
@@ -8,20 +8,31 @@
 // After any file write that changes .gsd/ contents, all three must be
 // invalidated together to prevent stale reads. This module provides a
 // single function that clears all three atomically.
+//
+// NOTE: The DB `artifacts` table is NOT included here. Earlier versions
+// called clearArtifacts() as part of this bundle (#793), intending to
+// force deriveState() to re-parse from disk when files were edited
+// out-of-band. But invalidateAllCaches() fires on every post-unit pass,
+// so bundling a DESTRUCTIVE `DELETE FROM artifacts` with routine cache
+// invalidation meant every row written by saveArtifactToDb / writeAndStore
+// was wiped within seconds — leaving the milestone completed on disk but
+// the `artifacts` table empty and the agent looping on "file exists but
+// DB record missing" recovery calls. If a call site genuinely needs the
+// artifact table cleared after an out-of-band file mutation, it should
+// invoke clearArtifacts() from gsd-db.js explicitly — do not add it back
+// here.
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
 import { clearParseCache } from './files.js';
-import { clearArtifacts } from './gsd-db.js';
 /**
- * Invalidate all GSD runtime caches in one call.
+ * Invalidate all GSD runtime read caches in one call.
  *
  * Call this after file writes, milestone transitions, merge reconciliation,
  * or any operation that changes .gsd/ contents on disk. Forgetting to clear
- * any single cache causes stale reads (see #431, #793).
+ * any single cache causes stale reads (see #431).
  */
 export function invalidateAllCaches() {
     invalidateStateCache();
     clearPathCache();
     clearParseCache();
-    clearArtifacts();
 }

package/dist/resources/extensions/gsd/guided-flow.js

@@ -219,7 +219,7 @@ export function checkAutoStartAfterDiscuss() {
         logWarning("guided", `manifest unlink failed: ${e.message}`);
     }
     pendingAutoStartMap.delete(basePath);
-    ctx.ui.notify(`Milestone ${milestoneId} ready.`, "info");
+    ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
     startAutoDetached(ctx, pi, basePath, false, { step });
     return true;
 }

package/dist/resources/extensions/gsd/safety/evidence-collector.js

@@ -32,11 +32,11 @@ export function getFilePaths() {
  * Record a tool call at dispatch time (before execution).
  * Exit codes and output are filled in by recordToolResult after execution.
  */
-export function recordToolCall(toolName, input) {
+export function recordToolCall(toolCallId, toolName, input) {
     if (toolName === "bash" || toolName === "Bash") {
         unitEvidence.push({
             kind: "bash",
-            toolCallId: "",
+            toolCallId,
             command: String(input.command ?? ""),
             exitCode: -1,
             outputSnippet: "",
@@ -46,7 +46,7 @@ export function recordToolCall(toolName, input) {
     else if (toolName === "write" || toolName === "Write") {
         unitEvidence.push({
             kind: "write",
-            toolCallId: "",
+            toolCallId,
             path: String(input.file_path ?? input.path ?? ""),
             timestamp: Date.now(),
         });
@@ -54,44 +54,29 @@ export function recordToolCall(toolName, input) {
     else if (toolName === "edit" || toolName === "Edit") {
         unitEvidence.push({
             kind: "edit",
-            toolCallId: "",
+            toolCallId,
             path: String(input.file_path ?? input.path ?? ""),
             timestamp: Date.now(),
         });
     }
 }
 /**
- * Record a tool execution result. Matches the most recent unresolved entry
- * of the same kind and fills in the toolCallId, exit code, and output.
+ * Record a tool execution result. Matches the entry by toolCallId (assigned
+ * at dispatch time) and fills in exit code + output. Prior versions matched
+ * by `kind + empty-string` which corrupted parallel tool calls.
  */
 export function recordToolResult(toolCallId, toolName, result, isError) {
-    const normalizedName = toolName.toLowerCase();
-    if (normalizedName === "bash") {
-        const entry = findLastUnresolved("bash");
-        if (entry) {
-            entry.toolCallId = toolCallId;
-            const text = extractResultText(result);
-            entry.outputSnippet = text.slice(0, 500);
-            const exitMatch = text.match(/Command exited with code (\d+)/);
-            entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
-        }
-    }
-    else if (normalizedName === "write" || normalizedName === "edit") {
-        const entry = findLastUnresolved(normalizedName);
-        if (entry) {
-            entry.toolCallId = toolCallId;
-        }
+    const entry = unitEvidence.find(e => e.toolCallId === toolCallId);
+    if (!entry)
+        return;
+    if (entry.kind === "bash") {
+        const text = extractResultText(result);
+        entry.outputSnippet = text.slice(0, 500);
+        const exitMatch = text.match(/Command exited with code (\d+)/);
+        entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
     }
 }
 // ─── Internals ──────────────────────────────────────────────────────────────
-function findLastUnresolved(kind) {
-    for (let i = unitEvidence.length - 1; i >= 0; i--) {
-        if (unitEvidence[i].kind === kind && unitEvidence[i].toolCallId === "") {
-            return unitEvidence[i];
-        }
-    }
-    return undefined;
-}
 function extractResultText(result) {
     if (typeof result === "string")
         return result;