gsd-pi 2.41.0-dev.0acbce9 → 2.41.0-dev.5a170d0

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/context-store.js

@@ -39,6 +39,7 @@ export function queryDecisions(opts) {
             choice: row['choice'],
             rationale: row['rationale'],
             revisable: row['revisable'],
+            made_by: row['made_by'] ?? 'agent',
             superseded_by: null,
         }));
     }
@@ -99,9 +100,9 @@ export function queryRequirements(opts) {
 export function formatDecisionsForPrompt(decisions) {
     if (decisions.length === 0)
         return '';
-    const header = '| # | When | Scope | Decision | Choice | Rationale | Revisable? |';
-    const separator = '|---|------|-------|----------|--------|-----------|------------|';
-    const rows = decisions.map(d => `| ${d.id} | ${d.when_context} | ${d.scope} | ${d.decision} | ${d.choice} | ${d.rationale} | ${d.revisable} |`);
+    const header = '| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |';
+    const separator = '|---|------|-------|----------|--------|-----------|------------|---------|';
+    const rows = decisions.map(d => `| ${d.id} | ${d.when_context} | ${d.scope} | ${d.decision} | ${d.choice} | ${d.rationale} | ${d.revisable} | ${d.made_by ?? 'agent'} |`);
     return [header, separator, ...rows].join('\n');
 }
 /**

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: [] };
+    }
+}

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

@@ -0,0 +1,145 @@
+/**
+ * custom-verification.ts — Step verification for custom workflows.
+ *
+ * Reads the frozen DEFINITION.yaml from a run directory, finds the step's
+ * `verify` policy, and dispatches to the appropriate handler. Four policies:
+ *
+ *   - content-heuristic: file existence + optional minSize + optional pattern match
+ *   - shell-command: spawnSync with 30s timeout, exit 0 → continue, else retry
+ *   - prompt-verify: always "pause" (defers to agent)
+ *   - human-review: always "pause" (waits for manual inspection)
+ *   - (no policy): returns "continue" (passthrough)
+ *
+ * Observability:
+ * - Return value is the typed verification outcome ("continue" | "retry" | "pause").
+ * - shell-command captures stderr from spawnSync — callers can inspect on retry.
+ * - content-heuristic logs the specific failure (missing file, below minSize, pattern mismatch).
+ * - The frozen DEFINITION.yaml on disk is the single source of truth for step policies.
+ */
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { resolve, sep } from "node:path";
+import { spawnSync } from "node:child_process";
+import { readFrozenDefinition } from "./custom-workflow-engine.js";
+/**
+ * Run custom verification for a specific step in a workflow run.
+ *
+ * Reads the frozen DEFINITION.yaml from `runDir`, finds the step with the
+ * given `stepId`, and dispatches to the appropriate verification handler
+ * based on the step's `verify.policy` field.
+ *
+ * @param runDir — absolute path to the workflow run directory
+ * @param stepId — the step ID to verify (e.g. "step-1")
+ * @returns "continue" if verification passes, "retry" if it should retry, "pause" if it needs review
+ * @throws Error if DEFINITION.yaml is missing or unreadable
+ */
+export function runCustomVerification(runDir, stepId) {
+    const def = readFrozenDefinition(runDir);
+    const step = def.steps.find((s) => s.id === stepId);
+    if (!step) {
+        // Step not found in definition — nothing to verify, continue
+        return "continue";
+    }
+    if (!step.verify) {
+        // No verification policy configured — passthrough
+        return "continue";
+    }
+    return dispatchPolicy(runDir, step, step.verify);
+}
+/**
+ * Dispatch to the correct policy handler.
+ */
+function dispatchPolicy(runDir, step, verify) {
+    switch (verify.policy) {
+        case "content-heuristic":
+            return handleContentHeuristic(runDir, step, verify);
+        case "shell-command":
+            return handleShellCommand(runDir, verify);
+        case "prompt-verify":
+            return "pause";
+        case "human-review":
+            return "pause";
+        default:
+            // Unknown policy — safe default is pause
+            return "pause";
+    }
+}
+/**
+ * content-heuristic handler.
+ *
+ * For each path in the step's `produces` array:
+ * 1. Check that the file exists (resolved relative to runDir)
+ * 2. If `minSize` is set, check that file size >= minSize bytes
+ * 3. If `pattern` is set, check that file content matches the regex
+ *
+ * Returns "continue" if all checks pass, "pause" if any fail.
+ * If `produces` is empty or undefined, returns "continue" (nothing to check).
+ */
+function handleContentHeuristic(runDir, step, verify) {
+    const produces = step.produces;
+    if (!produces || produces.length === 0) {
+        return "continue";
+    }
+    for (const relPath of produces) {
+        const absPath = resolve(runDir, relPath);
+        // Path traversal guard
+        if (!absPath.startsWith(resolve(runDir) + sep) && absPath !== resolve(runDir)) {
+            return "pause";
+        }
+        // 1. File existence
+        if (!existsSync(absPath)) {
+            return "pause";
+        }
+        // 2. Minimum size check
+        if (verify.minSize !== undefined) {
+            const stat = statSync(absPath);
+            if (stat.size < verify.minSize) {
+                return "pause";
+            }
+        }
+        // 3. Pattern match check (with timeout guard against ReDoS)
+        if (verify.pattern !== undefined) {
+            const content = readFileSync(absPath, "utf-8");
+            try {
+                if (!new RegExp(verify.pattern).test(content)) {
+                    return "pause";
+                }
+            }
+            catch {
+                // Invalid regex at runtime — treat as verification failure
+                return "pause";
+            }
+        }
+    }
+    return "continue";
+}
+/**
+ * shell-command handler.
+ *
+ * Runs the command via `sh -c` with cwd set to the run directory
+ * and a 30-second timeout. Returns "continue" if exit code 0,
+ * "retry" otherwise (including timeout/signal kills).
+ *
+ * SECURITY: The command string comes from a frozen DEFINITION.yaml written
+ * at run-creation time. The trust boundary is the workflow definition author.
+ * Commands run with the same privileges as the GSD process. Only use
+ * shell-command verification with definitions you trust.
+ */
+function handleShellCommand(runDir, verify) {
+    // Guard: reject commands containing shell expansion patterns that suggest injection
+    const dangerousPatterns = /\$\(|`|;\s*(rm|curl|wget|nc|bash|sh|eval)\b/;
+    if (dangerousPatterns.test(verify.command)) {
+        console.warn(`custom-verification: shell-command contains suspicious pattern, skipping: ${verify.command}`);
+        return "pause";
+    }
+    const result = spawnSync("sh", ["-c", verify.command], {
+        cwd: runDir,
+        timeout: 30_000,
+        encoding: "utf-8",
+        stdio: "pipe",
+        env: { ...process.env, PATH: process.env.PATH },
+    });
+    if (result.status === 0) {
+        return "continue";
+    }
+    return "retry";
+}

package/dist/resources/extensions/gsd/custom-workflow-engine.js

@@ -0,0 +1,164 @@
+/**
+ * custom-workflow-engine.ts — WorkflowEngine implementation for custom workflows.
+ *
+ * Drives the auto-loop using GRAPH.yaml step state from a run directory.
+ * Each iteration: deriveState reads the graph, resolveDispatch picks the
+ * next eligible step, reconcile marks it complete and persists.
+ *
+ * Observability:
+ * - All state reads/writes go through graph.ts YAML I/O — inspectable on disk.
+ * - `resolveDispatch` returns unitType "custom-step" with unitId "<name>/<stepId>".
+ * - `getDisplayMetadata` provides step N/M progress for dashboard rendering.
+ * - Phase transitions are derivable from GRAPH.yaml step statuses.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parse } from "yaml";
+import { readGraph, writeGraph, getNextPendingStep, markStepComplete, expandIteration, } from "./graph.js";
+import { injectContext } from "./context-injector.js";
+/** Read and parse the frozen DEFINITION.yaml from a run directory. */
+export function readFrozenDefinition(runDir) {
+    const defPath = join(runDir, "DEFINITION.yaml");
+    const raw = readFileSync(defPath, "utf-8");
+    return parse(raw, { schema: "core" });
+}
+export class CustomWorkflowEngine {
+    engineId = "custom";
+    runDir;
+    constructor(runDir) {
+        this.runDir = runDir;
+    }
+    /**
+     * Derive engine state from GRAPH.yaml on disk.
+     *
+     * Phase is "complete" when all steps are complete or expanded,
+     * "running" otherwise (any pending or active steps remain).
+     */
+    async deriveState(_basePath) {
+        const graph = readGraph(this.runDir);
+        const allDone = graph.steps.every((s) => s.status === "complete" || s.status === "expanded");
+        const phase = allDone ? "complete" : "running";
+        return {
+            phase,
+            currentMilestoneId: null,
+            activeSliceId: null,
+            activeTaskId: null,
+            isComplete: allDone,
+            raw: graph,
+        };
+    }
+    /**
+     * Resolve the next dispatch action from graph state.
+     *
+     * Uses getNextPendingStep to find the first step whose dependencies
+     * are all satisfied. If the step has an `iterate` config in the frozen
+     * DEFINITION.yaml, expands it into instance steps before dispatching.
+     *
+     * Returns a dispatch with unitType "custom-step" and unitId in
+     * "<workflowName>/<stepId>" format.
+     *
+     * Observability:
+     * - Iterate expansion is logged to stderr with item count and parent step ID.
+     * - Missing source artifacts throw with the full resolved path for diagnosis.
+     * - Zero-match expansions return a stop action with level "info".
+     * - Expanded GRAPH.yaml is written to disk before dispatch — inspectable on disk.
+     */
+    async resolveDispatch(state, _context) {
+        let graph = state.raw;
+        let next = getNextPendingStep(graph);
+        if (!next) {
+            return {
+                action: "stop",
+                reason: "All steps complete",
+                level: "info",
+            };
+        }
+        // Check frozen DEFINITION.yaml for iterate config on this step
+        const def = readFrozenDefinition(this.runDir);
+        const stepDef = def.steps.find((s) => s.id === next.id);
+        if (stepDef?.iterate) {
+            const iterate = stepDef.iterate;
+            // Read source artifact
+            const sourcePath = join(this.runDir, iterate.source);
+            let sourceContent;
+            try {
+                sourceContent = readFileSync(sourcePath, "utf-8");
+            }
+            catch {
+                throw new Error(`Iterate source artifact not found: ${sourcePath} (step "${next.id}", source: "${iterate.source}")`);
+            }
+            // Extract items via regex with global+multiline flags.
+            // Guard against ReDoS: if matching takes too long on large inputs, bail.
+            const regex = new RegExp(iterate.pattern, "gm");
+            const items = [];
+            const matchStart = Date.now();
+            let match;
+            while ((match = regex.exec(sourceContent)) !== null) {
+                if (match[1] !== undefined)
+                    items.push(match[1]);
+                if (Date.now() - matchStart > 5_000) {
+                    throw new Error(`Iterate pattern "${iterate.pattern}" exceeded 5s timeout on step "${next.id}" — possible ReDoS`);
+                }
+            }
+            // Expand the graph
+            const expandedGraph = expandIteration(graph, next.id, items, next.prompt);
+            writeGraph(this.runDir, expandedGraph);
+            graph = expandedGraph;
+            // Re-query for first instance step
+            next = getNextPendingStep(expandedGraph);
+            if (!next) {
+                return {
+                    action: "stop",
+                    reason: "Iterate expansion produced no instances",
+                    level: "info",
+                };
+            }
+        }
+        // Enrich prompt with context from prior step artifacts
+        const enrichedPrompt = injectContext(this.runDir, next.id, next.prompt);
+        return {
+            action: "dispatch",
+            step: {
+                unitType: "custom-step",
+                unitId: `${graph.metadata.name}/${next.id}`,
+                prompt: enrichedPrompt,
+            },
+        };
+    }
+    /**
+     * Reconcile state after a step completes.
+     *
+     * Extracts the stepId from the completedStep's unitId (last segment after `/`),
+     * marks it complete in the graph, and writes the updated GRAPH.yaml to disk.
+     *
+     * Returns "milestone-complete" when all steps are now done, "continue" otherwise.
+     */
+    async reconcile(state, completedStep) {
+        const graph = state.raw;
+        // Extract stepId from "<workflowName>/<stepId>"
+        const parts = completedStep.unitId.split("/");
+        const stepId = parts[parts.length - 1];
+        const updatedGraph = markStepComplete(graph, stepId);
+        writeGraph(this.runDir, updatedGraph);
+        const allDone = updatedGraph.steps.every((s) => s.status === "complete" || s.status === "expanded");
+        return {
+            outcome: allDone ? "milestone-complete" : "continue",
+        };
+    }
+    /**
+     * Return UI-facing metadata for progress display.
+     *
+     * Shows "Step N/M" progress where N = completed count and M = total.
+     */
+    getDisplayMetadata(state) {
+        const graph = state.raw;
+        const total = graph.steps.length;
+        const completed = graph.steps.filter((s) => s.status === "complete").length;
+        return {
+            engineLabel: "WORKFLOW",
+            currentPhase: state.phase,
+            progressSummary: `Step ${completed}/${total}`,
+            stepCount: { completed, total },
+        };
+    }
+}

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

@@ -30,6 +30,7 @@ function unitLabel(type) {
         case "triage-captures": return "Triage";
         case "quick-task": return "Quick Task";
         case "replan-slice": return "Replan";
+        case "custom-step": return "Workflow Step";
         default: return type;
     }
 }

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

@@ -30,8 +30,8 @@ export function generateDecisionsMd(decisions) {
     lines.push('     To reverse a decision, add a new row that supersedes it.');
     lines.push('     Read this file at the start of any planning or research phase. -->');
     lines.push('');
-    lines.push('| # | When | Scope | Decision | Choice | Rationale | Revisable? |');
-    lines.push('|---|------|-------|----------|--------|-----------|------------|');
+    lines.push('| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |');
+    lines.push('|---|------|-------|----------|--------|-----------|------------|---------|');
     for (const d of decisions) {
         // Escape pipe characters within cell values to preserve table structure
         const cells = [
@@ -42,6 +42,7 @@ export function generateDecisionsMd(decisions) {
             d.choice,
             d.rationale,
             d.revisable,
+            d.made_by ?? 'agent',
         ].map(cell => (cell ?? '').replace(/\|/g, '\\|'));
         lines.push(`| ${cells.join(' | ')} |`);
     }
@@ -172,6 +173,7 @@ export async function saveDecisionToDb(fields, basePath) {
             choice: fields.choice,
             rationale: fields.rationale,
             revisable: fields.revisable ?? 'Yes',
+            made_by: fields.made_by ?? 'agent',
             superseded_by: null,
         });
         // Fetch all decisions (including superseded for the full register)
@@ -188,6 +190,7 @@ export async function saveDecisionToDb(fields, basePath) {
                 choice: row['choice'],
                 rationale: row['rationale'],
                 revisable: row['revisable'],
+                made_by: row['made_by'] ?? 'agent',
                 superseded_by: row['superseded_by'] ?? null,
             }));
         }