tulingcode 0.1.0

package/test/workflow/runtime.test.ts

@@ -0,0 +1,1078 @@
+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 },
+    ),
+  )
+})