gsd-pi 2.63.0 → 2.64.0-dev.05b8a94

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

@@ -9,13 +9,15 @@
  * value instead of calling return/pauseAuto directly — the caller
  * checks the result and handles control flow.
  */
+import { mkdirSync, writeFileSync } from "node:fs";
 import { resolveSlicePath } from "./paths.js";
 import { parseUnitId } from "./unit-id.js";
-import { isDbAvailable, getTask } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSliceTasks } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
 import { writeVerificationJSON } from "./verification-evidence.js";
 import { logWarning } from "./workflow-logger.js";
+import { runPostExecutionChecks } from "./post-execution-checks.js";
 import { join } from "node:path";
 function isInfraVerificationFailure(stderr) {
     return /\b(ENOENT|ENOTFOUND|ETIMEDOUT|ECONNRESET|EAI_AGAIN|spawn\s+\S+\s+ENOENT|command not found)\b/i.test(stderr);
@@ -128,12 +130,104 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
                 : "Verification failed due to infrastructure/runtime environment issues — treating as advisory.", "warning");
             return "continue";
         }
+        // ── Post-execution checks (run after main verification passes for execute-task units) ──
+        let postExecChecks;
+        let postExecBlockingFailure = false;
+        if (result.passed && mid && sid && tid) {
+            // Check preferences — respect enhanced_verification and enhanced_verification_post
+            const enhancedEnabled = prefs?.enhanced_verification !== false; // default true
+            const postEnabled = prefs?.enhanced_verification_post !== false; // default true
+            if (enhancedEnabled && postEnabled && isDbAvailable()) {
+                try {
+                    // Get the completed task from DB
+                    const taskRow = getTask(mid, sid, tid);
+                    if (taskRow && taskRow.key_files && taskRow.key_files.length > 0) {
+                        // Get all tasks in the slice
+                        const allTasks = getSliceTasks(mid, sid);
+                        // Filter to prior completed tasks (status = 'complete' or 'done', before current task)
+                        const priorTasks = allTasks.filter((t) => (t.status === "complete" || t.status === "done") &&
+                            t.id !== tid &&
+                            t.sequence < taskRow.sequence);
+                        // Run post-execution checks
+                        const postExecResult = runPostExecutionChecks(taskRow, priorTasks, s.basePath);
+                        // Store checks for evidence JSON
+                        postExecChecks = postExecResult.checks;
+                        // Log summary to stderr with gsd-post-exec: prefix
+                        const emoji = postExecResult.status === "pass"
+                            ? "✅"
+                            : postExecResult.status === "warn"
+                                ? "⚠️"
+                                : "❌";
+                        process.stderr.write(`gsd-post-exec: ${emoji} Post-execution checks ${postExecResult.status} for ${mid}/${sid}/${tid} (${postExecResult.durationMs}ms)\n`);
+                        // Log individual check results
+                        for (const check of postExecResult.checks) {
+                            const checkEmoji = check.passed
+                                ? "✓"
+                                : check.blocking
+                                    ? "✗"
+                                    : "⚠";
+                            process.stderr.write(`gsd-post-exec:   ${checkEmoji} [${check.category}] ${check.target}: ${check.message}\n`);
+                        }
+                        // Check for blocking failures
+                        if (postExecResult.status === "fail") {
+                            postExecBlockingFailure = true;
+                            const blockingCount = postExecResult.checks.filter((c) => !c.passed && c.blocking).length;
+                            ctx.ui.notify(`Post-execution checks failed: ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} found`, "error");
+                        }
+                        else if (postExecResult.status === "warn") {
+                            ctx.ui.notify(`Post-execution checks passed with warnings`, "warning");
+                            // Strict mode: treat warnings as blocking
+                            if (prefs?.enhanced_verification_strict === true) {
+                                postExecBlockingFailure = true;
+                            }
+                        }
+                    }
+                }
+                catch (postExecErr) {
+                    // Post-execution check errors are non-fatal — log and continue
+                    logWarning("engine", `gsd-post-exec: error — ${postExecErr.message}`);
+                }
+            }
+        }
+        // Re-write verification evidence JSON with post-execution checks
+        if (postExecChecks && postExecChecks.length > 0 && mid && sid && tid) {
+            try {
+                const sDir = resolveSlicePath(s.basePath, mid, sid);
+                if (sDir) {
+                    const tasksDir = join(sDir, "tasks");
+                    // Add postExecutionChecks to the result for the JSON write
+                    const resultWithPostExec = {
+                        ...result,
+                        // Mark as failed if there was a blocking post-exec failure
+                        passed: result.passed && !postExecBlockingFailure,
+                    };
+                    // Manually write with postExecutionChecks field
+                    writeVerificationJSONWithPostExec(resultWithPostExec, tasksDir, tid, s.currentUnit.id, postExecChecks, postExecBlockingFailure ? attempt + 1 : undefined, postExecBlockingFailure ? maxRetries : undefined);
+                }
+            }
+            catch (evidenceErr) {
+                logWarning("engine", `verification-evidence: post-exec write error — ${evidenceErr.message}`);
+            }
+        }
+        // Update result.passed based on post-execution checks
+        if (postExecBlockingFailure) {
+            result.passed = false;
+        }
         // ── Auto-fix retry logic ──
         if (result.passed) {
             s.verificationRetryCount.delete(s.currentUnit.id);
             s.pendingVerificationRetry = null;
             return "continue";
         }
+        else if (postExecBlockingFailure) {
+            // Post-execution failures are cross-task consistency issues — retrying the same task won't fix them.
+            // Skip retry and pause immediately for human review.
+            s.verificationRetryCount.delete(s.currentUnit.id);
+            s.pendingVerificationRetry = null;
+            ctx.ui.notify(`Post-execution checks failed — cross-task consistency issue detected, pausing for human review`, "error");
+            await pauseAuto(ctx, pi);
+            return "pause";
+        }
         else if (autoFixEnabled && attempt + 1 <= maxRetries) {
             const nextAttempt = attempt + 1;
             s.verificationRetryCount.set(s.currentUnit.id, nextAttempt);
@@ -173,3 +267,46 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
         return "continue";
     }
 }
+/**
+ * Write verification evidence JSON with post-execution checks included.
+ * This is a variant of writeVerificationJSON that adds the postExecutionChecks field.
+ */
+function writeVerificationJSONWithPostExec(result, tasksDir, taskId, unitId, postExecutionChecks, retryAttempt, maxRetries) {
+    mkdirSync(tasksDir, { recursive: true });
+    const evidence = {
+        schemaVersion: 1,
+        taskId,
+        unitId: unitId ?? taskId,
+        timestamp: result.timestamp,
+        passed: result.passed,
+        discoverySource: result.discoverySource,
+        checks: result.checks.map((check) => ({
+            command: check.command,
+            exitCode: check.exitCode,
+            durationMs: check.durationMs,
+            verdict: check.exitCode === 0 ? "pass" : "fail",
+        })),
+        ...(retryAttempt !== undefined ? { retryAttempt } : {}),
+        ...(maxRetries !== undefined ? { maxRetries } : {}),
+        postExecutionChecks,
+    };
+    if (result.runtimeErrors && result.runtimeErrors.length > 0) {
+        evidence.runtimeErrors = result.runtimeErrors.map(e => ({
+            source: e.source,
+            severity: e.severity,
+            message: e.message,
+            blocking: e.blocking,
+        }));
+    }
+    if (result.auditWarnings && result.auditWarnings.length > 0) {
+        evidence.auditWarnings = result.auditWarnings.map(w => ({
+            name: w.name,
+            severity: w.severity,
+            title: w.title,
+            url: w.url,
+            fixAvailable: w.fixAvailable,
+        }));
+    }
+    const filePath = join(tasksDir, `${taskId}-VERIFY.json`);
+    writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
+}

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

@@ -14,7 +14,7 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { execFileSync } from "node:child_process";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import { gsdRoot } from "./paths.js";
-import { createWorktree, removeWorktree, resolveGitDir, worktreePath, } from "./worktree-manager.js";
+import { createWorktree, removeWorktree, resolveGitDir, worktreePath, isInsideWorktreesDir, } from "./worktree-manager.js";
 import { detectWorktreeName, nudgeGitBranchCache, } from "./worktree.js";
 import { MergeConflictError, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
 import { debugLog } from "./debug-logger.js";
@@ -1025,13 +1025,19 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
         logWarning("reconcile", `Worktree directory still exists after teardown: ${wtDir}. ` +
             `This is likely an orphaned directory consuming disk space. ` +
             `Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`, { worktree: milestoneId });
-        // Attempt a direct filesystem removal as a fallback
-        try {
-            rmSync(wtDir, { recursive: true, force: true });
+        // Attempt a direct filesystem removal as a fallback — but ONLY if the
+        // path is safely inside .gsd/worktrees/ to prevent #2365 data loss.
+        if (isInsideWorktreesDir(originalBasePath, wtDir)) {
+            try {
+                rmSync(wtDir, { recursive: true, force: true });
+            }
+            catch (err) {
+                // Non-fatal — the warning above tells the user how to clean up
+                logWarning("worktree", `worktree directory removal failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
-        catch (err) {
-            // Non-fatal — the warning above tells the user how to clean up
-            logWarning("worktree", `worktree directory removal failed: ${err instanceof Error ? err.message : String(err)}`);
+        else {
+            console.error(`[GSD] REFUSING fallback rmSync — path is outside .gsd/worktrees/: ${wtDir}`);
         }
     }
 }

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

@@ -23,7 +23,7 @@ import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSes
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, } from "./auto-budget.js";
-import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, } from "./auto-tool-tracking.js";
+import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { selectAndApplyModel, resolveModelId } from "./auto-model-selection.js";
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
@@ -57,7 +57,7 @@ import { clearCmuxSidebar, logCmuxEvent, syncCmuxSidebar } from "../cmux/index.j
 import { startUnitSupervision } from "./auto-timers.js";
 import { runPostUnitVerification } from "./auto-verification.js";
 import { postUnitPreVerification, postUnitPostVerification, } from "./auto-post-unit.js";
-import { bootstrapAutoSession } from "./auto-start.js";
+import { bootstrapAutoSession, openProjectDbIfPresent } from "./auto-start.js";
 import { autoLoop, resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight } from "./auto-loop.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
@@ -192,6 +192,19 @@ export function markToolStart(toolCallId, toolName) {
 export function markToolEnd(toolCallId) {
     _markToolEnd(toolCallId);
 }
+/**
+ * Record a tool invocation error on the current session (#2883).
+ * Called from tool_execution_end when a GSD tool fails with isError.
+ * Only stores the error if it matches the tool-invocation-error pattern
+ * (malformed/truncated JSON), not normal business-logic errors.
+ */
+export function recordToolInvocationError(toolName, errorMsg) {
+    if (!s.active)
+        return;
+    if (isToolInvocationError(errorMsg)) {
+        s.lastToolInvocationError = `${toolName}: ${errorMsg}`;
+    }
+}
 export function getOldestInFlightToolAgeMs() {
     return _getOldestInFlightToolAgeMs();
 }
@@ -630,6 +643,7 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
             sessionFile: s.pausedSessionFile,
             activeEngineId: s.activeEngineId,
             activeRunDir: s.activeRunDir,
+            autoStartTime: s.autoStartTime,
         };
         const runtimeDir = join(gsdRoot(s.originalBasePath || s.basePath), "runtime");
         mkdirSync(runtimeDir, { recursive: true });
@@ -829,6 +843,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                     s.activeRunDir = meta.activeRunDir ?? null;
                     s.originalBasePath = meta.originalBasePath || base;
                     s.stepMode = meta.stepMode ?? requestedStepMode;
+                    s.autoStartTime = meta.autoStartTime || Date.now();
                     s.paused = true;
                     try {
                         unlinkSync(pausedPath);
@@ -856,6 +871,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         s.currentMilestoneId = meta.milestoneId;
                         s.originalBasePath = meta.originalBasePath || base;
                         s.stepMode = meta.stepMode ?? requestedStepMode;
+                        s.autoStartTime = meta.autoStartTime || Date.now();
                         s.paused = true;
                         // Clean up the persisted file — we're consuming it
                         try {
@@ -887,6 +903,8 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.cmdCtx = ctx;
         s.basePath = base;
         setLogBasePath(base);
+        if (!s.autoStartTime || s.autoStartTime <= 0)
+            s.autoStartTime = Date.now();
         s.unitDispatchCount.clear();
         s.unitLifetimeDispatches.clear();
         if (!getLedger())
@@ -909,6 +927,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         ctx.ui.setFooter(hideFooter);
         ctx.ui.notify(s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "info");
         restoreHookState(s.basePath);
+        // Open the project DB before rebuild/derive so resume uses DB-backed
+        // state instead of falling back to stale markdown parsing (#2940).
+        await openProjectDbIfPresent(s.basePath);
         try {
             await rebuildState(s.basePath);
             syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
@@ -1005,6 +1026,7 @@ const widgetStateAccessors = {
     getBasePath: () => s.basePath,
     isVerbose: () => s.verbose,
     isSessionSwitching: isSessionSwitchInFlight,
+    getCurrentDispatchedModelId: () => s.currentDispatchedModelId,
 };
 // ─── Preconditions ────────────────────────────────────────────────────────────
 /**

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

@@ -486,28 +486,10 @@ export function registerDbTools(pi) {
             "Use the canonical name gsd_plan_milestone; gsd_milestone_plan is only an alias.",
         ],
         parameters: Type.Object({
+            // ── Core identification + content (required) ──────────────────────
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
             title: Type.String({ description: "Milestone title" }),
-            status: Type.Optional(Type.String({ description: "Milestone status (defaults to active)" })),
-            dependsOn: Type.Optional(Type.Array(Type.String(), { description: "Milestone dependencies" })),
             vision: Type.String({ description: "Milestone vision" }),
-            successCriteria: Type.Array(Type.String(), { description: "Top-level success criteria bullets" }),
-            keyRisks: Type.Array(Type.Object({
-                risk: Type.String({ description: "Risk statement" }),
-                whyItMatters: Type.String({ description: "Why the risk matters" }),
-            }), { description: "Structured risk entries" }),
-            proofStrategy: Type.Array(Type.Object({
-                riskOrUnknown: Type.String({ description: "Risk or unknown to retire" }),
-                retireIn: Type.String({ description: "Where it will be retired" }),
-                whatWillBeProven: Type.String({ description: "What proof will be produced" }),
-            }), { description: "Structured proof strategy entries" }),
-            verificationContract: Type.String({ description: "Verification contract text" }),
-            verificationIntegration: Type.String({ description: "Integration verification text" }),
-            verificationOperational: Type.String({ description: "Operational verification text" }),
-            verificationUat: Type.String({ description: "UAT verification text" }),
-            definitionOfDone: Type.Array(Type.String(), { description: "Definition of done bullets" }),
-            requirementCoverage: Type.String({ description: "Requirement coverage text" }),
-            boundaryMapMarkdown: Type.String({ description: "Boundary map markdown block" }),
             slices: Type.Array(Type.Object({
                 sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
                 title: Type.String({ description: "Slice title" }),
@@ -520,6 +502,26 @@ export function registerDbTools(pi) {
                 integrationClosure: Type.String({ description: "Slice integration closure" }),
                 observabilityImpact: Type.String({ description: "Slice observability impact" }),
             }), { description: "Planned slices for the milestone" }),
+            // ── Enrichment metadata (optional — defaults to empty) ────────────
+            status: Type.Optional(Type.String({ description: "Milestone status (defaults to active)" })),
+            dependsOn: Type.Optional(Type.Array(Type.String(), { description: "Milestone dependencies" })),
+            successCriteria: Type.Optional(Type.Array(Type.String(), { description: "Top-level success criteria bullets" })),
+            keyRisks: Type.Optional(Type.Array(Type.Object({
+                risk: Type.String({ description: "Risk statement" }),
+                whyItMatters: Type.String({ description: "Why the risk matters" }),
+            }), { description: "Structured risk entries" })),
+            proofStrategy: Type.Optional(Type.Array(Type.Object({
+                riskOrUnknown: Type.String({ description: "Risk or unknown to retire" }),
+                retireIn: Type.String({ description: "Where it will be retired" }),
+                whatWillBeProven: Type.String({ description: "What proof will be produced" }),
+            }), { description: "Structured proof strategy entries" })),
+            verificationContract: Type.Optional(Type.String({ description: "Verification contract text" })),
+            verificationIntegration: Type.Optional(Type.String({ description: "Integration verification text" })),
+            verificationOperational: Type.Optional(Type.String({ description: "Operational verification text" })),
+            verificationUat: Type.Optional(Type.String({ description: "UAT verification text" })),
+            definitionOfDone: Type.Optional(Type.Array(Type.String(), { description: "Definition of done bullets" })),
+            requirementCoverage: Type.Optional(Type.String({ description: "Requirement coverage text" })),
+            boundaryMapMarkdown: Type.Optional(Type.String({ description: "Boundary map markdown block" })),
         }),
         execute: planMilestoneExecute,
     };
@@ -575,13 +577,10 @@ export function registerDbTools(pi) {
             "Use the canonical name gsd_plan_slice; gsd_slice_plan is only an alias.",
         ],
         parameters: Type.Object({
+            // ── Core identification + content (required) ──────────────────────
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
             sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
             goal: Type.String({ description: "Slice goal" }),
-            successCriteria: Type.String({ description: "Slice success criteria block" }),
-            proofLevel: Type.String({ description: "Slice proof level" }),
-            integrationClosure: Type.String({ description: "Slice integration closure" }),
-            observabilityImpact: Type.String({ description: "Slice observability impact" }),
             tasks: Type.Array(Type.Object({
                 taskId: Type.String({ description: "Task ID (e.g. T01)" }),
                 title: Type.String({ description: "Task title" }),
@@ -593,6 +592,11 @@ export function registerDbTools(pi) {
                 expectedOutput: Type.Array(Type.String(), { description: "Expected output files or artifacts" }),
                 observabilityImpact: Type.Optional(Type.String({ description: "Task observability impact" })),
             }), { description: "Planned tasks for the slice" }),
+            // ── Enrichment metadata (optional — defaults to empty) ────────────
+            successCriteria: Type.Optional(Type.String({ description: "Slice success criteria block" })),
+            proofLevel: Type.Optional(Type.String({ description: "Slice proof level" })),
+            integrationClosure: Type.Optional(Type.String({ description: "Slice integration closure" })),
+            observabilityImpact: Type.Optional(Type.String({ description: "Slice observability impact" })),
         }),
         execute: planSliceExecute,
     };
@@ -674,8 +678,11 @@ export function registerDbTools(pi) {
             };
         }
         try {
+            // Coerce string items to objects for verificationEvidence (#3541).
+            const coerced = { ...params };
+            coerced.verificationEvidence = (params.verificationEvidence ?? []).map((v) => typeof v === "string" ? { command: v, exitCode: -1, verdict: "unknown (coerced from string)", durationMs: 0 } : v);
             const { handleCompleteTask } = await import("../tools/complete-task.js");
-            const result = await handleCompleteTask(params, process.cwd());
+            const result = await handleCompleteTask(coerced, process.cwd());
             if ("error" in result) {
                 return {
                     content: [{ type: "text", text: `Error completing task: ${result.error}` }],
@@ -716,23 +723,28 @@ export function registerDbTools(pi) {
             "Idempotent — calling with the same params twice will upsert (INSERT OR REPLACE) without error.",
         ],
         parameters: Type.Object({
+            // ── Core identification + content (required) ──────────────────────
             taskId: Type.String({ description: "Task ID (e.g. T01)" }),
             sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
             oneLiner: Type.String({ description: "One-line summary of what was accomplished" }),
             narrative: Type.String({ description: "Detailed narrative of what happened during the task" }),
             verification: Type.String({ description: "What was verified and how — commands run, tests passed, behavior confirmed" }),
-            deviations: Type.String({ description: "Deviations from the task plan, or 'None.'" }),
-            knownIssues: Type.String({ description: "Known issues discovered but not fixed, or 'None.'" }),
-            keyFiles: Type.Array(Type.String(), { description: "List of key files created or modified" }),
-            keyDecisions: Type.Array(Type.String(), { description: "List of key decisions made during this task" }),
-            blockerDiscovered: Type.Boolean({ description: "Whether a plan-invalidating blocker was discovered" }),
-            verificationEvidence: Type.Array(Type.Object({
-                command: Type.String({ description: "Verification command that was run" }),
-                exitCode: Type.Number({ description: "Exit code of the command" }),
-                verdict: Type.String({ description: "Pass/fail verdict (e.g. '✅ pass', '❌ fail')" }),
-                durationMs: Type.Number({ description: "Duration of the command in milliseconds" }),
-            }), { description: "Array of verification evidence entries" }),
+            // ── Enrichment metadata (optional — defaults to empty) ────────────
+            deviations: Type.Optional(Type.String({ description: "Deviations from the task plan, or 'None.'" })),
+            knownIssues: Type.Optional(Type.String({ description: "Known issues discovered but not fixed, or 'None.'" })),
+            keyFiles: Type.Optional(Type.Array(Type.String(), { description: "List of key files created or modified" })),
+            keyDecisions: Type.Optional(Type.Array(Type.String(), { description: "List of key decisions made during this task" })),
+            blockerDiscovered: Type.Optional(Type.Boolean({ description: "Whether a plan-invalidating blocker was discovered" })),
+            verificationEvidence: Type.Optional(Type.Array(Type.Union([
+                Type.Object({
+                    command: Type.String({ description: "Verification command that was run" }),
+                    exitCode: Type.Number({ description: "Exit code of the command" }),
+                    verdict: Type.String({ description: "Pass/fail verdict (e.g. '✅ pass', '❌ fail')" }),
+                    durationMs: Type.Number({ description: "Duration of the command in milliseconds" }),
+                }),
+                Type.String({ description: "Fallback: verification summary string" }),
+            ]), { description: "Array of verification evidence entries" })),
         }),
         execute: taskCompleteExecute,
     };
@@ -748,8 +760,57 @@ export function registerDbTools(pi) {
             };
         }
         try {
+            // Coerce string items to objects for fields where LLMs sometimes pass
+            // plain strings instead of the expected { key, value } shape (#3541).
+            // Parses "key — value" or "key - value" format when possible.
+            const splitPair = (s) => {
+                const m = s.match(/^(.+?)\s*(?:—|-)\s+(.+)$/);
+                return m ? [m[1].trim(), m[2].trim()] : [s.trim(), ""];
+            };
+            const coerced = { ...params };
+            // Coerce simple string-array fields: LLMs sometimes pass a plain string
+            // instead of a single-element array (#3585).
+            const wrapArray = (v) => v == null ? [] : Array.isArray(v) ? v : [v];
+            coerced.provides = wrapArray(params.provides);
+            coerced.keyFiles = wrapArray(params.keyFiles);
+            coerced.keyDecisions = wrapArray(params.keyDecisions);
+            coerced.patternsEstablished = wrapArray(params.patternsEstablished);
+            coerced.observabilitySurfaces = wrapArray(params.observabilitySurfaces);
+            coerced.requirementsSurfaced = wrapArray(params.requirementsSurfaced);
+            coerced.drillDownPaths = wrapArray(params.drillDownPaths);
+            coerced.affects = wrapArray(params.affects);
+            coerced.filesModified = wrapArray(params.filesModified).map((f) => {
+                if (typeof f !== "string")
+                    return f;
+                const [path, description] = splitPair(f);
+                return { path, description };
+            });
+            coerced.requires = wrapArray(params.requires).map((r) => {
+                if (typeof r !== "string")
+                    return r;
+                const [slice, provides] = splitPair(r);
+                return { slice, provides };
+            });
+            coerced.requirementsAdvanced = wrapArray(params.requirementsAdvanced).map((r) => {
+                if (typeof r !== "string")
+                    return r;
+                const [id, how] = splitPair(r);
+                return { id, how };
+            });
+            coerced.requirementsValidated = wrapArray(params.requirementsValidated).map((r) => {
+                if (typeof r !== "string")
+                    return r;
+                const [id, proof] = splitPair(r);
+                return { id, proof };
+            });
+            coerced.requirementsInvalidated = wrapArray(params.requirementsInvalidated).map((r) => {
+                if (typeof r !== "string")
+                    return r;
+                const [id, what] = splitPair(r);
+                return { id, what };
+            });
             const { handleCompleteSlice } = await import("../tools/complete-slice.js");
-            const result = await handleCompleteSlice(params, process.cwd());
+            const result = await handleCompleteSlice(coerced, process.cwd());
             if ("error" in result) {
                 return {
                     content: [{ type: "text", text: `Error completing slice: ${result.error}` }],
@@ -789,44 +850,61 @@ export function registerDbTools(pi) {
             "Idempotent — calling with the same params twice will not crash.",
         ],
         parameters: Type.Object({
+            // ── Core identification + content (required) ──────────────────────
             sliceId: Type.String({ description: "Slice ID (e.g. S01)" }),
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
             sliceTitle: Type.String({ description: "Title of the slice" }),
             oneLiner: Type.String({ description: "One-line summary of what the slice accomplished" }),
             narrative: Type.String({ description: "Detailed narrative of what happened across all tasks" }),
             verification: Type.String({ description: "What was verified across all tasks" }),
-            deviations: Type.String({ description: "Deviations from the slice plan, or 'None.'" }),
-            knownLimitations: Type.String({ description: "Known limitations or gaps, or 'None.'" }),
-            followUps: Type.String({ description: "Follow-up work discovered during execution, or 'None.'" }),
-            keyFiles: Type.Array(Type.String(), { description: "Key files created or modified" }),
-            keyDecisions: Type.Array(Type.String(), { description: "Key decisions made during this slice" }),
-            patternsEstablished: Type.Array(Type.String(), { description: "Patterns established by this slice" }),
-            observabilitySurfaces: Type.Array(Type.String(), { description: "Observability surfaces added" }),
-            provides: Type.Array(Type.String(), { description: "What this slice provides to downstream slices" }),
-            requirementsSurfaced: Type.Array(Type.String(), { description: "New requirements surfaced" }),
-            drillDownPaths: Type.Array(Type.String(), { description: "Paths to task summaries for drill-down" }),
-            affects: Type.Array(Type.String(), { description: "Downstream slices affected" }),
-            requirementsAdvanced: Type.Array(Type.Object({
-                id: Type.String({ description: "Requirement ID" }),
-                how: Type.String({ description: "How it was advanced" }),
-            }), { description: "Requirements advanced by this slice" }),
-            requirementsValidated: Type.Array(Type.Object({
-                id: Type.String({ description: "Requirement ID" }),
-                proof: Type.String({ description: "What proof validates it" }),
-            }), { description: "Requirements validated by this slice" }),
-            requirementsInvalidated: Type.Array(Type.Object({
-                id: Type.String({ description: "Requirement ID" }),
-                what: Type.String({ description: "What changed" }),
-            }), { description: "Requirements invalidated or re-scoped" }),
-            filesModified: Type.Array(Type.Object({
-                path: Type.String({ description: "File path" }),
-                description: Type.String({ description: "What changed" }),
-            }), { description: "Files modified with descriptions" }),
-            requires: Type.Array(Type.Object({
-                slice: Type.String({ description: "Dependency slice ID" }),
-                provides: Type.String({ description: "What was consumed from it" }),
-            }), { description: "Upstream slice dependencies consumed" }),
             uatContent: Type.String({ description: "UAT test content (markdown body)" }),
+            // ── Enrichment metadata (optional — defaults to empty) ────────────
+            deviations: Type.Optional(Type.String({ description: "Deviations from the slice plan, or 'None.'" })),
+            knownLimitations: Type.Optional(Type.String({ description: "Known limitations or gaps, or 'None.'" })),
+            followUps: Type.Optional(Type.String({ description: "Follow-up work discovered during execution, or 'None.'" })),
+            keyFiles: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Key files created or modified" })),
+            keyDecisions: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Key decisions made during this slice" })),
+            patternsEstablished: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Patterns established by this slice" })),
+            observabilitySurfaces: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Observability surfaces added" })),
+            provides: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "What this slice provides to downstream slices" })),
+            requirementsSurfaced: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "New requirements surfaced" })),
+            drillDownPaths: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Paths to task summaries for drill-down" })),
+            affects: Type.Optional(Type.Union([Type.Array(Type.String()), Type.String()], { description: "Downstream slices affected" })),
+            requirementsAdvanced: Type.Optional(Type.Array(Type.Union([
+                Type.Object({
+                    id: Type.String({ description: "Requirement ID" }),
+                    how: Type.String({ description: "How it was advanced" }),
+                }),
+                Type.String({ description: "Fallback: 'ID — how' string" }),
+            ]), { description: "Requirements advanced by this slice" })),
+            requirementsValidated: Type.Optional(Type.Array(Type.Union([
+                Type.Object({
+                    id: Type.String({ description: "Requirement ID" }),
+                    proof: Type.String({ description: "What proof validates it" }),
+                }),
+                Type.String({ description: "Fallback: 'ID — proof' string" }),
+            ]), { description: "Requirements validated by this slice" })),
+            requirementsInvalidated: Type.Optional(Type.Array(Type.Union([
+                Type.Object({
+                    id: Type.String({ description: "Requirement ID" }),
+                    what: Type.String({ description: "What changed" }),
+                }),
+                Type.String({ description: "Fallback: 'ID — what' string" }),
+            ]), { description: "Requirements invalidated or re-scoped" })),
+            filesModified: Type.Optional(Type.Array(Type.Union([
+                Type.Object({
+                    path: Type.String({ description: "File path" }),
+                    description: Type.String({ description: "What changed" }),
+                }),
+                Type.String({ description: "Fallback: file path string" }),
+            ]), { description: "Files modified with descriptions" })),
+            requires: Type.Optional(Type.Array(Type.Union([
+                Type.Object({
+                    slice: Type.String({ description: "Dependency slice ID" }),
+                    provides: Type.String({ description: "What was consumed from it" }),
+                }),
+                Type.String({ description: "Fallback: slice ID string" }),
+            ]), { description: "Upstream slice dependencies consumed" })),
         }),
         execute: sliceCompleteExecute,
     };
@@ -912,8 +990,11 @@ export function registerDbTools(pi) {
             };
         }
         try {
+            // ── Input sanitization: normalize markdown parameters (#3013) ──────
+            const { sanitizeCompleteMilestoneParams } = await import("./sanitize-complete-milestone.js");
+            const sanitized = sanitizeCompleteMilestoneParams(params);
             const { handleCompleteMilestone } = await import("../tools/complete-milestone.js");
-            const result = await handleCompleteMilestone(params, process.cwd());
+            const result = await handleCompleteMilestone(sanitized, process.cwd());
             if ("error" in result) {
                 return {
                     content: [{ type: "text", text: `Error completing milestone: ${result.error}` }],
@@ -951,19 +1032,21 @@ export function registerDbTools(pi) {
             "On success, returns summaryPath where the MILESTONE-SUMMARY.md was written.",
         ],
         parameters: Type.Object({
+            // ── Core identification + content (required) ──────────────────────
             milestoneId: Type.String({ description: "Milestone ID (e.g. M001)" }),
             title: Type.String({ description: "Milestone title" }),
             oneLiner: Type.String({ description: "One-sentence summary of what the milestone achieved" }),
             narrative: Type.String({ description: "Detailed narrative of what happened during the milestone" }),
-            successCriteriaResults: Type.String({ description: "Markdown detailing how each success criterion was met or not met" }),
-            definitionOfDoneResults: Type.String({ description: "Markdown detailing how each definition-of-done item was met" }),
-            requirementOutcomes: Type.String({ description: "Markdown detailing requirement status transitions with evidence" }),
-            keyDecisions: Type.Array(Type.String(), { description: "Key architectural/pattern decisions made during the milestone" }),
-            keyFiles: Type.Array(Type.String(), { description: "Key files created or modified during the milestone" }),
-            lessonsLearned: Type.Array(Type.String(), { description: "Lessons learned during the milestone" }),
+            verificationPassed: Type.Boolean({ description: "Must be true — confirms that code change verification, success criteria, and definition of done checks all passed before completion" }),
+            // ── Enrichment metadata (optional — defaults to empty) ────────────
+            successCriteriaResults: Type.Optional(Type.String({ description: "Markdown detailing how each success criterion was met or not met" })),
+            definitionOfDoneResults: Type.Optional(Type.String({ description: "Markdown detailing how each definition-of-done item was met" })),
+            requirementOutcomes: Type.Optional(Type.String({ description: "Markdown detailing requirement status transitions with evidence" })),
+            keyDecisions: Type.Optional(Type.Array(Type.String(), { description: "Key architectural/pattern decisions made during the milestone" })),
+            keyFiles: Type.Optional(Type.Array(Type.String(), { description: "Key files created or modified during the milestone" })),
+            lessonsLearned: Type.Optional(Type.Array(Type.String(), { description: "Lessons learned during the milestone" })),
             followUps: Type.Optional(Type.String({ description: "Follow-up items for future milestones" })),
             deviations: Type.Optional(Type.String({ description: "Deviations from the original plan" })),
-            verificationPassed: Type.Boolean({ description: "Must be true — confirms that code change verification, success criteria, and definition of done checks all passed before completion" }),
         }),
         execute: milestoneCompleteExecute,
     };