@quintinshaw/pi-dynamic-workflows 1.6.0 → 1.7.0

package/README.md

@@ -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

@@ -3,6 +3,7 @@
  * Shares the extension's single WorkflowManager so background runs are reachable.
  */
 import { 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> | 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;
@@ -34,7 +35,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)
@@ -103,6 +104,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.0",
   "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

@@ -6,7 +6,9 @@
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import { renderWorkflowText } 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> | stop <id> | pause <id> | resume <id> | rm <id> | save <name> [runId]";
 
 function summarizeRun(run: PersistedRunState): string {
   const icon = STATUS_ICON[run.status] ?? "?";
@@ -40,8 +43,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;
@@ -109,6 +123,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");
       }