@quintinshaw/pi-dynamic-workflows 1.6.0 → 1.7.1

package/README.md

@@ -52,7 +52,7 @@ Ask for a background workflow (the model passes `background: true`) and it runs
 
 ```text
 /workflows                 # list runs (default)
-/workflows status <id>     # show a run's progress
+/workflows status <id>     # watch a running run live (status bar), prints result when done
 /workflows stop <id>       # abort a running run
 /workflows pause <id>      # pause a running run
 /workflows resume <id>     # resume an interrupted run (replays cached results)
@@ -68,6 +68,8 @@ Ask for a background workflow (the model passes `background: true`) and it runs
 
 `/deep-research` fans out web searches across several angles, fetches the top sources with real `web_search` / `web_fetch` tools, keeps only claims supported by multiple sources, and writes a cited report.
 
+Save any run as a reusable command: `/workflows save <name>` writes the most recent run's script to `.pi/workflows/saved/<name>.json`, and it immediately becomes `/<name>` (arguments parsed as `key=value` + positionals into `args`).
+
 ## Workflow script shape
 
 A workflow is plain JavaScript. The first statement must export literal metadata:
@@ -146,6 +148,7 @@ Scripts run inside a Node `vm` sandbox. Intentionally unavailable: `Date.now()`,
 - **Real per-agent / per-phase model routing** — `opts.model` and `meta.phases[].model` actually select the model (resolved against your authed model registry), with graceful fallback
 - **`/workflows` command** — list, inspect, stop, pause, **resume**, and remove background runs; runs started with `background: true` are reachable from the command
 - **Bundled `/deep-research` & `/adversarial-review`** — `/deep-research` runs real web searches (via built-in `web_search` / `web_fetch` tools), extracts claims, cross-checks them across sources, and reports only what survived; `/adversarial-review` investigates a task then has independent skeptics try to refute each finding, keeping only those that clear an agreement threshold
+- **Saved workflows as `/<name>`** — save a run's script with `/workflows save <name>` and it becomes a reusable slash command; arguments are parsed (`key=value` and positionals) and passed through as `args`
 - **Resume** — each agent result is journaled by a deterministic call index; resuming replays the unchanged prefix from cache (no re-run, no tokens) and runs only new or edited calls live
 - **Worktree isolation** — `isolation: "worktree"` runs an agent in its own git worktree on a throwaway branch, so parallel agents can edit the same files without conflict; the worktree is torn down after (results are not auto-merged), and it falls back to a logged no-op outside a git repo
 - **Safety limits** — 1000-agent cap (`maxAgents`), per-agent timeout (`agentTimeoutMs`), recoverable-vs-fatal error classification
@@ -156,7 +159,6 @@ Scripts run inside a Node `vm` sandbox. Intentionally unavailable: `Date.now()`,
 
 Tracked toward closer parity with Claude Code dynamic workflows:
 
-- **Saved workflows** as `/<name>` slash commands
 - **Nested `workflow()`** to compose saved workflows inline
 
 ## How it works

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export type { ModelRoute, ModelRoutingConfig } from "./model-routing.js";
 export { buildModelRoutingInstructions, parseModelRoutingFromMeta, resolveModelForPhase } from "./model-routing.js";
 export type { PersistedRunState, RunPersistence, RunStatus } from "./run-persistence.js";
 export { createRunPersistence, generateRunId } from "./run-persistence.js";
+export { parseCommandArgs, registerAllSavedWorkflows, registerSavedWorkflow, } from "./saved-commands.js";
 export type { StructuredOutputCapture, StructuredOutputToolOptions } from "./structured-output.js";
 export { createStructuredOutputTool } from "./structured-output.js";
 export { createWebFetchTool, createWebSearchTool, createWebTools } from "./web-tools.js";

package/dist/index.js

@@ -9,6 +9,7 @@ export { isAbortError, isTimeoutError, isWorkflowError, WorkflowError, WorkflowE
 export { createWorkflowLogger } from "./logger.js";
 export { buildModelRoutingInstructions, parseModelRoutingFromMeta, resolveModelForPhase } from "./model-routing.js";
 export { createRunPersistence, generateRunId } from "./run-persistence.js";
+export { parseCommandArgs, registerAllSavedWorkflows, registerSavedWorkflow, } from "./saved-commands.js";
 export { createStructuredOutputTool } from "./structured-output.js";
 export { createWebFetchTool, createWebSearchTool, createWebTools } from "./web-tools.js";
 export { parseWorkflowScript, runWorkflow } from "./workflow.js";

package/dist/saved-commands.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Saved workflows as `/<name>` slash commands. Each saved workflow becomes a
+ * command that runs its script, passing parsed arguments through as `args`.
+ */
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { SavedWorkflow, WorkflowStorage } from "./workflow-saved.js";
+/**
+ * Parse a command argument string into an `args` object for the script.
+ * Supports `key=value` tokens; everything else collects into `_` (and `_raw`).
+ * Declared parameter defaults fill in missing keys.
+ */
+export declare function parseCommandArgs(raw: string, parameters?: SavedWorkflow["parameters"]): Record<string, unknown>;
+/** Register one saved workflow as a `/<name>` command (idempotent). */
+export declare function registerSavedWorkflow(pi: ExtensionAPI, cwd: string, wf: SavedWorkflow): void;
+/** Register every saved workflow found in storage. */
+export declare function registerAllSavedWorkflows(pi: ExtensionAPI, cwd: string, storage: WorkflowStorage): void;

package/dist/saved-commands.js

@@ -0,0 +1,72 @@
+/**
+ * Saved workflows as `/<name>` slash commands. Each saved workflow becomes a
+ * command that runs its script, passing parsed arguments through as `args`.
+ */
+import { createCodingTools } from "@earendil-works/pi-coding-agent";
+import { runWorkflow } from "./workflow.js";
+function isRegistered(pi, name) {
+    try {
+        return (pi.getCommands?.() ?? []).some((c) => c.name === name);
+    }
+    catch {
+        return false;
+    }
+}
+function reportText(result) {
+    const r = result.result;
+    if (r && typeof r.report === "string" && r.report.trim())
+        return r.report;
+    return JSON.stringify(result.result, null, 2);
+}
+/**
+ * Parse a command argument string into an `args` object for the script.
+ * Supports `key=value` tokens; everything else collects into `_` (and `_raw`).
+ * Declared parameter defaults fill in missing keys.
+ */
+export function parseCommandArgs(raw, parameters) {
+    const out = {};
+    const positional = [];
+    for (const tok of raw.trim().split(/\s+/).filter(Boolean)) {
+        const eq = tok.indexOf("=");
+        if (eq > 0)
+            out[tok.slice(0, eq)] = tok.slice(eq + 1);
+        else
+            positional.push(tok);
+    }
+    out._ = positional.join(" ");
+    out._raw = raw.trim();
+    for (const [key, spec] of Object.entries(parameters ?? {})) {
+        if (out[key] === undefined && spec.default !== undefined)
+            out[key] = spec.default;
+    }
+    return out;
+}
+/** Register one saved workflow as a `/<name>` command (idempotent). */
+export function registerSavedWorkflow(pi, cwd, wf) {
+    if (isRegistered(pi, wf.name))
+        return;
+    pi.registerCommand(wf.name, {
+        description: wf.description || `Saved workflow: ${wf.name}`,
+        async handler(args, ctx) {
+            try {
+                const result = await runWorkflow(wf.script, {
+                    cwd,
+                    args: parseCommandArgs(args, wf.parameters),
+                    tools: createCodingTools(cwd),
+                    onPhase: (title) => ctx.ui.setStatus(`wf:${wf.name}`, `${wf.name}: ${title}`),
+                });
+                ctx.ui.setStatus(`wf:${wf.name}`, undefined);
+                await pi.sendMessage({ customType: `workflow:${wf.name}`, content: reportText(result), display: true });
+            }
+            catch (error) {
+                ctx.ui.setStatus(`wf:${wf.name}`, undefined);
+                ctx.ui.notify(`/${wf.name} failed: ${error instanceof Error ? error.message : error}`, "error");
+            }
+        },
+    });
+}
+/** Register every saved workflow found in storage. */
+export function registerAllSavedWorkflows(pi, cwd, storage) {
+    for (const wf of storage.list())
+        registerSavedWorkflow(pi, cwd, wf);
+}

package/dist/workflow-commands.d.ts

@@ -4,5 +4,12 @@
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { WorkflowManager } from "./workflow-manager.js";
+import type { WorkflowStorage } from "./workflow-saved.js";
+export interface WorkflowCommandOptions {
+    /** Saved-workflow storage, enabling `/workflows save`. */
+    storage?: WorkflowStorage;
+    /** Working directory for saved workflows registered via `save`. */
+    cwd?: string;
+}
 /** Register the `/workflows` command against the shared manager. Idempotent. */
-export declare function registerWorkflowCommands(pi: ExtensionAPI, manager: WorkflowManager): void;
+export declare function registerWorkflowCommands(pi: ExtensionAPI, manager: WorkflowManager, opts?: WorkflowCommandOptions): void;

package/dist/workflow-commands.js

@@ -2,7 +2,8 @@
  * `/workflows` slash command: list, inspect, and control background workflow runs.
  * Shares the extension's single WorkflowManager so background runs are reachable.
  */
-import { renderWorkflowText } from "./display.js";
+import { recomputeWorkflowSnapshot, renderWorkflowText } from "./display.js";
+import { registerSavedWorkflow } from "./saved-commands.js";
 const STATUS_ICON = {
     pending: "·",
     running: "◆",
@@ -11,7 +12,7 @@ const STATUS_ICON = {
     failed: "✗",
     aborted: "⊘",
 };
-const USAGE = "Usage: /workflows [list] | status <id> | stop <id> | pause <id> | resume <id> | rm <id>";
+const USAGE = "Usage: /workflows [list] | status <id> | watch <id> | stop <id> | pause <id> | resume <id> | rm <id> | save <name> [runId]";
 function summarizeRun(run) {
     const icon = STATUS_ICON[run.status] ?? "?";
     const done = run.agents.filter((a) => a.status === "done").length;
@@ -19,6 +20,64 @@ function summarizeRun(run) {
     const tokens = run.tokenUsage ? ` · ${run.tokenUsage.total.toLocaleString()} tok` : "";
     return `${icon} ${run.runId}  ${run.workflowName} [${run.status}] ${done}/${total} agents${tokens}`;
 }
+function oneLineProgress(snapshot) {
+    const total = snapshot.agents.length;
+    const done = snapshot.agents.filter((a) => a.status === "done").length;
+    const running = snapshot.agents.filter((a) => a.status === "running").length;
+    const errs = snapshot.agents.filter((a) => a.status === "error").length;
+    const phase = snapshot.currentPhase ? ` · ${snapshot.currentPhase}` : "";
+    return `◆ ${snapshot.name}: ${done}/${total} done${running ? `, ${running} running` : ""}${errs ? `, ${errs} err` : ""}${phase}`;
+}
+/**
+ * Subscribe to a running run's events and stream live progress to the status bar,
+ * printing the final snapshot when it finishes. Non-blocking: returns true if the
+ * run was active and is now being watched, false otherwise. Listeners clean up on
+ * completion so nothing leaks.
+ */
+function watchRun(manager, pi, ctx, id) {
+    const active = manager.getRun(id);
+    if (!active || active.status !== "running")
+        return false;
+    const key = `wf:${id}`;
+    const update = () => {
+        const run = manager.getRun(id);
+        if (run)
+            ctx.ui.setStatus(key, oneLineProgress(run.snapshot));
+    };
+    const onEvent = (e) => {
+        if (!e || e.runId === id)
+            update();
+    };
+    let settled = false;
+    const progressEvents = ["agentStart", "agentEnd", "phase", "log"];
+    const finalEvents = ["complete", "error", "stopped", "paused"];
+    const finish = (e) => {
+        if (e && e.runId !== id)
+            return;
+        if (settled)
+            return;
+        settled = true;
+        for (const ev of progressEvents)
+            manager.off(ev, onEvent);
+        for (const ev of finalEvents)
+            manager.off(ev, finish);
+        ctx.ui.setStatus(key, undefined);
+        const run = manager.getRun(id);
+        if (run) {
+            void pi.sendMessage({
+                customType: "workflows",
+                content: renderWorkflowText(recomputeWorkflowSnapshot(run.snapshot), true),
+                display: true,
+            });
+        }
+    };
+    for (const ev of progressEvents)
+        manager.on(ev, onEvent);
+    for (const ev of finalEvents)
+        manager.on(ev, finish);
+    update();
+    return true;
+}
 function renderPersistedStatus(run) {
     const lines = [`${STATUS_ICON[run.status] ?? "?"} ${run.workflowName} (${run.runId}) — ${run.status}`];
     if (run.currentPhase)
@@ -34,7 +93,7 @@ function renderPersistedStatus(run) {
     return lines.join("\n");
 }
 /** Register the `/workflows` command against the shared manager. Idempotent. */
-export function registerWorkflowCommands(pi, manager) {
+export function registerWorkflowCommands(pi, manager, opts = {}) {
     try {
         const taken = (pi.getCommands?.() ?? []).some((c) => c.name === "workflows");
         if (taken)
@@ -60,14 +119,21 @@ export function registerWorkflowCommands(pi, manager) {
                     await print(["Workflow runs:", ...runs.map(summarizeRun), "", USAGE].join("\n"));
                     return;
                 }
+                case "watch":
                 case "status": {
                     if (!id) {
                         ctx.ui.notify(USAGE, "warning");
                         return;
                     }
+                    // A running run streams live progress to the status bar and prints the
+                    // final snapshot when it finishes — no need to re-run the command.
+                    if (watchRun(manager, pi, ctx, id)) {
+                        ctx.ui.notify(`Watching ${id} — live progress in the status bar; result prints when it finishes.`, "info");
+                        return;
+                    }
                     const live = manager.getSnapshot(id);
                     if (live) {
-                        await print(renderWorkflowText(live, false));
+                        await print(renderWorkflowText(recomputeWorkflowSnapshot(live), false));
                         return;
                     }
                     const run = manager.listRuns().find((r) => r.runId === id);
@@ -103,6 +169,30 @@ export function registerWorkflowCommands(pi, manager) {
                     ctx.ui.notify(manager.deleteRun(id) ? `Removed ${id}` : `No run ${id}`, "info");
                     return;
                 }
+                case "save": {
+                    const name = id;
+                    if (!name)
+                        return ctx.ui.notify("Usage: /workflows save <name> [runId]", "warning");
+                    if (!opts.storage)
+                        return ctx.ui.notify("Saving is not available (no storage configured)", "error");
+                    const runs = manager.listRuns();
+                    const runIdArg = parts[2];
+                    // Pick the named run, else the most recent run that still has its script.
+                    const run = runIdArg ? runs.find((r) => r.runId === runIdArg) : runs.find((r) => r.script);
+                    if (!run?.script) {
+                        ctx.ui.notify(runIdArg ? `No run ${runIdArg} with a script` : "No saved run to save", "error");
+                        return;
+                    }
+                    const saved = opts.storage.save({
+                        name,
+                        description: run.workflowName,
+                        script: run.script,
+                        location: "project",
+                    });
+                    registerSavedWorkflow(pi, opts.cwd ?? process.cwd(), saved);
+                    ctx.ui.notify(`Saved /${name} (from ${run.runId})`, "info");
+                    return;
+                }
                 default:
                     ctx.ui.notify(`Unknown subcommand "${sub}". ${USAGE}`, "warning");
             }

package/extensions/workflow.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
   createWorkflowStorage,
   createWorkflowTool,
+  registerAllSavedWorkflows,
   registerBuiltinWorkflows,
   registerWorkflowCommands,
   WorkflowManager,
@@ -16,8 +17,9 @@ export default function extension(pi: ExtensionAPI) {
 
   const workflowTool = createWorkflowTool({ cwd, manager, storage });
   pi.registerTool(workflowTool);
-  registerWorkflowCommands(pi, manager);
+  registerWorkflowCommands(pi, manager, { storage, cwd });
   registerBuiltinWorkflows(pi, { cwd });
+  registerAllSavedWorkflows(pi, cwd, storage);
 
   pi.on("session_start", () => {
     const active = pi.getActiveTools();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quintinshaw/pi-dynamic-workflows",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "Claude-Code-style dynamic workflow orchestration for Pi.",
   "type": "module",
   "main": "./dist/index.js",

package/src/index.ts

@@ -38,6 +38,11 @@ export type { ModelRoute, ModelRoutingConfig } from "./model-routing.js";
 export { buildModelRoutingInstructions, parseModelRoutingFromMeta, resolveModelForPhase } from "./model-routing.js";
 export type { PersistedRunState, RunPersistence, RunStatus } from "./run-persistence.js";
 export { createRunPersistence, generateRunId } from "./run-persistence.js";
+export {
+  parseCommandArgs,
+  registerAllSavedWorkflows,
+  registerSavedWorkflow,
+} from "./saved-commands.js";
 export type { StructuredOutputCapture, StructuredOutputToolOptions } from "./structured-output.js";
 export { createStructuredOutputTool } from "./structured-output.js";
 export { createWebFetchTool, createWebSearchTool, createWebTools } from "./web-tools.js";

package/src/saved-commands.ts

@@ -0,0 +1,71 @@
+/**
+ * Saved workflows as `/<name>` slash commands. Each saved workflow becomes a
+ * command that runs its script, passing parsed arguments through as `args`.
+ */
+
+import { createCodingTools, type ExtensionAPI, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { runWorkflow, type WorkflowRunResult } from "./workflow.js";
+import type { SavedWorkflow, WorkflowStorage } from "./workflow-saved.js";
+
+function isRegistered(pi: ExtensionAPI, name: string): boolean {
+  try {
+    return (pi.getCommands?.() ?? []).some((c: { name: string }) => c.name === name);
+  } catch {
+    return false;
+  }
+}
+
+function reportText(result: WorkflowRunResult): string {
+  const r = result.result as { report?: unknown } | undefined;
+  if (r && typeof r.report === "string" && r.report.trim()) return r.report;
+  return JSON.stringify(result.result, null, 2);
+}
+
+/**
+ * Parse a command argument string into an `args` object for the script.
+ * Supports `key=value` tokens; everything else collects into `_` (and `_raw`).
+ * Declared parameter defaults fill in missing keys.
+ */
+export function parseCommandArgs(raw: string, parameters?: SavedWorkflow["parameters"]): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  const positional: string[] = [];
+  for (const tok of raw.trim().split(/\s+/).filter(Boolean)) {
+    const eq = tok.indexOf("=");
+    if (eq > 0) out[tok.slice(0, eq)] = tok.slice(eq + 1);
+    else positional.push(tok);
+  }
+  out._ = positional.join(" ");
+  out._raw = raw.trim();
+  for (const [key, spec] of Object.entries(parameters ?? {})) {
+    if (out[key] === undefined && spec.default !== undefined) out[key] = spec.default;
+  }
+  return out;
+}
+
+/** Register one saved workflow as a `/<name>` command (idempotent). */
+export function registerSavedWorkflow(pi: ExtensionAPI, cwd: string, wf: SavedWorkflow): void {
+  if (isRegistered(pi, wf.name)) return;
+  pi.registerCommand(wf.name, {
+    description: wf.description || `Saved workflow: ${wf.name}`,
+    async handler(args: string, ctx: ExtensionCommandContext) {
+      try {
+        const result = await runWorkflow(wf.script, {
+          cwd,
+          args: parseCommandArgs(args, wf.parameters),
+          tools: createCodingTools(cwd),
+          onPhase: (title) => ctx.ui.setStatus(`wf:${wf.name}`, `${wf.name}: ${title}`),
+        });
+        ctx.ui.setStatus(`wf:${wf.name}`, undefined);
+        await pi.sendMessage({ customType: `workflow:${wf.name}`, content: reportText(result), display: true });
+      } catch (error) {
+        ctx.ui.setStatus(`wf:${wf.name}`, undefined);
+        ctx.ui.notify(`/${wf.name} failed: ${error instanceof Error ? error.message : error}`, "error");
+      }
+    },
+  });
+}
+
+/** Register every saved workflow found in storage. */
+export function registerAllSavedWorkflows(pi: ExtensionAPI, cwd: string, storage: WorkflowStorage): void {
+  for (const wf of storage.list()) registerSavedWorkflow(pi, cwd, wf);
+}

package/src/workflow-commands.ts

@@ -4,9 +4,11 @@
  */
 
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
-import { renderWorkflowText } from "./display.js";
+import { recomputeWorkflowSnapshot, renderWorkflowText, type WorkflowSnapshot } from "./display.js";
 import type { PersistedRunState } from "./run-persistence.js";
+import { registerSavedWorkflow } from "./saved-commands.js";
 import type { WorkflowManager } from "./workflow-manager.js";
+import type { WorkflowStorage } from "./workflow-saved.js";
 
 const STATUS_ICON: Record<string, string> = {
   pending: "·",
@@ -17,7 +19,8 @@ const STATUS_ICON: Record<string, string> = {
   aborted: "⊘",
 };
 
-const USAGE = "Usage: /workflows [list] | status <id> | stop <id> | pause <id> | resume <id> | rm <id>";
+const USAGE =
+  "Usage: /workflows [list] | status <id> | watch <id> | stop <id> | pause <id> | resume <id> | rm <id> | save <name> [runId]";
 
 function summarizeRun(run: PersistedRunState): string {
   const icon = STATUS_ICON[run.status] ?? "?";
@@ -27,6 +30,60 @@ function summarizeRun(run: PersistedRunState): string {
   return `${icon} ${run.runId}  ${run.workflowName} [${run.status}] ${done}/${total} agents${tokens}`;
 }
 
+function oneLineProgress(snapshot: WorkflowSnapshot): string {
+  const total = snapshot.agents.length;
+  const done = snapshot.agents.filter((a) => a.status === "done").length;
+  const running = snapshot.agents.filter((a) => a.status === "running").length;
+  const errs = snapshot.agents.filter((a) => a.status === "error").length;
+  const phase = snapshot.currentPhase ? ` · ${snapshot.currentPhase}` : "";
+  return `◆ ${snapshot.name}: ${done}/${total} done${running ? `, ${running} running` : ""}${
+    errs ? `, ${errs} err` : ""
+  }${phase}`;
+}
+
+/**
+ * Subscribe to a running run's events and stream live progress to the status bar,
+ * printing the final snapshot when it finishes. Non-blocking: returns true if the
+ * run was active and is now being watched, false otherwise. Listeners clean up on
+ * completion so nothing leaks.
+ */
+function watchRun(manager: WorkflowManager, pi: ExtensionAPI, ctx: ExtensionCommandContext, id: string): boolean {
+  const active = manager.getRun(id);
+  if (!active || active.status !== "running") return false;
+
+  const key = `wf:${id}`;
+  const update = () => {
+    const run = manager.getRun(id);
+    if (run) ctx.ui.setStatus(key, oneLineProgress(run.snapshot));
+  };
+  const onEvent = (e: { runId?: string }) => {
+    if (!e || e.runId === id) update();
+  };
+  let settled = false;
+  const progressEvents = ["agentStart", "agentEnd", "phase", "log"];
+  const finalEvents = ["complete", "error", "stopped", "paused"];
+  const finish = (e: { runId?: string }) => {
+    if (e && e.runId !== id) return;
+    if (settled) return;
+    settled = true;
+    for (const ev of progressEvents) manager.off(ev, onEvent);
+    for (const ev of finalEvents) manager.off(ev, finish);
+    ctx.ui.setStatus(key, undefined);
+    const run = manager.getRun(id);
+    if (run) {
+      void pi.sendMessage({
+        customType: "workflows",
+        content: renderWorkflowText(recomputeWorkflowSnapshot(run.snapshot), true),
+        display: true,
+      });
+    }
+  };
+  for (const ev of progressEvents) manager.on(ev, onEvent);
+  for (const ev of finalEvents) manager.on(ev, finish);
+  update();
+  return true;
+}
+
 function renderPersistedStatus(run: PersistedRunState): string {
   const lines = [`${STATUS_ICON[run.status] ?? "?"} ${run.workflowName} (${run.runId}) — ${run.status}`];
   if (run.currentPhase) lines.push(`  phase: ${run.currentPhase}`);
@@ -40,8 +97,19 @@ function renderPersistedStatus(run: PersistedRunState): string {
   return lines.join("\n");
 }
 
+export interface WorkflowCommandOptions {
+  /** Saved-workflow storage, enabling `/workflows save`. */
+  storage?: WorkflowStorage;
+  /** Working directory for saved workflows registered via `save`. */
+  cwd?: string;
+}
+
 /** Register the `/workflows` command against the shared manager. Idempotent. */
-export function registerWorkflowCommands(pi: ExtensionAPI, manager: WorkflowManager): void {
+export function registerWorkflowCommands(
+  pi: ExtensionAPI,
+  manager: WorkflowManager,
+  opts: WorkflowCommandOptions = {},
+): void {
   try {
     const taken = (pi.getCommands?.() ?? []).some((c: { name: string }) => c.name === "workflows");
     if (taken) return;
@@ -67,14 +135,21 @@ export function registerWorkflowCommands(pi: ExtensionAPI, manager: WorkflowMana
           await print(["Workflow runs:", ...runs.map(summarizeRun), "", USAGE].join("\n"));
           return;
         }
+        case "watch":
         case "status": {
           if (!id) {
             ctx.ui.notify(USAGE, "warning");
             return;
           }
+          // A running run streams live progress to the status bar and prints the
+          // final snapshot when it finishes — no need to re-run the command.
+          if (watchRun(manager, pi, ctx, id)) {
+            ctx.ui.notify(`Watching ${id} — live progress in the status bar; result prints when it finishes.`, "info");
+            return;
+          }
           const live = manager.getSnapshot(id);
           if (live) {
-            await print(renderWorkflowText(live, false));
+            await print(renderWorkflowText(recomputeWorkflowSnapshot(live), false));
             return;
           }
           const run = manager.listRuns().find((r) => r.runId === id);
@@ -109,6 +184,28 @@ export function registerWorkflowCommands(pi: ExtensionAPI, manager: WorkflowMana
           ctx.ui.notify(manager.deleteRun(id) ? `Removed ${id}` : `No run ${id}`, "info");
           return;
         }
+        case "save": {
+          const name = id;
+          if (!name) return ctx.ui.notify("Usage: /workflows save <name> [runId]", "warning");
+          if (!opts.storage) return ctx.ui.notify("Saving is not available (no storage configured)", "error");
+          const runs = manager.listRuns();
+          const runIdArg = parts[2];
+          // Pick the named run, else the most recent run that still has its script.
+          const run = runIdArg ? runs.find((r) => r.runId === runIdArg) : runs.find((r) => r.script);
+          if (!run?.script) {
+            ctx.ui.notify(runIdArg ? `No run ${runIdArg} with a script` : "No saved run to save", "error");
+            return;
+          }
+          const saved = opts.storage.save({
+            name,
+            description: run.workflowName,
+            script: run.script,
+            location: "project",
+          });
+          registerSavedWorkflow(pi, opts.cwd ?? process.cwd(), saved);
+          ctx.ui.notify(`Saved /${name} (from ${run.runId})`, "info");
+          return;
+        }
         default:
           ctx.ui.notify(`Unknown subcommand "${sub}". ${USAGE}`, "warning");
       }