@tangle-network/agent-runtime 0.15.1 → 0.16.1

package/dist/index.js

@@ -252,7 +252,9 @@ function mapCommonBackendEvent(event, context) {
   const type = String(record.type ?? "");
   const data = record.data && typeof record.data === "object" ? record.data : record;
   if (type === "message.part.updated" || type === "text_delta" || type === "delta") {
-    const text = stringValue(data.text) ?? stringValue(data.delta) ?? stringValue(record.text);
+    const part = data.part;
+    const partText = part !== void 0 && typeof part === "object" && (part.type === "text" || part.type === void 0) ? stringValue(part.text) : void 0;
+    const text = stringValue(data.text) ?? stringValue(data.delta) ?? stringValue(record.text) ?? partText;
     return text ? {
       type: "text_delta",
       task: context.task,
@@ -514,1691 +516,96 @@ function sandboxAsChatTurnTarget(instance, opts) {
   };
 }
 
-// src/durable/identity.ts
-import { createHash } from "crypto";
-function canonicalHash(value) {
-  const json = canonicalJson(value);
-  return createHash("sha256").update(json).digest("hex");
-}
-function canonicalJson(value) {
-  return JSON.stringify(canonicalize(value));
-}
-function canonicalize(value) {
-  if (value === null) return null;
-  if (Array.isArray(value)) return value.map(canonicalize);
-  const t = typeof value;
-  if (t === "string" || t === "boolean") return value;
-  if (t === "number") {
-    if (!Number.isFinite(value)) {
-      throw new TypeError(`canonicalJson: non-finite number ${String(value)} not serializable`);
-    }
-    return value;
-  }
-  if (t === "undefined" || t === "function" || t === "symbol") {
-    throw new TypeError(`canonicalJson: ${t} is not JSON-serializable`);
-  }
-  if (t === "bigint") {
-    return { __bigint: String(value) };
-  }
-  if (t === "object") {
-    const obj = value;
-    const proto = Object.getPrototypeOf(obj);
-    if (proto !== null && proto !== Object.prototype) {
-      const ctor = obj.constructor?.name ?? "unknown";
-      throw new TypeError(
-        `canonicalJson: class instance (${ctor}) is not JSON-serializable. Project to plain { ... } at the boundary.`
-      );
-    }
-    const keys = Object.keys(obj).sort();
-    const out = {};
-    for (const k of keys) out[k] = canonicalize(obj[k]);
-    return out;
-  }
-  throw new TypeError(`canonicalJson: unsupported type ${t}`);
-}
-function manifestHash(manifest) {
-  return canonicalHash({
-    projectId: manifest.projectId,
-    scenarioId: manifest.scenarioId ?? null,
-    taskId: manifest.task.id,
-    taskIntent: manifest.task.intent,
-    taskDomain: manifest.task.domain,
-    input: manifest.input
-  });
-}
-function stepId(runId, stepIndex, intent) {
-  return canonicalHash({ runId, stepIndex, intent });
-}
-var counter = 0;
-function deriveWorkerId() {
-  const host = process.env.HOSTNAME ?? "host";
-  const pid = process.pid ?? 0;
-  const rand = Math.random().toString(36).slice(2, 10);
-  counter += 1;
-  return `${host}:${pid}:${rand}:${counter}`;
-}
-
-// src/durable/turn.ts
-var STEP_INDEX = 0;
-function runDurableTurn(options) {
-  const { store, runId, manifest, workerId } = options;
-  const leaseMs = options.leaseMs ?? 6e4;
-  const intent = options.intent ?? "turn";
-  const inputHash = canonicalHash(manifest.input);
-  let accumulated = "";
-  let didReplay = false;
-  let finalRecord;
-  async function* stream() {
-    const { completedSteps } = await store.startOrResume({
-      runId,
-      manifest,
-      workerId,
-      leaseMs
-    });
-    const prior = completedSteps.find((s) => s.stepIndex === STEP_INDEX);
-    if (prior && prior.status === "completed") {
-      didReplay = true;
-      const cached = prior.result;
-      accumulated = cached?.finalText ?? "";
-      yield options.replayEvent(accumulated);
-      finalRecord = await store.endRun({ runId, workerId, status: "completed" });
-      return;
-    }
-    await store.beginStep({
-      runId,
-      stepIndex: STEP_INDEX,
-      intent,
-      kind: "llm",
-      inputHash
-    });
-    try {
-      const producer = options.produce();
-      for await (const event of producer.stream) {
-        if (options.accumulate) {
-          const next = options.accumulate(event, accumulated);
-          if (typeof next === "string") accumulated = next;
-        }
-        yield event;
-      }
-      const producerText = producer.finalText();
-      if (producerText) accumulated = producerText;
-      await store.completeStep({
-        runId,
-        stepIndex: STEP_INDEX,
-        result: { finalText: accumulated }
-      });
-      finalRecord = await store.endRun({
-        runId,
-        workerId,
-        status: "completed",
-        outcome: { notes: intent, metadata: { chars: accumulated.length } }
-      });
-    } catch (err) {
-      await store.failStep({
-        runId,
-        stepIndex: STEP_INDEX,
-        error: { message: err instanceof Error ? err.message : String(err) }
-      });
-      finalRecord = await store.endRun({ runId, workerId, status: "failed" });
-      throw err;
-    }
-  }
-  return {
-    stream: stream(),
-    finalText: () => accumulated,
-    replayed: () => didReplay,
-    record: () => finalRecord
-  };
-}
-
 // src/durable/chat-engine.ts
 var encoder = new TextEncoder();
 function encodeLine(event) {
   return encoder.encode(`${JSON.stringify(event)}
 `);
 }
-var DurableChatTurnEngine = class {
-  /**
-   * Run one durable chat turn. Returns immediately with a `ReadableStream`
-   * body; the turn executes as the body is pulled. Never rejects — backend
-   * failures surface as `error` + `session.run.failed` events.
-   */
-  runTurn(input) {
-    const workerId = input.workerId ?? deriveWorkerId();
-    const log = input.log ?? (() => void 0);
-    const { identity } = input;
-    const runId = `chat:${identity.sessionId}:${identity.turnIndex}`;
-    const manifest = {
-      projectId: input.projectId,
-      scenarioId: identity.sessionId,
-      task: {
-        id: `${input.projectId}:chat:${identity.sessionId}:${identity.turnIndex}`,
-        intent: `Run a ${input.domain} chat turn with workspace context.`,
-        domain: input.domain,
-        requiredKnowledge: [],
-        metadata: {
-          tenantId: identity.tenantId,
-          sessionId: identity.sessionId,
-          turnIndex: identity.turnIndex
+function defaultLog(message, meta) {
+  if (meta) console.error(message, meta);
+  else console.error(message);
+}
+function handleChatTurn(input) {
+  const log = input.log ?? defaultLog;
+  const { identity, hooks } = input;
+  const body = new ReadableStream({
+    start: async (controller) => {
+      const emit2 = async (event) => {
+        controller.enqueue(encodeLine(event));
+        if (hooks.onEvent) {
+          try {
+            await hooks.onEvent(event);
+          } catch (err) {
+            log("[chat-engine] onEvent hook threw", {
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
         }
-      },
-      input: {
-        userMessage: input.userMessage,
-        model: input.model ?? null
-      },
-      tags: {
-        session_id: identity.sessionId,
-        tenant_id: identity.tenantId
-      }
-    };
-    const body = new ReadableStream({
-      start: async (controller) => {
-        const emit2 = async (event) => {
-          controller.enqueue(encodeLine(event));
-          if (input.hooks.onEvent) {
-            try {
-              await input.hooks.onEvent(event);
-            } catch (err) {
-              log("[chat-engine] onEvent hook threw", {
-                error: err instanceof Error ? err.message : String(err)
-              });
-            }
+      };
+      try {
+        await emit2({
+          type: "session.run.started",
+          data: {
+            sessionId: identity.sessionId,
+            tenantId: identity.tenantId,
+            turnIndex: identity.turnIndex
           }
-        };
-        let turnFailed = false;
+        });
+        const producer = hooks.produce();
+        for await (const event of producer.stream) {
+          await emit2(event);
+        }
+        const rawFinal = producer.finalText();
+        const finalText = hooks.transformFinalText ? await hooks.transformFinalText(rawFinal) : rawFinal;
         try {
-          await emit2({
-            type: "session.run.started",
-            data: {
-              sessionId: identity.sessionId,
-              tenantId: identity.tenantId,
-              turnIndex: identity.turnIndex
-            }
-          });
-          const turn = runDurableTurn({
-            store: input.store,
-            runId,
-            manifest,
-            workerId,
-            leaseMs: input.leaseMs,
-            intent: `chat:turn-${identity.turnIndex}`,
-            produce: input.hooks.produce,
-            replayEvent: (finalText2) => ({ type: "result", data: { finalText: finalText2 } }),
-            accumulate: (event, current) => {
-              if (event.type === "message.part.updated") {
-                const data = event.data ?? {};
-                const delta = typeof data.delta === "string" ? data.delta : "";
-                const part = data.part;
-                if (delta) return current + delta;
-                if (part?.type === "text" && typeof part.text === "string") return part.text;
-                return void 0;
-              }
-              if (event.type === "result") {
-                const data = event.data ?? {};
-                if (typeof data.finalText === "string") return data.finalText;
-              }
-              return void 0;
-            }
-          });
-          for await (const event of turn.stream) {
-            await emit2(event);
-          }
-          const rawFinal = turn.finalText();
-          const finalText = input.hooks.transformFinalText ? await input.hooks.transformFinalText(rawFinal) : rawFinal;
-          if (!turn.replayed()) {
-            try {
-              await input.hooks.persistAssistantMessage({
-                identity,
-                finalText,
-                record: turn.record()
-              });
-            } catch (err) {
-              log("[chat-engine] persistAssistantMessage threw", {
-                error: err instanceof Error ? err.message : String(err)
-              });
-            }
-            if (input.hooks.onTurnComplete) {
-              try {
-                await input.hooks.onTurnComplete({ identity, finalText });
-              } catch (err) {
-                log("[chat-engine] onTurnComplete threw", {
-                  error: err instanceof Error ? err.message : String(err)
-                });
-              }
-            }
-          }
-          await emit2({
-            type: "session.run.completed",
-            data: { sessionId: identity.sessionId, replayed: turn.replayed() }
-          });
+          await hooks.persistAssistantMessage({ identity, finalText });
         } catch (err) {
-          turnFailed = true;
-          const message = err instanceof Error ? err.message : String(err);
-          log("[chat-engine] turn failed", { error: message });
-          await emit2({ type: "error", data: { message } });
-          await emit2({
-            type: "session.run.failed",
-            data: { sessionId: identity.sessionId, message }
+          log("[chat-engine] persistAssistantMessage threw", {
+            error: err instanceof Error ? err.message : String(err)
           });
-        } finally {
-          if (input.hooks.traceFlush) {
-            const flush = input.hooks.traceFlush().catch(
-              (err) => log("[chat-engine] traceFlush threw", {
-                error: err instanceof Error ? err.message : String(err)
-              })
-            );
-            if (input.waitUntil) input.waitUntil(flush);
-            else await flush;
-          }
-          controller.close();
-          void turnFailed;
         }
-      }
-    });
-    return { body, contentType: "application/x-ndjson" };
-  }
-};
-var durableChatTurnEngine = new DurableChatTurnEngine();
-
-// src/durable/types.ts
-var DurableRunError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = this.constructor.name;
-  }
-  code;
-};
-var DurableRunLeaseHeldError = class extends DurableRunError {
-  constructor(message) {
-    super(message, "lease_held");
-  }
-};
-var DurableRunInputMismatchError = class extends DurableRunError {
-  constructor(message) {
-    super(message, "manifest_mismatch");
-  }
-};
-var DurableRunDivergenceError = class extends DurableRunError {
-  constructor(message) {
-    super(message, "step_divergence");
-  }
-};
-var DurableAwaitEventTimeoutError = class extends DurableRunError {
-  constructor(message) {
-    super(message, "await_event_timeout");
-  }
-};
-
-// src/durable/d1-store.ts
-var DEFAULT_LEASE_MS = 3e4;
-var D1DurableRunStore = class {
-  constructor(db) {
-    this.db = db;
-  }
-  db;
-  /** Override for tests — defaults to Date.now(). */
-  now = () => Date.now();
-  async startOrResume(input) {
-    const leaseMs = input.leaseMs ?? DEFAULT_LEASE_MS;
-    const hash = manifestHash(input.manifest);
-    const nowMs = this.now();
-    const nowIso2 = new Date(nowMs).toISOString();
-    const leaseExpiresAt = new Date(nowMs + leaseMs).toISOString();
-    const existing = await this.db.prepare("SELECT * FROM durable_runs WHERE run_id = ?").bind(input.runId).first();
-    if (!existing) {
-      await this.db.prepare(
-        `INSERT INTO durable_runs
-             (run_id, manifest_hash, project_id, scenario_id, status,
-              created_at, updated_at, lease_holder_id, lease_expires_at, step_count)
-           VALUES (?, ?, ?, ?, 'running', ?, ?, ?, ?, 0)`
-      ).bind(
-        input.runId,
-        hash,
-        input.manifest.projectId,
-        input.manifest.scenarioId ?? null,
-        nowIso2,
-        nowIso2,
-        input.workerId,
-        leaseExpiresAt
-      ).run();
-      const record2 = {
-        runId: input.runId,
-        manifestHash: hash,
-        projectId: input.manifest.projectId,
-        scenarioId: input.manifest.scenarioId,
-        status: "running",
-        createdAt: nowIso2,
-        updatedAt: nowIso2,
-        leaseHolderId: input.workerId,
-        leaseExpiresAt,
-        stepCount: 0
-      };
-      return { run: record2, completedSteps: [], leaseExpiresAt };
-    }
-    if (existing.manifest_hash !== hash) {
-      throw new DurableRunInputMismatchError(
-        `runId ${input.runId} exists with a different manifest hash; refuse to corrupt prior steps`
-      );
-    }
-    const claim = await this.db.prepare(
-      `UPDATE durable_runs
-           SET lease_holder_id = ?,
-               lease_expires_at = ?,
-               updated_at = ?,
-               status = CASE WHEN status IN ('completed','failed') THEN status ELSE 'running' END
-         WHERE run_id = ?
-           AND (
-             lease_holder_id = ? OR
-             lease_holder_id IS NULL OR
-             lease_expires_at IS NULL OR
-             lease_expires_at < ?
-           )`
-    ).bind(input.workerId, leaseExpiresAt, nowIso2, input.runId, input.workerId, nowIso2).run();
-    const changes = claim.meta?.changes ?? 0;
-    if (changes === 0) {
-      throw new DurableRunLeaseHeldError(
-        `runId ${input.runId} leased by ${existing.lease_holder_id} until ${existing.lease_expires_at}`
-      );
-    }
-    const completedSteps = await this.readSteps(input.runId, "completed");
-    const record = rowToRunRecord({
-      ...existing,
-      lease_holder_id: input.workerId,
-      lease_expires_at: leaseExpiresAt,
-      updated_at: nowIso2,
-      status: existing.status === "completed" || existing.status === "failed" ? existing.status : "running"
-    });
-    return { run: record, completedSteps, leaseExpiresAt };
-  }
-  async renewLease(input) {
-    const nowMs = this.now();
-    const nowIso2 = new Date(nowMs).toISOString();
-    const leaseExpiresAt = new Date(nowMs + (input.leaseMs ?? DEFAULT_LEASE_MS)).toISOString();
-    const res = await this.db.prepare(
-      `UPDATE durable_runs
-           SET lease_expires_at = ?, updated_at = ?
-         WHERE run_id = ?
-           AND (lease_holder_id = ? OR lease_expires_at IS NULL OR lease_expires_at < ?)`
-    ).bind(leaseExpiresAt, nowIso2, input.runId, input.workerId, nowIso2).run();
-    const ok = (res.meta?.changes ?? 0) > 0;
-    return ok ? { ok: true, leaseExpiresAt } : { ok: false };
-  }
-  async loadStep(runId, stepIndex) {
-    const row = await this.db.prepare("SELECT * FROM durable_steps WHERE run_id = ? AND step_index = ?").bind(runId, stepIndex).first();
-    return row ? rowToStepRecord(row) : void 0;
-  }
-  async beginStep(input) {
-    const nowIso2 = new Date(this.now()).toISOString();
-    const prior = await this.loadStep(input.runId, input.stepIndex);
-    if (prior) {
-      if (prior.intent !== input.intent) {
-        throw new DurableRunDivergenceError(
-          `step ${input.stepIndex}: intent changed ('${prior.intent}' -> '${input.intent}')`
-        );
-      }
-      await this.db.prepare(
-        `UPDATE durable_steps
-             SET status='running', attempts = attempts + 1, started_at = ?, error_json = NULL
-           WHERE run_id = ? AND step_index = ?`
-      ).bind(nowIso2, input.runId, input.stepIndex).run();
-      await this.bumpUpdated(input.runId, nowIso2);
-      return {
-        ...prior,
-        attempts: prior.attempts + 1,
-        status: "running",
-        startedAt: nowIso2,
-        error: void 0
-      };
-    }
-    await this.db.prepare(
-      `INSERT INTO durable_steps
-           (run_id, step_index, intent, kind, input_hash, status, attempts, started_at)
-         VALUES (?, ?, ?, ?, ?, 'running', 1, ?)`
-    ).bind(input.runId, input.stepIndex, input.intent, input.kind, input.inputHash, nowIso2).run();
-    await this.db.prepare(
-      `UPDATE durable_runs
-           SET step_count = MAX(step_count, ?), updated_at = ?
-         WHERE run_id = ?`
-    ).bind(input.stepIndex + 1, nowIso2, input.runId).run();
-    return {
-      runId: input.runId,
-      stepIndex: input.stepIndex,
-      intent: input.intent,
-      kind: input.kind,
-      inputHash: input.inputHash,
-      status: "running",
-      attempts: 1,
-      startedAt: nowIso2
-    };
-  }
-  async completeStep(input) {
-    const nowIso2 = new Date(this.now()).toISOString();
-    await this.db.prepare(
-      `UPDATE durable_steps
-           SET status='completed', result_json = ?, completed_at = ?, error_json = NULL
-         WHERE run_id = ? AND step_index = ?`
-    ).bind(JSON.stringify(input.result ?? null), nowIso2, input.runId, input.stepIndex).run();
-    await this.bumpUpdated(input.runId, nowIso2);
-    const row = await this.loadStep(input.runId, input.stepIndex);
-    if (!row) {
-      throw new Error(`durable-runs: completeStep cannot find step ${input.stepIndex}`);
-    }
-    return row;
-  }
-  async failStep(input) {
-    const nowIso2 = new Date(this.now()).toISOString();
-    await this.db.prepare(
-      `UPDATE durable_steps
-           SET status='failed', error_json = ?, completed_at = ?
-         WHERE run_id = ? AND step_index = ?`
-    ).bind(JSON.stringify(input.error), nowIso2, input.runId, input.stepIndex).run();
-    await this.bumpUpdated(input.runId, nowIso2);
-    const row = await this.loadStep(input.runId, input.stepIndex);
-    if (!row) {
-      throw new Error(`durable-runs: failStep cannot find step ${input.stepIndex}`);
-    }
-    return row;
-  }
-  async endRun(input) {
-    const nowIso2 = new Date(this.now()).toISOString();
-    await this.db.prepare(
-      `UPDATE durable_runs
-           SET status = ?, completed_at = ?, updated_at = ?,
-               outcome_json = ?,
-               lease_holder_id = CASE WHEN lease_holder_id = ? THEN NULL ELSE lease_holder_id END,
-               lease_expires_at = CASE WHEN lease_holder_id = ? THEN NULL ELSE lease_expires_at END
-         WHERE run_id = ?`
-    ).bind(
-      input.status,
-      nowIso2,
-      nowIso2,
-      input.outcome ? JSON.stringify(input.outcome) : null,
-      input.workerId,
-      input.workerId,
-      input.runId
-    ).run();
-    const row = await this.db.prepare("SELECT * FROM durable_runs WHERE run_id = ?").bind(input.runId).first();
-    if (!row) throw new Error(`durable-runs: endRun cannot find run ${input.runId}`);
-    return rowToRunRecord(row);
-  }
-  async emitEvent(input) {
-    const nowIso2 = new Date(this.now()).toISOString();
-    const res = await this.db.prepare(
-      `INSERT OR IGNORE INTO durable_events (run_id, key, payload_json, emitted_at)
-         VALUES (?, ?, ?, ?)`
-    ).bind(input.runId, input.key, JSON.stringify(input.payload ?? null), nowIso2).run();
-    const accepted = (res.meta?.changes ?? 0) > 0;
-    const row = await this.db.prepare("SELECT * FROM durable_events WHERE run_id = ? AND key = ?").bind(input.runId, input.key).first();
-    if (!row) throw new Error("durable-runs: emitEvent failed to persist or read back");
-    return {
-      accepted,
-      record: rowToEventRecord(row)
-    };
-  }
-  async loadEvent(runId, key) {
-    const row = await this.db.prepare("SELECT * FROM durable_events WHERE run_id = ? AND key = ?").bind(runId, key).first();
-    return row ? rowToEventRecord(row) : void 0;
-  }
-  async appendStreamEvent(input) {
-    const nowIso2 = new Date(this.now()).toISOString();
-    const res = await this.db.prepare(
-      `INSERT OR IGNORE INTO durable_stream_events (run_id, seq, event_id, payload_json, appended_at)
-         VALUES (
-           ?,
-           (SELECT COALESCE(MAX(seq), -1) + 1 FROM durable_stream_events WHERE run_id = ?),
-           ?, ?, ?
-         )`
-    ).bind(input.runId, input.runId, input.eventId, JSON.stringify(input.payload ?? null), nowIso2).run();
-    const accepted = (res.meta?.changes ?? 0) > 0;
-    const row = await this.db.prepare("SELECT * FROM durable_stream_events WHERE run_id = ? AND event_id = ?").bind(input.runId, input.eventId).first();
-    if (!row) throw new Error("durable-runs: appendStreamEvent failed to persist or read back");
-    return { accepted, record: rowToStreamEventRecord(row) };
-  }
-  async readStreamEvents(runId, afterSeq) {
-    const { results } = await this.db.prepare("SELECT * FROM durable_stream_events WHERE run_id = ? AND seq > ? ORDER BY seq").bind(runId, afterSeq ?? -1).all();
-    return results.map(rowToStreamEventRecord);
-  }
-  async setRunHandle(input) {
-    const nowIso2 = new Date(this.now()).toISOString();
-    await this.db.prepare("UPDATE durable_runs SET handle_json = ?, updated_at = ? WHERE run_id = ?").bind(JSON.stringify(input.handle), nowIso2, input.runId).run();
-  }
-  async close() {
-  }
-  /** Inspect the currently-applied schema version. */
-  async getSchemaVersion() {
-    const row = await this.db.prepare("SELECT MAX(version) AS version FROM durable_schema_info").first();
-    return row?.version ?? void 0;
-  }
-  // ── internals ──────────────────────────────────────────────────────
-  async readSteps(runId, status) {
-    const { results } = await this.db.prepare("SELECT * FROM durable_steps WHERE run_id = ? AND status = ? ORDER BY step_index").bind(runId, status).all();
-    return results.map(rowToStepRecord);
-  }
-  async bumpUpdated(runId, nowIso2) {
-    await this.db.prepare("UPDATE durable_runs SET updated_at = ? WHERE run_id = ?").bind(nowIso2, runId).run();
-  }
-};
-function rowToRunRecord(row) {
-  return {
-    runId: row.run_id,
-    manifestHash: row.manifest_hash,
-    projectId: row.project_id,
-    scenarioId: row.scenario_id ?? void 0,
-    status: row.status,
-    createdAt: row.created_at,
-    updatedAt: row.updated_at,
-    completedAt: row.completed_at ?? void 0,
-    leaseHolderId: row.lease_holder_id ?? void 0,
-    leaseExpiresAt: row.lease_expires_at ?? void 0,
-    outcome: row.outcome_json ? JSON.parse(row.outcome_json) : void 0,
-    stepCount: row.step_count,
-    handle: row.handle_json ? JSON.parse(row.handle_json) : void 0
-  };
-}
-function rowToStreamEventRecord(row) {
-  return {
-    runId: row.run_id,
-    seq: row.seq,
-    eventId: row.event_id,
-    payload: row.payload_json ? JSON.parse(row.payload_json) : null,
-    appendedAt: row.appended_at
-  };
-}
-function rowToStepRecord(row) {
-  return {
-    runId: row.run_id,
-    stepIndex: row.step_index,
-    intent: row.intent,
-    kind: row.kind,
-    inputHash: row.input_hash,
-    status: row.status,
-    attempts: row.attempts,
-    result: row.result_json ? JSON.parse(row.result_json) : void 0,
-    error: row.error_json ? JSON.parse(row.error_json) : void 0,
-    startedAt: row.started_at ?? void 0,
-    completedAt: row.completed_at ?? void 0
-  };
-}
-function rowToEventRecord(row) {
-  return {
-    runId: row.run_id,
-    key: row.key,
-    payload: row.payload_json ? JSON.parse(row.payload_json) : null,
-    emittedAt: row.emitted_at
-  };
-}
-
-// src/durable/file-system-store.ts
-import { existsSync, mkdirSync } from "fs";
-import { appendFile, readdir, readFile, rename, writeFile } from "fs/promises";
-import { join } from "path";
-var DEFAULT_LEASE_MS2 = 3e4;
-var FileSystemDurableRunStore = class {
-  constructor(root) {
-    this.root = root;
-    mkdirSync(root, { recursive: true });
-  }
-  root;
-  /** Override for tests — defaults to Date.now(). */
-  now = () => Date.now();
-  async startOrResume(input) {
-    const leaseMs = input.leaseMs ?? DEFAULT_LEASE_MS2;
-    const hash = manifestHash(input.manifest);
-    const nowMs = this.now();
-    const nowIso2 = new Date(nowMs).toISOString();
-    const leaseExpiresAt = new Date(nowMs + leaseMs).toISOString();
-    const dir = this.runDir(input.runId);
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
-      const record2 = {
-        runId: input.runId,
-        manifestHash: hash,
-        projectId: input.manifest.projectId,
-        scenarioId: input.manifest.scenarioId,
-        status: "running",
-        createdAt: nowIso2,
-        updatedAt: nowIso2,
-        leaseHolderId: input.workerId,
-        leaseExpiresAt,
-        stepCount: 0
-      };
-      await this.writeRun(record2);
-      await this.writeLease(input.runId, { workerId: input.workerId, leaseExpiresAt });
-      await appendFile(join(dir, "steps.jsonl"), "", "utf8");
-      await appendFile(join(dir, "events.jsonl"), "", "utf8");
-      await appendFile(join(dir, "stream-events.jsonl"), "", "utf8");
-      return { run: record2, completedSteps: [], leaseExpiresAt };
-    }
-    const record = await this.readRun(input.runId);
-    if (record.manifestHash !== hash) {
-      throw new DurableRunInputMismatchError(
-        `runId ${input.runId} exists with a different manifest hash; refuse to corrupt prior steps`
-      );
-    }
-    const lease = await this.readLeaseSafe(input.runId);
-    const leaseStillLive = lease && lease.workerId !== input.workerId && new Date(lease.leaseExpiresAt).getTime() > nowMs;
-    if (leaseStillLive) {
-      throw new DurableRunLeaseHeldError(
-        `runId ${input.runId} leased by ${lease.workerId} until ${lease.leaseExpiresAt}`
-      );
-    }
-    const completedSteps = await this.readSteps(input.runId);
-    const nextRecord = {
-      ...record,
-      status: record.status === "completed" || record.status === "failed" ? record.status : "running",
-      updatedAt: nowIso2,
-      leaseHolderId: input.workerId,
-      leaseExpiresAt
-    };
-    await this.writeRun(nextRecord);
-    await this.writeLease(input.runId, { workerId: input.workerId, leaseExpiresAt });
-    return { run: nextRecord, completedSteps, leaseExpiresAt };
-  }
-  async renewLease(input) {
-    const lease = await this.readLeaseSafe(input.runId);
-    const nowMs = this.now();
-    if (lease && lease.workerId !== input.workerId) {
-      if (new Date(lease.leaseExpiresAt).getTime() > nowMs) {
-        return { ok: false };
-      }
-    }
-    const leaseExpiresAt = new Date(nowMs + (input.leaseMs ?? DEFAULT_LEASE_MS2)).toISOString();
-    await this.writeLease(input.runId, { workerId: input.workerId, leaseExpiresAt });
-    return { ok: true, leaseExpiresAt };
-  }
-  async loadStep(runId, stepIndex) {
-    const steps = await this.readSteps(runId, { includeFailed: true, includeRunning: true });
-    return steps.find((s) => s.stepIndex === stepIndex);
-  }
-  async beginStep(input) {
-    const all = await this.readSteps(input.runId, { includeFailed: true, includeRunning: true });
-    const prior = all.find((s) => s.stepIndex === input.stepIndex);
-    const nowIso2 = new Date(this.now()).toISOString();
-    if (prior) {
-      if (prior.intent !== input.intent) {
-        throw new DurableRunDivergenceError(
-          `step ${input.stepIndex}: intent changed ('${prior.intent}' -> '${input.intent}')`
-        );
-      }
-      const rec2 = {
-        ...prior,
-        attempts: prior.attempts + 1,
-        status: "running",
-        startedAt: nowIso2,
-        error: void 0
-      };
-      await this.appendStep(input.runId, rec2);
-      await this.bumpRunUpdated(input.runId, nowIso2);
-      return rec2;
-    }
-    const rec = {
-      runId: input.runId,
-      stepIndex: input.stepIndex,
-      intent: input.intent,
-      kind: input.kind,
-      inputHash: input.inputHash,
-      status: "running",
-      attempts: 1,
-      startedAt: nowIso2
-    };
-    await this.appendStep(input.runId, rec);
-    const record = await this.readRun(input.runId);
-    record.stepCount = Math.max(record.stepCount, input.stepIndex + 1);
-    record.updatedAt = nowIso2;
-    await this.writeRun(record);
-    return rec;
-  }
-  async completeStep(input) {
-    const all = await this.readSteps(input.runId, { includeFailed: true, includeRunning: true });
-    const prior = all.find((s) => s.stepIndex === input.stepIndex);
-    if (!prior) {
-      throw new Error(
-        `durable-runs: completeStep called before beginStep (step ${input.stepIndex})`
-      );
-    }
-    const nowIso2 = new Date(this.now()).toISOString();
-    const rec = {
-      ...prior,
-      status: "completed",
-      result: input.result,
-      completedAt: nowIso2,
-      error: void 0
-    };
-    await this.appendStep(input.runId, rec);
-    await this.bumpRunUpdated(input.runId, nowIso2);
-    return rec;
-  }
-  async failStep(input) {
-    const all = await this.readSteps(input.runId, { includeFailed: true, includeRunning: true });
-    const prior = all.find((s) => s.stepIndex === input.stepIndex);
-    if (!prior) {
-      throw new Error(`durable-runs: failStep called before beginStep (step ${input.stepIndex})`);
-    }
-    const nowIso2 = new Date(this.now()).toISOString();
-    const rec = {
-      ...prior,
-      status: "failed",
-      error: input.error,
-      completedAt: nowIso2
-    };
-    await this.appendStep(input.runId, rec);
-    await this.bumpRunUpdated(input.runId, nowIso2);
-    return rec;
-  }
-  async endRun(input) {
-    const record = await this.readRun(input.runId);
-    const nowIso2 = new Date(this.now()).toISOString();
-    record.status = input.status;
-    record.outcome = input.outcome;
-    record.completedAt = nowIso2;
-    record.updatedAt = nowIso2;
-    const lease = await this.readLeaseSafe(input.runId);
-    if (lease && lease.workerId === input.workerId) {
-      record.leaseHolderId = void 0;
-      record.leaseExpiresAt = void 0;
-      await this.writeLease(input.runId, null);
-    }
-    await this.writeRun(record);
-    return record;
-  }
-  async emitEvent(input) {
-    const existing = await this.loadEvent(input.runId, input.key);
-    if (existing) return { accepted: false, record: existing };
-    const rec = {
-      runId: input.runId,
-      key: input.key,
-      payload: input.payload,
-      emittedAt: new Date(this.now()).toISOString()
-    };
-    await appendFile(
-      join(this.runDir(input.runId), "events.jsonl"),
-      `${JSON.stringify(rec)}
-`,
-      "utf8"
-    );
-    return { accepted: true, record: rec };
-  }
-  async loadEvent(runId, key) {
-    const path = join(this.runDir(runId), "events.jsonl");
-    if (!existsSync(path)) return void 0;
-    const content = await readFile(path, "utf8");
-    for (const line of content.split("\n").reverse()) {
-      if (!line) continue;
-      const rec = JSON.parse(line);
-      if (rec.key === key) return rec;
-    }
-    return void 0;
-  }
-  async appendStreamEvent(input) {
-    const existing = await this.readStreamEventsRaw(input.runId);
-    const dup = existing.find((e) => e.eventId === input.eventId);
-    if (dup) return { accepted: false, record: dup };
-    const rec = {
-      runId: input.runId,
-      seq: existing.length,
-      eventId: input.eventId,
-      payload: input.payload,
-      appendedAt: new Date(this.now()).toISOString()
-    };
-    await appendFile(
-      join(this.runDir(input.runId), "stream-events.jsonl"),
-      `${JSON.stringify(rec)}
-`,
-      "utf8"
-    );
-    return { accepted: true, record: rec };
-  }
-  async readStreamEvents(runId, afterSeq) {
-    const cutoff = afterSeq ?? -1;
-    return (await this.readStreamEventsRaw(runId)).filter((e) => e.seq > cutoff);
-  }
-  async setRunHandle(input) {
-    const record = await this.readRun(input.runId);
-    record.handle = input.handle;
-    record.updatedAt = new Date(this.now()).toISOString();
-    await this.writeRun(record);
-  }
-  async close() {
-  }
-  async readStreamEventsRaw(runId) {
-    const path = join(this.runDir(runId), "stream-events.jsonl");
-    if (!existsSync(path)) return [];
-    const content = await readFile(path, "utf8");
-    const out = [];
-    for (const line of content.split("\n")) {
-      if (!line) continue;
-      out.push(JSON.parse(line));
-    }
-    return out.sort((a, b) => a.seq - b.seq);
-  }
-  /** @internal — used by tests to list runs in the store. */
-  async _listRunIds() {
-    if (!existsSync(this.root)) return [];
-    const entries = await readdir(this.root, { withFileTypes: true });
-    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
-  }
-  // ── internals ──────────────────────────────────────────────────────
-  runDir(runId) {
-    return join(this.root, runId);
-  }
-  async readRun(runId) {
-    const path = join(this.runDir(runId), "run.json");
-    const content = await readFile(path, "utf8");
-    return JSON.parse(content);
-  }
-  async writeRun(record) {
-    const dir = this.runDir(record.runId);
-    const path = join(dir, "run.json");
-    const tmp = `${path}.tmp`;
-    await writeFile(tmp, JSON.stringify(record, null, 2), "utf8");
-    await rename(tmp, path);
-  }
-  async readLeaseSafe(runId) {
-    const path = join(this.runDir(runId), "lease.json");
-    if (!existsSync(path)) return void 0;
-    try {
-      const content = await readFile(path, "utf8");
-      if (!content.trim()) return void 0;
-      return JSON.parse(content);
-    } catch {
-      return void 0;
-    }
-  }
-  async writeLease(runId, lease) {
-    const path = join(this.runDir(runId), "lease.json");
-    const tmp = `${path}.tmp`;
-    await writeFile(tmp, lease ? JSON.stringify(lease) : "", "utf8");
-    await rename(tmp, path);
-  }
-  async readSteps(runId, opts = {}) {
-    const path = join(this.runDir(runId), "steps.jsonl");
-    if (!existsSync(path)) return [];
-    const content = await readFile(path, "utf8");
-    const latest = /* @__PURE__ */ new Map();
-    for (const line of content.split("\n")) {
-      if (!line) continue;
-      const rec = JSON.parse(line);
-      latest.set(rec.stepIndex, rec);
-    }
-    const out = [...latest.values()].sort((a, b) => a.stepIndex - b.stepIndex);
-    return out.filter((s) => {
-      if (s.status === "completed") return true;
-      if (s.status === "failed") return opts.includeFailed ?? false;
-      if (s.status === "running") return opts.includeRunning ?? false;
-      return false;
-    });
-  }
-  async appendStep(runId, rec) {
-    await appendFile(join(this.runDir(runId), "steps.jsonl"), `${JSON.stringify(rec)}
-`, "utf8");
-  }
-  async bumpRunUpdated(runId, nowIso2) {
-    const record = await this.readRun(runId);
-    record.updatedAt = nowIso2;
-    await this.writeRun(record);
-  }
-};
-
-// src/durable/in-memory-store.ts
-var DEFAULT_LEASE_MS3 = 3e4;
-var InMemoryDurableRunStore = class {
-  runs = /* @__PURE__ */ new Map();
-  /** Override for tests — defaults to Date.now(). */
-  now = () => Date.now();
-  async startOrResume(input) {
-    const leaseMs = input.leaseMs ?? DEFAULT_LEASE_MS3;
-    const hash = manifestHash(input.manifest);
-    const nowMs = this.now();
-    const nowIso2 = new Date(nowMs).toISOString();
-    const leaseExpiresMs = nowMs + leaseMs;
-    const leaseExpiresAt = new Date(leaseExpiresMs).toISOString();
-    let state = this.runs.get(input.runId);
-    if (!state) {
-      const record = {
-        runId: input.runId,
-        manifestHash: hash,
-        projectId: input.manifest.projectId,
-        scenarioId: input.manifest.scenarioId,
-        status: "running",
-        createdAt: nowIso2,
-        updatedAt: nowIso2,
-        leaseHolderId: input.workerId,
-        leaseExpiresAt,
-        stepCount: 0
-      };
-      state = { record, steps: /* @__PURE__ */ new Map(), events: /* @__PURE__ */ new Map(), streamEvents: [] };
-      this.runs.set(input.runId, state);
-      return { run: { ...record }, completedSteps: [], leaseExpiresAt };
-    }
-    if (state.record.manifestHash !== hash) {
-      throw new DurableRunInputMismatchError(
-        `runId ${input.runId} exists with a different manifest hash; refuse to corrupt prior steps`
-      );
-    }
-    const leaseStillLive = state.record.leaseHolderId !== void 0 && state.record.leaseHolderId !== input.workerId && state.record.leaseExpiresAt !== void 0 && new Date(state.record.leaseExpiresAt).getTime() > nowMs;
-    if (leaseStillLive) {
-      throw new DurableRunLeaseHeldError(
-        `runId ${input.runId} is leased by ${state.record.leaseHolderId} until ${state.record.leaseExpiresAt}`
-      );
-    }
-    state.record.leaseHolderId = input.workerId;
-    state.record.leaseExpiresAt = leaseExpiresAt;
-    state.record.status = state.record.status === "completed" || state.record.status === "failed" ? state.record.status : "running";
-    state.record.updatedAt = nowIso2;
-    const completed = [...state.steps.values()].filter((s) => s.status === "completed").sort((a, b) => a.stepIndex - b.stepIndex);
-    return {
-      run: { ...state.record },
-      completedSteps: completed.map((s) => ({ ...s })),
-      leaseExpiresAt
-    };
-  }
-  async renewLease(input) {
-    const state = this.runs.get(input.runId);
-    if (!state) return { ok: false };
-    const nowMs = this.now();
-    if (state.record.leaseHolderId !== input.workerId) {
-      if (state.record.leaseExpiresAt && new Date(state.record.leaseExpiresAt).getTime() > nowMs) {
-        return { ok: false };
-      }
-    }
-    const leaseExpiresMs = nowMs + (input.leaseMs ?? DEFAULT_LEASE_MS3);
-    const leaseExpiresAt = new Date(leaseExpiresMs).toISOString();
-    state.record.leaseHolderId = input.workerId;
-    state.record.leaseExpiresAt = leaseExpiresAt;
-    state.record.updatedAt = new Date(nowMs).toISOString();
-    return { ok: true, leaseExpiresAt };
-  }
-  async loadStep(runId, stepIndex) {
-    const state = this.runs.get(runId);
-    return state ? cloneStep(state.steps.get(stepIndex)) : void 0;
-  }
-  async beginStep(input) {
-    const state = this.requireRun(input.runId);
-    const nowIso2 = new Date(this.now()).toISOString();
-    const prior = state.steps.get(input.stepIndex);
-    if (prior) {
-      if (prior.intent !== input.intent) {
-        throw new DurableRunDivergenceError(
-          `step ${input.stepIndex}: intent changed across replays ('${prior.intent}' -> '${input.intent}')`
-        );
-      }
-      prior.attempts += 1;
-      prior.status = "running";
-      prior.startedAt = nowIso2;
-      prior.error = void 0;
-      state.record.updatedAt = nowIso2;
-      return cloneStep(prior);
-    }
-    const rec = {
-      runId: input.runId,
-      stepIndex: input.stepIndex,
-      intent: input.intent,
-      kind: input.kind,
-      inputHash: input.inputHash,
-      status: "running",
-      attempts: 1,
-      startedAt: nowIso2
-    };
-    state.steps.set(input.stepIndex, rec);
-    state.record.stepCount = Math.max(state.record.stepCount, input.stepIndex + 1);
-    state.record.updatedAt = nowIso2;
-    return cloneStep(rec);
-  }
-  async completeStep(input) {
-    const state = this.requireRun(input.runId);
-    const rec = state.steps.get(input.stepIndex);
-    if (!rec) {
-      throw new Error(
-        `durable-runs: completeStep called before beginStep (step ${input.stepIndex})`
-      );
-    }
-    const nowIso2 = new Date(this.now()).toISOString();
-    rec.status = "completed";
-    rec.result = input.result;
-    rec.completedAt = nowIso2;
-    rec.error = void 0;
-    state.record.updatedAt = nowIso2;
-    return cloneStep(rec);
-  }
-  async failStep(input) {
-    const state = this.requireRun(input.runId);
-    const rec = state.steps.get(input.stepIndex);
-    if (!rec) {
-      throw new Error(`durable-runs: failStep called before beginStep (step ${input.stepIndex})`);
-    }
-    const nowIso2 = new Date(this.now()).toISOString();
-    rec.status = "failed";
-    rec.error = input.error;
-    rec.completedAt = nowIso2;
-    state.record.updatedAt = nowIso2;
-    return cloneStep(rec);
-  }
-  async endRun(input) {
-    const state = this.requireRun(input.runId);
-    const nowIso2 = new Date(this.now()).toISOString();
-    state.record.status = input.status;
-    state.record.outcome = input.outcome;
-    state.record.completedAt = nowIso2;
-    state.record.updatedAt = nowIso2;
-    if (state.record.leaseHolderId === input.workerId) {
-      state.record.leaseHolderId = void 0;
-      state.record.leaseExpiresAt = void 0;
-    }
-    return { ...state.record };
-  }
-  async emitEvent(input) {
-    const state = this.requireRun(input.runId);
-    const existing = state.events.get(input.key);
-    if (existing) {
-      return { accepted: false, record: { ...existing } };
-    }
-    const rec = {
-      runId: input.runId,
-      key: input.key,
-      payload: input.payload,
-      emittedAt: new Date(this.now()).toISOString()
-    };
-    state.events.set(input.key, rec);
-    return { accepted: true, record: { ...rec } };
-  }
-  async loadEvent(runId, key) {
-    const state = this.runs.get(runId);
-    if (!state) return void 0;
-    const rec = state.events.get(key);
-    return rec ? { ...rec } : void 0;
-  }
-  async appendStreamEvent(input) {
-    const state = this.requireRun(input.runId);
-    const existing = state.streamEvents.find((e) => e.eventId === input.eventId);
-    if (existing) return { accepted: false, record: { ...existing } };
-    const rec = {
-      runId: input.runId,
-      seq: state.streamEvents.length,
-      eventId: input.eventId,
-      payload: input.payload,
-      appendedAt: new Date(this.now()).toISOString()
-    };
-    state.streamEvents.push(rec);
-    return { accepted: true, record: { ...rec } };
-  }
-  async readStreamEvents(runId, afterSeq) {
-    const state = this.runs.get(runId);
-    if (!state) return [];
-    const cutoff = afterSeq ?? -1;
-    return state.streamEvents.filter((e) => e.seq > cutoff).map((e) => ({ ...e }));
-  }
-  async setRunHandle(input) {
-    const state = this.requireRun(input.runId);
-    state.record.handle = { ...input.handle };
-    state.record.updatedAt = new Date(this.now()).toISOString();
-  }
-  async close() {
-    this.runs.clear();
-  }
-  // ── test helpers ───────────────────────────────────────────────────
-  /** @internal — used by tests to inspect lease metadata. */
-  _inspect(runId) {
-    const s = this.runs.get(runId);
-    return s ? { ...s.record } : void 0;
-  }
-  /** @internal — used by tests to simulate lease expiry. */
-  _expireLease(runId) {
-    const s = this.runs.get(runId);
-    if (s) {
-      s.record.leaseHolderId = void 0;
-      s.record.leaseExpiresAt = void 0;
-    }
-  }
-  requireRun(runId) {
-    const s = this.runs.get(runId);
-    if (!s) {
-      throw new Error(`durable-runs: run ${runId} not found (must call startOrResume first)`);
-    }
-    return s;
-  }
-};
-function cloneStep(rec) {
-  if (!rec) return void 0;
-  return { ...rec, error: rec.error ? { ...rec.error } : void 0 };
-}
-
-// src/durable/runner.ts
-var DEFAULT_LEASE_MS4 = 3e4;
-var DEFAULT_AWAIT_POLL_MS = 250;
-async function runDurable(input) {
-  const workerId = input.workerId ?? deriveWorkerId();
-  const leaseMs = input.leaseMs ?? DEFAULT_LEASE_MS4;
-  const { completedSteps } = await input.store.startOrResume({
-    runId: input.runId,
-    manifest: input.manifest,
-    workerId,
-    leaseMs
-  });
-  const priorByIndex = /* @__PURE__ */ new Map();
-  for (const s of completedSteps) priorByIndex.set(s.stepIndex, s);
-  const collected = [...completedSteps].sort((a, b) => a.stepIndex - b.stepIndex);
-  let leaseLost = false;
-  const heartbeatIntervalMs = Math.max(1e3, Math.floor(leaseMs / 3));
-  const heartbeat = setInterval(() => {
-    void input.store.renewLease({ runId: input.runId, workerId, leaseMs }).then((res) => {
-      if (!res.ok) leaseLost = true;
-    }).catch(() => {
-      leaseLost = true;
-    });
-  }, heartbeatIntervalMs);
-  if (typeof heartbeat.unref === "function") heartbeat.unref();
-  let positionCounter = 0;
-  const ctx = {
-    runId: input.runId,
-    projectId: input.manifest.projectId,
-    scenarioId: input.manifest.scenarioId,
-    async step(intent, fn, opts) {
-      checkAbortAndLease(input.signal, leaseLost);
-      const stepIndex = positionCounter++;
-      const prior = priorByIndex.get(stepIndex);
-      const inputHash = opts?.inputFingerprint !== void 0 ? canonicalHash(opts.inputFingerprint) : "";
-      if (prior && prior.status === "completed") {
-        if (prior.intent !== intent) {
-          throw new DurableRunDivergenceError(
-            `step ${stepIndex}: intent changed across replays ('${prior.intent}' -> '${intent}')`
-          );
+        if (hooks.onTurnComplete) {
+          try {
+            await hooks.onTurnComplete({ identity, finalText });
+          } catch (err) {
+            log("[chat-engine] onTurnComplete threw", {
+              error: err instanceof Error ? err.message : String(err)
+            });
+          }
         }
-        return prior.result;
-      }
-      const begun = await input.store.beginStep({
-        runId: input.runId,
-        stepIndex,
-        intent,
-        kind: opts?.kind ?? "logic",
-        inputHash
-      });
-      try {
-        const result = await fn();
-        const completed = await input.store.completeStep({
-          runId: input.runId,
-          stepIndex,
-          result
+        await emit2({
+          type: "session.run.completed",
+          data: { sessionId: identity.sessionId }
         });
-        upsertCollected(collected, completed);
-        priorByIndex.set(stepIndex, completed);
-        return result;
       } catch (err) {
-        const failed = await input.store.failStep({
-          runId: input.runId,
-          stepIndex,
-          error: toStepError(err)
+        const message = err instanceof Error ? err.message : String(err);
+        log("[chat-engine] turn failed", { error: message });
+        await emit2({ type: "error", data: { message } });
+        await emit2({
+          type: "session.run.failed",
+          data: { sessionId: identity.sessionId, message }
         });
-        upsertCollected(collected, failed);
-        priorByIndex.set(stepIndex, failed);
-        throw err;
       } finally {
-        void begun;
-      }
-    },
-    async awaitEvent(key, opts) {
-      const stepIndex = positionCounter++;
-      const prior = priorByIndex.get(stepIndex);
-      if (prior && prior.status === "completed") {
-        if (prior.intent !== `event:${key}`) {
-          throw new DurableRunDivergenceError(
-            `step ${stepIndex}: awaitEvent key changed across replays`
+        if (hooks.traceFlush) {
+          const flush = hooks.traceFlush().catch(
+            (err) => log("[chat-engine] traceFlush threw", {
+              error: err instanceof Error ? err.message : String(err)
+            })
           );
+          if (input.waitUntil) input.waitUntil(flush);
+          else await flush;
         }
-        return prior.result;
-      }
-      const beginAt = Date.now();
-      const timeoutMs = opts?.timeoutMs ?? 6e4;
-      const pollMs = opts?.pollMs ?? DEFAULT_AWAIT_POLL_MS;
-      await input.store.beginStep({
-        runId: input.runId,
-        stepIndex,
-        intent: `event:${key}`,
-        kind: "event",
-        inputHash: ""
-      });
-      try {
-        for (; ; ) {
-          checkAbortAndLease(input.signal, leaseLost);
-          const evt = await input.store.loadEvent(input.runId, key);
-          if (evt) {
-            const completed = await input.store.completeStep({
-              runId: input.runId,
-              stepIndex,
-              result: evt.payload
-            });
-            upsertCollected(collected, completed);
-            priorByIndex.set(stepIndex, completed);
-            return evt.payload;
-          }
-          if (Date.now() - beginAt > timeoutMs) {
-            const err = new DurableAwaitEventTimeoutError(
-              `awaitEvent('${key}') timed out after ${timeoutMs}ms`
-            );
-            const failed = await input.store.failStep({
-              runId: input.runId,
-              stepIndex,
-              error: toStepError(err)
-            });
-            upsertCollected(collected, failed);
-            priorByIndex.set(stepIndex, failed);
-            throw err;
-          }
-          await sleep2(pollMs, input.signal);
-        }
-      } catch (err) {
-        if (!(err instanceof DurableAwaitEventTimeoutError)) {
-          const existing = priorByIndex.get(stepIndex);
-          if (!existing || existing.status !== "failed") {
-            const failed = await input.store.failStep({
-              runId: input.runId,
-              stepIndex,
-              error: toStepError(err)
-            });
-            upsertCollected(collected, failed);
-            priorByIndex.set(stepIndex, failed);
-          }
-        }
-        throw err;
-      }
-    },
-    async emitEvent(key, payload) {
-      const res = await input.store.emitEvent({ runId: input.runId, key, payload });
-      return { accepted: res.accepted };
-    },
-    async now() {
-      const v = await this.step(`deterministic:now`, async () => (/* @__PURE__ */ new Date()).toISOString(), {
-        kind: "deterministic"
-      });
-      return new Date(v);
-    },
-    async uuid() {
-      return this.step(`deterministic:uuid`, async () => cryptoRandomUuid(), {
-        kind: "deterministic"
-      });
-    }
-  };
-  try {
-    const result = await input.taskFn(ctx);
-    const finalRecord = await input.store.endRun({
-      runId: input.runId,
-      workerId,
-      status: "completed",
-      outcome: input.defaultOutcome
-    });
-    return { result, record: finalRecord, steps: collected };
-  } catch (err) {
-    const finalRecord = await input.store.endRun({
-      runId: input.runId,
-      workerId,
-      status: "failed",
-      outcome: {
-        ...input.defaultOutcome,
-        notes: err instanceof Error ? err.message : String(err)
+        controller.close();
       }
-    });
-    void finalRecord;
-    throw err;
-  } finally {
-    clearInterval(heartbeat);
-  }
-}
-function checkAbortAndLease(signal, leaseLost) {
-  if (signal?.aborted) throw signal.reason ?? new Error("aborted");
-  if (leaseLost) throw new Error("durable-runs: lease lost; another worker has taken over this run");
-}
-function upsertCollected(list, rec) {
-  const i = list.findIndex((s) => s.stepIndex === rec.stepIndex);
-  if (i === -1) list.push(rec);
-  else list[i] = rec;
-}
-function toStepError(err) {
-  if (err instanceof Error) {
-    return {
-      message: err.message,
-      code: err.code,
-      stack: err.stack
-    };
-  }
-  return { message: String(err) };
-}
-function sleep2(ms, signal) {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(signal.reason ?? new Error("aborted"));
-      return;
     }
-    const t = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(t);
-      reject(signal?.reason ?? new Error("aborted"));
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
   });
+  return { body, contentType: "application/x-ndjson" };
 }
-function cryptoRandomUuid() {
-  if (typeof globalThis.crypto?.randomUUID === "function") {
-    return globalThis.crypto.randomUUID();
-  }
-  const bytes = new Uint8Array(16);
-  for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
-  bytes[6] = (bytes[6] ?? 0) & 15 | 64;
-  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-
-// src/durable/schema.ts
-var DURABLE_SCHEMA_VERSION = 2;
-var DURABLE_SCHEMA_SQL = `-- Durable-run substrate \u2014 versioned schema for D1 / SQLite.
---
--- Apply once per database. Subsequent migrations append; never rewrite a
--- prior version. See \`durable_schema_info\` for the migration trail.
---
--- Concurrency notes for D1:
---   - SQLite supports UNIQUE constraints for first-emit-wins (\`durable_events\`
---     PK is (run_id, key) \u2014 duplicate insert raises, caller treats as "already
---     emitted").
---   - Lease takeover happens via a conditional UPDATE: we only claim the lease
---     if (lease_holder_id IS NULL OR lease_expires_at < :now) \u2014 atomic under
---     SQLite's row-level locking.
---   - All timestamps stored as ISO-8601 TEXT for cross-platform consistency.
---   - \`result_json\` / \`error_json\` / \`outcome_json\` / \`payload_json\` are
---     JSON-encoded TEXT; the application enforces canonical-JSON discipline at
---     the boundary so the store stays type-agnostic.
-
-CREATE TABLE IF NOT EXISTS durable_schema_info (
-  version    INTEGER PRIMARY KEY,
-  applied_at TEXT    NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS durable_runs (
-  run_id           TEXT    PRIMARY KEY,
-  manifest_hash    TEXT    NOT NULL,
-  project_id       TEXT    NOT NULL,
-  scenario_id      TEXT,
-  status           TEXT    NOT NULL CHECK (status IN ('pending','running','completed','failed','suspended')),
-  created_at       TEXT    NOT NULL,
-  updated_at       TEXT    NOT NULL,
-  completed_at     TEXT,
-  lease_holder_id  TEXT,
-  lease_expires_at TEXT,
-  outcome_json     TEXT,
-  step_count       INTEGER NOT NULL DEFAULT 0
-);
-
-CREATE INDEX IF NOT EXISTS idx_durable_runs_project_status ON durable_runs(project_id, status);
-CREATE INDEX IF NOT EXISTS idx_durable_runs_lease_expires ON durable_runs(lease_expires_at);
-
-CREATE TABLE IF NOT EXISTS durable_steps (
-  run_id       TEXT    NOT NULL,
-  step_index   INTEGER NOT NULL,
-  intent       TEXT    NOT NULL,
-  kind         TEXT    NOT NULL,
-  input_hash   TEXT    NOT NULL DEFAULT '',
-  status       TEXT    NOT NULL CHECK (status IN ('pending','running','completed','failed')),
-  attempts     INTEGER NOT NULL DEFAULT 0,
-  result_json  TEXT,
-  error_json   TEXT,
-  started_at   TEXT,
-  completed_at TEXT,
-  PRIMARY KEY (run_id, step_index)
-);
-
-CREATE INDEX IF NOT EXISTS idx_durable_steps_status ON durable_steps(run_id, status);
-
-CREATE TABLE IF NOT EXISTS durable_events (
-  run_id     TEXT NOT NULL,
-  key        TEXT NOT NULL,
-  payload_json TEXT,
-  emitted_at TEXT NOT NULL,
-  PRIMARY KEY (run_id, key)
-);
-
-INSERT OR IGNORE INTO durable_schema_info (version, applied_at)
-VALUES (1, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'));
-
--- \u2500\u2500 Migration v2 \u2014 durable event-stream log + run handle \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
--- Run once on a database created at v1. \`ALTER TABLE\` is not idempotent; the
--- version trail in \`durable_schema_info\` is how migrations are sequenced \u2014
--- never by blind re-execution of this block.
---
---   - \`durable_stream_events\` is the ordered, replayable per-run event log.
---     \`seq\` is the store-assigned monotonic cursor; the UNIQUE index on
---     (run_id, event_id) makes appends idempotent \u2014 a reconnecting adapter
---     that re-yields a boundary event cannot double-log it.
---   - \`durable_runs.handle_json\` is the pointer (sandbox + substrate run id +
---     cursor) a fresh supervisor re-attaches by.
-
-ALTER TABLE durable_runs ADD COLUMN handle_json TEXT;
 
-CREATE TABLE IF NOT EXISTS durable_stream_events (
-  run_id       TEXT    NOT NULL,
-  seq          INTEGER NOT NULL,
-  event_id     TEXT    NOT NULL,
-  payload_json TEXT,
-  appended_at  TEXT    NOT NULL,
-  PRIMARY KEY (run_id, seq)
-);
-
-CREATE UNIQUE INDEX IF NOT EXISTS idx_durable_stream_events_event_id
-  ON durable_stream_events(run_id, event_id);
-
-INSERT OR IGNORE INTO durable_schema_info (version, applied_at)
-VALUES (2, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'));
-`;
-
-// src/durable/supervisor.ts
-var TURN_STEP = 0;
-function runSupervisedTurn(options) {
-  const { store, runId, manifest, workerId, adapter } = options;
-  const leaseMs = options.leaseMs ?? 6e4;
-  const heartbeatMs = options.heartbeatMs ?? 3e4;
-  const intent = options.intent ?? "turn";
-  const now = options.now ?? (() => Date.now());
-  const inputHash = canonicalHash(manifest.input);
-  let mode = "fresh";
-  let finalRecord;
-  let currentHandle;
-  let leaseLost = false;
-  async function* drain(source) {
-    let lastRenew = now();
-    for await (const event of source) {
-      if (event.handle) {
-        currentHandle = event.handle;
-        await store.setRunHandle({ runId, handle: event.handle });
-      }
-      const { accepted } = await store.appendStreamEvent({
-        runId,
-        eventId: event.eventId,
-        payload: event.payload
-      });
-      if (now() - lastRenew >= heartbeatMs) {
-        const renewed = await store.renewLease({ runId, workerId, leaseMs });
-        if (!renewed.ok) {
-          leaseLost = true;
-          throw new Error(`durable-runs: lease lost on ${runId} \u2014 another supervisor took over`);
-        }
-        lastRenew = now();
-      }
-      if (accepted) yield event.payload;
-    }
-  }
-  async function* stream() {
-    const { run, completedSteps } = await store.startOrResume({
-      runId,
-      manifest,
-      workerId,
-      leaseMs
-    });
-    if (completedSteps.some((s) => s.stepIndex === TURN_STEP && s.status === "completed")) {
-      mode = "replayed";
-      for (const e of await store.readStreamEvents(runId)) yield e.payload;
-      finalRecord = await store.endRun({ runId, workerId, status: "completed" });
-      return;
-    }
-    const logged = await store.readStreamEvents(runId);
-    const priorHandle = run.handle;
-    const resumable = priorHandle !== void 0 && priorHandle.status === "running" && typeof priorHandle.runId === "string";
-    let source;
-    if (resumable && priorHandle) {
-      mode = "resumed";
-      currentHandle = priorHandle;
-      for (const e of logged) yield e.payload;
-      const cursor = logged.length > 0 ? logged[logged.length - 1].eventId : priorHandle.cursor;
-      source = adapter.attach(priorHandle, cursor);
-    } else {
-      mode = "fresh";
-      source = adapter.start();
-    }
-    await store.beginStep({ runId, stepIndex: TURN_STEP, intent, kind: "llm", inputHash });
-    try {
-      yield* drain(source);
-      const eventCount = (await store.readStreamEvents(runId)).length;
-      await store.completeStep({ runId, stepIndex: TURN_STEP, result: { eventCount } });
-      if (currentHandle && currentHandle.status === "running") {
-        await store.setRunHandle({ runId, handle: { ...currentHandle, status: "completed" } });
-      }
-      finalRecord = await store.endRun({
-        runId,
-        workerId,
-        status: "completed",
-        outcome: { notes: intent, metadata: { events: eventCount, mode } }
-      });
-    } catch (err) {
-      if (!leaseLost) {
-        await store.failStep({
-          runId,
-          stepIndex: TURN_STEP,
-          error: { message: err instanceof Error ? err.message : String(err) }
-        });
-        finalRecord = await store.endRun({ runId, workerId, status: "failed" });
-      }
-      throw err;
-    }
-  }
-  return {
-    stream: stream(),
-    mode: () => mode,
-    record: () => finalRecord
-  };
-}
-
-// src/durable/session-supervisor-do.ts
-var ACTIVE_RUN_KEY = "agent-runtime:active-run-id";
-async function drainHeadless(stream) {
-  let next = await stream.next();
-  while (!next.done) next = await stream.next();
-}
-function createSessionSupervisorDO(config) {
-  const orphanCheckMs = config.orphanCheckMs ?? 6e4;
-  const now = config.now ?? (() => Date.now());
-  return class {
-    constructor(state, env) {
-      this.state = state;
-      this.env = env;
-    }
-    state;
-    env;
-    async fetch(request) {
-      const opts = await config.resolveRun(request, this.env, this.state);
-      if (!opts) return new Response("no run for this request", { status: 404 });
-      await this.state.storage.put(ACTIVE_RUN_KEY, opts.runId);
-      await this.state.storage.setAlarm(now() + orphanCheckMs);
-      const supervised = runSupervisedTurn(opts);
-      const storage = this.state.storage;
-      const encoder2 = new TextEncoder();
-      const body = new ReadableStream({
-        async pull(controller) {
-          try {
-            const next = await supervised.stream.next();
-            if (next.done) {
-              await storage.delete(ACTIVE_RUN_KEY);
-              controller.close();
-              return;
-            }
-            controller.enqueue(encoder2.encode(config.encodeEvent(next.value)));
-          } catch (err) {
-            controller.error(err instanceof Error ? err : new Error(String(err)));
-          }
-        }
-      });
-      return new Response(body, {
-        headers: { "content-type": "text/event-stream", "cache-control": "no-cache" }
-      });
-    }
-    async alarm() {
-      const runId = await this.state.storage.get(ACTIVE_RUN_KEY);
-      if (!runId) return;
-      const opts = await config.resolveOrphan(runId, this.env, this.state);
-      if (!opts) {
-        await this.state.storage.delete(ACTIVE_RUN_KEY);
-        return;
-      }
-      try {
-        await drainHeadless(runSupervisedTurn(opts).stream);
-        await this.state.storage.delete(ACTIVE_RUN_KEY);
-      } catch (err) {
-        if (err instanceof DurableRunLeaseHeldError) {
-          await this.state.storage.setAlarm(now() + orphanCheckMs);
-          return;
-        }
-        await this.state.storage.delete(ACTIVE_RUN_KEY);
-      }
-    }
-  };
-}
-
-// src/durable/workflows.ts
-async function runOnWorkflowStep(workflowStep, input) {
-  const stepCfg = input.stepConfig;
-  let counter2 = 0;
-  const stepName = (intent) => `${input.workflowName}/${counter2++}:${intent}`;
-  const ctx = {
-    runId: `cf-workflow:${input.workflowName}`,
-    projectId: input.workflowName,
-    async step(intent, fn) {
-      const name = stepName(intent);
-      if (stepCfg) {
-        return workflowStep.do(name, stepCfg, fn);
-      }
-      return workflowStep.do(name, fn);
-    },
-    async awaitEvent(key, opts) {
-      const timeout = opts?.timeoutMs ? `${Math.ceil(opts.timeoutMs / 1e3)}s` : void 0;
-      const ev = await workflowStep.waitForEvent(stepName(`event:${key}`), {
-        type: key,
-        timeout
-      });
-      return ev.payload;
-    },
-    async emitEvent() {
-      throw new Error(
-        "runOnWorkflowStep: ctx.emitEvent is not available inside a Workflows entrypoint. Emit from the sibling worker that drives the workflow."
-      );
-    },
-    async now() {
-      const iso = await this.step("deterministic:now", async () => (/* @__PURE__ */ new Date()).toISOString());
-      return new Date(iso);
-    },
-    async uuid() {
-      return this.step("deterministic:uuid", async () => {
-        if (typeof globalThis.crypto?.randomUUID === "function") {
-          return globalThis.crypto.randomUUID();
-        }
-        const bytes = new Uint8Array(16);
-        crypto.getRandomValues(bytes);
-        bytes[6] = (bytes[6] ?? 0) & 15 | 64;
-        bytes[8] = (bytes[8] ?? 0) & 63 | 128;
-        const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-      });
-    }
-  };
-  return input.taskFn(ctx);
+// src/durable/execution-handle.ts
+function deriveExecutionId(input) {
+  return `${input.projectId}:${input.sessionId}:${input.turnIndex}`;
 }
 
 // src/intent-router.ts
@@ -3366,8 +1773,8 @@ function createTraceBridge(options) {
   if (!options.runId) {
     throw new ValidationError("createTraceBridge: runId is required");
   }
-  let counter2 = 0;
-  const newEventId = options.newEventId ?? (() => `evt-${++counter2}`);
+  let counter = 0;
+  const newEventId = options.newEventId ?? (() => `evt-${++counter}`);
   const baseSpanId = options.spanId;
   const toTraceEvent = (event) => {
     const projection = projectToTraceEvent(event);
@@ -3554,18 +1961,7 @@ export {
   CaptureIntegrityError,
   ChatTurnError,
   ConfigError,
-  D1DurableRunStore,
   DEFAULT_ROUTER_BASE_URL,
-  DURABLE_SCHEMA_SQL,
-  DURABLE_SCHEMA_VERSION,
-  DurableAwaitEventTimeoutError,
-  DurableChatTurnEngine,
-  DurableRunDivergenceError,
-  DurableRunError,
-  DurableRunInputMismatchError,
-  DurableRunLeaseHeldError,
-  FileSystemDurableRunStore,
-  InMemoryDurableRunStore,
   InMemoryRuntimeSessionStore,
   JudgeError,
   NotFoundError,
@@ -3575,8 +1971,6 @@ export {
   ValidationError,
   VerificationError,
   assertProfileConformance,
-  canonicalHash,
-  canonicalJson,
   classifyIntent,
   cleanModelId,
   composeTurnProfile,
@@ -3585,31 +1979,24 @@ export {
   createRuntimeEventCollector,
   createRuntimeStreamEventCollector,
   createSandboxPromptBackend,
-  createSessionSupervisorDO,
   createTraceBridge,
   decideKnowledgeReadiness,
-  deriveWorkerId,
-  durableChatTurnEngine,
+  deriveExecutionId,
   encodeServerSentEvent,
   getModels,
-  manifestHash,
+  handleChatTurn,
   readinessServerSentEvent,
   resolveChatModel,
   resolveRouterBaseUrl,
   runAgentTask,
   runAgentTaskStream,
   runChatTurn,
-  runDurable,
-  runDurableTurn,
-  runOnWorkflowStep,
-  runSupervisedTurn,
   runtimeStreamServerSentEvent,
   sandboxAsChatTurnTarget,
   sanitizeAgentRuntimeEvent,
   sanitizeKnowledgeReadinessReport,
   sanitizeRuntimeStreamEvent,
   startRuntimeRun,
-  stepId,
   summarizeAgentTaskRun,
   toAgentEvalTrace,
   validateChatModelId,