gsd-pi 2.82.0 → 3.0.0-dev.8b8d129d7

package/dist/resources/extensions/gsd/migrate/writer.js

@@ -296,7 +296,17 @@ export function formatProject(content) {
  */
 export function formatDecisions(content) {
     if (!content || !content.trim()) {
-        return '# Decisions\n\n<!-- Append-only register of architectural and pattern decisions -->\n\n| ID | Decision | Rationale | Date |\n|----|----------|-----------|------|\n';
+        return [
+            '# Decisions Register',
+            '',
+            '<!-- Append-only. Never edit or remove existing rows.',
+            '     To reverse a decision, add a new row that supersedes it.',
+            '     Read this file at the start of any planning or research phase. -->',
+            '',
+            '| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |',
+            '|---|------|-------|----------|--------|-----------|------------|---------|',
+            '',
+        ].join('\n');
     }
     return content.endsWith('\n') ? content : content + '\n';
 }

package/dist/resources/extensions/gsd/migration-auto-check.js

@@ -1,10 +1,8 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
-import { clearEngineHierarchy, getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, transaction, } from "./gsd-db.js";
-import { migrateHierarchyToDb } from "./md-importer.js";
+import { getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, } from "./gsd-db.js";
 import { parsePlan, parseRoadmap } from "./parsers-legacy.js";
 import { milestonesDir, resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
-import { invalidateStateCache } from "./state.js";
 function zeroCounts() {
     return { milestones: 0, slices: 0, tasks: 0 };
 }
@@ -50,7 +48,7 @@ export function countDbHierarchy() {
     }
     return counts;
 }
-export async function autoImportMarkdownHierarchyIfDbMismatch(basePath) {
+export async function checkMarkdownHierarchyAgainstDb(basePath) {
     const markdown = countMarkdownHierarchy(basePath);
     if (sameCounts(markdown, zeroCounts())) {
         return {
@@ -70,18 +68,15 @@ export async function autoImportMarkdownHierarchyIfDbMismatch(basePath) {
         return { action: "none", reason: "in-sync", markdown, beforeDb, afterDb: beforeDb };
     }
     const reason = sameCounts(beforeDb, zeroCounts()) ? "db-empty" : "count-mismatch";
-    const imported = transaction(() => {
-        clearEngineHierarchy();
-        return migrateHierarchyToDb(basePath);
-    });
-    invalidateStateCache();
-    const afterDb = {
-        milestones: imported.milestones,
-        slices: imported.slices,
-        tasks: imported.tasks,
+    return {
+        action: "recovery-required",
+        reason,
+        markdown,
+        beforeDb,
+        afterDb: beforeDb,
+        recoveryCommand: "gsd recover",
+        message: `Markdown planning artifacts (${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T) ` +
+            `do not match the authoritative DB (${beforeDb.milestones}M/${beforeDb.slices}S/${beforeDb.tasks}T). ` +
+            "Runtime startup will not import markdown automatically; run explicit GSD recovery if markdown should repopulate the database.",
     };
-    if (!sameCounts(markdown, afterDb)) {
-        throw new Error(`migration auto-import verification failed: markdown ${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T, db ${afterDb.milestones}M/${afterDb.slices}S/${afterDb.tasks}T`);
-    }
-    return { action: "imported", reason, markdown, beforeDb, afterDb };
 }

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -19,6 +19,7 @@ import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } f
 import { removeWorktree } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
 import { isAutoActive } from "./auto.js";
+import { isClosedStatus } from "./status-guards.js";
 /**
  * Writer-side assert for mutations that race with auto-mode's squash merge (#4704).
  * Auto-mode is confirmed not to call parkMilestone/discardMilestone/unparkMilestone
@@ -34,7 +35,7 @@ function assertNotAutoActive(action) {
 /**
  * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
  * Parked milestones are skipped during active-milestone discovery but stay on disk.
- * Returns true if successfully parked, false if milestone not found or already parked.
+ * Returns true if successfully parked, false if milestone not found, already parked, or complete.
  */
 export function parkMilestone(basePath, milestoneId, reason) {
     assertNotAutoActive("park milestone");
@@ -42,9 +43,15 @@ export function parkMilestone(basePath, milestoneId, reason) {
     if (!mDir || !existsSync(mDir))
         return false;
     // Guard: do not park a completed milestone — it would corrupt depends_on satisfaction
-    const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
-    if (summaryFile)
+    const dbAvailable = isDbAvailable();
+    const milestone = dbAvailable ? getMilestone(milestoneId) : null;
+    if (milestone && isClosedStatus(milestone.status))
         return false;
+    if (!dbAvailable) {
+        const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
+        if (summaryFile)
+            return false;
+    }
     const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
     if (existsSync(parkedPath))
         return false; // already parked
@@ -61,7 +68,7 @@ export function parkMilestone(basePath, milestoneId, reason) {
     ].join("\n");
     writeFileSync(parkedPath, content, "utf-8");
     // Sync DB status so deriveStateFromDb also skips this milestone (#2694)
-    if (isDbAvailable()) {
+    if (dbAvailable) {
         try {
             updateMilestoneStatus(milestoneId, "parked");
         }

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -14,6 +14,8 @@ import { isInfrastructureError } from "./auto/infra-errors.js";
 // Issue #453: keep auto-mode bookkeeping on the stable git CLI path unless a
 // caller explicitly opts into the native helper.
 const NATIVE_GSD_GIT_ENABLED = process.env.GSD_ENABLE_NATIVE_GSD_GIT === "1";
+const TRANSIENT_GIT_RETRY_CODES = new Set(["ENOBUFS", "EAGAIN"]);
+const GIT_RETRY_DELAY_MS = 200;
 // ─── Native Module Loading ──────────────────────────────────────────────────
 let nativeModule = null;
 let loadAttempted = false;
@@ -46,10 +48,42 @@ function gitExec(basePath, args, allowFailure = false) {
             env: GIT_NO_PROMPT_ENV,
         }).trim();
     }
-    catch {
+    catch (err) {
         if (allowFailure)
             return "";
-        throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}`);
+        throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}: ${getErrorMessage(err)}`);
+    }
+}
+/** sleepSync uses Atomics.wait for a blocking pause without busy-waiting; it blocks the current thread and requires Atomics.wait support. */
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function isRetryableGitError(err) {
+    const code = isInfrastructureError(err)
+        ?? isInfrastructureError(err?.stderr ?? "");
+    return code !== null && TRANSIENT_GIT_RETRY_CODES.has(code);
+}
+function execGitFileSyncWithRetry(basePath, args, options) {
+    try {
+        return execFileSync("git", args, {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+            ...options,
+        }).trim();
+    }
+    catch (err) {
+        if (!isRetryableGitError(err))
+            throw err;
+        sleepSync(GIT_RETRY_DELAY_MS);
+        return execFileSync("git", args, {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+            ...options,
+        }).trim();
     }
 }
 /** Run a git command via execFileSync. Returns trimmed stdout. */
@@ -62,10 +96,10 @@ function gitFileExec(basePath, args, allowFailure = false) {
             env: GIT_NO_PROMPT_ENV,
         }).trim();
     }
-    catch {
+    catch (err) {
         if (allowFailure)
             return "";
-        throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}`);
+        throw new GSDError(GSD_GIT_ERROR, `git ${args.join(" ")} failed in ${basePath}: ${getErrorMessage(err)}`);
     }
 }
 // ─── Existing Read Functions ──────────────────────────────────────────────
@@ -303,15 +337,20 @@ export function nativeDiffNameStatus(basePath, fromRef, toRef, pathspec, useMerg
 }
 /**
  * Get numstat diff between two refs.
+ * useMergeBase: if true, uses three-dot semantics.
  * Native: libgit2 patch line stats.
  * Fallback: `git diff --numstat`.
  */
-export function nativeDiffNumstat(basePath, fromRef, toRef) {
+export function nativeDiffNumstat(basePath, fromRef, toRef, useMergeBase) {
     const native = loadNative();
-    if (native) {
+    if (native && !useMergeBase) {
         return native.gitDiffNumstat(basePath, fromRef, toRef);
     }
-    const result = gitExec(basePath, ["diff", "--numstat", fromRef, toRef], true);
+    const refspec = useMergeBase ? `${fromRef}...${toRef}` : undefined;
+    const args = refspec
+        ? ["diff", "--numstat", refspec]
+        : ["diff", "--numstat", fromRef, toRef];
+    const result = gitExec(basePath, args, true);
     if (!result)
         return [];
     return result.split("\n").filter(Boolean).map(line => {
@@ -409,7 +448,10 @@ export function nativeBranchList(basePath, pattern) {
     const result = gitFileExec(basePath, args, true);
     if (!result)
         return [];
-    return result.split("\n").map(b => b.trim().replace(/^\* /, "")).filter(Boolean);
+    return result
+        .split("\n")
+        .map(b => b.trim().replace(/^[*+]\s+/, ""))
+        .filter(Boolean);
 }
 /**
  * List branches merged into target.
@@ -777,13 +819,10 @@ export function nativeCommit(basePath, message, options) {
         const args = ["commit", "-F", "-"];
         if (options?.allowEmpty)
             args.push("--allow-empty");
-        const result = execFileSync("git", args, {
-            cwd: basePath,
+        const result = execGitFileSyncWithRetry(basePath, args, {
             stdio: ["pipe", "pipe", "pipe"],
-            encoding: "utf-8",
-            env: GIT_NO_PROMPT_ENV,
             input: message,
-        }).trim();
+        });
         return result;
     }
     catch (err) {
@@ -792,7 +831,11 @@ export function nativeCommit(basePath, message, options) {
         if (combined.includes("nothing to commit") || combined.includes("nothing added to commit") || combined.includes("no changes added")) {
             return null;
         }
-        throw err;
+        const commitDetail = errObj.stderr?.trim() || errObj.message || "git commit failed";
+        const wrapped = new Error(`git commit failed: ${commitDetail}`);
+        wrapped.stdout = errObj.stdout;
+        wrapped.stderr = errObj.stderr;
+        throw wrapped;
     }
 }
 /**

package/dist/resources/extensions/gsd/parallel-orchestrator.js

@@ -849,6 +849,9 @@ export function refreshWorkerStatuses(basePath, options = {}) {
     for (const [mid, worker] of state.workers) {
         const diskStatus = statusMap.get(mid);
         if (!diskStatus) {
+            if (worker.state === "stopped" || worker.state === "error") {
+                continue;
+            }
             if (!isPidAlive(worker.pid)) {
                 worker.cleanup?.();
                 worker.cleanup = undefined;

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

@@ -320,6 +320,10 @@ export function resolveGsdPathContract(workRoot, originalProjectRoot) {
         isWorktree,
     };
 }
+export function gsdProjectionRoot(basePath) {
+    const contract = resolveGsdPathContract(basePath);
+    return normalizeRealPath(contract.worktreeGsd ?? contract.projectGsd);
+}
 /**
  * Invalidate the gsdRoot cache.
  * Use ONLY at session-reset boundaries: workspace switch, process exit, or

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

@@ -0,0 +1,52 @@
+// GSD-2 — Pending auto-start handoff state.
+// Stores discuss-to-auto handoff entries keyed by project root.
+import { createWorkspace, scopeMilestone } from "./workspace.js";
+const pendingAutoStartMap = new Map();
+export function getPendingAutoStart(basePath) {
+    if (basePath)
+        return pendingAutoStartMap.get(basePath) ?? null;
+    if (pendingAutoStartMap.size === 1)
+        return pendingAutoStartMap.values().next().value;
+    return null;
+}
+export const _getPendingAutoStart = getPendingAutoStart;
+export function hasPendingAutoStart(basePath) {
+    if (basePath)
+        return pendingAutoStartMap.has(basePath);
+    return pendingAutoStartMap.size > 0;
+}
+export function setPendingAutoStart(basePath, entry) {
+    if (!entry.ctx || !entry.pi) {
+        throw new Error("setPendingAutoStart requires ctx and pi");
+    }
+    const ws = createWorkspace(entry.basePath);
+    const scope = scopeMilestone(ws, entry.milestoneId);
+    pendingAutoStartMap.set(basePath, {
+        createdAt: Date.now(),
+        planBlockedRecoveryCount: 0,
+        ...entry,
+        scope,
+        ctx: entry.ctx,
+        pi: entry.pi,
+    });
+}
+export function deletePendingAutoStart(basePath) {
+    pendingAutoStartMap.delete(basePath);
+}
+export function clearPendingAutoStart(basePath) {
+    if (basePath) {
+        pendingAutoStartMap.delete(basePath);
+    }
+    else {
+        pendingAutoStartMap.clear();
+    }
+}
+export function getDiscussionMilestoneId(basePath) {
+    if (basePath) {
+        return pendingAutoStartMap.get(basePath)?.milestoneId ?? null;
+    }
+    if (pendingAutoStartMap.size === 1) {
+        return pendingAutoStartMap.values().next().value.milestoneId;
+    }
+    return null;
+}

package/dist/resources/extensions/gsd/planning-path-scope.js

@@ -6,20 +6,26 @@ function isInsideBase(basePath, candidate) {
     const rel = relative(base, abs);
     return rel === "" || (!!rel && !rel.startsWith("..") && !isAbsolute(rel));
 }
+function isInsideAnyBase(bases, candidate) {
+    return bases.some((base) => isInsideBase(base, candidate));
+}
 /**
  * Planning IO fields are execution contracts. Absolute paths are only safe when
  * they stay inside the active working directory; in worktree mode, an absolute
  * path to the original checkout makes executors edit the wrong tree.
  */
-export function validatePlanningPathScope(basePath, fields) {
+export function validatePlanningPathScope(basePath, fields, allowedAbsoluteRoots) {
+    const absoluteRoots = (allowedAbsoluteRoots && allowedAbsoluteRoots.length > 0)
+        ? allowedAbsoluteRoots
+        : [basePath];
     for (const { field, values } of fields) {
         for (const raw of values) {
             const candidate = normalizePlannedFileReference(raw);
             if (!isAbsolute(candidate))
                 continue;
-            if (isInsideBase(basePath, candidate))
+            if (isInsideAnyBase(absoluteRoots, candidate))
                 continue;
-            return `${field} contains absolute path outside working directory: ${candidate}. Use a path relative to ${basePath}.`;
+            return `${field} contains absolute path outside allowed repository roots: ${candidate}. Use a path relative to one of: ${absoluteRoots.join(", ")}.`;
         }
     }
     return null;

package/dist/resources/extensions/gsd/post-execution-checks.js

@@ -17,6 +17,43 @@
 import { existsSync, readFileSync } from "node:fs";
 import { resolve, dirname, extname } from "node:path";
 // ─── Import Resolution Check ─────────────────────────────────────────────────
+/**
+ * Replace the contents of single- and double-quoted string literals on a single
+ * source line with spaces so import patterns do not match text inside strings.
+ * Template-literal spans are handled separately via the inTemplateLiteral flag.
+ */
+function stripStringLiterals(line) {
+    let result = "";
+    let i = 0;
+    while (i < line.length) {
+        const ch = line[i];
+        if (ch === '"' || ch === "'") {
+            result += ch;
+            i++;
+            while (i < line.length) {
+                const c = line[i];
+                if (c === "\\" && i + 1 < line.length) {
+                    result += "  ";
+                    i += 2;
+                }
+                else if (c === ch) {
+                    result += ch;
+                    i++;
+                    break;
+                }
+                else {
+                    result += " ";
+                    i++;
+                }
+            }
+        }
+        else {
+            result += ch;
+            i++;
+        }
+    }
+    return result;
+}
 /**
  * Extract relative import paths from TypeScript/JavaScript source code.
  * Returns array of { importPath, lineNum } for relative imports.
@@ -30,11 +67,19 @@ export function extractRelativeImports(source) {
     //   import './path'
     //   require('./path')
     //   require("../path")
-    const importPattern = /(?:import\s+(?:.*?\s+from\s+)?|require\s*\(\s*)(['"])(\.\.?\/[^'"]+)\1/g;
+    const importPattern = /(?:^|[;{}]\s*)import\s+(?:.*?\s+from\s+)?(['"])(\.\.?\/[^'"]+)\1/g;
+    const requirePattern = /require\s*\(\s*(['"])(\.\.?\/[^'"]+)\1/g;
     // Track if we're inside a block comment
     let inBlockComment = false;
+    let inTemplateLiteral = false;
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
+        if (inTemplateLiteral) {
+            if ((line.match(/(?<!\\)`/g) ?? []).length % 2 === 1) {
+                inTemplateLiteral = false;
+            }
+            continue;
+        }
         // Handle block comment boundaries
         if (inBlockComment) {
             if (line.includes("*/")) {
@@ -61,9 +106,17 @@ export function extractRelativeImports(source) {
         let match;
         // Reset lastIndex for each line
         importPattern.lastIndex = 0;
+        requirePattern.lastIndex = 0;
+        const strippedLine = stripStringLiterals(line);
         while ((match = importPattern.exec(line)) !== null) {
+            const importOffset = match[0].indexOf("import");
+            const importStart = match.index + importOffset;
+            if (strippedLine.slice(importStart, importStart + "import".length) !==
+                "import") {
+                continue;
+            }
             // Check if this match is after a // comment marker on the same line
-            const beforeMatch = line.substring(0, match.index);
+            const beforeMatch = strippedLine.substring(0, match.index);
             if (beforeMatch.includes("//")) {
                 continue;
             }
@@ -72,6 +125,24 @@ export function extractRelativeImports(source) {
                 lineNum: i + 1,
             });
         }
+        while ((match = requirePattern.exec(line)) !== null) {
+            if (strippedLine.slice(match.index, match.index + "require".length) !==
+                "require") {
+                continue;
+            }
+            // Check if this match is after a // comment marker on the same line
+            const beforeMatch = strippedLine.substring(0, match.index);
+            if (beforeMatch.includes("//")) {
+                continue;
+            }
+            imports.push({
+                importPath: match[2],
+                lineNum: i + 1,
+            });
+        }
+        if ((strippedLine.match(/(?<!\\)`/g) ?? []).length % 2 === 1) {
+            inTemplateLiteral = true;
+        }
     }
     return imports;
 }
@@ -109,13 +180,6 @@ export function resolveImportPath(importPath, sourceFile, basePath) {
             ".woff", ".woff2", ".ttf", ".otf", ".eot",
         ]);
         const runtimeFallbackExtensions = new Set([".js", ".jsx", ".mjs", ".cjs"]);
-        const dottedStemFallbackExtensions = new Set([".server", ".client", ".webhook"]);
-        if (explicitExt !== "" &&
-            !runtimeFallbackExtensions.has(explicitExt) &&
-            !nonFallbackExtensions.has(explicitExt) &&
-            !dottedStemFallbackExtensions.has(explicitExt)) {
-            return { exists: false, resolvedPath: null };
-        }
         if (nonFallbackExtensions.has(explicitExt) && !runtimeFallbackExtensions.has(explicitExt)) {
             return { exists: false, resolvedPath: null };
         }

package/dist/resources/extensions/gsd/pre-execution-checks.js

@@ -19,7 +19,33 @@ import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
+import { validateVerificationCommand } from "./verification-gate.js";
 const NPM_COMMAND = process.platform === "win32" ? "npm.cmd" : "npm";
+export function checkVerificationCommands(tasks) {
+    const results = [];
+    for (const task of tasks) {
+        const verify = task.verify.trim();
+        if (!verify)
+            continue;
+        const commands = verify
+            .split("&&")
+            .map((command) => command.trim())
+            .filter(Boolean);
+        for (const command of commands) {
+            const validation = validateVerificationCommand(command);
+            if (!validation.ok) {
+                results.push({
+                    category: "tool",
+                    target: `${task.id} Verify`,
+                    passed: false,
+                    message: `Unsafe or non-runnable Verify command: ${command} (${validation.reason})`,
+                    blocking: true,
+                });
+            }
+        }
+    }
+    return results;
+}
 // ─── Package Existence Check ─────────────────────────────────────────────────
 /**
  * Extract npm package names from task descriptions.
@@ -81,7 +107,7 @@ export function extractPackageReferences(description) {
     while ((importMatch = importPattern.exec(description)) !== null) {
         // Skip relative imports and node builtins
         const pkg = importMatch[1];
-        if (!pkg.startsWith(".") && !pkg.startsWith("node:")) {
+        if (!pkg.startsWith(".") && !pkg.startsWith("node:") && !pkg.startsWith("@/")) {
             packages.add(normalizePackageName(pkg));
         }
     }
@@ -389,8 +415,9 @@ function getExpectedOutputsUpTo(tasks, taskIndex) {
  *
  * All paths are normalized before comparison to ensure ./src/a.ts matches src/a.ts.
  */
-export function checkFilePathConsistency(tasks, basePath) {
+export function checkFilePathConsistency(tasks, basePath, context) {
     const results = [];
+    const resolutionRoots = [basePath, ...(context?.additionalRoots ?? [])];
     // Build a set of all files created by any task at any position (normalized).
     // Used to suppress consistency errors for files that will be caught with a
     // more precise message by checkTaskOrdering (sequence violation).
@@ -416,8 +443,7 @@ export function checkFilePathConsistency(tasks, basePath) {
             if (containsGlobPattern(normalizedFile))
                 continue;
             // Check if file exists on disk
-            const absolutePath = resolve(basePath, normalizedFile);
-            const existsOnDisk = existsSync(absolutePath);
+            const existsOnDisk = resolutionRoots.some((root) => existsSync(resolve(root, normalizedFile)));
             // Check if file is in prior expected outputs (priorOutputs already normalized)
             const inPriorOutputs = priorOutputs.has(normalizedFile);
             const inOwnOutputs = ownOutputs.has(normalizedFile);
@@ -455,8 +481,9 @@ export function checkFilePathConsistency(tasks, basePath) {
  *
  * All paths are normalized before comparison to ensure ./src/a.ts matches src/a.ts.
  */
-export function checkTaskOrdering(tasks, basePath) {
+export function checkTaskOrdering(tasks, basePath, context) {
     const results = [];
+    const resolutionRoots = [basePath, ...(context?.additionalRoots ?? [])];
     // Build map: normalized file → task index that creates it
     const fileCreators = new Map();
     for (let i = 0; i < tasks.length; i++) {
@@ -494,8 +521,7 @@ export function checkTaskOrdering(tasks, basePath) {
             if (isDirectoryReference(file))
                 continue;
             const creator = fileCreators.get(normalizedFile);
-            const absolutePath = resolve(basePath, normalizedFile);
-            const existsOnDisk = existsSync(absolutePath);
+            const existsOnDisk = resolutionRoots.some((root) => existsSync(resolve(root, normalizedFile)));
             // Skip if the creating task has already completed — its output is available
             // regardless of disk state (e.g. file was a temp artifact cleaned up after
             // the task ran, or a replan introduced a new earlier-sequence task that
@@ -640,14 +666,15 @@ export function checkInterfaceContracts(tasks, _basePath) {
  * @param basePath - Base path for resolving file references
  * @returns PreExecutionResult with status, checks, and duration
  */
-export async function runPreExecutionChecks(tasks, basePath) {
+export async function runPreExecutionChecks(tasks, basePath, context) {
     const startTime = Date.now();
     const allChecks = [];
     // Run sync checks first
-    const fileChecks = checkFilePathConsistency(tasks, basePath);
-    const orderingChecks = checkTaskOrdering(tasks, basePath);
+    const fileChecks = checkFilePathConsistency(tasks, basePath, context);
+    const orderingChecks = checkTaskOrdering(tasks, basePath, context);
     const contractChecks = checkInterfaceContracts(tasks, basePath);
-    allChecks.push(...fileChecks, ...orderingChecks, ...contractChecks);
+    const verificationChecks = checkVerificationCommands(tasks);
+    allChecks.push(...fileChecks, ...orderingChecks, ...contractChecks, ...verificationChecks);
     // Run async package checks
     const packageChecks = await checkPackageExistence(tasks, basePath);
     allChecks.push(...packageChecks);

package/dist/resources/extensions/gsd/preferences-mcp.js

@@ -0,0 +1,19 @@
+/**
+ * Resolve MCP server config for a given model ID using longest-prefix-wins matching.
+ *
+ * Keys in config.per_model are model-ID prefixes. When modelId.startsWith(key),
+ * the key is a candidate; the longest matching key wins. Returns undefined when
+ * no key matches or per_model is empty.
+ */
+export function resolveModelMcpConfig(modelId, config) {
+    let bestKey;
+    const perModel = config.per_model ?? {};
+    for (const key of Object.keys(perModel)) {
+        if (modelId.startsWith(key)) {
+            if (bestKey === undefined || key.length > bestKey.length) {
+                bestKey = key;
+            }
+        }
+    }
+    return bestKey !== undefined ? perModel[bestKey] : undefined;
+}

package/dist/resources/extensions/gsd/preferences-types.js

@@ -99,6 +99,8 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "context_window_override",
     "context_mode",
     "planning_depth",
+    "claude_code_mcp",
+    "workspace",
 ]);
 /**
  * Broad union of every recognized unit-type *label* used across the codebase.