gsd-pi 2.76.0 → 2.77.0

package/dist/resources/extensions/gsd/safety/file-change-validator.js

@@ -4,13 +4,18 @@
  *
  * Uses tasks.expected_output (DB column, populated from per-task ## Expected Output)
  * and tasks.files (from slice PLAN.md - Files: subline) as the expected set.
- * Compares against git diff HEAD~1 --name-only after auto-commit.
+ * Compares against `git diff-tree --root --no-commit-id -r --name-only HEAD` after auto-commit.
+ * Using diff-tree --root handles initial commits, shallow clones, and merge commits correctly
+ * (Bug #4385 — git diff HEAD~1 failed on initial commits).
  *
  * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
  */
+import { createRequire } from "node:module";
 import { execFileSync } from "node:child_process";
 import { normalizePlannedFileReference } from "../files.js";
 import { logWarning } from "../workflow-logger.js";
+const _require = createRequire(import.meta.url);
+const picomatch = _require("picomatch");
 // ─── Public API ─────────────────────────────────────────────────────────────
 /**
  * Validate file changes after auto-commit for an execute-task unit.
@@ -20,7 +25,7 @@ import { logWarning } from "../workflow-logger.js";
  * @param expectedOutput - JSON array from tasks.expected_output DB column
  * @param plannedFiles - JSON array from tasks.files DB column
  */
-export function validateFileChanges(basePath, expectedOutput, plannedFiles) {
+export function validateFileChanges(basePath, expectedOutput, plannedFiles, fileChangeAllowlist = []) {
     const allExpected = new Set([...expectedOutput, ...plannedFiles]);
     // If no expected files were planned, skip validation
     if (allExpected.size === 0)
@@ -33,8 +38,11 @@ export function validateFileChanges(basePath, expectedOutput, plannedFiles) {
     const projectFiles = actualFiles.filter(f => !f.startsWith(".gsd/") && !f.startsWith(".gsd\\"));
     // Normalize expected paths (strip leading ./ or /)
     const normalizedExpected = new Set([...allExpected].map((f) => normalizePlannedFileReference(f).replace(/^\.\//, "").replace(/^\//, "")));
-    // Compute symmetric difference
-    const unexpectedFiles = projectFiles.filter(f => !normalizedExpected.has(f));
+    // Build allowlist matchers once (dot: true so patterns like `**/.hidden` work).
+    const allowlistMatchers = fileChangeAllowlist.map(p => picomatch(p, { dot: true }));
+    const isAllowlisted = (f) => allowlistMatchers.some(m => m(f));
+    // Compute symmetric difference, excluding allowlisted files
+    const unexpectedFiles = projectFiles.filter(f => !normalizedExpected.has(f) && !isAllowlisted(f));
     const missingFiles = [...normalizedExpected].filter(f => !projectFiles.includes(f));
     const violations = [];
     for (const f of unexpectedFiles) {
@@ -62,7 +70,7 @@ export function validateFileChanges(basePath, expectedOutput, plannedFiles) {
 // ─── Internals ──────────────────────────────────────────────────────────────
 function getChangedFilesFromLastCommit(basePath) {
     try {
-        const result = execFileSync("git", ["diff", "--name-only", "HEAD~1", "HEAD"], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+        const result = execFileSync("git", ["diff-tree", "--root", "--no-commit-id", "-r", "--name-only", "HEAD"], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
         return result ? result.split("\n").filter(Boolean) : [];
     }
     catch (e) {

package/dist/resources/extensions/gsd/safety/safety-harness.js

@@ -23,6 +23,7 @@ const DEFAULTS = {
     checkpoints: true,
     auto_rollback: false,
     timeout_scale_cap: 6,
+    file_change_allowlist: [],
 };
 // ─── Public API ─────────────────────────────────────────────────────────────
 /**
@@ -42,6 +43,9 @@ export function resolveSafetyHarnessConfig(raw) {
         checkpoints: typeof raw.checkpoints === "boolean" ? raw.checkpoints : DEFAULTS.checkpoints,
         auto_rollback: typeof raw.auto_rollback === "boolean" ? raw.auto_rollback : DEFAULTS.auto_rollback,
         timeout_scale_cap: typeof raw.timeout_scale_cap === "number" ? raw.timeout_scale_cap : DEFAULTS.timeout_scale_cap,
+        file_change_allowlist: Array.isArray(raw.file_change_allowlist)
+            ? raw.file_change_allowlist.filter((p) => typeof p === "string")
+            : DEFAULTS.file_change_allowlist,
     };
 }
 /**
@@ -56,7 +60,7 @@ export function isHarnessEnabled(raw) {
     return DEFAULTS.enabled;
 }
 // ─── Re-exports ─────────────────────────────────────────────────────────────
-export { resetEvidence, getEvidence, getBashEvidence, getFilePaths, recordToolCall, recordToolResult, } from "./evidence-collector.js";
+export { resetEvidence, getEvidence, getBashEvidence, getFilePaths, recordToolCall, recordToolResult, saveEvidenceToDisk, loadEvidenceFromDisk, clearEvidenceFromDisk, } from "./evidence-collector.js";
 export { classifyCommand } from "./destructive-guard.js";
 export { validateFileChanges } from "./file-change-validator.js";
 export { crossReferenceEvidence } from "./evidence-cross-ref.js";

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

@@ -501,7 +501,7 @@ async function handleAllSlicesDone(basePath, activeMilestone, registry, requirem
     const validationContent = validationFile ? await loadFile(validationFile) : null;
     const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
     const verdict = validationContent ? extractVerdict(validationContent) : undefined;
-    if (!validationTerminal || verdict === 'needs-remediation') {
+    if (!validationTerminal) {
         return {
             activeMilestone, activeSlice: null, activeTask: null,
             phase: 'validating-milestone',
@@ -511,6 +511,23 @@ async function handleAllSlicesDone(basePath, activeMilestone, registry, requirem
             progress: { milestones: milestoneProgress, slices: sliceProgress },
         };
     }
+    // All roadmap slices are done (enforced by caller) and verdict is
+    // needs-remediation — remediation cannot progress without new slices.
+    // Return blocked instead of re-dispatching validate-milestone (#4506).
+    if (verdict === 'needs-remediation') {
+        return {
+            activeMilestone, activeSlice: null, activeTask: null,
+            phase: 'blocked',
+            recentDecisions: [],
+            blockers: [
+                `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
+                    `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+            ],
+            nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
+            registry, requirements,
+            progress: { milestones: milestoneProgress, slices: sliceProgress },
+        };
+    }
     return {
         activeMilestone, activeSlice: null, activeTask: null,
         phase: 'completing-milestone',
@@ -1278,9 +1295,11 @@ export async function _deriveStateImpl(basePath) {
             done: activeRoadmap.slices.length,
             total: activeRoadmap.slices.length,
         };
-        // Force re-validation when verdict is needs-remediation — remediation slices
-        // may have completed since the stale validation was written (#3596).
-        if (!validationTerminal || verdict === 'needs-remediation') {
+        // Force re-validation when VALIDATION.md is absent or non-terminal —
+        // remediation slices may have completed since the stale validation was
+        // written (#3596). But needs-remediation with all slices done is a dead
+        // end — return blocked to avoid an infinite dispatch loop (#4506).
+        if (!validationTerminal) {
             return {
                 activeMilestone,
                 activeSlice: null,
@@ -1297,6 +1316,26 @@ export async function _deriveStateImpl(basePath) {
                 },
             };
         }
+        if (verdict === 'needs-remediation') {
+            return {
+                activeMilestone,
+                activeSlice: null,
+                activeTask: null,
+                phase: 'blocked',
+                recentDecisions: [],
+                blockers: [
+                    `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
+                        `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+                ],
+                nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
+                registry,
+                requirements,
+                progress: {
+                    milestones: milestoneProgress,
+                    slices: sliceProgress,
+                },
+            };
+        }
         return {
             activeMilestone,
             activeSlice: null,

package/dist/resources/extensions/gsd/token-counter.js

@@ -16,7 +16,11 @@ async function getEncoder() {
     try {
         // @ts-ignore — tiktoken may not have type declarations in extensions tsconfig
         const tiktoken = await import("tiktoken");
-        encoder = tiktoken.encoding_for_model("gpt-4o");
+        // Use cl100k_base — the most conservative and broadly compatible BPE encoding.
+        // It is shared by GPT-3.5/GPT-4 and gives a safer (larger) estimate than
+        // gpt-4o's o200k_base encoding, which produces fewer tokens for the same text
+        // and would cause context windows for non-OpenAI providers to be under-counted.
+        encoder = tiktoken.get_encoding("cl100k_base");
         return encoder;
     }
     catch {
@@ -24,19 +28,32 @@ async function getEncoder() {
         return null;
     }
 }
-export async function countTokens(text) {
+/**
+ * Count tokens in `text` using tiktoken (cl100k_base) when available.
+ *
+ * When tiktoken is not loaded, falls back to a provider-aware character-ratio
+ * estimate via `estimateTokensForProvider`. Passing `provider` is recommended
+ * so the heuristic fallback is as accurate as possible.
+ */
+export async function countTokens(text, provider) {
     const enc = await getEncoder();
     if (enc) {
         const tokens = enc.encode(text);
         return tokens.length;
     }
-    return Math.ceil(text.length / 4);
+    return estimateTokensForProvider(text, provider ?? "unknown");
 }
-export function countTokensSync(text) {
+/**
+ * Synchronous token count — only accurate after `initTokenCounter()` resolves.
+ *
+ * Before init, or when tiktoken is unavailable, falls back to a provider-aware
+ * character-ratio estimate. Passing `provider` is recommended.
+ */
+export function countTokensSync(text, provider) {
     if (encoder) {
         return encoder.encode(text).length;
     }
-    return Math.ceil(text.length / 4);
+    return estimateTokensForProvider(text, provider ?? "unknown");
 }
 export async function initTokenCounter() {
     const enc = await getEncoder();

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

@@ -6,7 +6,7 @@
  * for recovery, and invalidates caches.
  */
 import { join } from "node:path";
-import { mkdirSync } from "node:fs";
+import { mkdirSync, existsSync } from "node:fs";
 import { transaction, getMilestone, getMilestoneSlices, getSliceTasks, updateMilestoneStatus, } from "../gsd-db.js";
 import { resolveMilestonePath, clearPathCache } from "../paths.js";
 import { isClosedStatus } from "../status-guards.js";
@@ -141,15 +141,21 @@ export async function handleCompleteMilestone(params, basePath) {
         mkdirSync(manualDir, { recursive: true });
         summaryPath = join(manualDir, `${params.milestoneId}-SUMMARY.md`);
     }
-    try {
-        await saveFile(summaryPath, summaryMd);
-    }
-    catch (renderErr) {
-        // Disk render failed — roll back DB status so state stays consistent
-        logWarning("tool", `complete_milestone — disk render failed, rolling back DB status: ${renderErr.message}`);
-        updateMilestoneStatus(params.milestoneId, 'active', null);
-        invalidateStateCache();
-        return { error: `disk render failed: ${renderErr.message}` };
+    // Guard (#4598): if SUMMARY.md already exists on disk, do not overwrite it.
+    // This handles re-dispatch scenarios (DB/disk state divergence) where a prior
+    // completion already wrote the file. Overwriting would silently destroy the
+    // richer content the agent produced during the original completion run.
+    if (!existsSync(summaryPath)) {
+        try {
+            await saveFile(summaryPath, summaryMd);
+        }
+        catch (renderErr) {
+            // Disk render failed — roll back DB status so state stays consistent
+            logWarning("tool", `complete_milestone — disk render failed, rolling back DB status: ${renderErr.message}`);
+            updateMilestoneStatus(params.milestoneId, 'active', null);
+            invalidateStateCache();
+            return { error: `disk render failed: ${renderErr.message}` };
+        }
     }
     // Invalidate all caches
     invalidateStateCache();

package/dist/resources/extensions/gsd/tools/exec-search-tool.js

@@ -0,0 +1,59 @@
+// GSD Exec Search Tool — lists and filters prior gsd_exec runs.
+//
+// Scans .gsd/exec/*.meta.json and returns a ranked summary so agents can
+// re-discover past runs without re-executing. Read-only; no DB writes.
+import { searchExecHistory } from "../exec-history.js";
+export function executeExecSearch(params, opts) {
+    const searchOpts = {
+        query: typeof params.query === "string" ? params.query : undefined,
+        runtime: params.runtime,
+        failing_only: params.failing_only === true,
+        limit: typeof params.limit === "number" ? params.limit : undefined,
+    };
+    const hits = searchExecHistory(opts.baseDir, searchOpts);
+    if (hits.length === 0) {
+        return {
+            content: [{ type: "text", text: "No prior gsd_exec runs match those filters." }],
+            details: { operation: "gsd_exec_search", matches: 0 },
+        };
+    }
+    const lines = [`Found ${hits.length} exec run(s), most recent first:`];
+    for (const hit of hits) {
+        const e = hit.entry;
+        const status = formatStatus(e);
+        const purpose = e.purpose ? ` — ${e.purpose}` : "";
+        const truncated = e.stdout_truncated ? " (stdout truncated)" : "";
+        lines.push(`- [${e.id}] ${e.runtime} ${status} ${e.duration_ms}ms${truncated}${purpose}`, `    stdout: ${e.stdout_path}`);
+        if (hit.digest_preview) {
+            const preview = hit.digest_preview.replace(/\n/g, "\n      ");
+            lines.push(`    preview:\n      ${preview}`);
+        }
+    }
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        details: {
+            operation: "gsd_exec_search",
+            matches: hits.length,
+            results: hits.map((hit) => ({
+                id: hit.entry.id,
+                runtime: hit.entry.runtime,
+                exit_code: hit.entry.exit_code,
+                timed_out: hit.entry.timed_out,
+                duration_ms: hit.entry.duration_ms,
+                purpose: hit.entry.purpose,
+                stdout_path: hit.entry.stdout_path,
+                stderr_path: hit.entry.stderr_path,
+                meta_path: hit.entry.meta_path,
+            })),
+        },
+    };
+}
+function formatStatus(entry) {
+    if (entry.timed_out)
+        return "timeout";
+    if (entry.signal)
+        return `signal:${entry.signal}`;
+    if (entry.exit_code === null)
+        return "exit:null";
+    return `exit:${entry.exit_code}`;
+}

package/dist/resources/extensions/gsd/tools/exec-tool.js

@@ -0,0 +1,126 @@
+// GSD Exec Tool — executor for the gsd_exec MCP tool.
+//
+// Thin wrapper around exec-sandbox.ts that reads effective options from
+// the project preferences (context_mode block) and formats the result
+// for MCP return.
+import { EXEC_DEFAULTS, runExecSandbox, } from "../exec-sandbox.js";
+import { isContextModeEnabled } from "../preferences-types.js";
+export function buildExecOptions(baseDir, cfg, extras) {
+    const allowlist = Array.isArray(cfg?.exec_env_allowlist) ? cfg.exec_env_allowlist : EXEC_DEFAULTS.envAllowlist;
+    const stdoutCap = clampNumber(cfg?.exec_stdout_cap_bytes, EXEC_DEFAULTS.stdoutCapBytes, 4_096, 16_777_216);
+    const defaultTimeout = clampNumber(cfg?.exec_timeout_ms, EXEC_DEFAULTS.defaultTimeoutMs, 1_000, EXEC_DEFAULTS.clampTimeoutMs);
+    const digestChars = clampNumber(cfg?.exec_digest_chars, EXEC_DEFAULTS.digestChars, 0, 4_000);
+    return {
+        baseDir,
+        clamp_timeout_ms: EXEC_DEFAULTS.clampTimeoutMs,
+        default_timeout_ms: defaultTimeout,
+        stdout_cap_bytes: stdoutCap,
+        stderr_cap_bytes: EXEC_DEFAULTS.stderrCapBytes,
+        digest_chars: digestChars,
+        env_allowlist: allowlist,
+        ...extras,
+    };
+}
+function clampNumber(value, fallback, min, max) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return fallback;
+    if (value < min)
+        return min;
+    if (value > max)
+        return max;
+    return Math.floor(value);
+}
+function isEnabled(prefs) {
+    return isContextModeEnabled(prefs);
+}
+function disabledResult() {
+    return {
+        content: [
+            {
+                type: "text",
+                text: "gsd_exec is disabled by `context_mode.enabled: false` in preferences. Remove that " +
+                    "override (or set it to true) to re-enable sandboxed tool-output execution.",
+            },
+        ],
+        details: { operation: "gsd_exec", error: "context_mode_disabled" },
+        isError: true,
+    };
+}
+function paramError(message) {
+    return {
+        content: [{ type: "text", text: `Error: ${message}` }],
+        details: { operation: "gsd_exec", error: "invalid_params", detail: message },
+        isError: true,
+    };
+}
+export async function executeGsdExec(params, deps) {
+    if (!isEnabled(deps.preferences))
+        return disabledResult();
+    const runtime = params.runtime;
+    if (runtime !== "bash" && runtime !== "node" && runtime !== "python") {
+        return paramError(`invalid runtime "${String(runtime)}" — must be bash | node | python`);
+    }
+    const script = typeof params.script === "string" ? params.script : "";
+    if (script.trim().length === 0) {
+        return paramError("script is required and must be a non-empty string");
+    }
+    if (Buffer.byteLength(script, "utf8") > 200_000) {
+        return paramError("script exceeds the 200 KB length limit");
+    }
+    const opts = buildExecOptions(deps.baseDir, deps.preferences?.context_mode, { now: deps.now, generateId: deps.generateId });
+    const run = deps.run ?? runExecSandbox;
+    try {
+        const result = await run({
+            runtime,
+            script,
+            ...(typeof params.purpose === "string" ? { purpose: params.purpose } : {}),
+            ...(typeof params.timeout_ms === "number" ? { timeout_ms: params.timeout_ms } : {}),
+        }, opts);
+        return formatResult(result);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            content: [{ type: "text", text: `Error: gsd_exec failed — ${message}` }],
+            details: { operation: "gsd_exec", error: message },
+            isError: true,
+        };
+    }
+}
+function formatResult(result) {
+    const headerLines = [
+        `gsd_exec[${result.id}] runtime=${result.runtime} exit=${formatExit(result)} duration=${result.duration_ms}ms`,
+        `  stdout: ${result.stdout_bytes}B${result.stdout_truncated ? " (truncated)" : ""} → ${result.stdout_path}`,
+        `  stderr: ${result.stderr_bytes}B${result.stderr_truncated ? " (truncated)" : ""} → ${result.stderr_path}`,
+    ];
+    const summary = `${headerLines.join("\n")}\n--- digest ---\n${result.digest}`.trimEnd();
+    return {
+        content: [{ type: "text", text: summary }],
+        details: {
+            operation: "gsd_exec",
+            id: result.id,
+            runtime: result.runtime,
+            exit_code: result.exit_code,
+            signal: result.signal,
+            timed_out: result.timed_out,
+            duration_ms: result.duration_ms,
+            stdout_bytes: result.stdout_bytes,
+            stderr_bytes: result.stderr_bytes,
+            stdout_truncated: result.stdout_truncated,
+            stderr_truncated: result.stderr_truncated,
+            stdout_path: result.stdout_path,
+            stderr_path: result.stderr_path,
+            meta_path: result.meta_path,
+        },
+        isError: result.timed_out || result.signal !== null || result.exit_code !== 0,
+    };
+}
+function formatExit(result) {
+    if (result.timed_out)
+        return "timeout";
+    if (result.signal)
+        return `signal:${result.signal}`;
+    if (result.exit_code === null)
+        return "null";
+    return String(result.exit_code);
+}

package/dist/resources/extensions/gsd/tools/memory-tools.js

@@ -58,7 +58,8 @@ export function executeMemoryCapture(params) {
     const confidence = clampConfidence(params.confidence);
     const scope = normalizeScope(params.scope);
     const tags = normalizeTags(params.tags);
-    const id = createMemory({ category, content, confidence, scope, tags });
+    const structuredFields = normalizeStructuredFields(params.structuredFields);
+    const id = createMemory({ category, content, confidence, scope, tags, structuredFields });
     if (!id) {
         return {
             content: [{ type: "text", text: "Error: failed to create memory." }],
@@ -82,6 +83,19 @@ function normalizeTags(value) {
         return [];
     return value.filter((t) => typeof t === "string" && t.trim().length > 0).slice(0, 10);
 }
+function normalizeStructuredFields(value) {
+    if (value == null)
+        return null;
+    if (typeof value !== "object" || Array.isArray(value))
+        return null;
+    // Only accept plain objects (Object.prototype or null prototype). Class
+    // instances and exotic objects won't round-trip cleanly through JSON, so
+    // reject them here instead of producing a partially-serialized payload.
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== null && proto !== Object.prototype)
+        return null;
+    return value;
+}
 function clampConfidence(value) {
     if (typeof value !== "number" || !Number.isFinite(value))
         return 0.8;
@@ -200,6 +214,16 @@ function includeSupersededMemories(rankedActive) {
                     /* leave empty */
                 }
             }
+            let structuredFields = null;
+            if (typeof row["structured_fields"] === "string" && row["structured_fields"].length > 0) {
+                try {
+                    const parsed = JSON.parse(row["structured_fields"]);
+                    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                        structuredFields = parsed;
+                    }
+                }
+                catch { /* leave null */ }
+            }
             return {
                 seq: row["seq"],
                 id: row["id"],
@@ -214,6 +238,7 @@ function includeSupersededMemories(rankedActive) {
                 hit_count: row["hit_count"],
                 scope: row["scope"] ?? "project",
                 tags,
+                structured_fields: structuredFields,
             };
         });
     }

package/dist/resources/extensions/gsd/tools/resume-tool.js

@@ -0,0 +1,23 @@
+// GSD Resume Tool — returns the contents of .gsd/last-snapshot.md so
+// agents can re-orient after compaction or session resume without
+// re-deriving project memory state.
+import { readCompactionSnapshot } from "../compaction-snapshot.js";
+export function executeResume(_params, opts) {
+    const snapshot = readCompactionSnapshot(opts.baseDir);
+    if (snapshot == null) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "No snapshot found at .gsd/last-snapshot.md. The snapshot is written automatically " +
+                        "on session_before_compact (enabled by default; set context_mode.enabled=false to opt out).",
+                },
+            ],
+            details: { operation: "gsd_resume", found: false },
+        };
+    }
+    return {
+        content: [{ type: "text", text: snapshot }],
+        details: { operation: "gsd_resume", found: true, bytes: Buffer.byteLength(snapshot, "utf-8") },
+    };
+}

package/dist/resources/extensions/gsd/uok/plan-v2.js

@@ -22,6 +22,23 @@ function hasFileContent(path) {
         return false;
     }
 }
+function getArtifactLookupBases(basePath) {
+    const bases = [basePath];
+    const projectRoot = process.env.GSD_PROJECT_ROOT;
+    if (projectRoot && projectRoot.trim().length > 0 && projectRoot !== basePath) {
+        bases.push(projectRoot);
+    }
+    return bases;
+}
+function hasMilestoneFileContent(basePath, milestoneId, suffix) {
+    const bases = getArtifactLookupBases(basePath);
+    for (const candidateBase of bases) {
+        if (hasFileContent(resolveMilestoneFile(candidateBase, milestoneId, suffix))) {
+            return true;
+        }
+    }
+    return false;
+}
 function countSliceResearchArtifacts(basePath, milestoneId, slices) {
     let count = 0;
     for (const slice of slices) {
@@ -43,9 +60,9 @@ export function compileUnitGraphFromState(basePath, state) {
     const slices = getMilestoneSlices(mid).sort((a, b) => Number(a.sequence ?? 0) - Number(b.sequence ?? 0));
     const nodes = [];
     const clarifyRoundLimit = PLAN_V2_CLARIFY_ROUND_LIMIT;
-    const draftContextIncluded = hasFileContent(resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT"));
-    const finalizedContextIncluded = hasFileContent(resolveMilestoneFile(basePath, mid, "CONTEXT"));
-    const researchSynthesized = hasFileContent(resolveMilestoneFile(basePath, mid, "RESEARCH"))
+    const draftContextIncluded = hasMilestoneFileContent(basePath, mid, "CONTEXT-DRAFT");
+    const finalizedContextIncluded = hasMilestoneFileContent(basePath, mid, "CONTEXT");
+    const researchSynthesized = hasMilestoneFileContent(basePath, mid, "RESEARCH")
         || countSliceResearchArtifacts(basePath, mid, slices) > 0;
     if (isExecutionEntryPhase(state.phase) && !finalizedContextIncluded) {
         const reason = draftContextIncluded

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

@@ -5,6 +5,9 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 const MCP_WORKFLOW_TOOL_SURFACE = new Set([
     "ask_user_questions",
     "gsd_decision_save",
+    "gsd_exec",
+    "gsd_exec_search",
+    "gsd_resume",
     "gsd_complete_milestone",
     "gsd_complete_task",
     "gsd_complete_slice",

package/dist/resources/extensions/gsd/workflow-templates/spike.md

@@ -66,5 +66,11 @@ Use for: technology evaluation, architecture decisions, "should we X?" questions
    - Recommendation with rationale
    - Next steps if the recommendation is accepted
 4. **Present** the recommendation to the user for discussion
+5. **Offer wrap-up:** If the findings are reusable on future work, offer to run
+   the `spike-wrap-up` skill to package them as a project-local skill at
+   `.claude/skills/<name>/SKILL.md`. That skill will auto-load on future
+   similar tasks via `skill-discovery.ts`. If the recommendation is
+   decision-only (no reusable guidance), suggest appending a one-liner to
+   `.gsd/DECISIONS.md` instead.
 
 </process>