@vellumai/assistant 0.8.12 → 0.9.0-staging.2

package/src/workflows/run-manager.test.ts

@@ -0,0 +1,711 @@
+import { describe, expect, mock, test } from "bun:test";
+
+// Silence the logger.
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import type { AssistantConfig } from "../config/schema.js";
+import type { TrustContext } from "../daemon/trust-context.js";
+import type { ExecuteWorkflowOptions } from "./engine.js";
+import { WorkflowNotFoundError } from "./engine.js";
+import type {
+  CreateRunInput,
+  WorkflowRun,
+  WorkflowRunStatus,
+} from "./journal-store.js";
+import {
+  WorkflowResumeNotPossibleError,
+  WorkflowRunCapError,
+  WorkflowRunManager,
+  type WorkflowRunManagerDeps,
+  WorkflowsDisabledError,
+} from "./run-manager.js";
+
+const TRUST: TrustContext = {
+  sourceChannel: "vellum",
+  trustClass: "guardian",
+};
+
+/** Minimal config exposing only the fields the manager reads. */
+function makeConfig(maxConcurrentRuns = 3): AssistantConfig {
+  return {
+    workflows: {
+      maxAgentsPerRun: 500,
+      maxConcurrentLeaves: 6,
+      maxConcurrentRuns,
+      journalRetentionDays: 30,
+    },
+  } as unknown as AssistantConfig;
+}
+
+/**
+ * In-memory journal store standing in for `./journal-store.js`. Implements only
+ * the surface the manager touches (`createRun`, `getRun`, `listRuns`) plus the
+ * engine's surface (unused here since we also fake the engine).
+ */
+function makeFakeJournal() {
+  const rows = new Map<string, WorkflowRun>();
+  const setStats = (id: string, patch: Partial<WorkflowRun>): void => {
+    const existing = rows.get(id);
+    if (existing) rows.set(id, { ...existing, ...patch });
+  };
+  return {
+    rows,
+    setStats,
+    journal: {
+      createRun: (input: CreateRunInput): WorkflowRun => {
+        const run: WorkflowRun = {
+          id: input.id,
+          name: input.name ?? null,
+          scriptSource: input.scriptSource,
+          scriptHash: input.scriptHash,
+          args: input.args ?? null,
+          capabilities: input.capabilities ?? null,
+          status: input.status ?? "running",
+          conversationId: input.conversationId ?? null,
+          trust: input.trust ?? null,
+          agentsSpawned: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          result: null,
+          error: null,
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+          finishedAt: null,
+        };
+        rows.set(input.id, run);
+        return run;
+      },
+      getRun: (id: string): WorkflowRun | null => rows.get(id) ?? null,
+      updateRun: (
+        id: string,
+        patch: Partial<WorkflowRun>,
+      ): WorkflowRun | null => {
+        const existing = rows.get(id);
+        if (!existing) return null;
+        const updated = { ...existing, ...patch, updatedAt: Date.now() };
+        rows.set(id, updated);
+        return updated;
+      },
+      markRunningAsInterrupted: (): number => {
+        let n = 0;
+        for (const [id, run] of rows) {
+          if (run.status === "running") {
+            rows.set(id, { ...run, status: "interrupted" });
+            n += 1;
+          }
+        }
+        return n;
+      },
+      listRuns: ({
+        limit,
+        status,
+      }: {
+        limit: number;
+        status?: WorkflowRunStatus;
+      }): WorkflowRun[] => {
+        const all = [...rows.values()].sort(
+          (a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0),
+        );
+        return (status ? all.filter((r) => r.status === status) : all).slice(
+          0,
+          limit,
+        );
+      },
+    } as unknown as WorkflowRunManagerDeps["journal"],
+  };
+}
+
+interface ManagerHarness {
+  manager: WorkflowRunManager;
+  executeCalls: ExecuteWorkflowOptions[];
+  broadcasts: Array<{ type: string; [k: string]: unknown }>;
+  wakes: Array<{ conversationId: string; hint: string; source: string }>;
+  fake: ReturnType<typeof makeFakeJournal>;
+  /** Resolve the latest in-flight engine run with a given result. */
+  resolveLatest: (result: EngineResult) => Promise<void>;
+}
+
+interface EngineResult {
+  status: WorkflowRunStatus;
+  result: unknown;
+  agentsSpawned: number;
+  inputTokens: number;
+  outputTokens: number;
+}
+
+/**
+ * Build a manager with a fully-injected, provider-free seam: a fake engine that
+ * surfaces a resolver hook (so a test can drive progress/abort/completion
+ * deterministically), an in-memory journal, and spies for broadcast + wake.
+ */
+function makeHarness(opts?: {
+  flagEnabled?: boolean;
+  maxConcurrentRuns?: number;
+  /** Custom engine impl; defaults to the deferred-resolver fake. */
+  engine?: WorkflowRunManagerDeps["executeWorkflow"];
+  /** Saved-workflow resolver for the `start({ name })` path. */
+  getWorkflow?: WorkflowRunManagerDeps["getWorkflow"];
+}): ManagerHarness {
+  const fake = makeFakeJournal();
+  const executeCalls: ExecuteWorkflowOptions[] = [];
+  const broadcasts: ManagerHarness["broadcasts"] = [];
+  const wakes: ManagerHarness["wakes"] = [];
+
+  // Deferred-resolution engine: capture each invocation and let the test settle
+  // it. Tracks the resolver so `resolveLatest` can fire completion on demand.
+  const resolvers: Array<(r: EngineResult) => void> = [];
+  const defaultEngine: WorkflowRunManagerDeps["executeWorkflow"] = (
+    options,
+  ) => {
+    executeCalls.push(options);
+    // Reflect the engine's count-flushing so `getRun` mirrors mid-flight state.
+    return new Promise<EngineResult>((resolve) => {
+      resolvers.push((r) => {
+        fake.setStats(options.runId, {
+          status: r.status,
+          agentsSpawned: r.agentsSpawned,
+          inputTokens: r.inputTokens,
+          outputTokens: r.outputTokens,
+          result: r.status === "completed" ? r.result : null,
+          error:
+            r.status === "completed"
+              ? null
+              : `Workflow ended with status ${r.status}`,
+          finishedAt: Date.now(),
+        });
+        resolve(r);
+      });
+    }) as ReturnType<WorkflowRunManagerDeps["executeWorkflow"]>;
+  };
+
+  const deps: Partial<WorkflowRunManagerDeps> = {
+    executeWorkflow: opts?.engine ?? defaultEngine,
+    leafRunner: (() => {
+      throw new Error("leafRunner must not be called in run-manager tests");
+    }) as unknown as WorkflowRunManagerDeps["leafRunner"],
+    journal: fake.journal,
+    getConfig: () => makeConfig(opts?.maxConcurrentRuns),
+    isFlagEnabled: () => opts?.flagEnabled ?? true,
+    wake: (async (wakeOpts) => {
+      wakes.push({
+        conversationId: wakeOpts.conversationId,
+        hint: wakeOpts.hint,
+        source: wakeOpts.source,
+      });
+      return { invoked: true, producedToolCalls: false };
+    }) as WorkflowRunManagerDeps["wake"],
+    broadcast: ((msg) => {
+      broadcasts.push(msg as { type: string });
+    }) as WorkflowRunManagerDeps["broadcast"],
+    newRunId: (() => {
+      let n = 0;
+      return () => `run-${++n}`;
+    })(),
+    ...(opts?.getWorkflow ? { getWorkflow: opts.getWorkflow } : {}),
+  };
+
+  const manager = new WorkflowRunManager(deps);
+
+  return {
+    manager,
+    executeCalls,
+    broadcasts,
+    wakes,
+    fake,
+    resolveLatest: async (result) => {
+      const resolve = resolvers[resolvers.length - 1];
+      if (!resolve) throw new Error("no in-flight engine run to resolve");
+      resolve(result);
+      // Let the manager's post-completion microtasks (broadcast + wake) settle.
+      await new Promise((r) => setTimeout(r, 0));
+    },
+  };
+}
+
+describe("WorkflowRunManager.start — flag gate", () => {
+  test("flag off → start throws and the engine is never invoked", () => {
+    const h = makeHarness({ flagEnabled: false });
+    expect(() =>
+      h.manager.start({
+        scriptSource: "export const meta = { name: 'x', description: 'y' }",
+        args: {},
+        manifest: { tools: [], hostFunctions: [], persona: false },
+        trustContext: TRUST,
+      }),
+    ).toThrow(WorkflowsDisabledError);
+    expect(h.executeCalls).toHaveLength(0);
+    expect(h.fake.rows.size).toBe(0);
+  });
+});
+
+describe("WorkflowRunManager.start — concurrent-run cap", () => {
+  test("the (N+1)th concurrent start is rejected", () => {
+    const h = makeHarness({ maxConcurrentRuns: 2 });
+    const startOne = () =>
+      h.manager.start({
+        scriptSource: "export const meta = { name: 'x', description: 'y' }",
+        args: {},
+        manifest: { tools: [], hostFunctions: [], persona: false },
+        trustContext: TRUST,
+      });
+
+    startOne();
+    startOne();
+    expect(h.manager.inflightCount()).toBe(2);
+    expect(() => startOne()).toThrow(WorkflowRunCapError);
+    // The rejected start created no extra run row.
+    expect(h.fake.rows.size).toBe(2);
+  });
+
+  test("a finished run frees a cap slot", async () => {
+    const h = makeHarness({ maxConcurrentRuns: 1 });
+    const start = () =>
+      h.manager.start({
+        scriptSource: "export const meta = { name: 'x', description: 'y' }",
+        args: {},
+        manifest: { tools: [], hostFunctions: [], persona: false },
+        trustContext: TRUST,
+      });
+
+    start();
+    expect(() => start()).toThrow(WorkflowRunCapError);
+
+    await h.resolveLatest({
+      status: "completed",
+      result: "ok",
+      agentsSpawned: 1,
+      inputTokens: 10,
+      outputTokens: 5,
+    });
+
+    expect(h.manager.inflightCount()).toBe(0);
+    // Slot freed: a second run now starts without throwing.
+    expect(() => start()).not.toThrow();
+  });
+});
+
+describe("WorkflowRunManager.abort", () => {
+  test("abort signals the engine's AbortController", () => {
+    const h = makeHarness();
+    const { runId } = h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      trustContext: TRUST,
+    });
+
+    const passedSignal = h.executeCalls[0]!.signal!;
+    expect(passedSignal.aborted).toBe(false);
+    h.manager.abort(runId);
+    expect(passedSignal.aborted).toBe(true);
+  });
+
+  test("an aborted run resolves with status 'aborted' and persists it", async () => {
+    const h = makeHarness();
+    const { runId } = h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      trustContext: TRUST,
+    });
+
+    h.manager.abort(runId);
+    // The (faked) engine observes the abort and reports the terminal status.
+    await h.resolveLatest({
+      status: "aborted",
+      result: null,
+      agentsSpawned: 2,
+      inputTokens: 0,
+      outputTokens: 0,
+    });
+
+    expect(h.manager.status(runId)?.status).toBe("aborted");
+    const completed = h.broadcasts.find((b) => b.type === "workflow_completed");
+    expect(completed?.status).toBe("aborted");
+  });
+});
+
+describe("WorkflowRunManager — progress events", () => {
+  test("onProgress phase/log are republished as workflow_progress", async () => {
+    const h = makeHarness();
+    h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      label: "My Flow",
+      trustContext: TRUST,
+    });
+
+    const onProgress = h.executeCalls[0]!.onProgress!;
+    onProgress({ type: "phase", title: "Gathering" });
+    onProgress({ type: "log", message: "step done" });
+
+    const progress = h.broadcasts.filter((b) => b.type === "workflow_progress");
+    expect(progress).toHaveLength(2);
+    expect(progress[0]).toMatchObject({
+      type: "workflow_progress",
+      label: "My Flow",
+      phase: "Gathering",
+    });
+    expect(progress[1]).toMatchObject({
+      type: "workflow_progress",
+      message: "step done",
+    });
+  });
+});
+
+describe("WorkflowRunManager — completion", () => {
+  test("completion publishes workflow_completed and injects into the conversation", async () => {
+    const h = makeHarness();
+    const { runId } = h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      conversationId: "conv-1",
+      label: "Digest",
+      trustContext: TRUST,
+    });
+
+    await h.resolveLatest({
+      status: "completed",
+      result: { summary: "all good" },
+      agentsSpawned: 4,
+      inputTokens: 100,
+      outputTokens: 50,
+    });
+
+    const completed = h.broadcasts.find((b) => b.type === "workflow_completed");
+    expect(completed).toMatchObject({
+      type: "workflow_completed",
+      runId,
+      status: "completed",
+      agentsSpawned: 4,
+      inputTokens: 100,
+      outputTokens: 50,
+    });
+    expect(typeof completed?.summary).toBe("string");
+
+    // Completion summary surfaced to the originating conversation via a wake.
+    expect(h.wakes).toHaveLength(1);
+    expect(h.wakes[0]).toMatchObject({
+      conversationId: "conv-1",
+      source: "workflow_completed",
+    });
+    expect(h.wakes[0]!.hint).toContain("completed");
+
+    // Final stats persisted to the run row.
+    const run = h.manager.status(runId);
+    expect(run?.status).toBe("completed");
+    expect(run?.agentsSpawned).toBe(4);
+    expect(run?.inputTokens).toBe(100);
+    expect(run?.outputTokens).toBe(50);
+  });
+
+  test("a large result is truncated in the summary but kept whole on the run row", async () => {
+    const h = makeHarness();
+    const big = "x".repeat(50_000);
+    const { runId } = h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      conversationId: "conv-big",
+      label: "Digest",
+      trustContext: TRUST,
+    });
+
+    await h.resolveLatest({
+      status: "completed",
+      result: big,
+      agentsSpawned: 1,
+      inputTokens: 1,
+      outputTokens: 1,
+    });
+
+    const completed = h.broadcasts.find((b) => b.type === "workflow_completed");
+    // The summary (event + wake) is bounded well under the raw result size.
+    const summary = String(completed?.summary ?? "");
+    expect(summary.length).toBeLessThan(big.length);
+    expect(summary).toContain("[truncated");
+    expect(h.wakes[0]!.hint).toContain("[truncated");
+
+    // The durable run row keeps the FULL, untruncated result.
+    expect(h.manager.status(runId)?.result).toBe(big);
+  });
+
+  test("no conversationId → completion events fire but no wake", async () => {
+    const h = makeHarness();
+    h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      trustContext: TRUST,
+    });
+
+    await h.resolveLatest({
+      status: "completed",
+      result: "x",
+      agentsSpawned: 1,
+      inputTokens: 1,
+      outputTokens: 1,
+    });
+
+    expect(h.broadcasts.some((b) => b.type === "workflow_completed")).toBe(
+      true,
+    );
+    expect(h.wakes).toHaveLength(0);
+  });
+});
+
+describe("WorkflowRunManager.start — saved-workflow name resolution", () => {
+  const SAVED_SOURCE =
+    "export const meta = { name: 'saved-flow', description: 'd' }";
+
+  test("start({ name }) resolves the library source and runs it", () => {
+    const h = makeHarness({
+      getWorkflow: (name) =>
+        name === "saved-flow"
+          ? { source: SAVED_SOURCE, path: "/ws/workflows/saved.workflow.ts" }
+          : null,
+    });
+
+    const { runId } = h.manager.start({
+      name: "saved-flow",
+      args: { x: 1 },
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      trustContext: TRUST,
+    });
+
+    // The run row + engine call carry the RESOLVED source, not the name.
+    expect(h.fake.rows.get(runId)?.scriptSource).toBe(SAVED_SOURCE);
+    expect(h.executeCalls).toHaveLength(1);
+    expect(h.executeCalls[0]!.scriptSource).toBe(SAVED_SOURCE);
+    // meta.name is extracted from the resolved source.
+    expect(h.fake.rows.get(runId)?.name).toBe("saved-flow");
+  });
+
+  test("start({ name }) with an unknown name throws and creates no run row", () => {
+    const h = makeHarness({ getWorkflow: () => null });
+    expect(() =>
+      h.manager.start({
+        name: "ghost",
+        args: {},
+        manifest: { tools: [], hostFunctions: [], persona: false },
+        trustContext: TRUST,
+      }),
+    ).toThrow(WorkflowNotFoundError);
+    expect(h.executeCalls).toHaveLength(0);
+    expect(h.fake.rows.size).toBe(0);
+  });
+});
+
+// Seed a run row directly into the fake journal (bypassing `start`), so resume
+// tests can stand up a pre-existing `interrupted`/other-status row.
+function seedRun(
+  h: ManagerHarness,
+  overrides: Partial<WorkflowRun> & { id: string },
+): WorkflowRun {
+  const run: WorkflowRun = {
+    name: "seeded",
+    scriptSource: "export const meta = { name: 'seeded', description: 'd' }",
+    scriptHash: "hash",
+    args: { k: "v" },
+    capabilities: { tools: [], hostFunctions: [], persona: false },
+    status: "interrupted",
+    conversationId: null,
+    trust: null,
+    agentsSpawned: 3,
+    inputTokens: 100,
+    outputTokens: 50,
+    result: null,
+    error: null,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    finishedAt: null,
+    ...overrides,
+  };
+  h.fake.rows.set(run.id, run);
+  return run;
+}
+
+describe("WorkflowRunManager.reconcileOrphanedRuns", () => {
+  test("flips running rows to interrupted, leaving counters untouched", () => {
+    const h = makeHarness({});
+    seedRun(h, { id: "r-run", status: "running", agentsSpawned: 7 });
+    seedRun(h, { id: "r-done", status: "completed", agentsSpawned: 2 });
+
+    const n = h.manager.reconcileOrphanedRuns();
+
+    expect(n).toBe(1);
+    const reconciled = h.fake.rows.get("r-run")!;
+    expect(reconciled.status).toBe("interrupted");
+    // Accounting preserved — reconciliation is status-only.
+    expect(reconciled.agentsSpawned).toBe(7);
+    expect(reconciled.inputTokens).toBe(100);
+    expect(reconciled.outputTokens).toBe(50);
+    // A completed run is untouched.
+    expect(h.fake.rows.get("r-done")!.status).toBe("completed");
+  });
+});
+
+describe("WorkflowRunManager.resume", () => {
+  test("an interrupted run re-invokes the engine with the SAME runId and carries accounting", async () => {
+    const h = makeHarness({});
+    seedRun(h, {
+      id: "run-x",
+      status: "interrupted",
+      args: { foo: 1 },
+      agentsSpawned: 4,
+    });
+
+    const { runId } = h.manager.resume("run-x");
+    expect(runId).toBe("run-x");
+
+    // Engine invoked with the same runId + reconstructed args; no NEW row.
+    expect(h.executeCalls).toHaveLength(1);
+    expect(h.executeCalls[0]!.runId).toBe("run-x");
+    expect(h.executeCalls[0]!.args).toEqual({ foo: 1 });
+
+    // Status transitions interrupted → running before launch.
+    expect(h.fake.rows.get("run-x")!.status).toBe("running");
+
+    // The engine reports the carried-forward accounting (seed: 4 agents) plus
+    // newly spawned work — the count carries, it does NOT reset.
+    await h.resolveLatest({
+      status: "completed",
+      result: "done",
+      agentsSpawned: 6,
+      inputTokens: 200,
+      outputTokens: 90,
+    });
+
+    const run = h.manager.status("run-x");
+    expect(run?.status).toBe("completed");
+    expect(run?.agentsSpawned).toBe(6);
+    expect(h.manager.inflightCount()).toBe(0);
+  });
+
+  test("resume replays the SAME (non-guardian) trust the run started under — never escalates", () => {
+    const h = makeHarness({});
+    // A run started by a low-trust actor: persisted trust is NOT guardian.
+    const lowTrust: TrustContext = {
+      sourceChannel: "slack",
+      trustClass: "unknown",
+      requesterIdentifier: "@someone",
+    };
+    seedRun(h, {
+      id: "run-x",
+      status: "interrupted",
+      conversationId: null,
+      trust: lowTrust,
+    });
+
+    h.manager.resume("run-x");
+
+    const replayed = h.executeCalls[0]!.trustContext;
+    // SECURITY: resume must reconstruct the exact trust the run started under,
+    // never elevate to guardian (which would clear the side-effect gate).
+    expect(replayed.trustClass).toBe("unknown");
+    expect(replayed.trustClass).not.toBe("guardian");
+    expect(replayed.sourceChannel).toBe("slack");
+  });
+
+  test("resume of a trusted_contact run keeps trusted_contact (no escalation)", () => {
+    const h = makeHarness({});
+    seedRun(h, {
+      id: "run-tc",
+      status: "interrupted",
+      trust: { sourceChannel: "slack", trustClass: "trusted_contact" },
+    });
+
+    h.manager.resume("run-tc");
+
+    expect(h.executeCalls[0]!.trustContext.trustClass).toBe("trusted_contact");
+  });
+
+  test("SECURITY: a legacy run row with no persisted trust resumes at LOW trust, never guardian", () => {
+    const h = makeHarness({});
+    // Legacy row: written before the trust_json column existed → trust is null.
+    seedRun(h, { id: "run-legacy", status: "interrupted", trust: null });
+
+    h.manager.resume("run-legacy");
+
+    const replayed = h.executeCalls[0]!.trustContext;
+    expect(replayed.trustClass).toBe("unknown");
+    expect(replayed.trustClass).not.toBe("guardian");
+  });
+
+  test("a persisted trust with an unrecognized trustClass falls back to LOW trust", () => {
+    const h = makeHarness({});
+    seedRun(h, {
+      id: "run-bad",
+      status: "interrupted",
+      // Corrupt/forward-incompatible snapshot: not a known trust class.
+      trust: { sourceChannel: "slack", trustClass: "superuser" },
+    });
+
+    h.manager.resume("run-bad");
+
+    expect(h.executeCalls[0]!.trustContext.trustClass).toBe("unknown");
+  });
+
+  test("start persists the originating trust context on the run row", () => {
+    const h = makeHarness({});
+    const startTrust: TrustContext = {
+      sourceChannel: "slack",
+      trustClass: "unknown",
+    };
+    const { runId } = h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      trustContext: startTrust,
+    });
+
+    expect(h.fake.rows.get(runId)?.trust).toEqual(startTrust);
+  });
+
+  test("a non-interrupted run throws WorkflowResumeNotPossibleError and does not invoke the engine", () => {
+    const h = makeHarness({});
+    seedRun(h, { id: "run-done", status: "completed" });
+
+    expect(() => h.manager.resume("run-done")).toThrow(
+      WorkflowResumeNotPossibleError,
+    );
+    expect(h.executeCalls).toHaveLength(0);
+    // The row is untouched (still completed).
+    expect(h.fake.rows.get("run-done")!.status).toBe("completed");
+  });
+
+  test("an unknown run throws WorkflowResumeNotPossibleError", () => {
+    const h = makeHarness({});
+    expect(() => h.manager.resume("ghost")).toThrow(
+      WorkflowResumeNotPossibleError,
+    );
+    expect(h.executeCalls).toHaveLength(0);
+  });
+
+  test("resume respects the concurrent-run cap", () => {
+    const h = makeHarness({ maxConcurrentRuns: 1 });
+    // Occupy the single slot with a live run.
+    h.manager.start({
+      scriptSource: "export const meta = { name: 'x', description: 'y' }",
+      args: {},
+      manifest: { tools: [], hostFunctions: [], persona: false },
+      trustContext: TRUST,
+    });
+    seedRun(h, { id: "run-x", status: "interrupted" });
+
+    expect(() => h.manager.resume("run-x")).toThrow(WorkflowRunCapError);
+  });
+
+  test("resume is rejected when the flag is off", () => {
+    const h = makeHarness({ flagEnabled: false });
+    seedRun(h, { id: "run-x", status: "interrupted" });
+    expect(() => h.manager.resume("run-x")).toThrow(WorkflowsDisabledError);
+  });
+});