gsd-pi 2.41.0-dev.cac69f9 → 2.42.0-dev.1df898f

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -15,10 +15,15 @@ import { saveActivityLog } from "../activity-log.js";
 // Skip the welcome screen on the very first session_start — cli.ts already
 // printed it before the TUI launched. Only re-print on /clear (subsequent sessions).
 let isFirstSession = true;
+async function syncServiceTierStatus(ctx) {
+    const { getEffectiveServiceTier, formatServiceTierFooterStatus } = await import("../service-tier.js");
+    ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus(getEffectiveServiceTier(), ctx.model?.id));
+}
 export function registerHooks(pi) {
     pi.on("session_start", async (_event, ctx) => {
         resetWriteGateState();
         resetToolCallLoopGuard();
+        await syncServiceTierStatus(ctx);
         if (isFirstSession) {
             isFirstSession = false;
         }
@@ -26,9 +31,9 @@ export function registerHooks(pi) {
             try {
                 const gsdBinPath = process.env.GSD_BIN_PATH;
                 if (gsdBinPath) {
-                    const { dirname } = await import('node:path');
-                    const { printWelcomeScreen } = await import(join(dirname(gsdBinPath), 'welcome-screen.js'));
-                    printWelcomeScreen({ version: process.env.GSD_VERSION || '0.0.0' });
+                    const { dirname } = await import("node:path");
+                    const { printWelcomeScreen } = await import(join(dirname(gsdBinPath), "welcome-screen.js"));
+                    printWelcomeScreen({ version: process.env.GSD_VERSION || "0.0.0" });
                 }
             }
             catch { /* non-fatal */ }
@@ -179,9 +184,10 @@ export function registerHooks(pi) {
     pi.on("tool_execution_end", async (event) => {
         markToolEnd(event.toolCallId);
     });
+    pi.on("model_select", async (_event, ctx) => {
+        await syncServiceTierStatus(ctx);
+    });
     pi.on("before_provider_request", async (event) => {
-        if (!isAutoActive())
-            return;
         const modelId = event.model?.id;
         if (!modelId)
             return;

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

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