@op1/threads 0.1.8 → 0.2.0

package/src/workflow-saved.ts

@@ -0,0 +1,88 @@
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { z } from "zod";
+import { parseWorkflow } from "./workflow-runtime";
+
+const Name = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,79}$/)
+  .refine((name) => name !== "run" && name !== "refresh", "This name is reserved for a workflow command");
+export const SavedWorkflow = z.object({
+  name: Name,
+  description: z.string(),
+  path: z.string(),
+  scope: z.enum(["project", "user"]),
+});
+
+async function present(path: string) {
+  return lstat(path).catch((error: unknown) => {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") return undefined;
+    throw error;
+  });
+}
+
+export function savedWorkflows(directory: string, canonical: string) {
+  const user = join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "opencode", "workflows");
+  const project = join(directory, ".opencode", "workflows");
+  const roots = [
+    { directory: project, scope: "project" as const },
+    ...(resolve(canonical) === resolve(directory) ? [] : [{ directory: join(canonical, ".opencode", "workflows"), scope: "project" as const }]),
+    { directory: user, scope: "user" as const },
+  ];
+  return {
+    async list() {
+      const found = new Map<string, z.infer<typeof SavedWorkflow>>();
+      for (const root of roots) {
+        if (!await present(root.directory)) continue;
+        for (const file of await readdir(root.directory)) {
+          if (!file.endsWith(".js")) continue;
+          const name = file.slice(0, -3);
+          if (!Name.safeParse(name).success || found.has(name)) continue;
+          const path = join(root.directory, file);
+          const info = await present(path);
+          if (!info?.isFile() || info.isSymbolicLink()) continue;
+          const script = await readFile(path, "utf8");
+          let description: string;
+          try {
+            description = parseWorkflow(script).meta.description;
+          } catch (error) {
+            description = `Invalid workflow: ${String(error)}`;
+          }
+          found.set(name, { name, description, path, scope: root.scope });
+        }
+      }
+      return [...found.values()];
+    },
+    async load(name: string) {
+      Name.parse(name);
+      const item = (await this.list()).find((item) => item.name === name);
+      if (!item) throw new Error(`Saved workflow "${name}" not found`);
+      const file = await open(item.path, constants.O_RDONLY | constants.O_NOFOLLOW);
+      try {
+        return await file.readFile("utf8");
+      } finally {
+        await file.close();
+      }
+    },
+    async save(name: string, script: string, scope: "project" | "user") {
+      Name.parse(name);
+      parseWorkflow(script);
+      const root = scope === "project" ? project : user;
+      if (scope === "project") {
+        for (const path of [dirname(root), root]) {
+          if ((await present(path))?.isSymbolicLink()) throw new Error(`Cannot save workflows through symlink: ${path}`);
+        }
+      }
+      await mkdir(root, { recursive: true, mode: 0o700 });
+      const path = join(root, `${name}.js`);
+      const file = await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+      try {
+        await file.writeFile(script, "utf8");
+        await file.sync();
+      } finally {
+        await file.close();
+      }
+      return { path };
+    },
+  };
+}

package/src/workflow-store.ts

@@ -0,0 +1,103 @@
+import { createHash } from "node:crypto";
+import type { Plugin } from "@opencode/plugin";
+import { serialized } from "./threads";
+import { Json, WORKFLOW_CONTROL_HEADROOM, WORKFLOW_DIAGNOSTIC_JSON_BYTES, WORKFLOW_SETTLEMENT_DIAGNOSTIC_JSON_BYTES, WorkflowRun } from "./workflow-types";
+
+export function workflowHash(value: unknown): string {
+  const json = Json.parse(value);
+  const canonical = (item: Json): string => {
+    if (Array.isArray(item)) return `[${item.map(canonical).join(",")}]`;
+    if (item !== null && typeof item === "object") {
+      return `{${Object.keys(item).sort().map((key) => `${JSON.stringify(key)}:${canonical(item[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(item);
+  };
+  return createHash("sha256").update(canonical(json)).digest("hex");
+}
+
+export function workflowStore(storage: Plugin.Context["storage"], options: {
+  onDiagnostic?: (issue: { id: string; ownerID: string; message: string }) => Promise<void>;
+} = {}) {
+  const journalLimit = 16 * 1024 * 1024;
+  const controlHeadroom = (run: WorkflowRun) => {
+    const settled = new Set(run.settlements?.filter((item) => item.kind === "agent").map((item) => item.key));
+    const pending = run.steps.reduce((bytes, step) => {
+      if (step.status === "completed") return bytes;
+      const settlementBytes = settled.has(step.key) ? 0
+        : Buffer.byteLength(JSON.stringify({ kind: "agent", key: step.key, outcome: "failure", error: "" }), "utf8")
+          + WORKFLOW_SETTLEMENT_DIAGNOSTIC_JSON_BYTES + 1;
+      return bytes + settlementBytes + (step.status === "failed" ? 0 : WORKFLOW_DIAGNOSTIC_JSON_BYTES + 256);
+    }, 0);
+    return Math.max(WORKFLOW_CONTROL_HEADROOM, WORKFLOW_DIAGNOSTIC_JSON_BYTES + 256 + pending);
+  };
+  const key = (id: string) => `workflows/runs/${id}`;
+  async function persist(run: WorkflowRun, kind: "payload" | "control") {
+    const value = structuredClone(Json.parse(run)) as Record<string, Json>;
+    const limits = value.limits as Record<string, Json>;
+    if (limits.concurrency === 3) delete limits.concurrency;
+    if (limits.maxAgents === 4) delete limits.maxAgents;
+    if (limits.agentTimeoutMs === 1_800_000) delete limits.agentTimeoutMs;
+    if (limits.timeoutMs === 86_400_000) delete limits.timeoutMs;
+    const limit = journalLimit - (kind === "payload" ? controlHeadroom(run) : 0);
+    if (Buffer.byteLength(JSON.stringify(value), "utf8") > limit) {
+      if (kind === "payload") {
+        throw new Error("Workflow payload exceeds 16 MiB journal capacity after required control headroom is reserved");
+      }
+      throw new Error("Workflow control update exceeds the 16 MiB journal hard limit and cannot be persisted without discarding durable data");
+    }
+    await storage.set(key(run.id), value);
+  }
+  async function get(id: string) {
+    const raw = await storage.get(key(id));
+    if (raw === undefined) throw new Error(`Workflow ${id} not found`);
+    const parsed = WorkflowRun.safeParse(raw);
+    if (!parsed.success) {
+      throw new Error(`Workflow ${id} has a corrupt or unsupported journal record; its raw data was preserved at ${key(id)}: ${parsed.error.issues[0]?.message ?? "validation failed"}. Inspect the retained record or start a new workflow run key.`);
+    }
+    return parsed.data;
+  }
+  return {
+    get,
+    async create(run: WorkflowRun) {
+      return serialized(`workflow-store:${run.id}`, async () => {
+        const existing = await storage.get(key(run.id));
+        if (existing !== undefined) {
+          const previous = await get(run.id);
+          if (previous.fingerprint !== run.fingerprint) throw new Error("This workflow key belongs to a different request");
+          return previous;
+        }
+        await persist(run, "payload");
+        return run;
+      });
+    },
+    async update(id: string, update: (run: WorkflowRun) => void, kind: "payload" | "control" = "payload") {
+      return serialized(`workflow-store:${id}`, async () => {
+        const run = await get(id);
+        update(run);
+        run.updated = Date.now();
+        const next = WorkflowRun.parse(run);
+        await persist(next, kind);
+        return next;
+      });
+    },
+    async list(ownerID: string) {
+      const runs: WorkflowRun[] = [];
+      let after: string | undefined;
+      do {
+        const page = await storage.scan({ prefix: "workflows/runs/", after, limit: 100 });
+        for (const entry of page.entries) {
+          const raw = entry.value;
+          if (typeof raw !== "object" || raw === null || !("ownerID" in raw) || raw.ownerID !== ownerID) continue;
+          const parsed = WorkflowRun.safeParse(raw);
+          if (parsed.success) runs.push(parsed.data);
+          else await options.onDiagnostic?.({
+            id: entry.key.slice("workflows/runs/".length), ownerID,
+            message: `Corrupt or unsupported journal record: ${parsed.error.issues[0]?.message ?? "validation failed"}`,
+          }).catch(() => undefined);
+        }
+        after = page.next;
+      } while (after);
+      return runs.sort((a, b) => b.created - a.created);
+    },
+  };
+}

package/src/workflow-types.ts

@@ -0,0 +1,144 @@
+import { z } from "zod";
+import { Report } from "./rpc";
+
+export const WORKFLOW_DIAGNOSTIC_JSON_BYTES = 4_096;
+export const WORKFLOW_SETTLEMENT_DIAGNOSTIC_JSON_BYTES = 512;
+export const WORKFLOW_CONTROL_HEADROOM = 64 * 1024;
+
+export const Json = z.json();
+export type Json = z.infer<typeof Json>;
+export const WorkflowModel = z.object({
+  providerID: z.string(),
+  id: z.string(),
+  variant: z.string().optional(),
+});
+export const WorkflowLimits = z.object({
+  concurrency: z.number().int().min(1).max(8).default(3),
+  maxAgents: z.number().int().min(1).max(1000).default(4),
+  agentTimeoutMs: z.number().int().min(1000).max(604800000).default(1800000),
+  timeoutMs: z.number().int().min(1000).max(604800000).default(86400000),
+  tokenBudget: z.number().int().positive().optional(),
+});
+export const WorkflowStart = WorkflowLimits.extend({
+  key: z.string().min(1).max(120),
+  script: z.string().min(1).max(200000).optional(),
+  name: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,79}$/).optional(),
+  args: Json.default(null),
+}).strict().refine((value) => Boolean(value.script) !== Boolean(value.name), {
+  message: "Supply exactly one of script or saved workflow name",
+});
+export type WorkflowStart = z.infer<typeof WorkflowStart>;
+
+export const WorkflowAgentInput = z.object({
+  key: z.string().min(1).max(120),
+  prompt: z.string().min(1).max(100000),
+  agent: z.string().min(1),
+  label: z.string().min(1).max(160).optional(),
+  phase: z.string().min(1).max(160).optional(),
+  schema: z.record(z.string(), Json).optional(),
+  access: z.enum(["read", "write"]).default("read"),
+  isolation: z.enum(["shared", "worktree"]).default("shared"),
+  directory: z.string().min(1).optional(),
+  timeoutMs: z.number().int().min(1000).max(604800000).optional(),
+}).strict();
+export type WorkflowAgentInput = z.infer<typeof WorkflowAgentInput>;
+export const WorkflowResult = Report.extend({ result: Json }).strict();
+export type WorkflowResult = z.infer<typeof WorkflowResult>;
+export const WorkflowUsage = z.object({
+  tokens: z.number().nonnegative(),
+  cost: z.number().nonnegative(),
+  measured: z.boolean(),
+});
+
+const StepBase = z.object({
+  key: z.string(),
+  fingerprint: z.string(),
+  index: z.number().int().nonnegative(),
+  input: WorkflowAgentInput,
+  workerID: z.string(),
+  spawnKey: z.string(),
+  created: z.number(),
+  phase: z.string(),
+  directory: z.string(),
+  model: WorkflowModel,
+  profileFingerprint: z.string(),
+});
+export const WorkflowStep = z.discriminatedUnion("status", [
+  StepBase.extend({ status: z.literal("prepared") }),
+  StepBase.extend({ status: z.literal("running"), usage: WorkflowUsage.optional() }),
+  StepBase.extend({
+    status: z.literal("completed"),
+    completed: z.number(),
+    report: WorkflowResult,
+    usage: WorkflowUsage,
+  }),
+  StepBase.extend({
+    status: z.literal("failed"),
+    error: z.string(),
+    retryable: z.boolean(),
+    usage: WorkflowUsage.optional(),
+  }),
+]);
+export type WorkflowStep = z.infer<typeof WorkflowStep>;
+export const WorkflowCheckpoint = z.object({
+  key: z.string(),
+  prompt: z.string(),
+  response: Json.optional(),
+});
+export const WorkflowSettlement = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("agent"), key: z.string(), outcome: z.enum(["success", "failure"]), error: z.string().optional() }),
+  z.object({ kind: z.literal("checkpoint"), key: z.string(), response: Json }),
+]);
+export type WorkflowSettlement = z.infer<typeof WorkflowSettlement>;
+export const WorkflowRun = z.object({
+  version: z.literal(1),
+  id: z.string(),
+  key: z.string(),
+  ownerID: z.string(),
+  callerAgent: z.string(),
+  model: WorkflowModel,
+  projectID: z.string(),
+  directory: z.string(),
+  name: z.string(),
+  description: z.string(),
+  script: z.string(),
+  args: Json,
+  fingerprint: z.string(),
+  limits: WorkflowLimits,
+  status: z.enum(["running", "pausing", "paused", "stopping", "stopped", "waiting", "interrupted", "failed", "completed"]),
+  created: z.number(),
+  updated: z.number(),
+  phase: z.string(),
+  steps: z.array(WorkflowStep),
+  logs: z.array(z.object({ time: z.number(), text: z.string() })),
+  checkpoints: z.array(WorkflowCheckpoint),
+  settlements: z.array(WorkflowSettlement).optional(),
+  result: Json.optional(),
+  error: z.string().optional(),
+  deliveryID: z.string(),
+  delivered: z.boolean(),
+});
+export type WorkflowRun = z.infer<typeof WorkflowRun>;
+export const WorkflowSummary = WorkflowRun.omit({ script: true, args: true, result: true, steps: true, logs: true, checkpoints: true, settlements: true, fingerprint: true, callerAgent: true, deliveryID: true, delivered: true }).extend({
+  counts: z.object({ completed: z.number(), running: z.number(), failed: z.number(), total: z.number() }),
+  usage: WorkflowUsage,
+});
+export type WorkflowSummary = z.infer<typeof WorkflowSummary>;
+export function workflowSummary(run: WorkflowRun): WorkflowSummary {
+  const completed = run.steps.filter((step) => step.status === "completed");
+  const accounted = run.steps.flatMap((step) => "usage" in step && step.usage !== undefined ? [step.usage] : []);
+  return WorkflowSummary.parse({
+    ...run,
+    counts: {
+      completed: completed.length,
+      running: run.steps.filter((step) => step.status === "running" || step.status === "prepared").length,
+      failed: run.steps.filter((step) => step.status === "failed").length,
+      total: run.steps.length,
+    },
+    usage: {
+      tokens: accounted.reduce((total, item) => total + item.tokens, 0),
+      cost: accounted.reduce((total, item) => total + item.cost, 0),
+      measured: run.steps.length > 0 && run.steps.every((step) => step.status === "prepared" || ("usage" in step && step.usage?.measured === true)),
+    },
+  });
+}

package/src/workflow-ui.tsx

@@ -0,0 +1,251 @@
+import type { Plugin } from "@opencode/plugin/tui";
+import { createEffect, createSignal, For, Show } from "solid-js";
+import type { Accessor } from "solid-js";
+import { WorkflowsRpc } from "./workflow-rpc";
+import { Json } from "./workflow-types";
+import type { WorkflowRun, WorkflowSummary } from "./workflow-types";
+
+export function workflowUI(ctx: Plugin.Context) {
+  const rpc = ctx.client.rpc(WorkflowsRpc);
+  const [runs, setRuns] = createSignal<WorkflowSummary[]>([]);
+  const [selected, setSelected] = createSignal<WorkflowRun>();
+  const [stepIndex, setStepIndex] = createSignal(0);
+  const [error, setError] = createSignal("");
+  const abort = new AbortController();
+  let owner = "";
+  let ownerGeneration = 0;
+  let refreshInFlight: Promise<RefreshResult | undefined> | undefined;
+  type OwnerContext = { ownerID: string; generation: number };
+  type RefreshResult = { context: OwnerContext; runs: WorkflowSummary[] };
+  const location = () => ctx.location ?? ctx.data.location.default();
+  function ownerID() {
+    const route = ctx.ui.router.current();
+    if (route.type !== "session") return undefined;
+    const session = ctx.data.session.get(route.sessionID);
+    const link = session?.metadata?.opThreads;
+    return link && typeof link === "object" && "coordinatorID" in link && typeof link.coordinatorID === "string"
+      ? link.coordinatorID
+      : route.sessionID;
+  }
+  function synchronizeOwner(): OwnerContext | undefined {
+    const current = ownerID() ?? "";
+    if (current !== owner) {
+      owner = current;
+      ownerGeneration += 1;
+      setRuns([]);
+      setSelected(undefined);
+    }
+    return current ? { ownerID: current, generation: ownerGeneration } : undefined;
+  }
+  function isCurrent(context: OwnerContext) {
+    const current = synchronizeOwner();
+    return !!current && current.ownerID === context.ownerID && current.generation === context.generation && !abort.signal.aborted;
+  }
+  function requestRefresh(context: OwnerContext) {
+    let request!: Promise<RefreshResult | undefined>;
+    request = (async () => {
+      try {
+        const snapshot = await rpc.snapshot({ ownerID: context.ownerID }, { location: location(), signal: abort.signal });
+        if (!isCurrent(context)) return;
+        setRuns(snapshot.runs);
+        const id = selected()?.id;
+        if (id) {
+          const run = await rpc.inspect({ ownerID: context.ownerID, runID: id }, { location: location(), signal: abort.signal });
+          if (!isCurrent(context)) return;
+          if (selected()?.id === id) setSelected(run);
+        }
+        setError("");
+        return { context, runs: snapshot.runs };
+      } catch (cause) {
+        if (isCurrent(context)) setError(String(cause));
+      } finally {
+        if (refreshInFlight === request) refreshInFlight = undefined;
+      }
+    })();
+    refreshInFlight = request;
+    return request;
+  }
+  function refreshInBackground() {
+    const context = synchronizeOwner();
+    if (!context || refreshInFlight || abort.signal.aborted) return;
+    void requestRefresh(context);
+  }
+  async function refreshFresh() {
+    synchronizeOwner();
+    while (refreshInFlight) await refreshInFlight;
+    const context = synchronizeOwner();
+    if (!context || abort.signal.aborted) return;
+    return requestRefresh(context);
+  }
+  async function openRun(id: string, expected = synchronizeOwner()) {
+    if (!expected || !isCurrent(expected)) return;
+    try {
+      const run = await rpc.inspect({ ownerID: expected.ownerID, runID: id }, { location: location(), signal: abort.signal });
+      if (!isCurrent(expected)) return;
+      setSelected(run);
+      setStepIndex(0);
+      ctx.ui.panel.open("threads.workflows");
+    } catch (cause) {
+      ctx.ui.toast.show({ message: String(cause), variant: "error" });
+    }
+  }
+  async function choose() {
+    const fresh = await refreshFresh();
+    if (!fresh || !isCurrent(fresh.context)) return;
+    if (!fresh.runs.length) {
+      ctx.ui.toast.show({ message: "No workflows yet. Use /workflow-run to describe a task.", variant: "info" });
+      return;
+    }
+    const id = await ctx.ui.dialog.select({
+      title: "Dynamic workflows",
+      options: fresh.runs.map((run) => ({
+        title: `${run.name} · ${run.status}`,
+        description: `${run.counts.completed}/${run.counts.total} recorded steps · ${run.phase || "starting"} · ${run.usage.measured ? "" : "≥"}${run.usage.tokens} tokens`,
+        value: run.id,
+      })),
+    });
+    if (id && fresh.runs.some((run) => run.id === id) && isCurrent(fresh.context)) await openRun(id, fresh.context);
+  }
+  function canControl(action: "pause" | "resume" | "stop") {
+    const run = selected();
+    const status = run?.status;
+    if (!status || run.ownerID !== ownerID()) return false;
+    if (action === "pause") return status === "running";
+    if (action === "resume") return status === "paused" || status === "interrupted" || status === "waiting";
+    return status === "running" || status === "pausing" || status === "paused" || status === "interrupted" || status === "waiting";
+  }
+  async function control(action: "pause" | "resume" | "stop") {
+    const run = selected();
+    const context = synchronizeOwner();
+    if (!run || !context || run.ownerID !== context.ownerID || !canControl(action)) return;
+    try {
+      const checkpoint = run.checkpoints.find((item) => item.response === undefined);
+      let answer: Json | undefined;
+      if (action === "resume" && checkpoint) {
+        const text = await ctx.ui.dialog.prompt({ title: checkpoint.prompt, placeholder: "JSON response, for example true or a quoted string" });
+        if (text === undefined) return;
+        if (!isCurrent(context) || selected()?.id !== run.id) return;
+        answer = Json.parse(JSON.parse(text));
+      }
+      const result = await rpc.control({
+        ownerID: run.ownerID,
+        runID: run.id,
+        action,
+        ...(checkpoint && action === "resume" ? { checkpointKey: checkpoint.key, response: answer } : {}),
+      }, { location: location(), signal: abort.signal });
+      if (!isCurrent(context) || selected()?.id !== run.id) return;
+      setSelected(result);
+      await refreshFresh();
+    } catch (cause) {
+      ctx.ui.toast.show({ message: String(cause), variant: "error" });
+    }
+  }
+  async function save() {
+    const run = selected();
+    if (!run) return;
+    const name = await ctx.ui.dialog.prompt({ title: "Save workflow", placeholder: run.name });
+    if (!name) return;
+    const scope = await ctx.ui.dialog.select({ title: "Save location", options: [
+      { title: "Project", value: "project" as const },
+      { title: "User", value: "user" as const },
+    ] });
+    if (!scope) return;
+    try {
+      const output = await rpc.save({ ownerID: run.ownerID, runID: run.id, name, scope }, { location: location(), signal: abort.signal });
+      ctx.ui.toast.show({ message: `Saved ${ctx.ui.format.path(output.path)}`, variant: "success" });
+    } catch (cause) {
+      ctx.ui.toast.show({ message: String(cause), variant: "error" });
+    }
+  }
+  const removePanel = ctx.ui.slot({
+    append: "session.panel",
+    render: (panel) => {
+      const moveStep = (delta: number) => {
+        const length = selected()?.steps.length ?? 0;
+        if (length) setStepIndex((index) => (index + delta + length) % length);
+      };
+      const openStep = () => {
+        const step = selected()?.steps[stepIndex()];
+        if (!step || step.status === "prepared") return;
+        panel.close();
+        ctx.ui.router.navigate({ type: "session", sessionID: step.workerID });
+      };
+      ctx.keymap.layer(() => ({ commands: panel.name === "threads.workflows" ? [
+        { id: "workflows.pause", bind: "p", title: "Pause workflow", enabled: () => canControl("pause"), run: () => control("pause") },
+        { id: "workflows.resume", bind: "r", title: "Resume workflow", enabled: () => canControl("resume"), run: () => control("resume") },
+        { id: "workflows.stop", bind: "x", title: "Stop workflow", enabled: () => canControl("stop"), run: () => control("stop") },
+        { id: "workflows.save", bind: "s", title: "Save workflow", run: save },
+        { id: "workflows.previous-step", bind: "up", title: "Previous workflow step", run: () => moveStep(-1) },
+        { id: "workflows.next-step", bind: "down", title: "Next workflow step", run: () => moveStep(1) },
+        { id: "workflows.open-step", bind: "return", title: "Open workflow worker", run: openStep },
+        { id: "workflows.fullscreen", bind: "f", title: "Toggle workflow fullscreen", run: panel.toggleFullscreen },
+        { id: "workflows.close", bind: "escape", run: panel.close },
+      ] : [] }));
+      return <Show when={panel.name === "threads.workflows"}>
+        <scrollbox flexGrow={1} padding={1}>
+          <text><b>Dynamic workflows</b></text>
+          <Show when={selected()}>{(run: Accessor<WorkflowRun>) => <box flexDirection="column" gap={1}>
+            <text><b>{run().name}</b>{` · ${run().status}`}</text>
+            <text>{run().description}</text>
+            <text>{`Run: ${run().id}`}</text>
+            <text>{`Phase: ${run().phase || "starting"}`}</text>
+            <text>{[
+              ...(canControl("pause") ? ["p pause"] : []),
+              ...(canControl("resume") ? ["r resume"] : []),
+              ...(canControl("stop") ? ["x stop"] : []),
+              "s save", "f fullscreen", "Esc close",
+            ].join(" · ")}</text>
+            <Show when={run().steps.length > 0}><text>↑/↓ select step · Enter open worker</text></Show>
+            <Show when={run().error}><text>{`Error: ${run().error}`}</text></Show>
+            <For each={run().steps}>{(step, index) => <box flexDirection="column" border={true} padding={1} onMouseUp={() => { setStepIndex(index()); openStep(); }}>
+              <text>{index() === stepIndex() ? "› " : "  "}<b>{step.input.label ?? step.key}</b>{` · ${step.status}`}</text>
+              <text>{`${step.phase} · ${step.input.agent} · ${step.model.providerID}/${step.model.id}`}</text>
+              <text>{ctx.ui.format.path(step.directory)}</text>
+              <Show when={step.status === "completed" && step}>{(done: Accessor<Extract<WorkflowRun["steps"][number], { status: "completed" }>>) => <>
+                <text>{`${done().report.verdict}: ${done().report.summary}`}</text>
+                <text>{`${done().usage.measured ? "" : "unmeasured · "}${done().usage.tokens} tokens · $${done().usage.cost.toFixed(4)}`}</text>
+                <For each={done().report.evidence}>{(evidence) => <text>{evidence}</text>}</For>
+              </>}</Show>
+              <Show when={step.status === "failed" && step}>{(failed: Accessor<Extract<WorkflowRun["steps"][number], { status: "failed" }>>) => <text>{failed().error}</text>}</Show>
+              <text>{step.status === "prepared" ? "Waiting for worker admission" : "Click or select and press Enter to open worker"}</text>
+            </box>}</For>
+            <For each={run().checkpoints}>{(checkpoint) => <text>{`${checkpoint.response === undefined ? "Waiting" : "Answered"}: ${checkpoint.prompt}`}</text>}</For>
+            <For each={run().logs.slice(-30)}>{(entry) => <text>{entry.text}</text>}</For>
+            <Show when={run().result !== undefined}><text>{`Result:\n${JSON.stringify(run().result, null, 2)}`}</text></Show>
+          </box>}</Show>
+          <Show when={error()}><text>{error()}</text></Show>
+        </scrollbox>
+      </Show>;
+    },
+  });
+  const removeFooter = ctx.ui.slot({
+    append: "session.composer.top",
+    render: () => {
+      createEffect(() => { ownerID(); refreshInBackground(); });
+      return <Show when={runs().find((run) => ["running", "pausing", "waiting"].includes(run.status))}>{(run: Accessor<WorkflowSummary>) =>
+        <box onMouseUp={() => void openRun(run().id)}><text>{`Workflow ${run().name}: ${run().status} · ${run().counts.completed}/${run().counts.total} recorded steps · /workflows`}</text></box>
+      }</Show>;
+    },
+  });
+  const removeCommands = ctx.ui.slot({
+    append: "app",
+    render: () => {
+      ctx.keymap.layer(() => ({ mode: "global", commands: [{
+        id: "workflows.open", title: "Open dynamic workflows", palette: true, slash: { name: "workflows" }, run: choose,
+      }] }));
+      return null;
+    },
+  });
+  const stopEvents = ctx.data.listen(({ details }) => {
+    if (details.type.startsWith("session.") || details.type.startsWith("rpc.workflows.")) refreshInBackground();
+  });
+  const timer = setInterval(refreshInBackground, 3000);
+  return () => {
+    abort.abort();
+    clearInterval(timer);
+    stopEvents();
+    removePanel();
+    removeFooter();
+    removeCommands();
+  };
+}