gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.b6ad8c5f7

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

@@ -61,6 +61,15 @@ function validateSlices(value) {
         const proofLevel = obj.proofLevel;
         const integrationClosure = obj.integrationClosure;
         const observabilityImpact = obj.observabilityImpact;
+        const isSketchRaw = obj.isSketch;
+        const sketchScopeRaw = obj.sketchScope;
+        // ADR-011: preserve the 3-valued semantics of isSketch (true / false / absent).
+        // Callers that omit isSketch must receive `undefined` here so `insertSlice`'s
+        // ON CONFLICT clause preserves any existing is_sketch on the row rather than
+        // silently overwriting a legitimate sketch to non-sketch.
+        const isSketch = isSketchRaw === true ? true
+            : isSketchRaw === false ? false
+                : undefined;
         if (!isNonEmptyString(sliceId))
             throw new Error(`slices[${index}].sliceId must be a non-empty string`);
         if (seen.has(sliceId))
@@ -77,14 +86,22 @@ function validateSlices(value) {
             throw new Error(`slices[${index}].demo must be a non-empty string`);
         if (!isNonEmptyString(goal))
             throw new Error(`slices[${index}].goal must be a non-empty string`);
-        if (!isNonEmptyString(successCriteria))
-            throw new Error(`slices[${index}].successCriteria must be a non-empty string`);
-        if (!isNonEmptyString(proofLevel))
-            throw new Error(`slices[${index}].proofLevel must be a non-empty string`);
-        if (!isNonEmptyString(integrationClosure))
-            throw new Error(`slices[${index}].integrationClosure must be a non-empty string`);
-        if (!isNonEmptyString(observabilityImpact))
-            throw new Error(`slices[${index}].observabilityImpact must be a non-empty string`);
+        // ADR-011: sketch slices may defer the heavyweight planning fields to refine-slice.
+        if (isSketch === true) {
+            if (!isNonEmptyString(sketchScopeRaw)) {
+                throw new Error(`slices[${index}].sketchScope must be a non-empty string when isSketch is true`);
+            }
+        }
+        else {
+            if (!isNonEmptyString(successCriteria))
+                throw new Error(`slices[${index}].successCriteria must be a non-empty string`);
+            if (!isNonEmptyString(proofLevel))
+                throw new Error(`slices[${index}].proofLevel must be a non-empty string`);
+            if (!isNonEmptyString(integrationClosure))
+                throw new Error(`slices[${index}].integrationClosure must be a non-empty string`);
+            if (!isNonEmptyString(observabilityImpact))
+                throw new Error(`slices[${index}].observabilityImpact must be a non-empty string`);
+        }
         return {
             sliceId,
             title,
@@ -92,10 +109,14 @@ function validateSlices(value) {
             depends,
             demo,
             goal,
-            successCriteria,
-            proofLevel,
-            integrationClosure,
-            observabilityImpact,
+            successCriteria: isNonEmptyString(successCriteria) ? successCriteria : "",
+            proofLevel: isNonEmptyString(proofLevel) ? proofLevel : "",
+            integrationClosure: isNonEmptyString(integrationClosure) ? integrationClosure : "",
+            observabilityImpact: isNonEmptyString(observabilityImpact) ? observabilityImpact : "",
+            isSketch,
+            // Only carry the sketch scope through if the caller explicitly provided it
+            // — preserves ON CONFLICT semantics for re-plans that omit the field.
+            sketchScope: sketchScopeRaw === undefined ? undefined : (isNonEmptyString(sketchScopeRaw) ? sketchScopeRaw : ""),
         };
     });
 }
@@ -209,6 +230,10 @@ export async function handlePlanMilestone(rawParams, basePath) {
                     depends: slice.depends,
                     demo: slice.demo,
                     sequence: i + 1, // Preserve agent-ordered sequence (#3356)
+                    // ADR-011: pass undefined through so ON CONFLICT preserves existing values
+                    // when the caller omitted the fields on a re-plan.
+                    isSketch: slice.isSketch,
+                    sketchScope: slice.sketchScope,
                 });
                 upsertSlicePlanning(params.milestoneId, slice.sliceId, {
                     goal: slice.goal,

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

@@ -1,7 +1,7 @@
 import { clearParseCache } from "../files.js";
-import { isClosedStatus } from "../status-guards.js";
+import { isClosedStatus, isDeferredStatus } from "../status-guards.js";
 import { isNonEmptyString } from "../validation.js";
-import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, } from "../gsd-db.js";
+import { transaction, getMilestone, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, insertGateRow, updateSliceStatus, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -114,6 +114,9 @@ export async function handlePlanSlice(rawParams, basePath) {
                 guardError = `cannot re-plan slice ${params.sliceId}: it is already complete — use gsd_slice_reopen first`;
                 return;
             }
+            if (isDeferredStatus(parentSlice.status)) {
+                updateSliceStatus(params.milestoneId, params.sliceId, "pending");
+            }
             upsertSlicePlanning(params.milestoneId, params.sliceId, {
                 goal: params.goal,
                 successCriteria: params.successCriteria,

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

@@ -0,0 +1,78 @@
+/**
+ * skip-slice handler — the core operation behind gsd_skip_slice.
+ *
+ * Marks a slice as skipped and cascades the skip to every non-closed task in
+ * that slice. Without the task cascade the deep-check in
+ * executeCompleteMilestone reports pending tasks inside the skipped slice and
+ * blocks milestone completion (see #4375).
+ *
+ * This function performs DB writes only. The MCP wrapper in
+ * bootstrap/db-tools.ts handles state-cache invalidation and STATE.md rebuild.
+ */
+import { getSlice, getSliceTasks, isDbAvailable, transaction, updateSliceStatus, updateTaskStatus, } from "../gsd-db.js";
+import { isClosedStatus } from "../status-guards.js";
+/**
+ * Mark a slice as "skipped" and cascade the skip to every non-closed task in
+ * that slice. Runs as a single transaction so slice status and task statuses
+ * are always consistent.
+ *
+ * Behaviour summary:
+ * - Unknown slice → returns {@link SkipSliceResult} with `error`.
+ * - Slice already complete/done → returns `error` (cannot un-complete).
+ * - Slice already skipped → still cascades leftover non-closed tasks
+ *   (heals inconsistent historical state from projects that ran older
+ *   versions before the #4375 cascade fix).
+ * - Tasks in closed status (complete/done/skipped) are never downgraded.
+ */
+export function handleSkipSlice(params) {
+    const base = {
+        milestoneId: params.milestoneId,
+        sliceId: params.sliceId,
+        tasksSkipped: 0,
+        wasAlreadySkipped: false,
+        reason: params.reason,
+    };
+    // Fail loudly on a closed DB so a `null` from getSlice() inside the
+    // transaction unambiguously means "slice not found", never "DB unavailable".
+    // The MCP wrapper in bootstrap/db-tools.ts runs ensureDbOpen() before calling
+    // this helper; this guard protects direct callers (tests, future code).
+    if (!isDbAvailable()) {
+        throw new Error("handleSkipSlice: GSD database is not available");
+    }
+    // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ────
+    let guardError = null;
+    let guardCode = null;
+    let wasAlreadySkipped = false;
+    let tasksSkipped = 0;
+    transaction(() => {
+        const slice = getSlice(params.milestoneId, params.sliceId);
+        if (!slice) {
+            guardError = `Slice ${params.sliceId} not found in milestone ${params.milestoneId}`;
+            guardCode = "slice_not_found";
+            return;
+        }
+        if (slice.status === "complete" || slice.status === "done") {
+            guardError = `Slice ${params.sliceId} is already complete — cannot skip.`;
+            guardCode = "already_complete";
+            return;
+        }
+        wasAlreadySkipped = slice.status === "skipped";
+        if (!wasAlreadySkipped) {
+            updateSliceStatus(params.milestoneId, params.sliceId, "skipped");
+        }
+        // Cascade: mark every non-closed task as skipped so milestone completion
+        // doesn't trip the deep-task guard (#4375). Closed tasks (complete/done/
+        // skipped) are left untouched — we never downgrade.
+        const tasks = getSliceTasks(params.milestoneId, params.sliceId);
+        for (const task of tasks) {
+            if (!isClosedStatus(task.status)) {
+                updateTaskStatus(params.milestoneId, params.sliceId, task.id, "skipped");
+                tasksSkipped++;
+            }
+        }
+    });
+    if (guardError) {
+        return { ...base, error: guardError, errorCode: guardCode ?? undefined };
+    }
+    return { ...base, tasksSkipped, wasAlreadySkipped };
+}

package/dist/resources/extensions/gsd/uok/flags.js

@@ -13,14 +13,14 @@ export function resolveUokFlags(prefs) {
     return {
         enabled: enabledByPreference && !legacyFallback,
         legacyFallback,
-        gates: uok?.gates?.enabled === true,
-        modelPolicy: uok?.model_policy?.enabled === true,
-        executionGraph: uok?.execution_graph?.enabled === true,
-        gitops: uok?.gitops?.enabled === true,
-        gitopsTurnAction: uok?.gitops?.turn_action ?? "status-only",
+        gates: uok?.gates?.enabled ?? true,
+        modelPolicy: uok?.model_policy?.enabled ?? true,
+        executionGraph: uok?.execution_graph?.enabled ?? true,
+        gitops: uok?.gitops?.enabled ?? true,
+        gitopsTurnAction: uok?.gitops?.turn_action ?? "commit",
         gitopsTurnPush: uok?.gitops?.turn_push === true,
-        auditUnified: uok?.audit_unified?.enabled === true,
-        planV2: uok?.plan_v2?.enabled === true,
+        auditUnified: uok?.audit_unified?.enabled ?? true,
+        planV2: uok?.plan_v2?.enabled ?? true,
     };
 }
 export function loadUokFlags() {

package/dist/resources/extensions/gsd/uok/kernel.js

@@ -20,10 +20,10 @@ function writeParityEvent(basePath, event) {
 function resolveKernelPathLabel(flags) {
     if (flags.legacyFallback)
         return "legacy-fallback";
-    return flags.enabled ? "uok-wrapper" : "legacy-wrapper";
+    return flags.enabled ? "uok-kernel" : "legacy-wrapper";
 }
 export async function runAutoLoopWithUok(args) {
-    const { ctx, pi, s, deps, runLegacyLoop } = args;
+    const { ctx, pi, s, deps, runKernelLoop, runLegacyLoop } = args;
     const prefs = deps.loadEffectiveGSDPreferences()?.preferences;
     const flags = resolveUokFlags(prefs);
     setUnifiedAuditEnabled(flags.auditUnified);
@@ -57,7 +57,12 @@ export async function runAutoLoopWithUok(args) {
         }
         : deps;
     try {
-        await runLegacyLoop(ctx, pi, s, decoratedDeps);
+        if (flags.enabled) {
+            await runKernelLoop(ctx, pi, s, decoratedDeps);
+        }
+        else {
+            await runLegacyLoop(ctx, pi, s, deps);
+        }
         writeParityEvent(s.basePath, {
             ts: new Date().toISOString(),
             path: resolveKernelPathLabel(flags),

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

@@ -7,6 +7,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join, basename } from "node:path";
 import { DEFAULT_COMMAND_TIMEOUT_MS } from "./constants.js";
 import { rewriteCommandWithRtk } from "../shared/rtk.js";
+import { normalizePythonCommand } from "./python-resolver.js";
 /** Maximum bytes of stdout/stderr to retain per command (10 KB). */
 const MAX_OUTPUT_BYTES = 10 * 1024;
 /** Truncate a string to maxBytes, appending a marker if truncated. */
@@ -211,7 +212,7 @@ export function runVerificationGate(options) {
     const checks = [];
     for (const command of commands) {
         const start = Date.now();
-        const rewrittenCommand = rewriteCommandWithRtk(command);
+        const rewrittenCommand = normalizePythonCommand(rewriteCommandWithRtk(command));
         // Pass the command string as an argument to the shell explicitly
         // to avoid Node.js DEP0190 (spawnSync with shell: true and no args).
         const shellBin = process.platform === "win32" ? "cmd" : "sh";

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

@@ -0,0 +1,64 @@
+/**
+ * workflow-dispatch.ts — Shared dispatchers for workflow plugins.
+ *
+ * Called by both `/gsd start <template>` (existing markdown path) and
+ * `/gsd workflow <name>` (new direct dispatch). Keeps the prompt-build
+ * logic in one place so md template behavior stays consistent.
+ */
+import { readFileSync } from "node:fs";
+import { loadPrompt } from "./prompt-loader.js";
+// ─── Oneshot dispatch ────────────────────────────────────────────────────
+/**
+ * Strip the `<template_meta>` block from markdown content so it's not
+ * repeated in the prompt body.
+ */
+function stripTemplateMeta(content) {
+    return content.replace(/<template_meta>[\s\S]*?<\/template_meta>\s*/, "");
+}
+/**
+ * For a oneshot YAML plugin, extract the single-step prompt.
+ * For multi-step YAML defined as oneshot, concatenate step prompts.
+ */
+function extractYamlOneshotPrompt(yamlContent) {
+    // Simple: just include the raw YAML so the model can follow it.
+    // This keeps the oneshot format flexible without re-parsing.
+    return `\`\`\`yaml\n${yamlContent}\n\`\`\``;
+}
+/**
+ * Dispatch a oneshot workflow: load the prompt, inject the body, send.
+ * No STATE.json, no branch switch, no auto-loop.
+ */
+export function dispatchOneshot(plugin, pi, userArgs) {
+    const raw = readFileSync(plugin.path, "utf-8");
+    const body = plugin.format === "yaml"
+        ? extractYamlOneshotPrompt(raw)
+        : stripTemplateMeta(raw);
+    const prompt = loadPrompt("workflow-oneshot", {
+        name: plugin.name,
+        displayName: plugin.meta.displayName,
+        body,
+        userArgs: userArgs || "(none)",
+    });
+    pi.sendMessage({ customType: "gsd-workflow-oneshot", content: prompt, display: false }, { triggerTurn: true });
+}
+/**
+ * Build and dispatch the `workflow-start.md` prompt for a markdown-phase plugin.
+ * Returns the prompt that was sent (useful for tests).
+ */
+export function dispatchMarkdownPhase(opts, pi) {
+    const prompt = loadPrompt("workflow-start", {
+        templateId: opts.templateId,
+        templateName: opts.templateName,
+        templateDescription: opts.templateDescription,
+        phases: opts.phases.join(" → "),
+        complexity: opts.complexity,
+        artifactDir: opts.artifactDir || "(none)",
+        branch: opts.branch,
+        description: opts.description || "(none provided)",
+        issueRef: opts.issueRef || "(none)",
+        date: opts.date,
+        workflowContent: opts.workflowContent,
+    });
+    pi.sendMessage({ customType: "gsd-workflow-template", content: prompt, display: false }, { triggerTurn: true });
+    return prompt;
+}

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

@@ -0,0 +1,327 @@
+/**
+ * workflow-install.ts — Fetch, validate, and install remote workflow plugins.
+ *
+ * Accepts:
+ *   - Full URL (https://raw.githubusercontent.com/... or gist raw URL)
+ *   - gist:abc123           → https://gist.githubusercontent.com/anonymous/abc123/raw
+ *   - gh:owner/repo/path[@ref] → raw.githubusercontent.com/owner/repo/<ref>/path
+ *
+ * Installed files land in `~/.gsd/workflows/<name>.<ext>` by default, or
+ * `.gsd/workflows/<name>.<ext>` with the `--project` flag.
+ *
+ * A provenance file `~/.gsd/workflows/.installed.json` (or project equivalent)
+ * records source URL, timestamp, and sha256 so `/gsd workflow uninstall` can
+ * clean up and future `/gsd workflow update` can refresh.
+ */
+import { existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { extname, join, resolve, sep as pathSep } from "node:path";
+import { createHash } from "node:crypto";
+import { parse as parseYaml } from "yaml";
+import { validateDefinition } from "./definition-loader.js";
+// ─── Constants ───────────────────────────────────────────────────────────
+const MAX_RESPONSE_BYTES = 256 * 1024;
+const FETCH_TIMEOUT_MS = 15_000;
+const PROVENANCE_FILE = ".installed.json";
+function provenancePath(dir) {
+    return join(dir, PROVENANCE_FILE);
+}
+function readProvenance(dir) {
+    const path = provenancePath(dir);
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeProvenance(dir, data) {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(provenancePath(dir), JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+export function globalInstallDir() {
+    const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+    return join(gsdHome, "workflows");
+}
+export function projectInstallDir(basePath) {
+    return join(basePath, ".gsd", "workflows");
+}
+/**
+ * Reject plugin names that could escape the workflows directory.
+ * Allows a-z, A-Z, 0-9, dot, underscore, hyphen — no separators, no dot-segments.
+ */
+function assertSafePluginName(name) {
+    if (!name || name === "." || name === "..") {
+        throw new Error(`Invalid plugin name: "${name}"`);
+    }
+    if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
+        throw new Error(`Invalid plugin name "${name}". Allowed characters: letters, digits, dot, underscore, hyphen.`);
+    }
+}
+/**
+ * Resolve `child` inside `dir` and refuse any result that escapes `dir`.
+ */
+function safeResolveInDir(dir, child) {
+    const resolvedDir = resolve(dir);
+    const resolvedPath = resolve(resolvedDir, child);
+    if (resolvedPath !== resolvedDir &&
+        !resolvedPath.startsWith(resolvedDir + pathSep)) {
+        throw new Error(`Refusing to operate outside ${dir}: ${child}`);
+    }
+    return resolvedPath;
+}
+// ─── Source URL resolution ───────────────────────────────────────────────
+/**
+ * Turn a user-supplied source specifier into a fetchable HTTPS URL.
+ * Throws on clearly unsafe inputs (file://, unsupported schemes).
+ */
+export function resolveSourceUrl(source) {
+    const trimmed = source.trim();
+    // gist:<id>
+    if (trimmed.startsWith("gist:")) {
+        const id = trimmed.slice("gist:".length).trim();
+        if (!/^[a-f0-9]{6,}$/i.test(id)) {
+            throw new Error(`Invalid gist id: ${id}`);
+        }
+        return `https://gist.githubusercontent.com/anonymous/${id}/raw`;
+    }
+    // gh:owner/repo/path[@ref]
+    if (trimmed.startsWith("gh:")) {
+        const rest = trimmed.slice("gh:".length);
+        const atIdx = rest.lastIndexOf("@");
+        const pathPart = atIdx === -1 ? rest : rest.slice(0, atIdx);
+        const ref = atIdx === -1 ? "main" : rest.slice(atIdx + 1);
+        const parts = pathPart.split("/");
+        if (parts.length < 3) {
+            throw new Error(`Expected gh:<owner>/<repo>/<path>: ${trimmed}`);
+        }
+        const [owner, repo, ...filePath] = parts;
+        return `https://raw.githubusercontent.com/${owner}/${repo}/${ref}/${filePath.join("/")}`;
+    }
+    // file:// — reject
+    if (trimmed.startsWith("file:")) {
+        throw new Error("file:// sources are not supported for security reasons.");
+    }
+    // Must be https:// (or http://localhost for dev)
+    if (trimmed.startsWith("https://"))
+        return trimmed;
+    if (trimmed.startsWith("http://")) {
+        const url = new URL(trimmed);
+        if (url.hostname === "localhost" || url.hostname === "127.0.0.1") {
+            return trimmed;
+        }
+        throw new Error("http:// is only allowed for localhost. Use https://.");
+    }
+    throw new Error(`Unsupported source format: ${trimmed}\n` +
+        `Use one of: https://..., gist:<id>, gh:<owner>/<repo>/<path>[@ref]`);
+}
+/**
+ * Fetch the resolved URL with a timeout and a max response size.
+ * Injects a simple User-Agent so GitHub doesn't 403.
+ */
+export async function fetchWorkflowSource(url) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: { "User-Agent": "gsd-workflow-install" },
+        });
+        if (!res.ok) {
+            throw new Error(`Fetch failed (${res.status} ${res.statusText}): ${url}`);
+        }
+        // Cap size: read as a stream and bail if it exceeds MAX_RESPONSE_BYTES.
+        const buf = await res.arrayBuffer();
+        if (buf.byteLength > MAX_RESPONSE_BYTES) {
+            throw new Error(`Response too large (${buf.byteLength} bytes, max ${MAX_RESPONSE_BYTES}): ${url}`);
+        }
+        const content = new TextDecoder().decode(buf);
+        // Prefer the final response URL after redirects (e.g., gist /raw → /raw/<sha>/file.ext).
+        const finalUrl = typeof res.url === "string" && res.url ? res.url : url;
+        let pathname;
+        try {
+            pathname = new URL(finalUrl).pathname;
+        }
+        catch {
+            pathname = new URL(url).pathname;
+        }
+        let basename = pathname.slice(pathname.lastIndexOf("/") + 1);
+        let rawExt = extname(basename).toLowerCase();
+        let ext;
+        if (rawExt === ".yaml" || rawExt === ".yml" || rawExt === ".md") {
+            ext = rawExt;
+        }
+        else {
+            // Fallback: sniff content. Gist /raw and similar URLs have no extension.
+            if (/<template_meta>[\s\S]*?<\/template_meta>/.test(content)) {
+                ext = ".md";
+            }
+            else {
+                let parsed;
+                try {
+                    parsed = parseYaml(content);
+                }
+                catch {
+                    parsed = undefined;
+                }
+                if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                    ext = ".yaml";
+                }
+                else {
+                    throw new Error(`Cannot determine workflow type from ${url}. ` +
+                        `Expected .yaml/.yml/.md URL, a markdown file with <template_meta>, ` +
+                        `or a YAML document.`);
+                }
+            }
+            // Synthesize a filename so downstream sanitizers have something to chew on.
+            if (!basename)
+                basename = "workflow";
+            basename = `${basename}${ext}`;
+        }
+        const filename = basename;
+        const sha256 = createHash("sha256").update(content).digest("hex");
+        return { url, filename, ext, content, sha256 };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+// ─── Validation ──────────────────────────────────────────────────────────
+/**
+ * Validate fetched content: YAML must pass validateDefinition, markdown must
+ * have a `<template_meta>` block with at least `name`.
+ */
+export function validateFetchedContent(fetched) {
+    if (fetched.ext === ".yaml" || fetched.ext === ".yml") {
+        let parsed;
+        try {
+            parsed = parseYaml(fetched.content);
+        }
+        catch (err) {
+            throw new Error(`Installed YAML failed to parse: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const result = validateDefinition(parsed);
+        if (!result.valid) {
+            throw new Error(`Installed YAML failed validation:\n  - ${result.errors.join("\n  - ")}`);
+        }
+        // Optional: validate `mode:` if present.
+        if (parsed && typeof parsed === "object") {
+            const mode = parsed.mode;
+            if (mode !== undefined && mode !== "oneshot" && mode !== "yaml-step") {
+                throw new Error(`YAML plugins must declare mode: oneshot or yaml-step (got "${String(mode)}")`);
+            }
+        }
+        return;
+    }
+    // Markdown: require a <template_meta> block with at least a name.
+    const metaMatch = fetched.content.match(/<template_meta>([\s\S]*?)<\/template_meta>/);
+    if (!metaMatch) {
+        throw new Error("Installed markdown must contain a <template_meta>…</template_meta> block.");
+    }
+    if (!/\bname\s*:/i.test(metaMatch[1])) {
+        throw new Error("Installed markdown <template_meta> must declare at least `name:`.");
+    }
+    // Optional: validate `mode:` if declared.
+    const modeLine = metaMatch[1].match(/\bmode\s*:\s*(\S+)/i);
+    if (modeLine) {
+        const mode = modeLine[1];
+        if (mode !== "oneshot" && mode !== "markdown-phase") {
+            throw new Error(`Markdown plugins must declare mode: oneshot or markdown-phase (got "${mode}")`);
+        }
+    }
+}
+// ─── Name inference ──────────────────────────────────────────────────────
+/**
+ * Infer a plugin name from fetched content. For YAML, prefer the top-level
+ * `name:` field. For markdown, prefer `<template_meta>.name`. Fall back to
+ * the filename stem.
+ */
+export function inferPluginName(fetched) {
+    if (fetched.ext === ".yaml" || fetched.ext === ".yml") {
+        try {
+            const parsed = parseYaml(fetched.content);
+            if (parsed && typeof parsed === "object") {
+                const n = parsed.name;
+                if (typeof n === "string" && n.trim())
+                    return sanitizeName(n);
+            }
+        }
+        catch {
+            // Fall through to filename.
+        }
+    }
+    else {
+        const metaMatch = fetched.content.match(/<template_meta>([\s\S]*?)<\/template_meta>/);
+        if (metaMatch) {
+            const nameMatch = metaMatch[1].match(/\bname\s*:\s*(\S+)/i);
+            if (nameMatch)
+                return sanitizeName(nameMatch[1]);
+        }
+    }
+    const stem = fetched.filename.replace(/\.[^.]+$/, "");
+    return sanitizeName(stem);
+}
+function sanitizeName(raw) {
+    return raw.trim().toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/^-+|-+$/g, "");
+}
+/**
+ * Write the fetched plugin to disk and update the provenance file.
+ * Does NOT prompt — caller is responsible for confirming with the user first.
+ */
+export function installPlugin(target, fetched, name) {
+    assertSafePluginName(name);
+    mkdirSync(target.dir, { recursive: true });
+    const filename = `${name}${fetched.ext}`;
+    const path = safeResolveInDir(target.dir, filename);
+    writeFileSync(path, fetched.content, "utf-8");
+    const prov = readProvenance(target.dir);
+    prov[name] = {
+        source: fetched.url,
+        installedAt: new Date().toISOString(),
+        sha256: fetched.sha256,
+        filename,
+    };
+    writeProvenance(target.dir, prov);
+    return { path, name, ext: fetched.ext, source: fetched.url };
+}
+/**
+ * Remove an installed plugin and its provenance record.
+ * Checks global dir first, then project (same order as install default).
+ */
+export function uninstallPlugin(basePath, name) {
+    assertSafePluginName(name);
+    for (const dir of [globalInstallDir(), projectInstallDir(basePath)]) {
+        const prov = readProvenance(dir);
+        const entry = prov[name];
+        if (entry) {
+            // Re-validate the filename recorded in provenance: a malicious provenance
+            // file must not trick us into deleting outside `dir`.
+            assertSafePluginName(entry.filename.replace(/\.(yaml|yml|md)$/i, ""));
+            const path = safeResolveInDir(dir, entry.filename);
+            if (existsSync(path))
+                unlinkSync(path);
+            delete prov[name];
+            writeProvenance(dir, prov);
+            return { removed: true, path };
+        }
+        // No provenance, but file might still exist.
+        for (const ext of [".yaml", ".yml", ".md"]) {
+            const candidate = safeResolveInDir(dir, `${name}${ext}`);
+            if (existsSync(candidate) && statSync(candidate).isFile()) {
+                unlinkSync(candidate);
+                return { removed: true, path: candidate, warnedNotInProvenance: true };
+            }
+        }
+    }
+    return { removed: false };
+}
+// ─── Preview helpers ─────────────────────────────────────────────────────
+/**
+ * First N lines of the fetched content, for the install confirmation UI.
+ */
+export function previewContent(content, maxLines = 20) {
+    const lines = content.split(/\r?\n/).slice(0, maxLines);
+    return lines.join("\n");
+}

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

@@ -82,6 +82,8 @@ export function snapshotState() {
             observability_impact: r["observability_impact"] ?? "",
             sequence: toNumeric(r["sequence"], 0),
             replan_triggered_at: r["replan_triggered_at"] ?? null,
+            is_sketch: toNumeric(r["is_sketch"], 0),
+            sketch_scope: r["sketch_scope"] ?? "",
         }));
         const rawTasks = db.prepare("SELECT * FROM tasks ORDER BY milestone_id, slice_id, sequence, id").all();
         const tasks = rawTasks.map((r) => ({
@@ -110,6 +112,11 @@ export function snapshotState() {
             observability_impact: r["observability_impact"] ?? "",
             full_plan_md: r["full_plan_md"] ?? "",
             sequence: toNumeric(r["sequence"], 0),
+            blocker_source: r["blocker_source"] ?? "",
+            escalation_pending: toNumeric(r["escalation_pending"], 0),
+            escalation_awaiting_review: toNumeric(r["escalation_awaiting_review"], 0),
+            escalation_artifact_path: r["escalation_artifact_path"] ?? null,
+            escalation_override_applied_at: r["escalation_override_applied_at"] ?? null,
         }));
         const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all();
         const decisions = rawDecisions.map((r) => ({
@@ -122,6 +129,7 @@ export function snapshotState() {
             rationale: r["rationale"] ?? "",
             revisable: r["revisable"] ?? "",
             made_by: r["made_by"] ?? "agent",
+            source: r["source"] ?? "discussion",
             superseded_by: r["superseded_by"] ?? null,
         }));
         const rawEvidence = db.prepare("SELECT * FROM verification_evidence ORDER BY id").all();