gsd-pi 2.41.0-dev.3557dc4 → 2.41.0-dev.5a170d0

package/README.md

@@ -28,7 +28,7 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ### New Features
 
-- **Browser-based web interface** — run GSD from the browser with `pi --web`. Full project management, real-time progress, and multi-project support via server-sent events. (#1717)
+- **Browser-based web interface** — run GSD from the browser with `gsd --web`. Full project management, real-time progress, and multi-project support via server-sent events. (#1717)
 - **Doctor: worktree lifecycle checks** — `/gsd doctor` now validates worktree health, detects orphaned worktrees, consolidates cleanup, and enhances `/worktree list` with lifecycle status. (#1814)
 - **CI: docs-only PR detection** — PRs that only change documentation skip build and test steps, with a new prompt injection scan for security. (#1699)
 - **Custom Models guide** — new documentation for adding custom providers (Ollama, vLLM, LM Studio, proxies) via `models.json`. (#1670)

package/dist/resources/extensions/gsd/auto/loop.js

@@ -12,6 +12,7 @@ import { _clearCurrentResolve } from "./resolve.js";
 import { runPreDispatch, runDispatch, runGuards, runUnitPhase, runFinalize, } from "./phases.js";
 import { debugLog } from "../debug-logger.js";
 import { isInfrastructureError } from "./infra-errors.js";
+import { resolveEngine } from "../engine-resolver.js";
 /**
  * Main auto-mode execution loop. Iterates: derive → dispatch → guards →
  * runUnit → finalize → repeat. Exits when s.active becomes false or a
@@ -82,6 +83,85 @@ export async function autoLoop(ctx, pi, s, deps) {
             const ic = { ctx, pi, s, deps, prefs, iteration, flowId, nextSeq };
             deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-start", data: { iteration } });
             let iterData;
+            // ── Custom engine path ──────────────────────────────────────────────
+            // When activeEngineId is a non-dev value, bypass runPreDispatch and
+            // runDispatch entirely — the custom engine drives its own state via
+            // GRAPH.yaml. Shares runGuards and runUnitPhase with the dev path.
+            // After unit execution, verifies then reconciles via the engine layer.
+            //
+            // GSD_ENGINE_BYPASS=1 skips the engine layer entirely — falls through
+            // to the dev path below.
+            if (s.activeEngineId != null && s.activeEngineId !== "dev" && !sidecarItem && process.env.GSD_ENGINE_BYPASS !== "1") {
+                debugLog("autoLoop", { phase: "custom-engine-derive", iteration, engineId: s.activeEngineId });
+                const { engine, policy } = resolveEngine({
+                    activeEngineId: s.activeEngineId,
+                    activeRunDir: s.activeRunDir,
+                });
+                const engineState = await engine.deriveState(s.basePath);
+                if (engineState.isComplete) {
+                    await deps.stopAuto(ctx, pi, "Workflow complete");
+                    break;
+                }
+                debugLog("autoLoop", { phase: "custom-engine-dispatch", iteration });
+                const dispatch = await engine.resolveDispatch(engineState, { basePath: s.basePath });
+                if (dispatch.action === "stop") {
+                    await deps.stopAuto(ctx, pi, dispatch.reason ?? "Engine stopped");
+                    break;
+                }
+                if (dispatch.action === "skip") {
+                    continue;
+                }
+                // dispatch.action === "dispatch"
+                const step = dispatch.step;
+                const gsdState = await deps.deriveState(s.basePath);
+                iterData = {
+                    unitType: step.unitType,
+                    unitId: step.unitId,
+                    prompt: step.prompt,
+                    finalPrompt: step.prompt,
+                    pauseAfterUatDispatch: false,
+                    observabilityIssues: [],
+                    state: gsdState,
+                    mid: s.currentMilestoneId ?? "workflow",
+                    midTitle: "Workflow",
+                    isRetry: false,
+                    previousTier: undefined,
+                };
+                // ── Progress widget (mirrors dev path in runDispatch) ──
+                deps.updateProgressWidget(ctx, iterData.unitType, iterData.unitId, iterData.state);
+                // ── Guards (shared with dev path) ──
+                const guardsResult = await runGuards(ic, s.currentMilestoneId ?? "workflow");
+                if (guardsResult.action === "break")
+                    break;
+                // ── Unit execution (shared with dev path) ──
+                const unitPhaseResult = await runUnitPhase(ic, iterData, loopState);
+                if (unitPhaseResult.action === "break")
+                    break;
+                // ── Verify first, then reconcile (only mark complete on pass) ──
+                debugLog("autoLoop", { phase: "custom-engine-verify", iteration, unitId: iterData.unitId });
+                const verifyResult = await policy.verify(iterData.unitType, iterData.unitId, { basePath: s.basePath });
+                if (verifyResult === "pause") {
+                    await deps.pauseAuto(ctx, pi);
+                    break;
+                }
+                if (verifyResult === "retry") {
+                    debugLog("autoLoop", { phase: "custom-engine-verify-retry", iteration, unitId: iterData.unitId });
+                    continue;
+                }
+                // Verification passed — mark step complete
+                debugLog("autoLoop", { phase: "custom-engine-reconcile", iteration, unitId: iterData.unitId });
+                await engine.reconcile(engineState, {
+                    unitType: iterData.unitType,
+                    unitId: iterData.unitId,
+                    startedAt: s.currentUnit?.startedAt ?? Date.now(),
+                    finishedAt: Date.now(),
+                });
+                deps.clearUnitTimeout();
+                consecutiveErrors = 0;
+                deps.emitJournalEvent({ ts: new Date().toISOString(), flowId, seq: nextSeq(), eventType: "iteration-end", data: { iteration } });
+                debugLog("autoLoop", { phase: "iteration-complete", iteration });
+                continue;
+            }
             if (!sidecarItem) {
                 // ── Phase 1: Pre-dispatch ─────────────────────────────────────────
                 const preDispatchResult = await runPreDispatch(ic, loopState);

package/dist/resources/extensions/gsd/auto/phases.js

@@ -776,8 +776,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     if (s.currentUnitRouting) {
         deps.recordOutcome(unitType, s.currentUnitRouting.tier, true);
     }
-    const isHookUnit = unitType.startsWith("hook/");
-    const artifactVerified = isHookUnit ||
+    const skipArtifactVerification = unitType.startsWith("hook/") || unitType === "custom-step";
+    const artifactVerified = skipArtifactVerification ||
         deps.verifyExpectedArtifact(unitType, unitId, s.basePath);
     if (artifactVerified) {
         s.completedUnits.push({

package/dist/resources/extensions/gsd/auto/session.js

@@ -27,6 +27,8 @@ export class AutoSession {
     paused = false;
     stepMode = false;
     verbose = false;
+    activeEngineId = null;
+    activeRunDir = null;
     cmdCtx = null;
     // ── Paths ────────────────────────────────────────────────────────────────
     basePath = "";
@@ -113,6 +115,8 @@ export class AutoSession {
         this.paused = false;
         this.stepMode = false;
         this.verbose = false;
+        this.activeEngineId = null;
+        this.activeRunDir = null;
         this.cmdCtx = null;
         // Paths
         this.basePath = "";
@@ -156,6 +160,8 @@ export class AutoSession {
             paused: this.paused,
             stepMode: this.stepMode,
             basePath: this.basePath,
+            activeEngineId: this.activeEngineId,
+            activeRunDir: this.activeRunDir,
             currentMilestoneId: this.currentMilestoneId,
             currentUnit: this.currentUnit,
             completedUnits: this.completedUnits.length,

package/dist/resources/extensions/gsd/auto-dashboard.js

@@ -46,6 +46,7 @@ export function unitVerb(unitType) {
         case "rewrite-docs": return "rewriting";
         case "reassess-roadmap": return "reassessing";
         case "run-uat": return "running UAT";
+        case "custom-step": return "executing workflow step";
         default: return unitType;
     }
 }
@@ -64,6 +65,7 @@ export function unitPhaseLabel(unitType) {
         case "rewrite-docs": return "REWRITE";
         case "reassess-roadmap": return "REASSESS";
         case "run-uat": return "UAT";
+        case "custom-step": return "WORKFLOW";
         default: return unitType.toUpperCase();
     }
 }

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

@@ -161,6 +161,18 @@ export function isAutoActive() {
 export function isAutoPaused() {
     return s.paused;
 }
+export function setActiveEngineId(id) {
+    s.activeEngineId = id;
+}
+export function getActiveEngineId() {
+    return s.activeEngineId;
+}
+export function setActiveRunDir(runDir) {
+    s.activeRunDir = runDir;
+}
+export function getActiveRunDir() {
+    return s.activeRunDir;
+}
 /**
  * Return the model captured at auto-mode start for this session.
  * Used by error-recovery to fall back to the session's own model
@@ -531,6 +543,8 @@ export async function pauseAuto(ctx, _pi) {
             stepMode: s.stepMode,
             pausedAt: new Date().toISOString(),
             sessionFile: s.pausedSessionFile,
+            activeEngineId: s.activeEngineId,
+            activeRunDir: s.activeRunDir,
         };
         const runtimeDir = join(gsdRoot(s.originalBasePath || s.basePath), "runtime");
         mkdirSync(runtimeDir, { recursive: true });
@@ -725,7 +739,20 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             const pausedPath = join(gsdRoot(base), "runtime", "paused-session.json");
             if (existsSync(pausedPath)) {
                 const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
-                if (meta.milestoneId) {
+                if (meta.activeEngineId && meta.activeEngineId !== "dev") {
+                    // Custom workflow resume — restore engine state
+                    s.activeEngineId = meta.activeEngineId;
+                    s.activeRunDir = meta.activeRunDir ?? null;
+                    s.originalBasePath = meta.originalBasePath || base;
+                    s.stepMode = meta.stepMode ?? requestedStepMode;
+                    s.paused = true;
+                    try {
+                        unlinkSync(pausedPath);
+                    }
+                    catch { /* non-fatal */ }
+                    ctx.ui.notify(`Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`, "info");
+                }
+                else if (meta.milestoneId) {
                     // Validate the milestone still exists and isn't already complete (#1664).
                     const mDir = resolveMilestonePath(base, meta.milestoneId);
                     const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");

package/dist/resources/extensions/gsd/bootstrap/tool-call-loop-guard.js

@@ -20,8 +20,13 @@ let enabled = true;
 function hashToolCall(toolName, args) {
     const h = createHash("sha256");
     h.update(toolName);
-    // Sort keys for deterministic hashing regardless of object key order
-    h.update(JSON.stringify(args, Object.keys(args).sort()));
+    // Sort keys recursively for deterministic hashing regardless of object key order
+    h.update(JSON.stringify(args, (_key, value) => value && typeof value === "object" && !Array.isArray(value)
+        ? Object.keys(value).sort().reduce((o, k) => {
+            o[k] = value[k];
+            return o;
+        }, {})
+        : value));
     return h.digest("hex").slice(0, 16);
 }
 /**

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
+import { resolveProjectRoot } from "../worktree.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|rate|skip|export|cleanup|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast";
 export const TOP_LEVEL_SUBCOMMANDS = [
@@ -53,6 +54,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "templates", desc: "List available workflow templates" },
     { cmd: "extensions", desc: "Manage extensions (list, enable, disable, info)" },
     { cmd: "fast", desc: "Toggle OpenAI service tier (on/off/flex/status)" },
+    { cmd: "workflow", desc: "Custom workflow lifecycle (new, run, list, validate, pause, resume)" },
 ];
 const NESTED_COMPLETIONS = {
     auto: [
@@ -193,6 +195,14 @@ const NESTED_COMPLETIONS = {
         { cmd: "ok", desc: "Model was appropriate for this task" },
         { cmd: "under", desc: "Model was underqualified for this task" },
     ],
+    workflow: [
+        { cmd: "new", desc: "Create a new workflow definition (via skill)" },
+        { cmd: "run", desc: "Create a run and start auto-mode" },
+        { cmd: "list", desc: "List workflow runs" },
+        { cmd: "validate", desc: "Validate a workflow definition YAML" },
+        { cmd: "pause", desc: "Pause custom workflow auto-mode" },
+        { cmd: "resume", desc: "Resume paused custom workflow auto-mode" },
+    ],
 };
 function filterOptions(partial, options, prefix = "") {
     const normalizedPrefix = prefix ? `${prefix} ` : "";
@@ -287,6 +297,28 @@ export function getGsdArgumentCompletions(prefix) {
     if (command === "undo" && parts.length <= 2) {
         return [{ value: "undo --force", label: "--force", description: "Skip confirmation prompt" }];
     }
+    // Workflow definition-name completion for `workflow run <name>` and `workflow validate <name>`
+    if (command === "workflow" && (subcommand === "run" || subcommand === "validate") && parts.length <= 3) {
+        try {
+            const defsDir = join(resolveProjectRoot(process.cwd()), ".gsd", "workflow-defs");
+            if (existsSync(defsDir)) {
+                return readdirSync(defsDir)
+                    .filter((f) => f.endsWith(".yaml") && f.startsWith(third))
+                    .map((f) => {
+                    const name = f.replace(/\.yaml$/, "");
+                    return {
+                        value: `workflow ${subcommand} ${name}`,
+                        label: name,
+                        description: `Workflow definition: ${name}`,
+                    };
+                });
+            }
+        }
+        catch {
+            // ignore filesystem errors during completion
+        }
+        return [];
+    }
     const nested = NESTED_COMPLETIONS[command];
     if (nested && parts.length <= 2) {
         return filterOptions(subcommand, nested, command);

package/dist/resources/extensions/gsd/commands/handlers/workflow.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
+import { parse as parseYaml } from "yaml";
 import { handleQuick } from "../../quick.js";
 import { showDiscuss, showHeadlessMilestoneCreation, showQueue } from "../../guided-flow.js";
 import { handleStart, handleTemplates } from "../../commands-workflow-templates.js";
@@ -10,7 +11,152 @@ import { loadEffectiveGSDPreferences } from "../../preferences.js";
 import { nextMilestoneId } from "../../milestone-ids.js";
 import { findMilestoneIds } from "../../guided-flow.js";
 import { projectRoot } from "../context.js";
+import { createRun, listRuns } from "../../run-manager.js";
+import { setActiveEngineId, setActiveRunDir, startAuto, pauseAuto, isAutoActive, getActiveEngineId, } from "../../auto.js";
+import { validateDefinition } from "../../definition-loader.js";
+// ─── Custom Workflow Subcommands ─────────────────────────────────────────
+const WORKFLOW_USAGE = [
+    "Usage: /gsd workflow <subcommand>",
+    "",
+    "  new               — Create a new workflow definition (via skill)",
+    "  run <name> [k=v]  — Create a run and start auto-mode",
+    "  list [name]       — List workflow runs (optionally filtered by name)",
+    "  validate <name>   — Validate a workflow definition YAML",
+    "  pause             — Pause custom workflow auto-mode",
+    "  resume            — Resume paused custom workflow auto-mode",
+].join("\n");
+async function handleCustomWorkflow(sub, ctx, pi) {
+    // Bare `/gsd workflow` — show usage
+    if (!sub) {
+        ctx.ui.notify(WORKFLOW_USAGE, "info");
+        return true;
+    }
+    // ── new ──
+    if (sub === "new") {
+        ctx.ui.notify("Use the create-workflow skill: /skill create-workflow", "info");
+        return true;
+    }
+    // ── run <name> [param=value ...] ──
+    if (sub === "run" || sub.startsWith("run ")) {
+        const args = sub.slice("run".length).trim();
+        if (!args) {
+            ctx.ui.notify("Usage: /gsd workflow run <name> [param=value ...]", "warning");
+            return true;
+        }
+        const parts = args.split(/\s+/);
+        const defName = parts[0];
+        const overrides = {};
+        for (let i = 1; i < parts.length; i++) {
+            const eqIdx = parts[i].indexOf("=");
+            if (eqIdx > 0) {
+                overrides[parts[i].slice(0, eqIdx)] = parts[i].slice(eqIdx + 1);
+            }
+        }
+        try {
+            const base = projectRoot();
+            const runDir = createRun(base, defName, Object.keys(overrides).length > 0 ? overrides : undefined);
+            setActiveEngineId("custom");
+            setActiveRunDir(runDir);
+            ctx.ui.notify(`Created workflow run: ${defName}\nRun dir: ${runDir}`, "info");
+            await startAuto(ctx, pi, base, false);
+        }
+        catch (err) {
+            // Clean up engine state so a failed workflow run doesn't pollute the next /gsd auto
+            setActiveEngineId(null);
+            setActiveRunDir(null);
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.ui.notify(`Failed to run workflow "${defName}": ${msg}`, "error");
+        }
+        return true;
+    }
+    // ── list [name] ──
+    if (sub === "list" || sub.startsWith("list ")) {
+        const filterName = sub.slice("list".length).trim() || undefined;
+        const base = projectRoot();
+        const runs = listRuns(base, filterName);
+        if (runs.length === 0) {
+            ctx.ui.notify("No workflow runs found.", "info");
+            return true;
+        }
+        const lines = runs.map((r) => {
+            const stepInfo = `${r.steps.completed}/${r.steps.total} steps`;
+            return `• ${r.name} [${r.timestamp}] — ${r.status} (${stepInfo})`;
+        });
+        ctx.ui.notify(lines.join("\n"), "info");
+        return true;
+    }
+    // ── validate <name> ──
+    if (sub === "validate" || sub.startsWith("validate ")) {
+        const defName = sub.slice("validate".length).trim();
+        if (!defName) {
+            ctx.ui.notify("Usage: /gsd workflow validate <name>", "warning");
+            return true;
+        }
+        const base = projectRoot();
+        const defPath = join(base, ".gsd", "workflow-defs", `${defName}.yaml`);
+        if (!existsSync(defPath)) {
+            ctx.ui.notify(`Definition not found: ${defPath}`, "error");
+            return true;
+        }
+        try {
+            const raw = readFileSync(defPath, "utf-8");
+            const parsed = parseYaml(raw);
+            const result = validateDefinition(parsed);
+            if (result.valid) {
+                ctx.ui.notify(`✓ "${defName}" is a valid workflow definition.`, "info");
+            }
+            else {
+                ctx.ui.notify(`✗ "${defName}" has errors:\n  - ${result.errors.join("\n  - ")}`, "error");
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.ui.notify(`Failed to validate "${defName}": ${msg}`, "error");
+        }
+        return true;
+    }
+    // ── pause ──
+    if (sub === "pause") {
+        const engineId = getActiveEngineId();
+        if (engineId === "dev" || engineId === null) {
+            ctx.ui.notify("No custom workflow is running. Use /gsd pause for dev workflow.", "warning");
+            return true;
+        }
+        if (!isAutoActive()) {
+            ctx.ui.notify("Auto-mode is not active.", "warning");
+            return true;
+        }
+        await pauseAuto(ctx, pi);
+        ctx.ui.notify("Custom workflow paused.", "info");
+        return true;
+    }
+    // ── resume ──
+    if (sub === "resume") {
+        const engineId = getActiveEngineId();
+        if (engineId === "dev" || engineId === null) {
+            ctx.ui.notify("No custom workflow to resume. Use /gsd auto for dev workflow.", "warning");
+            return true;
+        }
+        try {
+            await startAuto(ctx, pi, projectRoot(), false);
+            ctx.ui.notify("Custom workflow resumed.", "info");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.ui.notify(`Failed to resume workflow: ${msg}`, "error");
+        }
+        return true;
+    }
+    // Unknown subcommand — show usage
+    ctx.ui.notify(`Unknown workflow subcommand: "${sub}"\n\n${WORKFLOW_USAGE}`, "warning");
+    return true;
+}
 export async function handleWorkflowCommand(trimmed, ctx, pi) {
+    // ── Custom workflow commands (`/gsd workflow ...`) ──
+    if (trimmed === "workflow" || trimmed.startsWith("workflow ")) {
+        const sub = trimmed.slice("workflow".length).trim();
+        return handleCustomWorkflow(sub, ctx, pi);
+    }
     if (trimmed === "queue") {
         await showQueue(ctx, pi, projectRoot());
         return true;

package/dist/resources/extensions/gsd/context-injector.js

@@ -0,0 +1,74 @@
+/**
+ * context-injector.ts — Inject prior step artifacts as context into step prompts.
+ *
+ * Reads the frozen DEFINITION.yaml from a run directory, finds the current step's
+ * `contextFrom` references, locates each referenced step's `produces` artifacts
+ * on disk, reads their content (truncated to 10k chars), and prepends formatted
+ * context blocks to the step prompt.
+ *
+ * Observability:
+ * - Truncation is logged via console.warn when it occurs, preventing silent overflow.
+ * - Missing artifact files are skipped silently (the step may not have produced them yet).
+ * - Unknown step IDs in contextFrom produce a console.warn for diagnosis.
+ * - The frozen DEFINITION.yaml on disk is the single source of truth for contextFrom config.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, sep } from "node:path";
+import { readFrozenDefinition } from "./custom-workflow-engine.js";
+/** Maximum characters per artifact to prevent context window blowout. */
+const MAX_CONTEXT_CHARS = 10_000;
+/**
+ * Inject context from prior step artifacts into a step's prompt.
+ *
+ * Reads the frozen DEFINITION.yaml from `runDir`, finds the step matching
+ * `stepId`, and for each step ID in its `contextFrom` array, looks up that
+ * step's `produces` paths, reads them from disk (relative to `runDir`),
+ * truncates to MAX_CONTEXT_CHARS, and prepends as labeled context blocks.
+ *
+ * @param runDir — absolute path to the workflow run directory
+ * @param stepId — the step ID whose prompt to enrich
+ * @param prompt — the original step prompt
+ * @returns The prompt with context blocks prepended, or unchanged if no context applies
+ * @throws Error if DEFINITION.yaml is missing or unreadable
+ */
+export function injectContext(runDir, stepId, prompt) {
+    const def = readFrozenDefinition(runDir);
+    const step = def.steps.find((s) => s.id === stepId);
+    if (!step || !step.contextFrom || step.contextFrom.length === 0) {
+        return prompt;
+    }
+    const contextBlocks = [];
+    for (const refStepId of step.contextFrom) {
+        const refStep = def.steps.find((s) => s.id === refStepId);
+        if (!refStep) {
+            console.warn(`context-injector: step "${stepId}" references unknown step "${refStepId}" in contextFrom — skipping`);
+            continue;
+        }
+        if (!refStep.produces || refStep.produces.length === 0) {
+            continue;
+        }
+        for (const relPath of refStep.produces) {
+            const absPath = resolve(runDir, relPath);
+            // Path traversal guard: ensure resolved path stays within runDir
+            if (!absPath.startsWith(resolve(runDir) + sep) && absPath !== resolve(runDir)) {
+                console.warn(`context-injector: artifact path "${relPath}" resolves outside runDir — skipping`);
+                continue;
+            }
+            if (!existsSync(absPath)) {
+                // Artifact not yet produced or optional — skip silently
+                continue;
+            }
+            let content = readFileSync(absPath, "utf-8");
+            if (content.length > MAX_CONTEXT_CHARS) {
+                console.warn(`context-injector: truncating artifact "${relPath}" from step "${refStepId}" ` +
+                    `(${content.length} chars → ${MAX_CONTEXT_CHARS} chars)`);
+                content = content.slice(0, MAX_CONTEXT_CHARS) + "\n...[truncated]";
+            }
+            contextBlocks.push(`--- Context from step "${refStepId}" (file: ${relPath}) ---\n${content}\n---`);
+        }
+    }
+    if (contextBlocks.length === 0) {
+        return prompt;
+    }
+    return contextBlocks.join("\n\n") + "\n\n" + prompt;
+}

package/dist/resources/extensions/gsd/custom-execution-policy.js

@@ -0,0 +1,47 @@
+/**
+ * custom-execution-policy.ts — ExecutionPolicy for custom workflows.
+ *
+ * Delegates verification to the step-level verification module which reads
+ * the frozen DEFINITION.yaml and dispatches to the appropriate policy handler.
+ *
+ * Observability:
+ * - verify() returns the outcome from runCustomVerification() — four policies
+ *   are supported: content-heuristic, shell-command, prompt-verify, human-review.
+ * - selectModel() returns null — defers to loop defaults.
+ * - recover() returns retry — simple default recovery strategy.
+ */
+import { runCustomVerification } from "./custom-verification.js";
+export class CustomExecutionPolicy {
+    runDir;
+    constructor(runDir) {
+        this.runDir = runDir;
+    }
+    /** No workspace preparation needed for custom workflows. */
+    async prepareWorkspace(_basePath, _milestoneId) {
+        // No-op — custom workflows don't need worktree setup
+    }
+    /** Defer model selection to loop defaults. */
+    async selectModel(_unitType, _unitId, _context) {
+        return null;
+    }
+    /**
+     * Verify step output by dispatching to the step's configured verification policy.
+     *
+     * Extracts the step ID from unitId (format: "<workflowName>/<stepId>")
+     * and calls runCustomVerification() which reads the frozen DEFINITION.yaml
+     * to determine which policy to apply.
+     */
+    async verify(_unitType, unitId, _context) {
+        const parts = unitId.split("/");
+        const stepId = parts[parts.length - 1];
+        return runCustomVerification(this.runDir, stepId);
+    }
+    /** Default recovery: retry the step. */
+    async recover(_unitType, _unitId, _context) {
+        return { outcome: "retry", reason: "Default retry" };
+    }
+    /** No-op closeout — no commits or artifact capture. */
+    async closeout(_unitType, _unitId, _context) {
+        return { committed: false, artifacts: [] };
+    }
+}