gsd-pi 2.82.0-dev.9d5798940 → 2.82.0-dev.dfbc5f58f

package/dist/resources/extensions/gsd/doctor-runtime-checks.js

@@ -5,7 +5,7 @@ import { milestonesDir, gsdRoot, resolveGsdRootFile } from "./paths.js";
 import { deriveState, isGhostMilestone, isReusableGhostMilestone } from "./state.js";
 import { saveFile } from "./files.js";
 import { nativeIsRepo, nativeForEachRef, nativeUpdateRef } from "./native-git-bridge.js";
-import { readCrashLock, isLockProcessAlive, clearLock } from "./crash-recovery.js";
+import { readCrashLock, isLockProcessAlive, clearStaleWorkerLock } from "./crash-recovery.js";
 import { getActiveAutoWorkers } from "./db/auto-workers.js";
 import { normalizeRealPath } from "./paths.js";
 import { ensureGitignore, isGsdGitignored } from "./gitignore.js";
@@ -46,7 +46,7 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                     fixable: true,
                 });
                 if (shouldFix("stale_crash_lock")) {
-                    clearLock(basePath);
+                    clearStaleWorkerLock(basePath);
                     fixesApplied.push("cleared stale auto-mode worker state");
                 }
             }
@@ -70,15 +70,32 @@ export async function checkRuntimeHealth(basePath, issues, fixesApplied, shouldF
                 // heartbeat for this project?" — readCrashLock returns null for
                 // healthy live workers (it surfaces stale ones only), so we must
                 // consult getActiveAutoWorkers directly.
-                const projectRoot = normalizeRealPath(basePath);
-                const activeWorkers = getActiveAutoWorkers().filter((w) => w.project_root_realpath === projectRoot && isLockProcessAlive({
-                    pid: w.pid,
-                    startedAt: w.started_at,
-                    unitType: "starting",
-                    unitId: "bootstrap",
-                    unitStartedAt: w.started_at,
-                }));
-                const lockHolderAlive = activeWorkers.length > 0;
+                let lockHolderAlive = false;
+                try {
+                    const projectRoot = normalizeRealPath(basePath);
+                    for (const worker of getActiveAutoWorkers()) {
+                        if (worker.project_root_realpath !== projectRoot)
+                            continue;
+                        try {
+                            if (isLockProcessAlive({
+                                pid: worker.pid,
+                                startedAt: worker.started_at,
+                                unitType: "starting",
+                                unitId: "bootstrap",
+                                unitStartedAt: worker.started_at,
+                            })) {
+                                lockHolderAlive = true;
+                                break;
+                            }
+                        }
+                        catch {
+                            // Ignore malformed worker rows or transient PID probe failures.
+                        }
+                    }
+                }
+                catch {
+                    // If worker lookup fails, continue with the stranded lock diagnosis.
+                }
                 if (!lockHolderAlive) {
                     issues.push({
                         severity: "error",

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

@@ -12,37 +12,11 @@ import { GLOBAL_STATE_CODES } from "./doctor-types.js";
 import { checkGitHealth, checkRuntimeHealth, checkGlobalHealth, checkEngineHealth } from "./doctor-checks.js";
 import { checkEnvironmentHealth } from "./doctor-environment.js";
 import { runProviderChecks } from "./doctor-providers.js";
+import { validateTitle } from "./validation.js";
 export { summarizeDoctorIssues, filterDoctorIssues, formatDoctorReport, formatDoctorIssuesForPrompt, formatDoctorReportJson } from "./doctor-format.js";
 export { runEnvironmentChecks, runFullEnvironmentChecks, formatEnvironmentReport } from "./doctor-environment.js";
 export { computeProgressScore, computeProgressScoreWithContext, formatProgressLine, formatProgressReport } from "./progress-score.js";
-/**
- * Characters that are used as delimiters in GSD state management documents
- * and should not appear in milestone or slice titles.
- *
- * - "\u2014" (em dash, U+2014): used as a display separator in STATE.md and other docs.
- *   A title containing "\u2014" makes the separator ambiguous, corrupting state display
- *   and confusing the LLM agent that reads and writes these files.
- * - "\u2013" (en dash, U+2013): visually similar to em dash; same ambiguity risk.
- * - "/" (forward slash, U+002F): used as the path separator in unit IDs (M001/S01)
- *   and git branch names (gsd/M001/S01). A slash in a title can break path resolution.
- */
-const TITLE_DELIMITER_RE = /[\u2014\u2013\/]/; // em dash, en dash, forward slash
-/**
- * Check whether a milestone or slice title contains characters that conflict
- * with GSD's state document delimiter conventions.
- * Returns a human-readable description of the problem, or null if the title is safe.
- */
-export function validateTitle(title) {
-    if (TITLE_DELIMITER_RE.test(title)) {
-        const found = [];
-        if (/[\u2014\u2013]/.test(title))
-            found.push("em/en dash (\u2014 or \u2013)");
-        if (/\//.test(title))
-            found.push("forward slash (/)");
-        return `title contains ${found.join(" and ")}, which conflict with GSD state document delimiters`;
-    }
-    return null;
-}
+export { validateTitle } from "./validation.js";
 function validatePreferenceShape(preferences) {
     const issues = [];
     const listFields = ["always_use_skills", "prefer_skills", "avoid_skills", "custom_instructions"];

package/dist/resources/extensions/gsd/git-service.js

@@ -139,6 +139,30 @@ function isExcludedScopedPath(path, exclusions) {
     }
     return false;
 }
+function submodulePathsFromLsFiles(output) {
+    const submodulePaths = new Set();
+    if (!output)
+        return submodulePaths;
+    for (const line of output.split("\n")) {
+        const match = line.match(/^160000\s+\S+\s+\d+\t(.+)$/);
+        if (!match)
+            continue;
+        submodulePaths.add(match[1].replace(/\\/g, "/").replace(/\/+$/, ""));
+    }
+    return submodulePaths;
+}
+function isInsideSubmodule(path, submodulePaths) {
+    const normalizedPath = path.replace(/\\/g, "/");
+    if (submodulePaths.has(normalizedPath))
+        return true;
+    let slashIndex = normalizedPath.lastIndexOf("/");
+    while (slashIndex > 0) {
+        if (submodulePaths.has(normalizedPath.slice(0, slashIndex)))
+            return true;
+        slashIndex = normalizedPath.lastIndexOf("/", slashIndex - 1);
+    }
+    return false;
+}
 /**
  * Thrown when a slice merge hits code conflicts in non-.gsd files.
  * The working tree is left in a conflicted state (no reset) so the
@@ -572,6 +596,20 @@ export class GitServiceImpl {
             .filter((file) => file !== null)
             .filter(file => !nativeIsIgnored(this.basePath, file))
             .filter(file => !isExcludedScopedPath(file, allExclusions));
+        const scopedPaths = [];
+        const submodulePaths = [];
+        const repoSubmodules = submodulePathsFromLsFiles(runGit(this.basePath, ["ls-files", "--stage"], { allowFailure: true }));
+        for (const path of normalized) {
+            if (isInsideSubmodule(path, repoSubmodules)) {
+                submodulePaths.push(path);
+            }
+            else {
+                scopedPaths.push(path);
+            }
+        }
+        if (submodulePaths.length > 0) {
+            logWarning("engine", `scoped stage: dropping ${submodulePaths.length} keyFile(s) inside git submodule(s): ${submodulePaths.join(", ")}`, { file: "git-service.ts" });
+        }
         // Drop entries that don't exist on disk. The LLM occasionally lists files
         // it intended to write but didn't (or names them with wrong casing/path).
         // Pre-`b304f738b` `git add -A` swallowed these silently; the scoped
@@ -579,7 +617,7 @@ export class GitServiceImpl {
         // the whole commit fail (see #5500). Filter so valid paths still commit.
         const missing = [];
         const existing = [];
-        for (const path of normalized) {
+        for (const path of scopedPaths) {
             if (existsSync(join(this.basePath, path))) {
                 existing.push(path);
             }

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

@@ -1769,6 +1769,7 @@ export function deleteTask(milestoneId, sliceId, taskId) {
     transaction(() => {
         // Must delete verification_evidence first (FK constraint)
         currentDb.prepare(`DELETE FROM verification_evidence WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+        currentDb.prepare(`DELETE FROM quality_gates WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
         currentDb.prepare(`DELETE FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`).run({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
     });
 }

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

@@ -1238,6 +1238,7 @@ export async function showDiscuss(ctx, pi, basePath) {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
             const basePrompt = loadPrompt("guided-discuss-milestone", {
+                workingDirectory: basePath,
                 milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
                 fastPathInstruction: "",
@@ -1253,6 +1254,7 @@ export async function showDiscuss(ctx, pi, basePath) {
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
             setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId: mid, step: false });
             await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
+                workingDirectory: basePath,
                 milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
                 fastPathInstruction: "",
@@ -1488,6 +1490,7 @@ async function dispatchDiscussForMilestone(ctx, pi, basePath, mid, milestoneTitl
     const discussMilestoneTemplates = inlineTemplate("context", "Context");
     const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
     const basePrompt = loadPrompt("guided-discuss-milestone", {
+        workingDirectory: basePath,
         milestoneId: mid,
         milestoneTitle,
         inlinedTemplates: discussMilestoneTemplates,
@@ -1957,6 +1960,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
             const basePrompt = loadPrompt("guided-discuss-milestone", {
+                workingDirectory: basePath,
                 milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
                 fastPathInstruction: "",
@@ -1972,6 +1976,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
             setPendingAutoStart(basePath, { ctx, pi, basePath, milestoneId, step: stepMode });
             await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
+                workingDirectory: basePath,
                 milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
                 fastPathInstruction: "",
@@ -2052,6 +2057,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 const discussMilestoneTemplates = inlineTemplate("context", "Context");
                 const structuredQuestionsAvailable = getStructuredQuestionsAvailability(pi, ctx);
                 await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
+                    workingDirectory: basePath,
                     milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                     commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
                     fastPathInstruction: "",

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

@@ -71,6 +71,16 @@ function parsePhaseEntry(line) {
             raw: line,
         };
     }
+    // Format 3: - ✅ v1.0 MVP — Phases 1-6
+    const fmtVersionPhases = stripped.match(/^-\s+([✅🚧])\s+v\d+(?:\.\d+)*\s+(.+?)\s*[—–]\s*Phases?\s+(\d+(?:\.\d+)?)(?:\s*-\s*\d+(?:\.\d+)?)?(?:\s+\(.*\))?\s*$/iu);
+    if (fmtVersionPhases) {
+        return {
+            number: parseFloat(fmtVersionPhases[3]),
+            title: fmtVersionPhases[2].trim(),
+            done: fmtVersionPhases[1] === '✅',
+            raw: line,
+        };
+    }
     return null;
 }
 /**

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 ──────────────────────────────────────────────
@@ -782,13 +816,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) {

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;
 }

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.
@@ -647,7 +673,8 @@ export async function runPreExecutionChecks(tasks, basePath) {
     const fileChecks = checkFilePathConsistency(tasks, basePath);
     const orderingChecks = checkTaskOrdering(tasks, basePath);
     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/prompt-loader.js

@@ -181,7 +181,7 @@ export function loadPrompt(name, vars = {}) {
             .map(m => m.slice(2, -2))
             .filter(key => !(key in effectiveVars));
         if (missing.length > 0) {
-            throw new GSDError(GSD_PARSE_ERROR, `loadPrompt("${name}"): template declares {{${missing.join("}}, {{")}}}} but no value was provided. ` +
+            throw new GSDError(GSD_PARSE_ERROR, `loadPrompt("${name}"): template declares {{${missing.join("}}, {{")}}} but no value was provided. ` +
                 `This usually means the extension code in memory is older than the template on disk. ` +
                 `Restart pi to reload the extension.`);
         }

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -26,7 +26,7 @@ Before planning, validate roadmap assumptions against code and dependency summar
 
 {{sourceFilePaths}}
 
-If slice research is inlined, trust it. Explore enough code to confirm paths, boundaries, and verification. Executors later get only task plans, slice excerpt, and prior summaries, so put required paths, steps, inputs, and outputs in task plans.
+If slice research is inlined, trust its architectural findings, but verify every concrete file path you place in task `inputs` or `expectedOutput` against the current tree or prior/same-task outputs. Explore enough code to confirm paths, boundaries, and verification. Executors later get only task plans, slice excerpt, and prior summaries, so put required paths, steps, inputs, and outputs in task plans.
 
 {{executorContextConstraints}}
 
@@ -39,8 +39,8 @@ If slice research is inlined, trust it. Explore enough code to confirm paths, bo
 5. Define slice verification before tasks. Non-trivial slices need real tests or executable assertions; boundary contracts need contract-exercising checks. Tests must not read .gitignore/gitignored paths such as `.gsd/`, `.planning/`, or `.audits/`.
 6. Include Threat Surface (Q3), Requirement Impact (Q4), proof level, observability, integration closure, Failure Modes (Q5), Load Profile (Q6), and Negative Tests (Q7) only where applicable.
 7. Right-size tasks. Simple slices can be one task; split only when context, ownership, or verification boundaries justify it.
-8. Each task needs a concrete title, Why / Files / Do / Verify / Done when, plus task-plan description, steps, must-haves, verification, inputs, and expected output. Inputs and Expected Output must include concrete backtick-wrapped paths. Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expected_output` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, or tests — those belong only in `inputs`. If a task is a pure verification or test task that produces no new files, its `expected_output` may be empty or limited to test-result artifacts (e.g. a log or assertion output). A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expected_output` — if no prior task creates it, add a task before this one that does.
-9. Persist with `gsd_plan_slice` using goal, successCriteria, optional proofLevel/integrationClosure/observabilityImpact, and tasks. `gsd_plan_slice` handles task persistence transactionally and renders `{{outputPath}}` plus task plans; do not call `gsd_plan_task`. The DB-backed tool is the canonical write path. Do **not** rely on direct `PLAN.md` writes as the source of truth.
+8. Each task needs the exact `gsd_plan_slice.tasks[]` shape: `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. `description` should contain the Why / Do / Done-when narrative. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even when there is only one path (for example, `"inputs": ["src/index.ts"]`, never `"inputs": "src/index.ts"`). Use paths relative to `{{workingDirectory}}`; do not put absolute paths to the original checkout or any directory outside `{{workingDirectory}}` in `files`, `inputs`, `expectedOutput`, or verification commands. **`expectedOutput` must only list files the task actually creates or overwrites on disk.** Do NOT include files the task merely reads, verifies, or tests — those belong only in `inputs`. If a task is a pure verification or test task that produces no new files, `expectedOutput` may be `[]` or limited to test-result artifacts (e.g. a log or assertion output). A file that does not yet exist on disk and is needed as an `input` must be produced by an earlier task's `expectedOutput` — if no prior task creates it, add a task before this one that does.
+9. Persist with `gsd_plan_slice` using `milestoneId`, `sliceId`, `goal`, optional `successCriteria`/`proofLevel`/`integrationClosure`/`observabilityImpact`, and `tasks`. `gsd_plan_slice` handles task persistence transactionally and renders `{{outputPath}}` plus task plans; do not call `gsd_plan_task`. The DB-backed tool is the canonical write path. Do **not** rely on direct `PLAN.md` writes as the source of truth.
 10. Self-audit before finishing: goal/demo closure, requirement coverage, locked decisions, concrete paths, dependency order, wiring, scope size, proof truthfulness, feature completeness, and quality gates. Quality gates: non-trivial slices/tasks include specific Q3-Q7 coverage where applicable.
 11. If planning creates structural decisions, append them to `.gsd/DECISIONS.md`.
 12. {{commitInstruction}}

package/dist/resources/extensions/gsd/prompts/refine-slice.md

@@ -64,7 +64,7 @@ Then:
 2. {{skillActivation}} Record the installed skills you expect executors to use in each task plan's `skills_used` frontmatter.
 3. Define slice-level verification: the objective stopping condition. Plan real test files with real assertions; for simple slices, executable commands are fine.
 4. For non-trivial slices, plan observability / proof level / integration closure, threat surface, and requirement impact. Omit entirely for simple slices.
-5. Decompose the slice into tasks that fit one context window each. Every task must have Why / Files / Do / Verify / Done-when, plus a task plan with description, steps, must-haves, verification, inputs (backtick-wrapped paths), and expected output (backtick-wrapped paths).
+5. Decompose the slice into tasks that fit one context window each. Every task passed to `gsd_plan_slice` must use the exact keys `taskId`, `title`, `description`, `estimate`, `files`, `verify`, `inputs`, `expectedOutput`, and optional `observabilityImpact`. Put Why / Do / Done-when detail in `description`. `files`, `inputs`, and `expectedOutput` must be JSON arrays of strings, even for one path (for example, `"expectedOutput": ["src/index.ts"]`, never `"expectedOutput": "src/index.ts"`).
 6. **Persist planning state through `gsd_plan_slice`.** Call it with the full payload. The tool writes to the DB and renders `{{outputPath}}` and `{{slicePath}}/tasks/T##-PLAN.md` automatically. Do NOT rely on direct `PLAN.md` writes.
 7. **Self-audit the plan.** If every task were completed exactly as written, the slice goal/demo should be true. Every must-have maps to a task. Inputs and Expected Output are backtick-wrapped file paths.
 8. If refinement produced structural decisions that diverge from the sketch, append them to `.gsd/DECISIONS.md`.

package/dist/resources/extensions/gsd/status-guards.js

@@ -22,3 +22,7 @@ export function isDeferredStatus(status) {
 export function isInactiveStatus(status) {
     return isClosedStatus(status) || isDeferredStatus(status);
 }
+/** Returns true when a prior milestone should not block dispatch ordering. */
+export function isSkippedForDispatch(status) {
+    return isClosedStatus(status) || status === "parked" || isDeferredStatus(status);
+}

package/dist/resources/extensions/gsd/templates/plan.md

@@ -99,11 +99,11 @@
   - "Improve UI"
 
   Each task should usually include:
-  - Why: why this task exists / what part of the slice it closes
-  - Files: the main files likely touched
-  - Do: concrete implementation steps and important constraints
-  - Verify: the command, test, or runtime check that proves it worked
-  - Done when: a measurable acceptance condition
+  - description: why this task exists, concrete steps, and done-when acceptance
+  - files: JSON array of likely touched paths
+  - verify: the command, test, or runtime check that proves it worked
+  - inputs: JSON array of existing paths or prior task outputs this task consumes
+  - expectedOutput: JSON array of paths this task creates or overwrites
 
   Keep the checkbox line format exactly:
   - [ ] **T01: Title** `est:30m`
@@ -131,10 +131,13 @@
 
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
+  - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, or output trimming
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"
+  - BAD: `python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5`
   - BAD: "Sections 3.1 and 3.2 exist with exact formulas. Zero TBD/TODO."
+  - GOOD: `python3 -m pytest tests/ -q --tb=short`
   - GOOD: `grep -c "^## " doc.md` returns >= 4 (4+ sections), `! grep -q "TBD\|TODO" doc.md`
 
   Integration closure rule:

package/dist/resources/extensions/gsd/templates/task-plan.md

@@ -72,7 +72,8 @@ skills_used:
 <!-- Every input MUST be a backtick-wrapped file path. These paths are machine-parsed to
      derive task dependencies — vague descriptions without paths break dependency detection.
      For the first task in a slice with no prior task outputs, list the existing source files
-     this task reads or modifies. -->
+     this task reads or modifies.
+     Tool field: inputs must be an array of strings, e.g. ["src/index.ts"], never a single string. -->
 
 - `{{filePath}}` — {{whatThisTaskNeedsFromPriorWork}}
 
@@ -82,6 +83,7 @@ skills_used:
      or modifies. These paths are machine-parsed to derive task dependencies.
      This task should produce a real increment toward making the slice goal/demo true. A full
      slice plan should not be able to mark every task complete while the claimed slice behavior
-     still does not work at the stated proof level. -->
+     still does not work at the stated proof level.
+     Tool field: expectedOutput must be an array of strings, e.g. ["src/index.ts"], never a single string. -->
 
 - `{{filePath}}` — {{whatThisTaskCreatesOrModifies}}

package/dist/resources/extensions/gsd/tools/complete-milestone.js

@@ -24,11 +24,11 @@ function renderMilestoneSummaryMarkdown(params, completedAt) {
     const keyFiles = params.keyFiles ?? [];
     const lessonsLearned = params.lessonsLearned ?? [];
     const keyDecisionsYaml = keyDecisions.length > 0
-        ? keyDecisions.map(d => `  - ${d}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyDecisions.map(d => `  - ${d}`).join("\n")}`
+        : " []";
     const keyFilesYaml = keyFiles.length > 0
-        ? keyFiles.map(f => `  - ${f}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyFiles.map(f => `  - ${f}`).join("\n")}`
+        : " []";
     const lessonsYaml = lessonsLearned.length > 0
         ? lessonsLearned.map(l => `  - ${l}`).join("\n")
         : "  - (none)";
@@ -37,10 +37,8 @@ id: ${params.milestoneId}
 title: "${displayTitle}"
 status: complete
 completed_at: ${completedAt}
-key_decisions:
-${keyDecisionsYaml}
-key_files:
-${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
+key_files:${keyFilesYaml}
 lessons_learned:
 ${lessonsYaml}
 ---

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -65,11 +65,11 @@ function renderSliceSummaryMarkdown(params) {
         ? affects.map(a => `  - ${a}`).join("\n")
         : "  []";
     const keyFilesYaml = keyFiles.length > 0
-        ? keyFiles.map(f => `  - ${f}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyFiles.map(f => `  - ${f}`).join("\n")}`
+        : " []";
     const keyDecisionsYaml = keyDecisions.length > 0
-        ? keyDecisions.map(d => `  - ${d}`).join("\n")
-        : "  - (none)";
+        ? `\n${keyDecisions.map(d => `  - ${d}`).join("\n")}`
+        : " []";
     const patternsYaml = patternsEstablished.length > 0
         ? patternsEstablished.map(p => `  - ${p}`).join("\n")
         : "  - (none)";
@@ -106,10 +106,8 @@ requires:
 ${requiresYaml}
 affects:
 ${affectsYaml}
-key_files:
-${keyFilesYaml}
-key_decisions:
-${keyDecisionsYaml}
+key_files:${keyFilesYaml}
+key_decisions:${keyDecisionsYaml}
 patterns_established:
 ${patternsYaml}
 observability_surfaces: