woozlit 2.3.0 → 2.3.1

package/test/workflow/runtime.test.ts

@@ -1,1078 +0,0 @@
-import { describe, expect, afterEach } from "bun:test"
-import { Effect } from "effect"
-import { Session } from "../../src/session"
-import { Instance } from "../../src/project/instance"
-import { provideTmpdirServer } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { reply } from "../lib/llm-server"
-import { WorkflowRuntime } from "../../src/workflow/runtime"
-import { WorkflowAgentFailed } from "../../src/workflow/events"
-import { WorkflowPersistence } from "../../src/workflow/persistence"
-import { ActorRegistry } from "../../src/actor/registry"
-import { Bus } from "../../src/bus"
-import { makeLayer, ref, providerCfg } from "./lib"
-
-afterEach(async () => {
-  await Instance.disposeAll()
-})
-
-const it = testEffect(makeLayer())
-
-describe("WorkflowRuntime agent() fan-out", () => {
-  it.live("runs a script that fans out 3 agents and returns their results", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf fanout",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        yield* llm.text("done")
-        yield* llm.text("done")
-        yield* llm.text("done")
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const r = await parallel([() => agent("a"), () => agent("b"), () => agent("c")])`,
-          `return r`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const outcome = yield* runtime.wait({ runID })
-        expect(outcome.status).toBe("completed")
-        expect((outcome as { result: string[] }).result.filter((x) => x === "done").length).toBe(3)
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})
-
-describe("WorkflowRuntime concurrency + resilience", () => {
-  it.live("8 agents under cap=2 all complete", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf cap",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        for (let i = 0; i < 8; i++) yield* llm.text("done")
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const ts = []`,
-          `for (let i = 0; i < 8; i++) ts.push(() => agent("x" + i))`,
-          `return (await parallel(ts)).length`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({
-          script,
-          sessionID: parent.id,
-          parentActorID: "main",
-          model: ref,
-          maxConcurrentAgents: 2,
-        })
-        const outcome = yield* runtime.wait({ runID })
-        expect(outcome.status).toBe("completed")
-        expect((outcome as { result: number }).result).toBe(8)
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-
-  it.live("a failing child yields null; the run still completes", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf null",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        // A 400 is a non-retryable client error (see llm.retryable): the child
-        // that receives it finishes with no assistant text, so its AgentOutcome
-        // carries no finalText and agent() resolves to null. The other child gets
-        // "ok". agent() must NEVER throw the failure into the guest — both the run
-        // and the sibling agent must still complete. Assertions are
-        // order-independent, so the FIFO race over which child lands first is
-        // benign. (Each agent() is a subagent sharing the run's session, so
-        // result isolation rides on the agent-scoped lastAssistant fix — each
-        // child's outcome is extracted by its own agentID, so concurrent
-        // same-session children do not cross-contaminate — see runtime.ts.)
-        yield* llm.error(400, { error: { message: "bad request" } })
-        yield* llm.text("ok")
-        // A failed agent() resolves to a nullish value in the guest (the host
-        // returns null; the sandbox marshals host null → guest undefined). Treat
-        // both as the failure sentinel.
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const r = await parallel([() => agent("a"), () => agent("b")])`,
-          `return r.map((x) => (x === null || x === undefined) ? "null" : x)`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const outcome = yield* runtime.wait({ runID })
-        expect(outcome.status).toBe("completed")
-        const r = (outcome as { result: string[] }).result
-        expect(r).toContain("null")
-        expect(r).toContain("ok")
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})
-
-describe("WorkflowRuntime convergence (scout drives fan-out)", () => {
-  // The scout is an ordinary agent() call with a schema → it returns structured
-  // data. The mock LLM answers its turn with a StructuredOutput tool call; the
-  // runtime spawns it under format:{type:"json_schema"} (runtime.ts:199) and
-  // agent() resolves to the validated object (runtime.ts:205).
-  const scoutSchema = {
-    type: "object",
-    additionalProperties: false,
-    properties: { todo: { type: "array", items: { type: "string" } } },
-    required: ["todo"],
-  }
-
-  // Drives the real runtime with a mock LLM: scout reports `todo`, the script
-  // fans out one worker per todo. Asserts the run result and the run's cumulative
-  // agent-spawn tally (agentCount = +1 per agent() call, never decremented —
-  // runtime.ts:301), the deterministic observable immune to LLM-queue races.
-  const runWithTodo = (todo: string[], expectedAgentCount: number) =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf converge",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        // Scout turn FIRST: it is awaited before the fan-out, so it consumes this
-        // StructuredOutput reply before any worker dequeues — ordering is stable.
-        yield* llm.push(reply().tool("StructuredOutput", { todo }))
-        // One plain text reply per worker (no schema → finalText, runtime.ts:205).
-        for (let i = 0; i < todo.length; i++) yield* llm.text("done")
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const s = await agent("scout", { schema: ${JSON.stringify(scoutSchema)} })`,
-          `const todo = (s && s.todo) || []`,
-          `await parallel(todo.map((u) => () => agent("work " + u)))`,
-          `return todo.length`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const outcome = yield* runtime.wait({ runID })
-        expect(outcome.status).toBe("completed")
-        expect((outcome as { result: number }).result).toBe(todo.length)
-        // The load-bearing assertion: scout's reported todo count drives the
-        // worker fan-out → 1 scout + N workers spawned.
-        const snap = yield* runtime.status({ runID })
-        expect(snap.agentCount).toBe(expectedAgentCount)
-      }),
-      { git: true, config: providerCfg },
-    )
-
-  it.live("4 todo → 1 scout + 4 workers spawned", () => runWithTodo(["a", "b", "c", "d"], 5))
-
-  it.live("2 todo → 1 scout + 2 workers spawned (a re-run with fewer undone units does less work)", () =>
-    runWithTodo(["a", "b"], 3),
-  )
-})
-
-describe("WorkflowRuntime schema contract (schema'd agent never returns prose)", () => {
-  // A schema'd agent() whose model NEVER calls StructuredOutput (answers with plain
-  // prose, exhausting the format.retryCount=2 retries) MUST resolve to `null`, NOT
-  // the prose finalText. Returning prose breaks scripts that do `r.fields.map(...)`
-  // (the prose is a truthy non-object) and our pipeline's catch then injects a bare
-  // null that bypasses the script's own `r ? … : []` guard — exactly the full-tree
-  // Phase-0 Verify crash. So: schema requested + structured-output failed ⇒ null.
-  const fieldsSchema = {
-    type: "object",
-    additionalProperties: false,
-    properties: { fields: { type: "array", items: { type: "string" } } },
-    required: ["fields"],
-  }
-
-  it.live("schema'd agent that only returns prose resolves to null, not the prose", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf schema-contract",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        // The model refuses structured output every turn: original + 2 retries
-        // (format.retryCount=2) all answer with prose, never a StructuredOutput call.
-        yield* llm.text("I cannot call StructuredOutput; here is prose instead.")
-        yield* llm.text("Still prose, no tool call.")
-        yield* llm.text("Prose again.")
-        // The script returns typeof the agent result. With the fix it must be
-        // "object" (null is typeof "object") and specifically === null — NOT "string".
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const r = await agent("classify", { schema: ${JSON.stringify(fieldsSchema)} })`,
-          `return { isFailure: r === null || r === undefined, isProse: typeof r === "string" }`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const outcome = yield* runtime.wait({ runID })
-        expect(outcome.status).toBe("completed")
-        const result = (outcome as { result: { isFailure: boolean; isProse: boolean } }).result
-        expect(result.isProse).toBe(false) // never the prose string
-        expect(result.isFailure).toBe(true) // schema-fail ⇒ null/undefined sentinel
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})
-
-describe("WorkflowRuntime error visibility", () => {
-  // A script-logic error (a TypeError downstream of a never-throw agent()) must
-  // fail the run with a VISIBLE error — the real guest message — not the opaque
-  // Effect wrapper. Bare Effect.tryPromise wraps the sandbox rejection as an
-  // UnknownError whose .message is literally "An error occurred in
-  // Effect.tryPromise" (the real error is buried in .cause), so runtime.ts:547's
-  // `failure.message` extract emitted that useless string. The object-form
-  // tryPromise makes result.failure the raw sandbox Error, whose .message already
-  // carries the guest {name,message,stack} (vm.dump preserves it through the
-  // throw site). This is the test that would have caught the 3 opaque crashes.
-  it.live("a script-logic TypeError fails the run with a visible error (not the Effect wrapper)", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf err-visible",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        yield* llm.text("ok")
-        // agent("a") → "ok"; r = ["ok"]; r.map(x => x.nope.deeper) derefs a
-        // property of undefined downstream of the (now never-catching) parallel.
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const r = await parallel([() => agent("a")])`,
-          `return r.map((x) => x.nope.deeper)`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const outcome = yield* runtime.wait({ runID })
-        expect(outcome.status).toBe("failed")
-        const error = (outcome as { error: string }).error
-        // NOT the opaque Effect wrapper, and carries a script-logic token.
-        expect(error).not.toBe("An error occurred in Effect.tryPromise")
-        expect(error).toMatch(/nope|deeper|undefined|not an object|TypeError/)
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})
-
-describe("WorkflowRuntime cancel cascade", () => {
-  it.live("cancel stops in-flight child agents and marks the run cancelled", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf cancel",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        yield* llm.hang // children hang so they're in-flight at cancel time
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `return await parallel([() => agent("a"), () => agent("b"), () => agent("c")])`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        yield* Effect.sleep("250 millis") // let the fan-out spawn children
-        yield* runtime.cancel({ runID })
-        const s = yield* runtime.status({ runID })
-        expect(s.status).toBe("cancelled")
-      }),
-      { git: true, config: providerCfg },
-    ),
-    // Headroom over the default 5s: this cancel test can run concurrently with the
-    // heavyweight real-Instance worktree-isolation tests, where CI load occasionally
-    // pushed it past 5s. Generous margin keeps it deterministic without masking hangs.
-    15000,
-  )
-
-  // MR104 #2 — orphan-on-cancel race. The bug: spawnShared added the child's
-  // actorID to the run's reclaim set (entry.childActorIDs) only AFTER actor.spawn
-  // RESOLVED across the quickjs Promise bridge. A cancel landing during that gap
-  // reclaimed a STALE (empty) set, then interrupted the workflow fiber — but each
-  // child runs DETACHED in the actor scope (background:true + forkIn), so the
-  // interrupt never reaches it. Result: registered children that reclaim never
-  // cancels — orphans holding subscriptions/tokens/worktrees. Fix: register the id
-  // INSIDE the spawn Effect (onActorID), before the work fiber detaches.
-  //
-  // Observable: reclaim graceful-cancels every id in childActorIDs, and
-  // Actor.cancel writes lastOutcome="cancelled" on each (registry.test cancel
-  // cascade). So immediately after cancel returns, EVERY spawned child must carry
-  // lastOutcome="cancelled" — proof that reclaim saw it. Pre-fix the set is empty
-  // at reclaim time, so the children are never cancelled (lastOutcome stays unset).
-  // NOTE: we assert at the instant cancel returns, BEFORE any further sleep — a
-  // graceful-cancelled child can be re-driven by the auto-answering test LLM and
-  // bounce back to running:success later, which is a mock artifact unrelated to
-  // the orphan bug; the cancel-stamp at t0 is the stable signal.
-  it.live("cancel during an in-flight fan-out reclaims every child (no orphan)", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const registry = yield* ActorRegistry.Service
-        const parent = yield* session.create({
-          title: "wf cancel no-orphan",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        yield* llm.hang // every child hangs at the LLM → in-flight at cancel time
-        // A wide fan-out keeps spawns resolving across the bridge so the cancel
-        // lands while children are registered but the post-resolve add (the bug)
-        // has not run.
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const ts = []`,
-          `for (let i = 0; i < 8; i++) ts.push(() => agent("child" + i))`,
-          `return await parallel(ts)`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({
-          script,
-          sessionID: parent.id,
-          parentActorID: "main",
-          model: ref,
-          maxConcurrentAgents: 8,
-        })
-        // Let the fan-out register its children, then cancel mid-flight.
-        yield* Effect.sleep("150 millis")
-        yield* runtime.cancel({ runID })
-
-        const s = yield* runtime.status({ runID })
-        expect(s.status).toBe("cancelled")
-
-        // At least one child was actually spawned (else the test proves nothing).
-        const children = (yield* registry.listBySession(parent.id)).filter((a) => a.actorID !== "main")
-        expect(children.length).toBeGreaterThan(0)
-        // Every spawned child was reclaimed: cancel stamped lastOutcome="cancelled"
-        // on each. An orphan (never reclaimed) would have lastOutcome unset here.
-        expect(children.filter((a) => a.lastOutcome !== "cancelled")).toEqual([])
-      }),
-      { git: true, config: providerCfg },
-    ),
-    20000,
-  )
-})
-
-describe("WorkflowRuntime concurrency clamp", () => {
-  it.live("a request above 2x cores is clamped (run still completes)", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({ title: "wf clamp", permission: [{ permission: "*", pattern: "*", action: "allow" }] })
-        yield* llm.text("done"); yield* llm.text("done")
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `return (await parallel([() => agent("a"), () => agent("b")])).length`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref, maxConcurrentAgents: 100000 })
-        const o = yield* runtime.wait({ runID })
-        expect(o.status).toBe("completed")
-        expect((o as { result: number }).result).toBe(2)
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})
-
-describe("WorkflowRuntime per-agent timeout (straggler-abort)", () => {
-  // A single hung agent (e.g. a persistent mimo TTFT wall) must not stall the whole
-  // parallel/pipeline barrier indefinitely. With agentTimeoutMs set, the hung agent
-  // is gracefully cancelled and resolves to the never-throw null sentinel, so the
-  // sibling's "ok" and the run COMPLETE — bounded by the per-agent timeout, NOT the
-  // far-larger global scriptDeadline (a PASS proves the per-agent path fired).
-  it.live("a hung agent times out to null under agentTimeoutMs; the run completes", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf agent-timeout",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        // Queue ONE hang. The two agents race to dequeue it: whichever pulls it hangs
-        // forever; the other finds the queue empty and gets the server's auto-"ok".
-        // So exactly 1 hangs (→ times out → null) and 1 returns "ok", regardless of
-        // FIFO order — the assertion counts totals, so it's order-independent.
-        yield* llm.hang
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const r = await parallel([() => agent("a"), () => agent("b")])`,
-          `return r.map((x) => (x === null || x === undefined) ? "null" : "ok")`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({
-          script,
-          sessionID: parent.id,
-          parentActorID: "main",
-          model: ref,
-          agentTimeoutMs: 1500,
-          scriptDeadlineMs: 60000, // far above the per-agent timeout
-        })
-        const outcome = yield* runtime.wait({ runID })
-        expect(outcome.status).toBe("completed")
-        const r = (outcome as { result: string[] }).result
-        expect(r.filter((x) => x === "null").length).toBe(1)
-        expect(r.filter((x) => x === "ok").length).toBe(1)
-      }),
-      { git: true, config: providerCfg },
-    ),
-    20000, // budget >> the 1500ms per-agent timeout, well under any true hang
-  )
-})
-
-describe("WorkflowRuntime lifecycle cap", () => {
-  // Hitting the lifecycle agent cap is an EXPECTED steady-state for a large
-  // fan-out (lifetime-classify caps its own verify sample to stay under it), not
-  // a programming error. So an over-cap agent() must return the never-throw null
-  // sentinel (graceful degradation) — NOT throw, which post-NC-1 (combinators no
-  // longer catch) would reject the whole batch and waste every completed agent.
-  // maxLifecycleAgents parameterizes the cap so this is unit-testable at cap=2.
-  it.live("over-cap agent() returns null; the run still completes (cap=2, fan-out 3)", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf cap-null",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        // The check-then-increment is synchronous (no await between), so exactly 2
-        // of the 3 spawn (count 0→1, 1→2) and the 3rd sees count 2 ≥ cap → null.
-        // Two replies for the two that spawn; the 3rd never reaches the LLM.
-        yield* llm.text("done")
-        yield* llm.text("done")
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const r = await parallel([() => agent("a"), () => agent("b"), () => agent("c")])`,
-          `return r.map((x) => (x === null || x === undefined) ? "null" : "ok")`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({
-          script,
-          sessionID: parent.id,
-          parentActorID: "main",
-          model: ref,
-          maxLifecycleAgents: 2,
-        })
-        const outcome = yield* runtime.wait({ runID })
-        expect(outcome.status).toBe("completed")
-        const r = (outcome as { result: string[] }).result
-        expect(r.filter((x) => x === "ok").length).toBe(2)
-        expect(r.filter((x) => x === "null").length).toBe(1)
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})
-
-describe("WorkflowRuntime deadline", () => {
-  it.live("a script that exceeds scriptDeadlineMs is interrupted, not hung", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf deadline",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        yield* llm.hang // the single agent hangs forever
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `return await agent("x")`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({
-          script,
-          sessionID: parent.id,
-          parentActorID: "main",
-          model: ref,
-          scriptDeadlineMs: 1500,
-        })
-        const outcome = yield* runtime.wait({ runID })
-        // The deadline fires inside the sandbox; the run resolves failed (not completed, not hung).
-        expect(outcome.status).toBe("failed")
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})
-
-describe("WorkflowRuntime counters", () => {
-  it.live("running/succeeded/failed tracked separately and persisted", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({ title: "wf counters", permission: [{ permission: "*", pattern: "*", action: "allow" }] })
-        yield* llm.error(400, { error: { message: "bad" } })
-        yield* llm.text("ok")
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `return await parallel([() => agent("a"), () => agent("b")])`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        yield* runtime.wait({ runID })
-        const row = yield* WorkflowPersistence.load(runID)
-        expect(row?.succeeded).toBe(1)
-        expect(row?.failed).toBe(1)
-        expect(row?.running).toBe(0)
-        expect(row?.status).toBe("completed")
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})
-
-describe("WorkflowRuntime list + resume", () => {
-  it.live("list returns persisted runs newest-first, filtered by session", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({ title: "wf list", permission: [{ permission: "*", pattern: "*", action: "allow" }] })
-        yield* llm.text("done"); yield* llm.text("done")
-        const mk = () => [`export const meta = { name: "t", description: "d" }`, `return await agent("x")`].join("\n")
-        const r1 = yield* runtime.start({ script: mk(), sessionID: parent.id, parentActorID: "main", model: ref })
-        yield* runtime.wait({ runID: r1.runID })
-        const r2 = yield* runtime.start({ script: mk(), sessionID: parent.id, parentActorID: "main", model: ref })
-        yield* runtime.wait({ runID: r2.runID })
-        const rows = yield* runtime.list({ sessionID: parent.id })
-        expect(rows.length).toBe(2)
-        expect(rows[0].runID).toBe(r2.runID) // newest first
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-
-  it.live("resume re-launches the persisted script under the same runID (cached replay, zero new spawns)", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({ title: "wf resume", permission: [{ permission: "*", pattern: "*", action: "allow" }] })
-        yield* llm.text("done")
-        const script = [`export const meta = { name: "t", description: "d" }`, `return await agent("x")`].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const out1 = yield* runtime.wait({ runID })
-        expect(out1.status).toBe("completed")
-        // Resume: agent("x") is journaled, so it replays from cache. No reply is
-        // queued — and even if a stray spawn happened the test server would
-        // auto-"ok", so agentCount (not queue state) is the assertion that matters.
-        const resumed = yield* runtime.resume({ runID })
-        expect(resumed.runID).toBe(runID) // SAME runID
-        expect(resumed.resumed).toBe(true)
-        const out = yield* runtime.wait({ runID })
-        expect(out.status).toBe("completed")
-        expect((out as { result: unknown }).result).toBe("done") // replayed cached value
-        const st = yield* runtime.status({ runID })
-        expect(st.agentCount).toBe(0) // resume spawned nothing — pure replay
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-
-  it.live("resume refuses a still-running run", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({ title: "wf resume live", permission: [{ permission: "*", pattern: "*", action: "allow" }] })
-        yield* llm.hang
-        const script = [`export const meta = { name: "t", description: "d" }`, `return await agent("x")`].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        yield* Effect.sleep("200 millis") // let it be running
-        const r = yield* runtime.resume({ runID })
-        expect(r.resumed).toBe(false)
-        yield* runtime.cancel({ runID })
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-
-  // MR104 P2-1 — in-process double-resume race. The bug: resume()'s live-guard
-  // (runs.get(runID).status === "running") is a check-then-act, not atomic. Two
-  // concurrent resume(sameRunID) of a COMPLETED run BOTH read status "completed",
-  // BOTH pass the guard, BOTH launch() — and launch does runs.set(runID, entry),
-  // so the second clobbers the first (orphaned fiber, raced counter flush) and
-  // both fibers append to the SAME .jsonl journal (interleaved).
-  //
-  // The fix serializes the resume critical section (live-guard THROUGH launch's
-  // runs.set) with an in-process Lock.write keyed on the runID. The first waiter
-  // launches and flips the entry to "running" before releasing; the second waiter
-  // then sees status "running" at the guard and bails with resumed:false.
-  //
-  // DISCRIMINATING ASSERTION: with the lock, EXACTLY ONE of the two concurrent
-  // resumes returns resumed:true (the other resumed:false). Unlocked, BOTH pass
-  // the guard and BOTH re-launch → resumed:true twice. This is the direct, clean
-  // signal that the launch ran once, not twice, and it is DETERMINISTIC: Effect.all
-  // forks both resumes; both reach resume's first yield before either reaches
-  // launch, so unlocked they both observe status "completed" and both relaunch.
-  // (Verified empirically: against the unlocked code this assertion fails with
-  // Received: 2, fast and repeatably — not flaky.)
-  it.live("two concurrent resumes of the same completed run launch exactly once (no double-launch)", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf resume race",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        // First run: one real spawn for agent("x"). It is journaled, so every resume
-        // replays from cache (zero new spawns).
-        yield* llm.text("done")
-        const script = [`export const meta = { name: "t", description: "d" }`, `return await agent("x")`].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const first = yield* runtime.wait({ runID })
-        expect(first.status).toBe("completed")
-
-        // Fire two resume(sameRunID) concurrently. Without the lock both pass the
-        // live-guard (status is "completed") and both re-launch. With the lock the
-        // second serializes behind the first and sees status "running" → resumed:false.
-        const results = yield* Effect.all([runtime.resume({ runID }), runtime.resume({ runID })], {
-          concurrency: "unbounded",
-        })
-
-        // PRIMARY (and discriminating): exactly one re-launch happened — locked: 1
-        // true + 1 false; unlocked: 2 true (double-launch).
-        expect(results.filter((r) => r.resumed).length).toBe(1)
-        expect(results.filter((r) => !r.resumed).length).toBe(1)
-
-        // The single relaunched pass replays cleanly to completion.
-        const out = yield* runtime.wait({ runID })
-        expect(out.status).toBe("completed")
-        expect((out as { result: unknown }).result).toBe("done") // replayed cached value
-
-        // SANITY: the surviving entry is a pure cache replay (no spawn) — a double-
-        // launch that re-spawned would show agentCount > 0.
-        const st = yield* runtime.status({ runID })
-        expect(st.agentCount).toBe(0)
-
-        // Settle the relaunched fiber's terminal tail (bus.publish + inbox.send run
-        // AFTER Deferred.succeed, so wait() returns before the fiber is fully done)
-        // before the tmpdir fixture's Instance.disposeAll() tears the layer scope
-        // down. Without this drain, disposeAll can interrupt the fiber mid-tail and
-        // hang teardown — a PRE-EXISTING resume teardown flake (the upstream single-
-        // resume test exhibits it in isolation too), independent of the P2-1 lock.
-        yield* Effect.sleep("300 millis")
-      }),
-      { git: true, config: providerCfg },
-    ),
-    15000,
-  )
-})
-
-describe("WorkflowRuntime agent() label + phase opts", () => {
-  // label + phase are pure observability metadata. They land in the spawn
-  // `description` ONLY (no schema / currentPhase / counter change). The actor
-  // registry stores `description` (notNull, falls back to agentType otherwise),
-  // so the most direct observable is the child actor's registry row after the
-  // run: an agent() with {label,phase} must carry "[Implement] impl:foo".
-  it.live("label + phase thread into the spawned agent description", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const registry = yield* ActorRegistry.Service
-        const parent = yield* session.create({
-          title: "wf label",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        yield* llm.text("done")
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `return await agent("port it", { label: "impl:foo", phase: "Implement" })`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        yield* runtime.wait({ runID })
-        // The spawned subagent's registry row carries the [phase] label description.
-        // agent() defaults agentType to "general" and shares the parent session, so
-        // the child is the lone non-"main" actor in that session.
-        const actors = yield* registry.listBySession(parent.id)
-        const child = actors.find((a) => a.actorID !== "main")
-        expect(child?.description).toBe("[Implement] impl:foo")
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})
-
-describe("WorkflowRuntime replay journal", () => {
-  it.live("re-running the SAME runID replays cached results with zero new spawns", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf replay",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const r = await parallel([() => agent("a"), () => agent("b"), () => agent("c")])`,
-          `return r`,
-        ].join("\n")
-        // First run: 3 real spawns.
-        yield* llm.text("done")
-        yield* llm.text("done")
-        yield* llm.text("done")
-        const first = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const out1 = yield* runtime.wait({ runID: first.runID })
-        expect(out1.status).toBe("completed")
-        const st1 = yield* runtime.status({ runID: first.runID })
-        expect(st1.agentCount).toBe(3)
-
-        // Resume the SAME runID. The journal must replay all 3 — assert via
-        // agentCount (the spawn counter), NOT via queue starvation (the test
-        // server auto-"ok"s an unqueued request, so a stray spawn would silently
-        // succeed). We queue nothing to keep intent clear.
-        const r = yield* runtime.resume({ runID: first.runID })
-        expect(r.resumed).toBe(true)
-        const out2 = yield* runtime.wait({ runID: first.runID })
-        expect(out2.status).toBe("completed")
-        expect((out2 as { result: string[] }).result.filter((x) => x === "done").length).toBe(3)
-        const st2 = yield* runtime.status({ runID: first.runID })
-        expect(st2.agentCount).toBe(0) // ZERO new spawns on the resumed pass
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-
-  it.live("resume re-spawns ONLY the uncached unit (O(remaining), not O(all))", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf partial",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const r = await parallel([() => agent("u0"), () => agent("u1"), () => agent("u2")])`,
-          `return r`,
-        ].join("\n")
-        yield* llm.text("done")
-        yield* llm.text("done")
-        yield* llm.text("done")
-        const first = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        yield* runtime.wait({ runID: first.runID })
-
-        // Simulate a partial: drop ONE agent line from the journal so one unit is
-        // "unfinished". Distinct prompts => distinct hashes => occ 0 each, so we
-        // drop by line content (the last agent line).
-        const fs = yield* Effect.promise(() => import("fs/promises"))
-        const { Global } = yield* Effect.promise(() => import("../../src/global"))
-        const p = `${Global.Path.data}/workflow/${first.runID}.jsonl`
-        const lines = (yield* Effect.promise(() => Bun.file(p).text())).split("\n").filter(Boolean)
-        const agentLines = lines.filter((l) => l.includes('"t":"agent"'))
-        const dropKey = JSON.parse(agentLines[agentLines.length - 1]).key
-        const kept = lines.filter((l) => !l.includes(`"${dropKey}"`))
-        yield* Effect.promise(() => fs.writeFile(p, kept.join("\n") + "\n"))
-
-        // Resume: queue exactly ONE response (for the one dropped unit). The other
-        // two replay from cache. agentCount===1 is the proof.
-        yield* llm.text("done")
-        yield* runtime.resume({ runID: first.runID })
-        const out = yield* runtime.wait({ runID: first.runID })
-        expect(out.status).toBe("completed")
-        expect((out as { result: string[] }).result.filter((x) => x === "done").length).toBe(3)
-        const st = yield* runtime.status({ runID: first.runID })
-        expect(st.agentCount).toBe(1) // exactly the one uncached unit re-spawned
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-
-  // MR104 P1-2 — script-change invalidation. The journal keys results by
-  // {prompt,agentType,model,schema,phase}+occ but NOT by the script body. If the
-  // user edits the workflow script between resume cycles, replaying the OLD journal
-  // onto NEW code is silent divergence. Fix: recordStart stamps sha256(script body)
-  // on the run row; resume compares the stored sha to the current script's sha. On
-  // MISMATCH the stale journal is cleared and the run re-spawns fresh (re-stamping
-  // the new sha so a SUBSEQUENT resume of the now-current script replays correctly).
-  //
-  // DISCRIMINATOR vs the same-script resume test above: same body → sha matches →
-  // replay → agentCount 0. Changed body → sha differs → fresh → agentCount > 0, and
-  // the old journal lines are gone (cleared, not interleaved with the new pass).
-  it.live("resume with an EDITED script discards the stale journal and re-spawns fresh", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf script change",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        const scriptA = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const r = await parallel([() => agent("a"), () => agent("b")])`,
-          `return r`,
-        ].join("\n")
-        // First run under script A: 2 real spawns, both journaled.
-        yield* llm.text("done")
-        yield* llm.text("done")
-        const first = yield* runtime.start({ script: scriptA, sessionID: parent.id, parentActorID: "main", model: ref })
-        const out1 = yield* runtime.wait({ runID: first.runID })
-        expect(out1.status).toBe("completed")
-        const st1 = yield* runtime.status({ runID: first.runID })
-        expect(st1.agentCount).toBe(2)
-
-        // Edit the persisted script: overwrite <runID>.js with a DIFFERENT body
-        // (resume reads its script from this file). Same prompts but a changed body
-        // → a different sha → the stored journal must be discarded.
-        const scriptB = [
-          `export const meta = { name: "t", description: "d" }`,
-          `// edited between resume cycles — a different body changes the sha`,
-          `const r = await parallel([() => agent("a"), () => agent("b")])`,
-          `return r`,
-        ].join("\n")
-        yield* WorkflowPersistence.writeScript(first.runID, scriptB)
-
-        // Resume: the sha mismatch must force a fresh run. Queue 2 fresh replies; if
-        // the journal were (wrongly) replayed these would go unused and agentCount
-        // would be 0. agentCount === 2 is the proof of a fresh re-spawn.
-        yield* llm.text("done")
-        yield* llm.text("done")
-        const r = yield* runtime.resume({ runID: first.runID })
-        expect(r.resumed).toBe(true)
-        const out2 = yield* runtime.wait({ runID: first.runID })
-        expect(out2.status).toBe("completed")
-        expect((out2 as { result: string[] }).result.filter((x) => x === "done").length).toBe(2)
-        const st2 = yield* runtime.status({ runID: first.runID })
-        expect(st2.agentCount).toBe(2) // fresh re-spawn, NOT a 0-spawn replay
-
-        // The new sha was re-stamped: a SECOND resume of the now-current script B
-        // replays from the freshly-written journal (zero new spawns).
-        const r2 = yield* runtime.resume({ runID: first.runID })
-        expect(r2.resumed).toBe(true)
-        const out3 = yield* runtime.wait({ runID: first.runID })
-        expect(out3.status).toBe("completed")
-        const st3 = yield* runtime.status({ runID: first.runID })
-        expect(st3.agentCount).toBe(0) // sha now matches → pure replay
-      }),
-      { git: true, config: providerCfg },
-    ),
-    20000,
-  )
-})
-
-// agent() collapses every failure path to bare null, but operators need to know
-// the REASON to triage (mimo TTFT timeout vs spawn-reject vs over-cap). The
-// WorkflowAgentFailed bus event carries the reason without changing agent()'s
-// null contract — these tests pin both invariants: the script still sees null,
-// AND the bus carries one event per failed agent with the right reason.
-describe("WorkflowRuntime agent failure event (Gap 3)", () => {
-  it.live("a 400 client error → reason='no-deliverable'; success sibling → no event", () =>
-    // The actor outcome is status:"success" (agent finished its turn cleanly),
-    // but the failed-LLM call produced no assistant text → no finalText/structured
-    // to extract → deliverable is null → reason="no-deliverable". This matches the
-    // existing "a failing child yields null" test's mechanism (line 79).
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const bus = yield* Bus.Service
-        const events: Array<{ reason: string; label?: string; phase?: string }> = []
-        yield* bus.subscribeCallback(WorkflowAgentFailed, (e) => {
-          events.push({ reason: e.properties.reason, label: e.properties.label, phase: e.properties.phase })
-        })
-        const parent = yield* session.create({
-          title: "wf failreason",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        yield* llm.error(400, { error: { message: "bad request" } })
-        yield* llm.text("ok")
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `await parallel([`,
-          `  () => agent("a", { label: "fail-one", phase: "Test" }),`,
-          `  () => agent("b", { label: "ok-one" })`,
-          `])`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const outcome = yield* runtime.wait({ runID })
-        expect(outcome.status).toBe("completed")
-        // Bus is async; let the publish settle before asserting.
-        yield* Effect.sleep("100 millis")
-        expect(events.length).toBe(1)
-        expect(events[0].reason).toBe("no-deliverable")
-        expect(events[0].label).toBe("fail-one")
-        expect(events[0].phase).toBe("Test")
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-
-  it.live("a hung agent under timeoutMs → reason='timeout'", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const bus = yield* Bus.Service
-        const events: string[] = []
-        yield* bus.subscribeCallback(WorkflowAgentFailed, (e) => {
-          events.push(e.properties.reason)
-        })
-        const parent = yield* session.create({
-          title: "wf timeout",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        yield* llm.hang
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `return await agent("hangs", { timeoutMs: 50 })`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const outcome = yield* runtime.wait({ runID })
-        expect(outcome.status).toBe("completed")
-        // The script returned the null deliverable directly: it must be null
-        // (sandbox marshals host null → guest undefined; equate the two).
-        const v = (outcome as { result: unknown }).result
-        expect(v === null || v === undefined).toBe(true)
-        yield* Effect.sleep("100 millis")
-        expect(events.length).toBe(1)
-        expect(events[0]).toBe("timeout")
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-
-  it.live("over-cap rejections emit reason='over-cap' and don't increment agentCount", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* ({ llm }) {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const bus = yield* Bus.Service
-        const events: string[] = []
-        yield* bus.subscribeCallback(WorkflowAgentFailed, (e) => {
-          events.push(e.properties.reason)
-        })
-        const parent = yield* session.create({
-          title: "wf overcap",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        // 4 agents try to spawn, cap is 2 → 2 succeed, 2 hit over-cap → null.
-        for (let i = 0; i < 2; i++) yield* llm.text("done")
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `const ts = []`,
-          `for (let i = 0; i < 4; i++) ts.push(() => agent("x" + i))`,
-          `return await parallel(ts)`,
-        ].join("\n")
-        const { runID } = yield* runtime.start({
-          script,
-          sessionID: parent.id,
-          parentActorID: "main",
-          model: ref,
-          maxLifecycleAgents: 2,
-        })
-        const outcome = yield* runtime.wait({ runID })
-        expect(outcome.status).toBe("completed")
-        yield* Effect.sleep("100 millis")
-        // Exactly 2 over-cap events (the cap-exceeding spawn attempts); zero
-        // other-reason events since the 2 in-cap agents both succeeded.
-        const overCap = events.filter((r) => r === "over-cap")
-        expect(overCap.length).toBe(2)
-        expect(events.length).toBe(2) // no other reasons leaked in
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})
-
-// Math.random is seeded per-run from a hash of runID, so two unrelated runs of
-// the same script get DIFFERENT sequences (sampling-style scripts get fresh
-// coverage); a resume of the same run gets the SAME sequence (replay invariant
-// covered by other tests). This pins the cross-run divergence.
-describe("WorkflowRuntime PRNG seeding (cross-run divergence)", () => {
-  it.live("two unrelated runs of the same Math.random script get different sequences", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* () {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf prng",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        const script = [
-          `export const meta = { name: "t", description: "d" }`,
-          `return [Math.random(), Math.random(), Math.random()]`,
-        ].join("\n")
-        const a = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const ao = yield* runtime.wait({ runID: a.runID })
-        const b = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        const bo = yield* runtime.wait({ runID: b.runID })
-        expect(ao.status).toBe("completed")
-        expect(bo.status).toBe("completed")
-        const av = (ao as { result: number[] }).result
-        const bv = (bo as { result: number[] }).result
-        expect(av).not.toEqual(bv) // different runIDs → different seeds → different sequences
-        expect(av[0]).toBeGreaterThanOrEqual(0)
-        expect(av[0]).toBeLessThan(1)
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})
-
-// agent_timeout_ms is persisted on the workflow_run row at start time so a
-// resume that doesn't supply its own override (e.g. the TUI's /workflows resume
-// command, which currently passes only runID) inherits the original timeout
-// instead of silently dropping to unbounded — which used to let a wedged mimo
-// TTFT stall the resumed run forever. This test pins the "implicit-resume
-// inherits the persisted timeout" contract end-to-end via the persistence layer.
-describe("WorkflowRuntime persists agentTimeoutMs across resume (TUI-style)", () => {
-  it.live("a row started with agentTimeoutMs is readable via persistence.load", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* () {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf timeout-persist",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        const script = `export const meta = { name: "t", description: "d" }`
-        const r = yield* runtime.start({
-          script,
-          sessionID: parent.id,
-          parentActorID: "main",
-          model: ref,
-          agentTimeoutMs: 12345,
-        })
-        yield* runtime.wait({ runID: r.runID })
-        // Row is persisted with the timeout; a no-arg resume() would read this back
-        // (resume uses input.agentTimeoutMs ?? row.agentTimeoutMs as the effective
-        // value passed to launch()). Fresh-start with a value smaller than the
-        // smallest sleep would be a clean integration test, but it requires real
-        // mock timing; the persistence path is the load-bearing check so we pin
-        // that directly to keep the test cheap and deterministic.
-        const row = yield* WorkflowPersistence.load(r.runID)
-        expect(row).toBeDefined()
-        expect(row!.agentTimeoutMs).toBe(12345)
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-
-  it.live("a row started with NO timeout reads back undefined (no silent default)", () =>
-    provideTmpdirServer(
-      Effect.fnUntraced(function* () {
-        const runtime = yield* WorkflowRuntime.Service
-        const session = yield* Session.Service
-        const parent = yield* session.create({
-          title: "wf timeout-undef",
-          permission: [{ permission: "*", pattern: "*", action: "allow" }],
-        })
-        const script = `export const meta = { name: "t", description: "d" }`
-        const r = yield* runtime.start({ script, sessionID: parent.id, parentActorID: "main", model: ref })
-        yield* runtime.wait({ runID: r.runID })
-        const row = yield* WorkflowPersistence.load(r.runID)
-        expect(row).toBeDefined()
-        expect(row!.agentTimeoutMs).toBeUndefined()
-      }),
-      { git: true, config: providerCfg },
-    ),
-  )
-})