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

package/src/resources/extensions/gsd/auto.ts

@@ -358,6 +358,22 @@ export function isAutoPaused(): boolean {
   return s.paused;
 }
 
+export function setActiveEngineId(id: string | null): void {
+  s.activeEngineId = id;
+}
+
+export function getActiveEngineId(): string | null {
+  return s.activeEngineId;
+}
+
+export function setActiveRunDir(runDir: string | null): void {
+  s.activeRunDir = runDir;
+}
+
+export function getActiveRunDir(): string | null {
+  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
@@ -782,6 +798,8 @@ export async function pauseAuto(
       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 });
@@ -1018,7 +1036,19 @@ export async function startAuto(
       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/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -20,21 +20,27 @@ import { saveActivityLog } from "../activity-log.js";
 // printed it before the TUI launched. Only re-print on /clear (subsequent sessions).
 let isFirstSession = true;
 
+async function syncServiceTierStatus(ctx: ExtensionContext): Promise<void> {
+  const { getEffectiveServiceTier, formatServiceTierFooterStatus } = await import("../service-tier.js");
+  ctx.ui.setStatus("gsd-fast", formatServiceTierFooterStatus(getEffectiveServiceTier(), ctx.model?.id));
+}
+
 export function registerHooks(pi: ExtensionAPI): void {
   pi.on("session_start", async (_event, ctx) => {
     resetWriteGateState();
     resetToolCallLoopGuard();
+    await syncServiceTierStatus(ctx);
     if (isFirstSession) {
       isFirstSession = false;
     } else {
       try {
         const gsdBinPath = process.env.GSD_BIN_PATH;
         if (gsdBinPath) {
-          const { dirname } = await import('node:path');
+          const { dirname } = await import("node:path");
           const { printWelcomeScreen } = await import(
-            join(dirname(gsdBinPath), 'welcome-screen.js')
+            join(dirname(gsdBinPath), "welcome-screen.js")
           ) as { printWelcomeScreen: (opts: { version: string; modelName?: string; provider?: string }) => void };
-          printWelcomeScreen({ version: process.env.GSD_VERSION || '0.0.0' });
+          printWelcomeScreen({ version: process.env.GSD_VERSION || "0.0.0" });
         }
       } catch { /* non-fatal */ }
     }
@@ -192,8 +198,11 @@ export function registerHooks(pi: ExtensionAPI): void {
     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;
     const { getEffectiveServiceTier, supportsServiceTier } = await import("../service-tier.js");
@@ -205,4 +214,3 @@ export function registerHooks(pi: ExtensionAPI): void {
     return payload;
   });
 }
-

package/src/resources/extensions/gsd/bootstrap/tool-call-loop-guard.ts

@@ -24,8 +24,15 @@ let enabled = true;
 function hashToolCall(toolName: string, args: Record<string, unknown>): string {
   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<Record<string, unknown>>((o, k) => {
+          o[k] = value[k];
+          return o;
+        }, {})
+      : value
+  ));
   return h.digest("hex").slice(0, 16);
 }
 

package/src/resources/extensions/gsd/commands/catalog.ts

@@ -3,6 +3,7 @@ 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");
 
@@ -65,6 +66,7 @@ export const TOP_LEVEL_SUBCOMMANDS: readonly GsdCommandDefinition[] = [
   { 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: CompletionMap = {
@@ -206,6 +208,14 @@ const NESTED_COMPLETIONS: CompletionMap = {
     { 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(
@@ -309,6 +319,28 @@ export function getGsdArgumentCompletions(prefix: string) {
     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/src/resources/extensions/gsd/commands/handlers/workflow.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent
 
 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";
@@ -13,8 +14,171 @@ 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: string,
+  ctx: ExtensionCommandContext,
+  pi: ExtensionAPI,
+): Promise<boolean> {
+  // 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: Record<string, string> = {};
+    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: string, ctx: ExtensionCommandContext, pi: ExtensionAPI): Promise<boolean> {
+  // ── 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/src/resources/extensions/gsd/context-injector.ts

@@ -0,0 +1,100 @@
+/**
+ * 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 { join, resolve, sep } from "node:path";
+import type { StepDefinition } from "./definition-loader.js";
+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: string,
+  stepId: string,
+  prompt: string,
+): string {
+  const def = readFrozenDefinition(runDir);
+
+  const step = def.steps.find((s: StepDefinition) => s.id === stepId);
+  if (!step || !step.contextFrom || step.contextFrom.length === 0) {
+    return prompt;
+  }
+
+  const contextBlocks: string[] = [];
+
+  for (const refStepId of step.contextFrom) {
+    const refStep = def.steps.find((s: StepDefinition) => 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/src/resources/extensions/gsd/custom-execution-policy.ts

@@ -0,0 +1,73 @@
+/**
+ * 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 type { ExecutionPolicy } from "./execution-policy.js";
+import type { RecoveryAction, CloseoutResult } from "./engine-types.js";
+import { runCustomVerification } from "./custom-verification.js";
+
+export class CustomExecutionPolicy implements ExecutionPolicy {
+  private readonly runDir: string;
+
+  constructor(runDir: string) {
+    this.runDir = runDir;
+  }
+
+  /** No workspace preparation needed for custom workflows. */
+  async prepareWorkspace(_basePath: string, _milestoneId: string): Promise<void> {
+    // No-op — custom workflows don't need worktree setup
+  }
+
+  /** Defer model selection to loop defaults. */
+  async selectModel(
+    _unitType: string,
+    _unitId: string,
+    _context: { basePath: string },
+  ): Promise<{ tier: string; modelDowngraded: boolean } | null> {
+    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: string,
+    unitId: string,
+    _context: { basePath: string },
+  ): Promise<"continue" | "retry" | "pause"> {
+    const parts = unitId.split("/");
+    const stepId = parts[parts.length - 1];
+    return runCustomVerification(this.runDir, stepId);
+  }
+
+  /** Default recovery: retry the step. */
+  async recover(
+    _unitType: string,
+    _unitId: string,
+    _context: { basePath: string },
+  ): Promise<RecoveryAction> {
+    return { outcome: "retry", reason: "Default retry" };
+  }
+
+  /** No-op closeout — no commits or artifact capture. */
+  async closeout(
+    _unitType: string,
+    _unitId: string,
+    _context: { basePath: string; startedAt: number },
+  ): Promise<CloseoutResult> {
+    return { committed: false, artifacts: [] };
+  }
+}