pi-ultracode 0.1.0

package/README.md

@@ -0,0 +1,225 @@
+# pi-ultracode
+
+> Claude-Code-style **ultracode** for [Pi](https://github.com/earendil-works/pi).
+
+`ultracode` is an effort mode that turns Pi into a relentless, multi-agent
+orchestrator. While it's on, Pi raises its thinking to **xhigh** and treats
+"author and run a workflow" as the **default** for every substantive task —
+decomposing work, fanning it out across isolated subagents, and adversarially
+verifying findings before committing to an answer. Token cost is not the
+constraint; correctness and coverage are.
+
+This single extension implements the full ultracode surface:
+
+| Pillar | What you get |
+| --- | --- |
+| **Ultracode mode** | `/ultracode on` raises thinking to xhigh, keeps the `workflow` tool active, and injects a standing "orchestrate + verify by default" system block on every turn. Survives reload / resume / fork via session entries. Optional token budget. |
+| **The `workflow` tool** | A deterministic JavaScript orchestrator: `agent()`, `parallel()`, `pipeline()`, `phase()`, `log()`, `workflow()` (nesting), `args`, `budget`. Plus per-agent **model overrides**, **custom agent types**, **git-worktree isolation**, a real **token budget**, **resumable runs**, and **script persistence**. |
+| **`/workflows` manager** | List recent and in-flight runs with live progress; inspect or abort runs. |
+
+Inspired by Anthropic's [dynamic workflows in Claude Code](https://claude.com/blog/introducing-dynamic-workflows-in-claude-code),
+and a superset of the `pi-dynamic-workflows` prototype.
+
+## Install
+
+```bash
+pi install npm:pi-ultracode      # or: pi install /path/to/pi-ultracode
+```
+
+> **Conflict note:** pi-ultracode registers a tool named `workflow`, the same name
+> used by `pi-dynamic-workflows`. pi-ultracode is a strict superset, so remove the
+> prototype first: `pi remove npm:pi-dynamic-workflows`.
+
+Then in Pi: `/reload`.
+
+## Usage
+
+### Turn ultracode on
+
+```text
+/ultracode               # TOGGLE on/off
+/ultracode on            # xhigh thinking + default workflow orchestration
+/ultracode on 500k       # also cap the per-session output-token budget at ~500k
+/ultracode budget 1m     # change the budget later
+/ultracode status        # show current mode
+/ultracode off           # restore the previous thinking level
+```
+
+> **Models without `xhigh`:** pi clamps the requested level down to the model's
+> maximum (e.g. glm-5.2 tops out at `high`; non-reasoning models fall to `off`) —
+> it never errors. `/ultracode status` shows the level that actually applied
+> (e.g. `ultracode: on · thinking high`). The **workflow orchestration** half of
+> ultracode doesn't depend on the thinking level at all, so it's unaffected by
+> the model you run.
+
+You can also start a session in ultracode mode with the CLI flag:
+
+```bash
+pi --ultracode
+```
+
+While on, just describe the task. Pi will write a workflow script and call the
+`workflow` tool, with live progress shown inline:
+
+```text
+◆ ▶ audit_repo (4/7 done, 2 running) · 3 cached · 41.2k/500k tok
+  ✓ Survey 1/1
+    #1 ✓ repo inventory
+  ▶ Review 3/4 · 1 running
+    #2 ✓ auth module
+    #3 ✓ db layer
+    #4 ● payments module
+  ▶ Verify 0/2 · 2 running
+```
+
+Press `Esc` to cancel; running subagents are aborted and surfaced as skipped.
+
+### Manage runs
+
+```text
+/workflows               # toggle the run panel above the editor (run again to hide)
+/workflows wf_ab12-3     # show one run's detail
+/workflows clear         # hide the panel
+/workflows abort         # abort all active runs (and hide the panel)
+```
+
+The panel is a static snapshot taken when you run the command, so re-run
+`/workflows` to refresh it, or `/workflows clear` to dismiss it. Live progress
+while a workflow runs is shown inline in the tool result, not in this panel.
+
+## Workflow script shape
+
+A workflow is plain JavaScript whose first statement is a **pure literal**
+`export const meta`:
+
+```js
+export const meta = {
+  name: 'review_changes',
+  description: 'Review changed files across dimensions, verify each finding',
+  phases: [{ title: 'Review' }, { title: 'Verify' }],
+}
+
+const DIMENSIONS = [
+  { key: 'bugs', prompt: 'Find correctness bugs in the diff.' },
+  { key: 'perf', prompt: 'Find performance regressions in the diff.' },
+]
+
+// pipeline: each dimension verifies as soon as its review completes (no barrier).
+const results = await pipeline(
+  DIMENSIONS,
+  (d) => agent(d.prompt, { label: 'review:' + d.key, phase: 'Review', schema: FINDINGS }),
+  (review) => parallel((review.findings ?? []).map((f) => () =>
+    agent('Adversarially verify, default to refuted: ' + f.title,
+      { label: 'verify:' + f.file, phase: 'Verify', agentType: 'code-reviewer', schema: VERDICT })
+      .then((v) => ({ ...f, verdict: v }))
+  )),
+)
+
+const confirmed = results.flat().filter(Boolean).filter((f) => f.verdict?.isReal)
+return { confirmed }
+
+const FINDINGS = { type: 'object', properties: { findings: { type: 'array', items: { type: 'object' } } } }
+const VERDICT = { type: 'object', properties: { isReal: { type: 'boolean' }, why: { type: 'string' } }, required: ['isReal'] }
+```
+
+### Globals
+
+| Global | Description |
+| --- | --- |
+| `agent(prompt, opts)` | Spawn an isolated subagent. Returns its final text, or a validated object when `opts.schema` is set. |
+| `parallel(thunks)` | Run `() => agent(...)` thunks concurrently. **A barrier.** Failures become `null`. |
+| `pipeline(items, ...stages)` | Run each item through stages independently (no barrier). Stages get `(prev, original, index)`. **The default** for multi-stage work. |
+| `workflow(nameOrRef, args)` | Run a saved workflow (by name) or `{ scriptPath }` inline, sharing the run's concurrency cap, agent counter, and budget. One level of nesting. |
+| `phase(title)` | Mark the current progress group. |
+| `log(message)` | Append a workflow-level log line. |
+| `args`, `cwd` | The tool's `args` value; the working directory. |
+| `budget` | `{ total, spent(), remaining() }` — real output-token budget. |
+
+### `agent()` options
+
+| Option | Effect |
+| --- | --- |
+| `label` | Short (2-5 word) name shown in live progress. |
+| `phase` | Assign this agent to a progress group explicitly (use inside `parallel`/`pipeline`). |
+| `schema` | Plain JSON Schema; the subagent returns a validated object via a terminating `structured_output` tool. |
+| `model` | Override the subagent model by pattern, e.g. `'sonnet'` or `'provider/id:high'`. |
+| `agentType` | Use a custom role: built-ins `claude`, `general-purpose`, `Explore`, `Plan`, `code-reviewer`, or your own (below). |
+| `isolation: 'worktree'` | Run the agent in a throwaway git worktree (for parallel file mutation). Changes are applied back to the working tree under a lock; an unchanged worktree is auto-removed. |
+
+### Determinism
+
+Scripts run in a `vm` sandbox. `Date.now()`, `new Date()`, `Math.random()`,
+`require`/`import`, `fs`, and network APIs are unavailable — this keeps `meta`
+parseable and runs **reproducible and resumable**. Pass timestamps via `args`;
+vary randomness by agent index.
+
+## Custom agent types
+
+Drop a Markdown file with frontmatter under
+`.pi/ultracode/agents/<name>.md` (project) or `~/.pi/ultracode/agents/<name>.md`
+(user):
+
+```markdown
+---
+name: security
+description: Security-focused reviewer
+tools: read, grep, find, bash
+model: sonnet
+thinking: high
+---
+You are a security reviewer. Hunt for injection, authz gaps, and unsafe deserialization.
+Cite exact file:line evidence and prefer false negatives over invented findings.
+```
+
+Then `agent('Audit auth.ts', { agentType: 'security' })`.
+
+## Saved & resumable runs
+
+Every run persists its script and a JSONL journal under
+`<sessionDir>/ultracode-runs/<runId>.{workflow.js,jsonl}`. To resume after a
+pause, kill, or script edit, call the tool again with `resumeFromRunId`: the
+longest unchanged prefix of `agent()` calls returns cached results instantly;
+the first changed/new call and everything after it run live.
+
+Save reusable workflows under `.pi/ultracode/workflows/<name>.workflow.js` and
+run them with the tool's `name` parameter or `workflow('<name>')`.
+
+## Library modules
+
+| File | Purpose |
+| --- | --- |
+| `src/prompts.ts` | Ultracode system block + workflow tool guidelines. |
+| `src/mode.ts` | The ultracode mode controller (toggle, thinking, persistence, injection). |
+| `src/commands.ts` | `/ultracode` and `/workflows` commands. |
+| `src/workflow/parser.ts` | AST-validated, deterministic script parser. |
+| `src/workflow/runtime.ts` | The sandboxed runtime (agent/parallel/pipeline/phase/log/workflow/budget). |
+| `src/workflow/agent-runner.ts` | In-memory subagent runner (model, agent type, worktree, usage). |
+| `src/workflow/worktree.ts` | Git worktree isolation. |
+| `src/workflow/agent-types.ts` | Custom agent-type discovery. |
+| `src/workflow/journal.ts` | Run journal + resume. |
+| `src/workflow/registry.ts` | In-process run registry for `/workflows`. |
+| `src/workflow/display.ts` | Live progress snapshots and renderers. |
+| `src/workflow/structured-output.ts` / `json-schema.ts` | Terminating structured output + JSON-Schema → TypeBox. |
+| `src/workflow/tool.ts` | The Pi `workflow` tool. |
+| `extensions/ultracode.ts` | Extension entrypoint. |
+
+## Development
+
+```bash
+npm test          # node --test over the parser, runtime, journal, agent types, mode, and extension
+npm run typecheck # tsc --noEmit (requires a local TypeScript)
+```
+
+The test suite injects a mock subagent runner, so it runs without a model. A
+faithful end-to-end check (real subagents) just calls `runWorkflow` with the
+default runner.
+
+**Dependencies.** The only hard runtime dependency is `acorn`; Pi provides
+`typebox` and `@earendil-works/*` to extensions at load time. When running the
+node test runner directly (which has no Pi loader), link those peers into
+`node_modules/` — e.g. symlink them from your Pi install — alongside the
+real `acorn` that `pi install` / `npm install` provides.
+
+## License
+
+MIT

package/examples/workflows/loop-until-dry-bugs.workflow.js

@@ -0,0 +1,74 @@
+/// <reference types="pi-ultracode/workflow" />
+//
+// Example saved workflow. Copy to `.pi/ultracode/workflows/` and run it with
+// the `workflow` tool's `name` parameter, or call `workflow('loop-until-dry-bugs')`
+// from another workflow.
+//
+// Pattern: loop-until-dry discovery + perspective-diverse adversarial verify.
+// Keeps spawning finders until two consecutive rounds surface nothing new, then
+// confirms each fresh bug with three distinct lenses.
+
+export const meta = {
+  name: 'loop-until-dry-bugs',
+  description: 'Find bugs until the well runs dry, verifying each with three lenses',
+  phases: [{ title: 'Find' }, { title: 'Verify' }],
+}
+
+const FINDERS = [
+  'Find correctness bugs by reading the changed files closely.',
+  'Find bugs by tracing data flow across module boundaries.',
+  'Find bugs by hunting error-handling and edge-case gaps.',
+]
+
+const BUGS = {
+  type: 'object',
+  properties: {
+    bugs: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: { file: { type: 'string' }, line: { type: 'number' }, desc: { type: 'string' } },
+        required: ['file', 'desc'],
+      },
+    },
+  },
+  required: ['bugs'],
+}
+
+const VERDICT = {
+  type: 'object',
+  properties: { real: { type: 'boolean' }, why: { type: 'string' } },
+  required: ['real'],
+}
+
+const seen = new Set()
+const confirmed = []
+let dry = 0
+
+while (dry < 2) {
+  const rounds = await parallel(
+    FINDERS.map((prompt, i) => () => agent(prompt, { label: 'find ' + i, phase: 'Find', schema: BUGS })),
+  )
+  const found = rounds.filter(Boolean).flatMap((r) => r.bugs ?? [])
+  const fresh = found.filter((b) => !seen.has(b.file + ':' + b.desc))
+  if (fresh.length === 0) {
+    dry++
+    continue
+  }
+  dry = 0
+  for (const b of fresh) seen.add(b.file + ':' + b.desc)
+
+  const judged = await parallel(
+    fresh.map((b) => () =>
+      parallel(
+        ['correctness', 'security', 'does-it-reproduce'].map((lens) => () =>
+          agent('Judge via the ' + lens + ' lens — is this real? "' + b.desc + '" (' + b.file + '). Default to real:false if unsure.',
+            { label: 'verify ' + lens, phase: 'Verify', agentType: 'code-reviewer', schema: VERDICT }),
+        ),
+      ).then((votes) => ({ bug: b, real: votes.filter(Boolean).filter((v) => v.real).length >= 2 })),
+    ),
+  )
+  confirmed.push(...judged.filter((j) => j.real).map((j) => j.bug))
+}
+
+return { confirmed, totalSeen: seen.size }

package/extensions/ultracode.ts

@@ -0,0 +1,56 @@
+/**
+ * pi-ultracode extension entrypoint.
+ *
+ * Wires together the three pillars of Claude-Code-style "ultracode":
+ *   1. The ultracode effort mode (xhigh thinking + standing workflow opt-in).
+ *   2. The full `workflow` orchestration tool.
+ *   3. The `/ultracode` and `/workflows` commands.
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createWorkflowTool, type WorkflowToolDeps } from "../src/workflow/tool.ts";
+import { UltracodeMode } from "../src/mode.ts";
+import { registerCommands } from "../src/commands.ts";
+
+export default function extension(pi: ExtensionAPI, extraDeps: Partial<WorkflowToolDeps> = {}): void {
+  const mode = new UltracodeMode("workflow");
+
+  const workflowTool = createWorkflowTool({
+    getDefaultBudget: () => mode.getBudget(),
+    getThinkingLevel: () => mode.getSubagentThinkingLevel(),
+    ...extraDeps,
+  });
+  pi.registerTool(workflowTool);
+
+  registerCommands(pi, mode);
+
+  // Opt-in via CLI flag: `pi --ultracode`.
+  pi.registerFlag("ultracode", {
+    type: "boolean",
+    description: "Start the session in ultracode mode (xhigh thinking + default workflow orchestration).",
+  });
+
+  pi.on("session_start", (_event, ctx) => {
+    // Restore persisted mode state across reload / resume / fork.
+    try {
+      mode.restore(pi, ctx.sessionManager.getEntries() as any);
+    } catch {
+      // ignore
+    }
+    if (!mode.isEnabled() && pi.getFlag?.("ultracode") === true) {
+      mode.enable(pi);
+    }
+    // Always keep the workflow tool available so the model can use it on request.
+    try {
+      const active = pi.getActiveTools();
+      if (!active.includes(workflowTool.name)) pi.setActiveTools([...active, workflowTool.name]);
+    } catch {
+      // ignore
+    }
+    if (ctx.hasUI && mode.isEnabled()) ctx.ui.setStatus("ultracode", mode.statusLine());
+  });
+
+  pi.on("before_agent_start", (event) => {
+    return mode.beforeAgentStart(event);
+  });
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "pi-ultracode",
+  "version": "0.1.0",
+  "description": "Claude-Code-style \"ultracode\" for Pi: an effort mode that defaults to deterministic multi-agent workflow orchestration, with worktree isolation, per-agent model overrides, custom agent types, nested workflows, token budgets, resumable runs, and a /workflows manager.",
+  "type": "module",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "ultracode",
+    "workflow",
+    "workflows",
+    "agents",
+    "subagents",
+    "orchestration"
+  ],
+  "author": "pi-ultracode",
+  "license": "MIT",
+  "files": [
+    "extensions/",
+    "src/",
+    "types/",
+    "examples/",
+    "README.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions/ultracode.ts"
+    ]
+  },
+  "exports": {
+    "./workflow": {
+      "types": "./types/workflow.d.ts"
+    }
+  },
+  "scripts": {
+    "test": "node --experimental-strip-types --test test/*.test.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "acorn": "^8.11.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "peerDependenciesMeta": {
+    "@earendil-works/pi-agent-core": { "optional": true },
+    "@earendil-works/pi-ai": { "optional": true },
+    "@earendil-works/pi-coding-agent": { "optional": true },
+    "@earendil-works/pi-tui": { "optional": true },
+    "typebox": { "optional": true }
+  }
+}

package/src/commands.ts

@@ -0,0 +1,161 @@
+/**
+ * Slash commands: `/ultracode` (mode toggle) and `/workflows` (run manager).
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { parseBudget, type UltracodeMode } from "./mode.ts";
+import { getRegistry } from "./workflow/registry.ts";
+import { renderWorkflowLines } from "./workflow/display.ts";
+
+export function registerCommands(pi: ExtensionAPI, mode: UltracodeMode): void {
+  pi.registerCommand("ultracode", {
+    description: "Toggle ultracode mode (xhigh thinking + default workflow orchestration). Bare /ultracode toggles; subcommands: on|off|status|budget <n>",
+    getArgumentCompletions(prefix: string) {
+      return ["on", "off", "status", "budget"]
+        .filter((s) => s.startsWith(prefix))
+        .map((value) => ({ value, label: value }));
+    },
+    handler: async (args: string, ctx) => {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      const sub = (parts[0] ?? "").toLowerCase();
+
+      // Bare `/ultracode` is a toggle.
+      if (sub === "") {
+        const nowOn = mode.toggle(pi);
+        ctx.ui.notify(nowOn ? `Ultracode on — ${mode.statusLine()}` : "Ultracode off — thinking restored.", "info");
+        ctx.ui.setStatus("ultracode", nowOn ? mode.statusLine() : undefined);
+        return;
+      }
+
+      if (sub === "status") {
+        ctx.ui.notify(mode.statusLine(), "info");
+        return;
+      }
+
+      if (sub === "off") {
+        mode.disable(pi);
+        ctx.ui.notify("Ultracode off — thinking restored, workflow orchestration is opt-in again.", "info");
+        ctx.ui.setStatus("ultracode", undefined);
+        return;
+      }
+
+      if (sub === "budget") {
+        const budget = parts[1] ? parseBudget(parts[1]) : null;
+        mode.setBudget(pi, budget);
+        ctx.ui.notify(
+          budget ? `Ultracode token budget set to ~${budget} output tokens.` : "Ultracode token budget cleared.",
+          "info",
+        );
+        ctx.ui.setStatus("ultracode", mode.statusLine());
+        return;
+      }
+
+      // "on", "on 500k", "500k", "+500k"
+      let budget: number | null | undefined;
+      const budgetToken = sub === "on" ? parts[1] : sub;
+      if (budgetToken) {
+        const parsed = parseBudget(budgetToken);
+        if (parsed) budget = parsed;
+      }
+      mode.enable(pi, budget !== undefined ? { budget } : {});
+      ctx.ui.notify(
+        `Ultracode on — ${mode.statusLine()}${budget ? ` (budget ~${budget} tokens)` : ""}`,
+        "info",
+      );
+      ctx.ui.setStatus("ultracode", mode.statusLine());
+    },
+  });
+
+  // Tracks whether the run panel is currently shown, so bare /workflows toggles it.
+  let panelVisible = false;
+
+  pi.registerCommand("workflows", {
+    description: "Toggle the workflow-run panel. Usage: /workflows [runId | clear | abort]",
+    getArgumentCompletions(prefix: string) {
+      return ["clear", "abort"]
+        .filter((s) => s.startsWith(prefix))
+        .map((value) => ({ value, label: value }));
+    },
+    handler: async (args: string, ctx) => {
+      const registry = getRegistry();
+      const arg = args.trim();
+      const sub = arg.toLowerCase();
+
+      const hide = () => {
+        ctx.ui.setWidget("ultracode-workflows", undefined);
+        panelVisible = false;
+      };
+      const show = (lines: string[]) => {
+        ctx.ui.setWidget("ultracode-workflows", lines);
+        panelVisible = true;
+      };
+
+      if (sub === "clear" || sub === "hide" || sub === "off") {
+        hide();
+        ctx.ui.notify("Workflow panel hidden.", "info");
+        return;
+      }
+
+      if (sub === "abort") {
+        registry.abortAll();
+        hide();
+        ctx.ui.notify("Requested abort of all active workflow runs; panel hidden.", "info");
+        return;
+      }
+
+      const runs = registry.list();
+
+      // Explicit run id -> show that run's detail.
+      if (arg) {
+        const handle = registry.get(arg) ?? runs.find((r) => r.snapshot.runId?.startsWith(arg));
+        if (!handle) {
+          ctx.ui.notify(`No workflow run matching "${arg}". /workflows to list, /workflows clear to hide.`, "warning");
+          return;
+        }
+        show(renderWorkflowLines(handle.snapshot, { maxAgents: 12, maxLogs: 6, showResultPreviews: true, showStream: true }));
+        ctx.ui.notify(`Showing ${handle.snapshot.runId ?? "run"}. /workflows clear to hide.`, "info");
+        return;
+      }
+
+      // Bare /workflows toggles the panel off if it's already up.
+      if (panelVisible) {
+        hide();
+        ctx.ui.notify("Workflow panel hidden.", "info");
+        return;
+      }
+
+      if (runs.length === 0) {
+        hide();
+        ctx.ui.notify("No workflow runs in this session yet.", "info");
+        return;
+      }
+
+      const summary = runs.map((handle) => {
+        const s = handle.snapshot;
+        return `${statusGlyph(s.status)} ${s.runId}  ${s.name}  ${s.doneCount}/${s.agentCount}${
+          s.runningCount ? ` (${s.runningCount} running)` : ""
+        }`;
+      });
+      show(["◆ Ultracode workflow runs  ·  /workflows clear to hide", ...summary.map((l) => `  ${l}`)]);
+      ctx.ui.notify(
+        `${runs.length} run(s), ${registry.active().length} active. /workflows again (or /workflows clear) to hide.`,
+        "info",
+      );
+    },
+  });
+}
+
+function statusGlyph(status: string): string {
+  switch (status) {
+    case "completed":
+      return "✓";
+    case "running":
+      return "▶";
+    case "aborted":
+      return "■";
+    case "failed":
+      return "✗";
+    default:
+      return "·";
+  }
+}

package/src/index.ts

@@ -0,0 +1,55 @@
+/** Public API of pi-ultracode, for reuse and testing. */
+
+export { default } from "../extensions/ultracode.ts";
+export { UltracodeMode, parseBudget, MODE_ENTRY_TYPE } from "./mode.ts";
+export { registerCommands } from "./commands.ts";
+export {
+  ULTRACODE_TAGLINE,
+  ULTRACODE_ACTIVE_REMINDER,
+  ultracodeSystemBlock,
+  WORKFLOW_GUIDELINES,
+  WORKFLOW_PROMPT_SNIPPET,
+  WORKFLOW_TOOL_DESCRIPTION,
+} from "./prompts.ts";
+
+export { createWorkflowTool, type WorkflowToolDeps } from "./workflow/tool.ts";
+export { runWorkflow, type WorkflowRunOptions, type WorkflowRunResult } from "./workflow/runtime.ts";
+export { parseWorkflowScript, normalizeScript, type WorkflowMeta, type WorkflowMetaPhase } from "./workflow/parser.ts";
+export { jsonSchemaToTypeBox } from "./workflow/json-schema.ts";
+export {
+  WorkflowAgentRunner,
+  resolveModelSelection,
+  matchModelIn,
+  type AgentRunCall,
+  type AgentRunResult,
+  type ThinkingLevel,
+  type ModelLike,
+  type ModelRegistryLike,
+} from "./workflow/agent-runner.ts";
+export { createStructuredOutputTool, type StructuredOutputCapture } from "./workflow/structured-output.ts";
+export {
+  discoverAgentTypes,
+  resolveAgentType,
+  parseFrontmatter,
+  parseAgentTypeFile,
+  type AgentTypeDef,
+} from "./workflow/agent-types.ts";
+export { RunJournal, agentCallKey, hashString, stableStringify } from "./workflow/journal.ts";
+export { getRegistry, WorkflowRegistry } from "./workflow/registry.ts";
+export {
+  createSnapshot,
+  recompute,
+  renderWorkflowLines,
+  renderWorkflowText,
+  preview,
+  type WorkflowSnapshot,
+} from "./workflow/display.ts";
+export {
+  createWorktree,
+  captureWorktreeDiff,
+  removeWorktree,
+  applyPatch,
+  writeRescuePatch,
+  isGitRepo,
+  type Worktree,
+} from "./workflow/worktree.ts";