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

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

@@ -20,6 +20,8 @@ import { renderAllProjections, renderSummaryContent } from "../workflow-projecti
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
 import { logWarning, logError } from "../workflow-logger.js";
+import { loadEffectiveGSDPreferences } from "../preferences.js";
+import { buildEscalationArtifact, writeEscalationArtifact } from "../escalation.js";
 /**
  * Map an execute-task-owned gate id to the CompleteTaskParams field whose
  * presence drives `pass` vs. `omitted`. Keep in lockstep with the gates
@@ -80,6 +82,11 @@ function paramsToTaskRow(params, completedAt) {
         observability_impact: "",
         full_plan_md: "",
         sequence: 0,
+        blocker_source: "",
+        escalation_pending: 0,
+        escalation_awaiting_review: 0,
+        escalation_artifact_path: null,
+        escalation_override_applied_at: null,
     };
 }
 /**
@@ -111,6 +118,39 @@ export async function handleCompleteTask(params, basePath) {
     // ── Guards + DB writes inside a single transaction (prevents TOCTOU) ───
     const completedAt = new Date().toISOString();
     let guardError = null;
+    // ── ADR-011 Phase 2: validate escalation payload BEFORE any side effects ─
+    // Building the artifact runs the full shape validation (2-4 options, unique
+    // ids, recommendation references a real id). If the payload is malformed
+    // we must reject the call before marking the task complete, writing
+    // SUMMARY.md, flipping the plan checkbox, or closing execute-task gates —
+    // otherwise a rejected payload would leave the task marked complete with
+    // no escalation recorded, and the loop would silently advance past it.
+    // The filesystem write happens later (after side effects) because that's
+    // the cheapest ordering and validation is where 99% of failures live.
+    let validatedEscalationArtifact = null;
+    let escalationWriteEnabled = false;
+    if (params.escalation) {
+        escalationWriteEnabled = loadEffectiveGSDPreferences()?.preferences?.phases?.mid_execution_escalation === true;
+        if (escalationWriteEnabled) {
+            try {
+                validatedEscalationArtifact = buildEscalationArtifact({
+                    taskId: params.taskId,
+                    sliceId: params.sliceId,
+                    milestoneId: params.milestoneId,
+                    question: params.escalation.question,
+                    options: params.escalation.options,
+                    recommendation: params.escalation.recommendation,
+                    recommendationRationale: params.escalation.recommendationRationale,
+                    continueWithDefault: params.escalation.continueWithDefault,
+                });
+            }
+            catch (validationErr) {
+                return {
+                    error: `complete-task escalation payload invalid for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${validationErr.message}`,
+                };
+            }
+        }
+    }
     transaction(() => {
         // State machine preconditions (inside txn for atomicity).
         // Milestone/slice not existing is OK — insertMilestone/insertSlice below will auto-create.
@@ -239,6 +279,46 @@ export async function handleCompleteTask(params, basePath) {
     catch (gateErr) {
         logWarning("tool", `complete-task gate close warning for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${gateErr.message}`);
     }
+    // ── ADR-011 Phase 2: write escalation artifact (opt-in) ────────────────
+    // Validation already happened BEFORE side effects — this block only
+    // performs the disk write for a pre-validated artifact. For
+    // continueWithDefault=false, a write failure here would otherwise leave
+    // the task marked complete with SUMMARY.md + closed gates but no
+    // escalation, which silently advances the loop past a pause the user
+    // asked for. We compensate by reverting the DB-level completion: set
+    // status back to 'pending' and delete the verification_evidence rows
+    // (same shape as the disk-render-failure rollback above). SUMMARY.md
+    // on disk is left in place because the next complete-task retry will
+    // overwrite it; gate rows are UPSERT-keyed per task and will also be
+    // overwritten. This restores the invariant that deriveState() sees a
+    // consistent "task not done" view so the loop re-dispatches the task.
+    if (validatedEscalationArtifact) {
+        try {
+            writeEscalationArtifact(basePath, validatedEscalationArtifact);
+        }
+        catch (escalationErr) {
+            const msg = `complete-task escalation write failed for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${escalationErr.message}`;
+            logWarning("tool", msg);
+            if (validatedEscalationArtifact.continueWithDefault === false) {
+                // Compensating rollback: revert DB completion so the loop pauses on
+                // re-dispatch instead of silently advancing. Mirror the existing
+                // renderErr rollback (line ~261).
+                try {
+                    deleteVerificationEvidence(params.milestoneId, params.sliceId, params.taskId);
+                    updateTaskStatus(params.milestoneId, params.sliceId, params.taskId, 'pending');
+                    invalidateStateCache();
+                    logWarning("tool", `complete-task rolled back DB completion for ${params.milestoneId}/${params.sliceId}/${params.taskId} after escalation write failure; SUMMARY.md left on disk for retry.`);
+                }
+                catch (rollbackErr) {
+                    logWarning("tool", `complete-task rollback failed after escalation write failure for ${params.milestoneId}/${params.sliceId}/${params.taskId}: ${rollbackErr.message}`);
+                }
+                return { error: msg };
+            }
+        }
+    }
+    else if (params.escalation && !escalationWriteEnabled) {
+        logWarning("tool", `complete-task received escalation payload but phases.mid_execution_escalation is not enabled; ignoring (${params.milestoneId}/${params.sliceId}/${params.taskId})`);
+    }
     // Invalidate all caches
     invalidateStateCache();
     clearPathCache();

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/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/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");
+}