tnega 0.1.1 → 0.4.1

package/dist/agent.js

@@ -1,5 +1,373 @@
+import { createRequire as __tnegaCreateRequire } from 'node:module'; const require = __tnegaCreateRequire(import.meta.url);
+
+// packages/agent/src/service.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// packages/session/src/index.ts
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+
+// packages/session/src/invariant.ts
+function checkBalancedTurns(events) {
+  const opens = /* @__PURE__ */ new Map();
+  const failures = [];
+  for (const event of events) {
+    if (event.type === "turn/start") {
+      opens.set(event.payload.turn, (opens.get(event.payload.turn) ?? 0) + 1);
+    } else if (event.type === "turn/end") {
+      const remaining = opens.get(event.payload.turn) ?? 0;
+      if (remaining <= 0) {
+        failures.push({
+          name: "turn/end-without-start",
+          detail: `turn/end for turn ${event.payload.turn} has no matching turn/start`
+        });
+      } else {
+        opens.set(event.payload.turn, remaining - 1);
+      }
+    }
+  }
+  for (const [turn, count] of opens) {
+    for (let index = 0; index < count; index += 1) {
+      failures.push({
+        name: "turn/start-without-end",
+        detail: `turn/start ${turn} has no matching turn/end`
+      });
+    }
+  }
+  return failures;
+}
+function checkBalancedSteps(events) {
+  const open = /* @__PURE__ */ new Set();
+  const failures = [];
+  for (const event of events) {
+    if (event.type === "step/start") {
+      const key = `${event.payload.turn}:${event.payload.step}`;
+      if (open.has(key)) {
+        failures.push({
+          name: "duplicate-step-start",
+          detail: `step/start for ${key} appears twice without a matching step/end`
+        });
+      }
+      open.add(key);
+    } else if (event.type === "step/end") {
+      const key = `${event.payload.turn}:${event.payload.step}`;
+      if (!open.delete(key)) {
+        failures.push({
+          name: "step/end-without-start",
+          detail: `step/end for ${key} has no matching step/start`
+        });
+      }
+    }
+  }
+  for (const key of open) {
+    failures.push({
+      name: "step/start-without-end",
+      detail: `step/start ${key} has no matching step/end`
+    });
+  }
+  return failures;
+}
+function checkBalancedToolCalls(events) {
+  const open = /* @__PURE__ */ new Set();
+  const failures = [];
+  for (const event of events) {
+    if (event.type === "tool/call") {
+      open.add(event.payload.id);
+    } else if (event.type === "tool/result") {
+      const payload = event.payload;
+      const id = payload.toolCallId;
+      if (!open.delete(id)) {
+        failures.push({
+          name: "tool/result-without-call",
+          detail: `tool/result for call ${id} has no matching tool/call`
+        });
+      }
+    }
+  }
+  for (const id of open) {
+    failures.push({
+      name: "tool/call-without-result",
+      detail: `tool/call ${id} has no matching tool/result`
+    });
+  }
+  return failures;
+}
+function checkMonotonicSeq(events) {
+  const failures = [];
+  for (let index = 1; index < events.length; index += 1) {
+    const previous = events[index - 1];
+    const current = events[index];
+    if (current && previous && current.seq <= previous.seq) {
+      failures.push({
+        name: "non-monotonic-seq",
+        detail: `seq ${current.seq} follows ${previous.seq} out of order at index ${index}`
+      });
+    }
+  }
+  return failures;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function isJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object" || ancestors.has(value)) return false;
+  if (!Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return false;
+  ancestors.add(value);
+  const valid = (Array.isArray(value) ? Array.from(value) : Object.values(value)).every((member) => isJsonValue(member, ancestors));
+  ancestors.delete(value);
+  return valid;
+}
+function isStreamRecord(value) {
+  if (!isRecord(value) || !isNonNegativeInteger(value.time) || !isRecord(value.chunk)) return false;
+  const chunk = value.chunk;
+  if (chunk.type === "stream_error") {
+    return isRecord(chunk.error) && typeof chunk.error.message === "string" && (chunk.error.name === void 0 || typeof chunk.error.name === "string") && (chunk.error.stack === void 0 || typeof chunk.error.stack === "string");
+  }
+  if (typeof chunk.id !== "string") return false;
+  switch (chunk.type) {
+    case "message_start":
+      return chunk.model === void 0 || typeof chunk.model === "string";
+    case "message_delta":
+      return typeof chunk.delta === "string";
+    case "toolcall_start":
+    case "toolcall_end":
+      return isNonNegativeInteger(chunk.index) && typeof chunk.name === "string" && (chunk.type === "toolcall_start" || isJsonValue(chunk.arguments));
+    case "message_stop":
+      return chunk.finishReason === "stop" || chunk.finishReason === "tool_calls" || chunk.finishReason === "length" || chunk.finishReason === "max_turns" || chunk.finishReason === "max_steps" || chunk.finishReason === "error" || chunk.finishReason === "cancelled";
+    default:
+      return false;
+  }
+}
+function checkAssistantAttempts(events) {
+  const turns = /* @__PURE__ */ new Set();
+  const steps = /* @__PURE__ */ new Map();
+  const failures = [];
+  for (const event of events) {
+    if (event.type === "turn/start") turns.add(event.payload.turn);
+    if (event.type === "turn/end") {
+      turns.delete(event.payload.turn);
+      for (const [key, turn] of steps) {
+        if (turn === event.payload.turn) steps.delete(key);
+      }
+    }
+    if (event.type === "step/start" && turns.has(event.payload.turn)) {
+      steps.set(`${event.payload.turn}:${event.payload.step}`, event.payload.turn);
+    }
+    if (event.type === "step/end") steps.delete(`${event.payload.turn}:${event.payload.step}`);
+    if (event.type !== "assistant/attempt") continue;
+    const payload = event.payload;
+    if (!isRecord(payload) || !isNonNegativeInteger(payload.turn) || !isNonNegativeInteger(payload.step) || !turns.has(payload.turn) || !steps.has(`${payload.turn}:${payload.step}`)) {
+      failures.push({
+        name: "assistant/attempt-without-open-step",
+        detail: `assistant/attempt at seq ${event.seq} has no matching open turn and step`
+      });
+    }
+    if (!isRecord(payload) || !Array.isArray(payload.stream) || !payload.stream.every(isStreamRecord)) {
+      failures.push({
+        name: "assistant/attempt-invalid-stream",
+        detail: `assistant/attempt at seq ${event.seq} must contain an ordered array of normalized stream records`
+      });
+    }
+  }
+  return failures;
+}
+function checkSessionInvariants(events) {
+  return [
+    ...checkBalancedTurns(events),
+    ...checkBalancedSteps(events),
+    ...checkBalancedToolCalls(events),
+    ...checkMonotonicSeq(events),
+    ...checkAssistantAttempts(events)
+  ];
+}
+
 // packages/session/src/index.ts
+var SESSION_FORMAT_VERSION = 10;
+var SessionFormatError = class extends Error {
+  name = "SessionFormatError";
+};
+var liveSessions = /* @__PURE__ */ new Map();
+function sessionFileKey(file) {
+  return resolve(file);
+}
+function isMessageEventType(type) {
+  return type === "user/message" || type === "assistant/message" || type === "system/message";
+}
+function isMessageEvent(event) {
+  return isMessageEventType(event.type);
+}
 var DEFAULT_CONTEXT_LIMIT = 128e3;
+function isSessionEvent(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return typeof record.id === "string" && typeof record.seq === "number" && typeof record.ts === "number" && typeof record.type === "string" && "payload" in record;
+}
+function clone(value) {
+  return structuredClone(value);
+}
+function previousSurfaceSeq(nodes) {
+  return nodes.at(-1);
+}
+function isSurfaceEventType(type) {
+  return type === "user/message" || type === "system/message" || type === "assistant/message" || type === "tool/result";
+}
+function checkpointShadowRange(event) {
+  if (event.type !== "checkpoint") return void 0;
+  const op = event.payload.surfaceOp;
+  if (typeof op === "object" && op !== null && op.op === "replace") {
+    return { start: op.start, end: op.end };
+  }
+  return void 0;
+}
+function foldSurface(events) {
+  const nodes = [];
+  const replacements = [];
+  const applyReplace = (seq, start, end) => {
+    const startIndex = nodes.indexOf(start);
+    if (startIndex < 0) {
+      nodes.push(seq);
+      return;
+    }
+    const endIndex = nodes.indexOf(end, startIndex);
+    if (endIndex < 0) {
+      nodes.push(seq);
+      return;
+    }
+    const shadowed = nodes.splice(startIndex, endIndex - startIndex + 1);
+    nodes.splice(startIndex, 0, seq);
+    replacements.push({ seq, start, end, shadowedSeqs: shadowed });
+  };
+  for (const event of events) {
+    if (event.type === "checkpoint") {
+      const range = checkpointShadowRange(event);
+      if (!range) {
+        nodes.push(event.seq);
+        continue;
+      }
+      applyReplace(event.seq, range.start, range.end);
+      continue;
+    }
+    if (!isSurfaceEventType(event.type)) continue;
+    const op = event.surfaceOp ?? "append";
+    if (op === "append") {
+      nodes.push(event.seq);
+      continue;
+    }
+    applyReplace(event.seq, op.start, op.end);
+  }
+  return { nodes, replacements };
+}
+function deriveEventMessage(event) {
+  switch (event.type) {
+    case "user/message": {
+      const message = { role: "user", content: event.payload.content };
+      if (event.payload.name) message.name = event.payload.name;
+      return message;
+    }
+    case "system/message": {
+      const message = { role: "system", content: event.payload.content };
+      if (event.payload.name) message.name = event.payload.name;
+      return message;
+    }
+    case "assistant/message": {
+      const toolCalls = event.payload.toolCalls;
+      if (!event.payload.content && !(toolCalls && toolCalls.length)) return null;
+      const message = { role: "assistant", content: event.payload.content };
+      if (event.payload.name) message.name = event.payload.name;
+      if (toolCalls?.length) message.tool_calls = clone(toolCalls);
+      return message;
+    }
+    case "tool/result": {
+      const failed = !event.payload.ok;
+      const message = {
+        role: "tool",
+        content: failed ? `error: ${event.payload.error?.message ?? "unknown"}` : stringify(event.payload.output),
+        tool_call_id: event.payload.toolCallId
+      };
+      message.name = event.payload.name;
+      if (failed) {
+        message.toolOk = false;
+        if (event.payload.error) message.toolError = event.payload.error;
+      }
+      return message;
+    }
+    default:
+      return null;
+  }
+}
+function deriveSurfaceMessages(events) {
+  const { nodes } = foldSurface(events);
+  const bySeq = new Map(events.map((event) => [event.seq, event]));
+  const messages = [];
+  for (const seq of nodes) {
+    const event = bySeq.get(seq);
+    if (!event) continue;
+    if (event.type === "checkpoint") {
+      messages.splice(0, messages.length, ...clone(event.payload.messages));
+      continue;
+    }
+    const message = deriveEventMessage(event);
+    if (message) messages.push(message);
+  }
+  return messages;
+}
+function foldRequestHeader(events) {
+  let header;
+  for (const event of events) {
+    if (event.type === "request/header") header = clone(event.payload);
+  }
+  return header;
+}
+function foldRequestContext(events) {
+  let context;
+  for (const event of events) {
+    if (event.type === "request/context") context = clone(event.payload);
+  }
+  return context;
+}
+function foldSessionMeta(events) {
+  const meta = {};
+  for (const event of events) {
+    if (event.type === "meta") {
+      const payload = event.payload;
+      if (typeof payload.title === "string") meta.title = payload.title;
+      if (payload.agentType === "general" || payload.agentType === "coding") {
+        meta.agentType = payload.agentType;
+      }
+      if (payload.mode === "auto" || payload.mode === "plan" || payload.mode === "execute") {
+        meta.mode = payload.mode;
+      }
+      continue;
+    }
+    if (event.type === "meta/patch") {
+      const patch = event.payload;
+      if (patch.fields.includes("title") && typeof patch.title === "string") {
+        meta.title = patch.title;
+      }
+      if (patch.fields.includes("agentType") && patch.agentType !== void 0) {
+        meta.agentType = patch.agentType;
+      }
+      if (patch.fields.includes("mode") && patch.mode !== void 0) {
+        meta.mode = patch.mode;
+      }
+    }
+  }
+  return meta;
+}
+function stringify(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
 function estimateMessageTokens(messages) {
   let tokens = 0;
   for (const message of messages) {
@@ -11,6 +379,156 @@ function estimateMessageTokens(messages) {
   }
   return tokens;
 }
+function estimateEventTokens(event) {
+  switch (event.type) {
+    case "user/message":
+    case "system/message":
+      return Math.ceil(event.payload.content.length / 4);
+    case "assistant/message": {
+      let tokens = Math.ceil(event.payload.content.length / 4);
+      for (const call of event.payload.toolCalls ?? []) {
+        const raw = JSON.stringify(call.arguments ?? {}) ?? "";
+        tokens += Math.ceil(raw.length / 4);
+      }
+      return tokens;
+    }
+    case "assistant/chunk":
+      return Math.ceil(event.payload.content.length / 4);
+    case "tool/call": {
+      const raw = JSON.stringify(event.payload.arguments ?? {}) ?? "";
+      return Math.ceil(raw.length / 4);
+    }
+    case "tool/result": {
+      const raw = event.payload.ok ? stringify(event.payload.output) : event.payload.error?.message ?? "error";
+      return Math.ceil(raw.length / 4);
+    }
+    case "plan":
+    case "assistant/attempt":
+      return 0;
+    case "checkpoint":
+      return estimateMessageTokens(event.payload.messages);
+    case "compaction/start":
+    case "compaction/end":
+    case "meta":
+    case "meta/patch":
+      return 0;
+    case "llm/retry":
+    case "llm/retry-started":
+      return 0;
+    case "request/header":
+    case "request/context":
+    case "agent/inbox/spliced":
+      return 0;
+    case "turn/start":
+    case "turn/end":
+    case "step/start":
+    case "step/end":
+      return 0;
+  }
+}
+function suffixStartIndexForTokens(events, targetTokens) {
+  if (!events.length || targetTokens <= 0) return 0;
+  let tokens = 0;
+  let candidate = events.length;
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    tokens += estimateEventTokens(events[index]);
+    if (tokens >= targetTokens) {
+      candidate = index;
+      break;
+    }
+  }
+  if (candidate === events.length) return 0;
+  let cut = candidate;
+  while (cut < events.length) {
+    const event = events[cut];
+    if (event?.type === "user/message") return cut;
+    cut += 1;
+  }
+  return candidate;
+}
+function repairUnclosed(events) {
+  const openCalls = [];
+  const openSteps = [];
+  const openTurns = [];
+  for (const event of events) {
+    switch (event.type) {
+      case "tool/call":
+        openCalls.push(event);
+        break;
+      case "tool/result": {
+        const callIndex = openCalls.findIndex(
+          (call) => call.payload.id === event.payload.toolCallId
+        );
+        if (callIndex >= 0) openCalls.splice(callIndex, 1);
+        else openCalls.pop();
+        break;
+      }
+      case "step/start":
+        openSteps.push(event);
+        break;
+      case "step/end":
+        openSteps.pop();
+        break;
+      case "turn/start":
+        openTurns.push(event);
+        break;
+      case "turn/end":
+        openTurns.pop();
+        break;
+    }
+  }
+  if (!openCalls.length && !openSteps.length && !openTurns.length) return [];
+  const synthetic = [];
+  let nextSeq = (events.at(-1)?.seq ?? 0) + 1;
+  let nextTs = (events.at(-1)?.ts ?? Date.now()) + 1;
+  const push = (type, payload) => {
+    synthetic.push({
+      id: randomUUID(),
+      seq: nextSeq,
+      ts: nextTs,
+      type,
+      payload: clone(payload)
+    });
+    nextSeq += 1;
+    nextTs += 1;
+  };
+  for (const call of openCalls) {
+    push("tool/result", {
+      id: call.payload.id,
+      toolCallId: call.payload.id,
+      name: call.payload.name,
+      ok: false,
+      error: {
+        name: "SessionInterruptedError",
+        message: "session interrupted before tool result was recorded"
+      }
+    });
+  }
+  for (const step of openSteps) {
+    push("step/end", {
+      turn: step.payload.turn,
+      step: step.payload.step,
+      finishReason: "interrupted",
+      interrupted: true
+    });
+  }
+  for (let i = 0; i < openTurns.length; i++) {
+    const turn = openTurns[i].payload.turn;
+    push("turn/end", {
+      turn,
+      finishReason: "interrupted",
+      interrupted: true
+    });
+  }
+  return synthetic;
+}
+function resolveCompactKeep(events, options) {
+  if (typeof options.keepTokens === "number" && Number.isFinite(options.keepTokens) && options.keepTokens > 0) {
+    return events.length - suffixStartIndexForTokens(events, options.keepTokens);
+  }
+  const keep = typeof options.keep === "number" && Number.isFinite(options.keep) && options.keep > 0 ? Math.floor(options.keep) : 0;
+  return Math.min(keep, events.length);
+}
 function estimateContextUsage(messages, limit = DEFAULT_CONTEXT_LIMIT) {
   const tokens = estimateMessageTokens(messages);
   return {
@@ -19,6 +537,465 @@ function estimateContextUsage(messages, limit = DEFAULT_CONTEXT_LIMIT) {
     ratio: limit > 0 ? tokens / limit : 0
   };
 }
+var SessionLog = class {
+  constructor(file, _broadcast, publicationContext) {
+    this.file = file;
+    this._broadcast = _broadcast;
+    if (!this._broadcast && publicationContext) {
+      this._broadcast = (type, payload) => {
+        if (type === "event") publicationContext.emit("session/event", payload);
+        else publicationContext.emit("session/flush", payload);
+      };
+    }
+  }
+  file;
+  _broadcast;
+  _events = [];
+  _surface = [];
+  _surfaceNodes = [];
+  _requestHeader;
+  _requestContext;
+  _loaded = false;
+  _nextSeq = 1;
+  _queue = Promise.resolve();
+  _writeTail = Promise.resolve();
+  _pending = [];
+  _drainScheduled = false;
+  _writeError;
+  init() {
+    return this._run(async () => {
+      const key = sessionFileKey(this.file);
+      if (!liveSessions.has(key)) liveSessions.set(key, this);
+      try {
+        await this._ensureLoaded();
+        await this._drainWrite();
+        if (this._writeError) {
+          const error = this._writeError;
+          this._writeError = void 0;
+          throw error;
+        }
+      } catch (error) {
+        if (liveSessions.get(key) === this) liveSessions.delete(key);
+        throw error;
+      }
+    });
+  }
+  append(type, payload) {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      const event = this._buildEvent(type, payload);
+      this._commitEvent(event);
+      return event;
+    });
+  }
+  _buildEvent(type, payload) {
+    const eventPayload = clone(payload);
+    const event = {
+      id: randomUUID(),
+      seq: this._nextSeq,
+      ts: Date.now(),
+      type,
+      payload: eventPayload
+    };
+    if (isMessageEventType(type)) {
+      for (let index = this._events.length - 1; index >= 0; index -= 1) {
+        const previous2 = this._events[index];
+        if (previous2 && isMessageEvent(previous2)) {
+          const messagePayload = eventPayload;
+          messagePayload.parentId ??= previous2.id;
+          break;
+        }
+      }
+      event.surfaceOp ??= "append";
+      const previous = previousSurfaceSeq(this._surfaceNodes);
+      event.sourceEventSeqs ??= previous === void 0 ? [] : [previous];
+    } else if (type === "request/header") {
+      event.sourceEventSeqs ??= [];
+    } else if (type === "request/context") {
+      event.sourceEventSeqs ??= [];
+    } else if (type === "agent/inbox/spliced") {
+      event.sourceEventSeqs ??= [];
+    }
+    this._nextSeq += 1;
+    return event;
+  }
+  _commitEvent(event) {
+    this._events.push(event);
+    this._refreshSurface();
+    if (event.type === "request/header") this._requestHeader = clone(event.payload);
+    if (event.type === "request/context") this._requestContext = clone(event.payload);
+    this._broadcast?.("event", event);
+    this._enqueue(event);
+  }
+  /**
+   * Rebuild both surface views from the committed log. The nodes come from the
+   * positional {@link foldSurface} fold; the messages come from
+   * {@link deriveSurfaceMessages}, which walks those nodes in surface order —
+   * the model view is a pure function of the surface, never of raw file order.
+   */
+  _refreshSurface() {
+    this._surfaceNodes = foldSurface(this._events).nodes;
+    this._surface = deriveSurfaceMessages(this._events);
+  }
+  _enqueue(event) {
+    this._pending.push(event);
+    if (this._drainScheduled) return;
+    this._drainScheduled = true;
+    setImmediate(() => {
+      this._drainScheduled = false;
+      void this._drainWrite();
+    });
+  }
+  _drainWrite() {
+    const events = this._pending.splice(0);
+    if (!events.length) return this._writeTail;
+    const write = this._writeTail.then(() => appendFile(
+      this.file,
+      `${events.map((event) => JSON.stringify(event)).join("\n")}
+`,
+      "utf8"
+    ));
+    this._writeTail = write.catch((error) => {
+      this._writeError ??= error;
+    });
+    return write.then(() => void 0, () => void 0);
+  }
+  flush() {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      await this._drainWrite();
+      if (this._writeError) {
+        const error = this._writeError;
+        this._writeError = void 0;
+        throw error;
+      }
+      const seq = this._nextSeq - 1;
+      this._broadcast?.("flush", { file: this.file, seq });
+      return seq;
+    });
+  }
+  async lineage(messageId) {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      return this._resolveLineage(messageId);
+    });
+  }
+  /** The next turn number: one more than the highest recorded `turn/start`. */
+  async nextTurn() {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      let max = 0;
+      for (const event of this._events) {
+        if (event.type === "turn/start") max = Math.max(max, event.payload.turn);
+      }
+      return max + 1;
+    });
+  }
+  async forkAt(messageId) {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      const lineage = this._resolveLineage(messageId);
+      const lineageIds = new Set(lineage.map((event) => event.id));
+      const targetIndex = this._events.findIndex(
+        (event) => event.id === messageId && isMessageEvent(event)
+      );
+      if (targetIndex < 0) {
+        throw new Error(`message not found: ${messageId}`);
+      }
+      const selected = [];
+      let skippedMessage = false;
+      for (let index = 0; index <= targetIndex; index += 1) {
+        const event = this._events[index];
+        if (isMessageEvent(event)) {
+          if (!lineageIds.has(event.id)) {
+            skippedMessage = true;
+            continue;
+          }
+          skippedMessage = false;
+          selected.push(clone(event));
+          continue;
+        }
+        if (event.type === "meta" || event.type === "llm/retry" || event.type === "llm/retry-started" || event.type === "assistant/attempt" || event.type.startsWith("turn/") || event.type.startsWith("step/")) {
+          continue;
+        }
+        if (event.type === "checkpoint") {
+          selected.push(clone(event));
+          continue;
+        }
+        if (!skippedMessage) {
+          selected.push(clone(event));
+        }
+      }
+      return selected;
+    });
+  }
+  read() {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      return this._events.map((event) => clone(event));
+    });
+  }
+  deriveMessages() {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      return clone(this._surface);
+    });
+  }
+  /** The ordered surface events, after compaction replacements are applied. */
+  surfaceEvents() {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      const bySeq = new Map(this._events.map((event) => [event.seq, event]));
+      return this._surfaceNodes.map((seq) => bySeq.get(seq)).filter((event) => event !== void 0).map((event) => clone(event));
+    });
+  }
+  /** The latest `request/header` snapshot, or undefined before the first one. */
+  requestHeader() {
+    return this._requestHeader ? clone(this._requestHeader) : void 0;
+  }
+  /** The latest resolved route metadata, or undefined before the first one. */
+  requestContext() {
+    return this._requestContext ? clone(this._requestContext) : void 0;
+  }
+  /** Display metadata folded from the durable `meta` + `meta/patch` events. */
+  meta() {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      return foldSessionMeta(this._events);
+    });
+  }
+  estimateContext(limit = DEFAULT_CONTEXT_LIMIT) {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      return estimateContextUsage(this._surface, limit);
+    });
+  }
+  replay(reduce, initial) {
+    return this.read().then((events) => {
+      if (!reduce) return events;
+      let state = initial;
+      let pending = Promise.resolve();
+      for (const event of events) {
+        pending = pending.then(async () => {
+          state = await reduce(state, event);
+        });
+      }
+      return pending.then(() => state);
+    });
+  }
+  /** Structural violations in the loaded event stream (empty = balanced). */
+  runInvariants() {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      return checkSessionInvariants(this._events);
+    });
+  }
+  /**
+   * Compact the session without ever rewriting history.
+   *
+   * The surface (not the raw log) is the unit of compaction. A kept suffix —
+   * measured in tokens via `keepTokens`, or in nodes via `keep`, and always
+   * snapped to start on a fresh `user/message` turn so a tool result never
+   * outlives the assistant call it answers — stays visible; every earlier
+   * surface node is shadowed by the checkpoint's `surfaceOp.replace` range.
+   * The three compaction events are appended like any other event, so seqs
+   * stay immutable, live observers see the transition, and a crash can only
+   * leave an orphaned `compaction/start` rather than a torn rewrite.
+   *
+   * Returns the new event count, or the unchanged count when there is no
+   * useful surface span to shadow.
+   */
+  compact(options = {}) {
+    return this._run(async () => {
+      await this._ensureLoaded();
+      const events = this._events;
+      const bySeq = new Map(events.map((event) => [event.seq, event]));
+      const surfaceEvents = foldSurface(events).nodes.map((seq) => bySeq.get(seq)).filter((event) => event !== void 0);
+      const keep = resolveCompactKeep(surfaceEvents, options);
+      let split = Math.max(0, surfaceEvents.length - keep);
+      if (split < surfaceEvents.length && surfaceEvents[split].type !== "user/message") {
+        let next = split;
+        while (next < surfaceEvents.length && surfaceEvents[next].type !== "user/message") next += 1;
+        if (next < surfaceEvents.length) {
+          split = next;
+        } else {
+          let lastUser = surfaceEvents.length - 1;
+          while (lastUser >= 0 && surfaceEvents[lastUser].type !== "user/message") lastUser -= 1;
+          split = lastUser >= 0 ? lastUser : surfaceEvents.length;
+        }
+      }
+      const shadowed = surfaceEvents.slice(0, split);
+      if (!options.messages?.length) return this._events.length;
+      const range = shadowed.length ? { start: shadowed[0].seq, end: shadowed[shadowed.length - 1].seq } : void 0;
+      const boundary = split;
+      this._commitEvent(this._buildEvent("compaction/start", {
+        ...boundary > 0 ? { boundary } : {},
+        ...options.keep !== void 0 ? { keep: options.keep } : {},
+        ...options.tokensBefore !== void 0 ? { tokensBefore: options.tokensBefore } : {}
+      }));
+      const checkpoint = this._buildEvent("checkpoint", {
+        messages: clone(options.messages),
+        ...range ? { surfaceOp: { op: "replace", start: range.start, end: range.end } } : {},
+        ...options.summary ? { summary: options.summary } : {},
+        ...options.tokensBefore !== void 0 ? { tokensBefore: options.tokensBefore } : {}
+      });
+      this._commitEvent(checkpoint);
+      this._commitEvent(this._buildEvent("compaction/end", {
+        checkpointId: checkpoint.id,
+        ...options.keep !== void 0 ? { keep: options.keep } : {}
+      }));
+      return this._events.length;
+    });
+  }
+  close() {
+    return this._queue.then(async () => {
+      await this._drainWrite();
+      if (this._writeError) {
+        const error = this._writeError;
+        this._writeError = void 0;
+        throw error;
+      }
+      const key = sessionFileKey(this.file);
+      if (liveSessions.get(key) === this) liveSessions.delete(key);
+    });
+  }
+  _run(task) {
+    const next = this._queue.then(task, task);
+    this._queue = next.then(() => void 0, () => void 0);
+    return next;
+  }
+  async _ensureLoaded() {
+    if (this._loaded) return;
+    const key = sessionFileKey(this.file);
+    const owner = liveSessions.get(key);
+    if (owner && owner !== this && owner._loaded) {
+      this._events = owner._events.map((event) => clone(event));
+      this._surface = clone(owner._surface);
+      this._surfaceNodes = [...owner._surfaceNodes];
+      this._requestHeader = owner._requestHeader ? clone(owner._requestHeader) : void 0;
+      this._requestContext = owner._requestContext ? clone(owner._requestContext) : void 0;
+      this._nextSeq = owner._nextSeq;
+      this._loaded = true;
+      return;
+    }
+    await mkdir(dirname(resolve(this.file)), { recursive: true });
+    const read = await this._read();
+    if (!read.existing) {
+      const meta = {
+        id: randomUUID(),
+        seq: 1,
+        ts: Date.now(),
+        type: "meta",
+        payload: { formatVersion: SESSION_FORMAT_VERSION }
+      };
+      await writeFile(this.file, `${JSON.stringify(meta)}
+`, "utf8");
+      this._events = [meta];
+      this._refreshSurface();
+      this._nextSeq = 2;
+      this._loaded = true;
+      return;
+    }
+    this._events = read.events;
+    this._refreshSurface();
+    this._requestHeader = foldRequestHeader(this._events);
+    this._requestContext = foldRequestContext(this._events);
+    this._nextSeq = (this._events.at(-1)?.seq ?? 0) + 1;
+    this._loaded = true;
+  }
+  async _read() {
+    let text;
+    try {
+      text = await readFile(this.file, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { existing: false, events: [] };
+      }
+      throw error;
+    }
+    if (!text.trim()) return { existing: false, events: [] };
+    const lines = text.split("\n");
+    const events = [];
+    let torn = false;
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      if (torn) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        torn = true;
+        continue;
+      }
+      if (!isSessionEvent(parsed)) {
+        torn = true;
+        continue;
+      }
+      events.push(parsed);
+    }
+    this._assertFormat(events);
+    const key = sessionFileKey(this.file);
+    const owner = liveSessions.get(key);
+    if (owner && owner !== this) {
+      return { existing: true, events };
+    }
+    const synthetic = repairUnclosed(events);
+    if (!torn && !synthetic.length) return { existing: true, events };
+    const repaired = [...events, ...synthetic];
+    await writeFile(
+      this.file,
+      `${repaired.map((event) => JSON.stringify(event)).join("\n")}
+`,
+      "utf8"
+    );
+    return { existing: true, events: repaired };
+  }
+  _assertFormat(events) {
+    let version;
+    for (const event of events) {
+      if (event.type !== "meta") continue;
+      const value = event.payload.formatVersion;
+      if (typeof value === "number") version = value;
+    }
+    if (version === void 0) {
+      throw new SessionFormatError(
+        `session log is missing formatVersion; expected ${SESSION_FORMAT_VERSION}`
+      );
+    }
+    if (version !== SESSION_FORMAT_VERSION) {
+      throw new SessionFormatError(
+        `unsupported session format version ${version}; expected ${SESSION_FORMAT_VERSION}`
+      );
+    }
+  }
+  _resolveLineage(messageId) {
+    const messages = this._events.filter(
+      (event) => isMessageEvent(event)
+    );
+    const byId = new Map(
+      messages.map((event) => [event.id, event])
+    );
+    if (!byId.has(messageId)) {
+      throw new Error(`message not found: ${messageId}`);
+    }
+    const chain = [];
+    const seen = /* @__PURE__ */ new Set();
+    let cursorId = messageId;
+    while (cursorId && byId.has(cursorId) && !seen.has(cursorId)) {
+      seen.add(cursorId);
+      const event = byId.get(cursorId);
+      chain.unshift(clone(event));
+      const parentId = event.payload.parentId;
+      if (parentId && byId.has(parentId)) {
+        cursorId = parentId;
+        continue;
+      }
+      const index = messages.findIndex((message) => message.id === cursorId);
+      cursorId = index > 0 ? messages[index - 1].id : void 0;
+    }
+    return chain;
+  }
+};
 
 // packages/agent/src/service.ts
 var AgentError = class extends Error {
@@ -26,19 +1003,34 @@ var AgentError = class extends Error {
 };
 var AgentInbox = class {
   _queue = [];
+  _steerQueue = [];
   _injected = /* @__PURE__ */ new Map();
   get size() {
-    return this._queue.length;
+    return this._queue.length + this._steerQueue.length;
+  }
+  get steerSize() {
+    return this._steerQueue.length;
   }
   push(input) {
     this._queue.push(input);
     return input;
   }
+  followup(input) {
+    return this.push(input);
+  }
+  steer(input) {
+    this._steerQueue.push(input);
+    return input;
+  }
+  send(input, options = {}) {
+    if (options.mode === "steer") return this.steer(input);
+    return this.followup(input);
+  }
   claim() {
-    return this._queue.shift();
+    return this._steerQueue.shift() ?? this._queue.shift();
   }
   peek() {
-    return this._queue[0];
+    return this._steerQueue[0] ?? this._queue[0];
   }
   inject(key, value) {
     this._injected.set(key, value);
@@ -61,13 +1053,16 @@ function copyMessages(messages) {
       copy.tool_calls = message.tool_calls.map((call) => ({
         id: call.id,
         name: call.name,
-        arguments: call.arguments
+        arguments: structuredClone(call.arguments)
       }));
     }
     return copy;
   });
 }
-function stringify(value) {
+function isUserOrSystemMessage(message) {
+  return message.role === "system" || message.role === "user";
+}
+function stringify2(value) {
   if (typeof value === "string") return value;
   try {
     return JSON.stringify(value) ?? String(value);
@@ -89,27 +1084,268 @@ function copyCompletion(completion) {
   }
   return copy;
 }
-var AgentService = class {
-  constructor(ctx, config = {}) {
-    this.ctx = ctx;
-    this.config = config;
-    this.inbox = config.inbox ?? new AgentInbox();
-  }
-  ctx;
-  config;
-  inbox;
-  async run(input, options = {}) {
-    return consumeAgentStream(this._stream(input, options, false));
-  }
-  async *runStream(input, options = {}) {
-    const iterator = this._stream(input, options)[Symbol.asyncIterator]();
+function canonicalMessages(messages) {
+  return JSON.stringify(messages.map((message) => ({
+    role: message.role,
+    content: message.content,
+    ...message.name ? { name: message.name } : {},
+    ...message.tool_call_id ? { tool_call_id: message.tool_call_id } : {},
+    ...message.tool_calls?.length ? { tool_calls: message.tool_calls } : {},
+    ...message.toolOk !== void 0 ? { toolOk: message.toolOk } : {},
+    ...message.toolError ? {
+      toolError: { name: message.toolError.name, message: message.toolError.message }
+    } : {}
+  })));
+}
+function freezeRequestData(data) {
+  const visited = /* @__PURE__ */ new Set();
+  const freeze = (value) => {
+    if (typeof value !== "object" || value === null || visited.has(value)) return;
+    visited.add(value);
+    for (const child of Object.values(value)) freeze(child);
+    Object.freeze(value);
+  };
+  freeze(data);
+}
+function lockStreamRequest(request) {
+  freezeRequestData(request.messages);
+  request.tools = Object.freeze(request.tools.map((tool) => {
+    const schema = structuredClone(tool.schema);
+    freezeRequestData(schema);
+    return Object.freeze({ ...tool, schema });
+  }));
+  Object.freeze(request.options);
+  Object.freeze(request);
+}
+function requestHeaderFor(request, input) {
+  const system = input.find((message) => message.role === "system")?.content;
+  const tools = request.tools.map((tool) => ({
+    name: tool.schema.name,
+    description: tool.schema.description,
+    ...tool.schema.parameters ? { parameters: tool.schema.parameters } : {}
+  }));
+  const config = {
+    ...request.options.provider ? { provider: request.options.provider } : {},
+    ...request.options.model ? { model: request.options.model } : {},
+    ...request.options.temperature !== void 0 ? { temperature: request.options.temperature } : {}
+  };
+  return {
+    ...Object.keys(config).length ? { config } : {},
+    ...system !== void 0 ? { system } : {},
+    ...tools.length ? { tools } : {}
+  };
+}
+async function* completeAsStream(llm, messages, tools, options) {
+  const id = randomUUID2();
+  yield { type: "message_start", id };
+  const completion = await llm.complete(messages, tools, options);
+  if (completion.content) yield { type: "message_delta", id, delta: completion.content };
+  for (let index = 0; index < (completion.toolCalls?.length ?? 0); index += 1) {
+    const call = completion.toolCalls[index];
+    yield { type: "toolcall_start", id: call.id, index, name: call.name };
+    yield {
+      type: "toolcall_end",
+      id: call.id,
+      index,
+      name: call.name,
+      arguments: call.arguments
+    };
+  }
+  yield { type: "message_stop", id, finishReason: completion.finishReason };
+}
+function isCancelCause(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  if (record.type === "user" || record.type === "parent" || record.type === "disposed") {
+    return true;
+  }
+  if (record.type === "abort" && (record.message === void 0 || typeof record.message === "string")) {
+    return true;
+  }
+  if (record.type === "timeout" && typeof record.timeoutMs === "number") {
+    return true;
+  }
+  return false;
+}
+function cancelCauseFromSignal(signal) {
+  if (!signal?.aborted) return void 0;
+  const reason = signal.reason;
+  if (isCancelCause(reason)) return reason;
+  return { type: "abort" };
+}
+function abortedToolError(signal) {
+  const cause = cancelCauseFromSignal(signal);
+  return {
+    name: "AbortError",
+    message: `tool call aborted: ${cause?.type ?? "abort"}`
+  };
+}
+function toTurnEndReason(fields) {
+  const { cancelled, turnError, finishReason, cancelCause } = fields;
+  if (cancelled || finishReason === "cancelled") {
+    return { kind: "aborted", cause: cancelCause ?? { type: "user" } };
+  }
+  if (turnError || finishReason === "error") {
+    return {
+      kind: "error",
+      error: turnError ? toToolError(turnError) : { name: "TurnError", message: finishReason }
+    };
+  }
+  switch (finishReason) {
+    case "length":
+      return { kind: "max-tokens" };
+    case "max_steps":
+      return { kind: "max-steps" };
+    case "max_turns":
+      return { kind: "max-turns" };
+    default:
+      return { kind: "completed" };
+  }
+}
+function partialStreamContent(events) {
+  let content = "";
+  for (const event of events) {
+    if (event.type === "message_delta") content += event.delta;
+  }
+  return content;
+}
+async function cancellableDelay(ms, signal) {
+  if (ms <= 0) return !signal?.aborted;
+  if (signal?.aborted) return false;
+  return new Promise((resolve2) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve2(true);
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve2(false);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var AssistantStreamAttempt = class {
+  constructor(session, turn, step, nextRevision) {
+    this.session = session;
+    this.turn = turn;
+    this.step = step;
+    this.nextRevision = nextRevision;
+  }
+  session;
+  turn;
+  step;
+  nextRevision;
+  attemptId = randomUUID2();
+  records = [];
+  ended = false;
+  start() {
+    return { type: "assistant/stream", frame: {
+      type: "start",
+      attemptId: this.attemptId,
+      revision: this.nextRevision(),
+      turn: this.turn,
+      step: this.step
+    } };
+  }
+  push(chunk) {
+    if (this.ended) throw new AgentError("assistant attempt is already settled");
+    const record = { time: Date.now(), chunk: structuredClone(chunk) };
+    const index = this.records.length;
+    this.records.push(record);
+    return { type: "assistant/stream", frame: {
+      type: "chunk",
+      attemptId: this.attemptId,
+      revision: this.nextRevision(),
+      index,
+      ...structuredClone(record)
+    } };
+  }
+  async settle(message) {
+    if (this.ended) throw new AgentError("assistant attempt is already settled");
+    const eventType = message ? "assistant/message" : "assistant/attempt";
+    let event;
+    try {
+      event = message ? await this.session.append("assistant/message", { ...message, stream: this.records }) : await this.session.append("assistant/attempt", { turn: this.turn, step: this.step, stream: this.records });
+    } catch (cause) {
+      this.ended = true;
+      const frame = { type: "assistant/stream", frame: {
+        type: "end",
+        attemptId: this.attemptId,
+        revision: this.nextRevision(),
+        index: this.records.length,
+        outcome: { kind: "abandoned" }
+      } };
+      throw new AttemptSettlementError(cause, frame);
+    }
+    this.ended = true;
+    return { type: "assistant/stream", frame: {
+      type: "end",
+      attemptId: this.attemptId,
+      revision: this.nextRevision(),
+      index: this.records.length,
+      outcome: { kind: "committed", eventType, seq: event.seq }
+    } };
+  }
+};
+var AttemptSettlementError = class extends Error {
+  constructor(cause, frame) {
+    super("assistant attempt settlement failed");
+    this.cause = cause;
+    this.frame = frame;
+  }
+  cause;
+  frame;
+};
+var AgentService = class {
+  constructor(ctx, config = {}) {
+    this.ctx = ctx;
+    this.config = config;
+    this.inbox = config.inbox ?? new AgentInbox();
+  }
+  ctx;
+  config;
+  async *settleAttempt(attempt, message) {
+    try {
+      yield await attempt.settle(message);
+    } catch (error) {
+      if (error instanceof AttemptSettlementError) {
+        yield error.frame;
+        throw error.cause;
+      }
+      throw error;
+    }
+  }
+  inbox;
+  _seriesStarted = false;
+  _persistedRequest = false;
+  _streamRevision = 0;
+  _attempt(session, turn, step) {
+    return new AssistantStreamAttempt(session, turn, step, () => ++this._streamRevision);
+  }
+  /** Call when a request begins an explicit new model-message series. */
+  startSeries() {
+    this._seriesStarted = true;
+  }
+  /** Clear any pending series marker after a completed run. */
+  endSeriesBoundary() {
+    this._seriesStarted = false;
+  }
+  /** True when this service instance has already persisted a model-visible step. */
+  get hasPersistedRequest() {
+    return this._persistedRequest;
+  }
+  async run(input, options = {}) {
+    return consumeAgentStream(this._stream(input, options));
+  }
+  async *runStream(input, options = {}) {
+    const iterator = this._stream(input, options)[Symbol.asyncIterator]();
     while (true) {
       const next = await iterator.next();
       if (next.done) return next.value;
       yield next.value;
     }
   }
-  async *_stream(input, options = {}, useStream = true) {
+  async *_stream(input, options = {}) {
     const claimed = input ?? this.inbox.claim();
     if (!claimed) throw new AgentError("no agent input available");
     await this.config.hooks?.beforeRun?.(claimed, options);
@@ -117,162 +1353,377 @@ var AgentService = class {
     const tools = this._tools();
     const llm = this._llm();
     if (!llm) throw new AgentError("no LLM adapter available");
+    const streamAdapter = llm.stream;
+    const persistChunks = streamAdapter !== void 0;
     const maxTurns = options.maxTurns ?? this.config.maxTurns ?? 64;
     const maxSteps = options.maxSteps ?? this.config.maxSteps ?? 64;
     const contextBudget = options.contextBudget ?? this.config.contextBudget;
     const injected = this.inbox.injected();
     this.ctx.emit("agent/start", { input: claimed, options, injected });
-    let messages = this._initialMessages(claimed);
-    const systemPrompt = this.inbox.injected().get("agentSystem");
-    if (typeof systemPrompt === "string" && systemPrompt) {
-      await session.append("message", { role: "system", content: systemPrompt });
-    }
-    if (claimed.text) {
-      await session.append("message", { role: "user", content: claimed.text });
-    }
+    let messages = await this._initialMessages(claimed);
+    let claimedMessages = messages.filter((message) => message.role === "user");
     const steps = [];
     let output = "";
     let finishReason = "stop";
+    let lengthReached = false;
     this.ctx.emit("agent/turn-start", {
       input: claimed,
       messages: copyMessages(messages),
       injected
     });
+    const turn = options.turn ?? await session.nextTurn();
+    if (options.turn === void 0) {
+      await session.append("turn/start", {
+        turn,
+        input: claimed.text ?? claimed,
+        reason: "user"
+      });
+    }
     let index = 0;
     let finalTurnGranted = false;
-    while (index < maxTurns + (finalTurnGranted ? 1 : 0)) {
-      if (steps.length >= maxSteps) {
-        finishReason = "max_steps";
-        break;
-      }
-      if (contextBudget) {
-        messages = await this._enforceContextBudget(session, contextBudget, messages);
-      }
-      const stepInput = copyMessages(messages);
-      this.ctx.emit("agent/step", { index, input: copyMessages(stepInput) });
-      const availableTools = finalTurnGranted ? [] : tools.list();
-      const completeOptions = {
-        maxSteps: maxSteps - steps.length
-      };
-      if (options.signal) completeOptions.signal = options.signal;
-      let completion;
-      const streamMethod = useStream ? llm.stream : void 0;
-      if (streamMethod) {
-        const streamEvents = [];
-        let cancelled = false;
-        try {
-          for await (const event of streamMethod(stepInput, availableTools, completeOptions)) {
-            streamEvents.push(event);
-            yield event;
+    let currentStepIndex;
+    let turnError;
+    try {
+      while (index < maxTurns + (finalTurnGranted ? 1 : 0)) {
+        if (options.signal?.aborted) {
+          finishReason = "cancelled";
+          break;
+        }
+        if (steps.length >= maxSteps) {
+          finishReason = "max_steps";
+          break;
+        }
+        if (contextBudget) {
+          messages = await this._enforceContextBudget(session, contextBudget, messages);
+        }
+        const stepInput = copyMessages(messages);
+        const preStep = await this.ctx.waterfallAsync("agent/pre-step", {
+          index,
+          turn,
+          step: index,
+          messages: stepInput,
+          claimedMessages: copyMessages(claimedMessages),
+          ...options.signal ? { signal: options.signal } : {}
+        }, (payload) => payload);
+        if (!preStep || preStep.admission === "reject" || !Array.isArray(preStep.messages) || !preStep.messages.length) {
+          break;
+        }
+        if (preStep.startsRequestSeries) this._seriesStarted = true;
+        await session.append("step/start", { turn, step: index });
+        currentStepIndex = index;
+        const requestedInput = copyMessages(preStep.messages);
+        const admittedHistory = await session.deriveMessages();
+        this.ctx.emit("agent/step", {
+          index,
+          turn,
+          step: index,
+          input: copyMessages(requestedInput)
+        });
+        const availableTools = finalTurnGranted ? [] : await this._resolveAvailableTools();
+        const completeOptions = {
+          maxSteps: maxSteps - steps.length
+        };
+        if (options.signal) completeOptions.signal = options.signal;
+        let llmMessages = copyMessages(requestedInput);
+        let completion;
+        let activeAttempt;
+        let attempt = 0;
+        while (true) {
+          if (options.signal?.aborted) {
+            finishReason = "cancelled";
+            break;
           }
-        } catch (error) {
-          if (!options.signal?.aborted) throw error;
+          const streamEvents = [];
+          activeAttempt = this._attempt(session, turn, index);
+          yield activeAttempt.start();
+          const streamRequest = {
+            index,
+            messages: copyMessages(requestedInput),
+            tools: [...availableTools],
+            options: { ...completeOptions }
+          };
+          try {
+            const request = await this.ctx.waterfallAsync("agent/request", {
+              index,
+              messages: copyMessages(requestedInput),
+              tools: streamRequest.tools,
+              options: streamRequest.options
+            }, (payload) => payload);
+            if (!request || !request.options || !request.tools) {
+              throw new AgentError("agent/request must return a request payload");
+            }
+            streamRequest.tools = request.tools;
+            streamRequest.options = request.options;
+            let preparation;
+            const prepareRequest = () => preparation ??= (async () => {
+              lockStreamRequest(streamRequest);
+              llmMessages = copyMessages(streamRequest.messages);
+              await this._persistStepInput(session, streamRequest, llmMessages, admittedHistory);
+              await this._assertReplayable(session, streamRequest, llmMessages);
+            })();
+            const stream = await this.ctx.waterfallAsync(
+              "llm/stream",
+              streamRequest,
+              (payload) => (async function* () {
+                await prepareRequest();
+                yield* streamAdapter ? streamAdapter.call(llm, payload.messages, payload.tools, payload.options) : completeAsStream(llm, payload.messages, payload.tools, payload.options);
+              })()
+            );
+            if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
+              throw new AgentError("llm/stream must return an async iterable stream");
+            }
+            await prepareRequest();
+            let chunkIndex = 0;
+            for await (const event of stream) {
+              streamEvents.push(structuredClone(event));
+              yield activeAttempt.push(event);
+              if (persistChunks && event.type === "message_delta") {
+                await session.append("assistant/chunk", {
+                  id: event.id,
+                  content: event.delta,
+                  index: chunkIndex
+                });
+                chunkIndex += 1;
+              }
+              yield event;
+            }
+            completion = completionFromStreamEvents(streamEvents);
+            if (completion.finishReason === "error" || completion.finishReason === "cancelled") {
+              const terminalReason = completion.finishReason;
+              completion = void 0;
+              throw new AgentError(`LLM stream finished with ${terminalReason}`);
+            }
+            break;
+          } catch (error) {
+            yield activeAttempt.push({ type: "stream_error", error: toToolError(error) });
+            if (options.signal?.aborted) {
+              const content = partialStreamContent(streamEvents);
+              yield* this.settleAttempt(activeAttempt, content ? { content, interrupted: true } : void 0);
+              finishReason = "cancelled";
+              break;
+            }
+            yield* this.settleAttempt(activeAttempt);
+            attempt += 1;
+            const failure = toToolError(error);
+            const decision = await this.ctx.waterfallAsync(
+              "agent/request-error",
+              {
+                index,
+                turn,
+                step: index,
+                messages: copyMessages(streamRequest.messages),
+                tools: [...streamRequest.tools],
+                options: { ...streamRequest.options },
+                attempt,
+                error,
+                failure,
+                ...streamRequest.options.provider ? { provider: streamRequest.options.provider } : {},
+                ...streamRequest.options.model ? { model: streamRequest.options.model } : {},
+                ...options.signal ? { signal: options.signal } : {}
+              },
+              () => void 0
+            );
+            if (options.signal?.aborted) {
+              finishReason = "cancelled";
+              break;
+            }
+            if (decision?.kind !== "retry") throw error;
+            const retryId = randomUUID2();
+            const delayMs = decision.delayMs ?? 0;
+            await session.append("llm/retry", {
+              retryId,
+              retry: attempt,
+              ...delayMs > 0 ? { delayMs } : {},
+              failure: toToolError(error)
+            });
+            if (!await cancellableDelay(delayMs, options.signal)) {
+              finishReason = "cancelled";
+              break;
+            }
+            await session.append("llm/retry-started", { retryId, retry: attempt });
+          }
+        }
+        if (!completion || !activeAttempt) {
+          if (options.signal?.aborted) {
+            finishReason = "cancelled";
+            break;
+          }
+          throw new AgentError("LLM adapter did not produce a completion");
+        }
+        const toolCalls = completion.toolCalls ?? [];
+        if (completion.finishReason === "length") lengthReached = true;
+        if (options.signal?.aborted && toolCalls.length === 0) {
+          yield activeAttempt.push({ type: "stream_error", error: { name: "AbortError", message: "stream aborted" } });
+          yield* this.settleAttempt(activeAttempt);
           finishReason = "cancelled";
-          cancelled = true;
+          break;
         }
-        if (cancelled) break;
-        completion = completionFromStreamEvents(streamEvents);
-      } else {
-        try {
-          completion = await llm.complete(stepInput, availableTools, completeOptions);
-        } catch (error) {
-          if (!options.signal?.aborted) throw error;
+        if (finalTurnGranted && toolCalls.length && !options.signal?.aborted) {
+          yield activeAttempt.push({ type: "stream_error", error: { name: "AgentError", message: "maximum turns reached" } });
+          yield* this.settleAttempt(activeAttempt);
+          finishReason = "max_turns";
+          break;
+        }
+        const toolResults = [];
+        if (toolCalls.length) {
+          yield* this.settleAttempt(activeAttempt, {
+            content: completion.content ?? "",
+            toolCalls: toolCalls.map((call) => ({
+              id: call.id,
+              name: call.name,
+              arguments: call.arguments
+            }))
+          });
+        }
+        for (const call of toolCalls) {
+          this.ctx.emit("agent/tool-call", { index, turn, step: index, call });
+          yield { type: "tool/start", index, turn, step: index, call };
+          await session.append("tool/call", {
+            id: call.id,
+            name: call.name,
+            arguments: call.arguments
+          });
+          const toolOptions = { callId: call.id };
+          if (options.signal) toolOptions.signal = options.signal;
+          const startedAt = Date.now();
+          let result;
+          if (options.signal?.aborted) {
+            result = {
+              ok: false,
+              name: call.name,
+              callId: call.id,
+              input: call.arguments,
+              error: abortedToolError(options.signal),
+              startedAt,
+              durationMs: Date.now() - startedAt
+            };
+          } else {
+            try {
+              result = await tools.execute(call.name, call.arguments, toolOptions);
+            } catch (error) {
+              result = {
+                ok: false,
+                name: call.name,
+                callId: call.id,
+                input: call.arguments,
+                error: toToolError(error),
+                startedAt,
+                durationMs: Date.now() - startedAt
+              };
+            }
+          }
+          toolResults.push(result);
+          const toolResultPayload = {
+            id: call.id,
+            toolCallId: call.id,
+            name: call.name,
+            ok: result.ok,
+            durationMs: result.durationMs
+          };
+          if (result.output !== void 0) toolResultPayload.output = result.output;
+          if (result.error) {
+            toolResultPayload.error = {
+              name: result.error.name,
+              message: result.error.message
+            };
+            if (result.error.stack) toolResultPayload.error.stack = result.error.stack;
+          }
+          await session.append("tool/result", toolResultPayload);
+          yield { type: "tool/end", index, turn, step: index, call, result };
+          this.ctx.emit("agent/tool-result", {
+            index,
+            turn,
+            step: index,
+            call,
+            result
+          });
+        }
+        if (options.signal?.aborted) {
           finishReason = "cancelled";
           break;
         }
-      }
-      const toolCalls = completion.toolCalls ?? [];
-      if (finalTurnGranted && toolCalls.length) {
-        finishReason = "max_turns";
-        break;
-      }
-      const toolResults = [];
-      if (toolCalls.length) {
-        await session.append("message", {
-          role: "assistant",
-          content: completion.content ?? ""
+        steps.push({
+          index,
+          input: copyMessages(llmMessages),
+          completion,
+          toolResults
         });
-      }
-      for (const call of toolCalls) {
-        this.ctx.emit("agent/tool-call", { index, call });
-        yield { type: "tool/start", index, call };
-        await session.append("tool-call", {
-          id: call.id,
-          name: call.name,
-          arguments: call.arguments
+        if (completion.content) {
+          output = completion.content;
+        }
+        if (!toolCalls.length) {
+          yield* this.settleAttempt(activeAttempt, { content: completion.content ?? "" });
+        }
+        await session.append("step/end", {
+          turn,
+          step: index,
+          finishReason: completion.finishReason,
+          toolCalls: toolCalls.length
         });
-        const toolOptions = { callId: call.id };
-        if (options.signal) toolOptions.signal = options.signal;
-        const startedAt = Date.now();
-        let result;
-        try {
-          result = await tools.execute(call.name, call.arguments, toolOptions);
-        } catch (error) {
-          result = {
-            ok: false,
-            name: call.name,
-            callId: call.id,
-            input: call.arguments,
-            error: toToolError(error),
-            startedAt,
-            durationMs: Date.now() - startedAt
-          };
+        currentStepIndex = void 0;
+        const nextMessages = this._extendMessages(llmMessages, completion, toolResults);
+        const concludesTurn = toolResults.some((result) => result.concludesTurn === true);
+        let nextStepMessages = await this._claimNextStepMessages();
+        if ((toolCalls.length === 0 || concludesTurn) && nextStepMessages.length === 0) {
+          finishReason = lengthReached ? "length" : completion.finishReason === "error" ? "error" : "stop";
+          const keepGoing = await this.ctx.serial("agent/turn-stopping", {
+            index,
+            turn,
+            steps: copySteps(steps),
+            finishReason
+          });
+          if (!keepGoing) {
+            nextStepMessages = await this._claimNextStepMessages();
+            if (nextStepMessages.length === 0) break;
+          }
         }
-        toolResults.push(result);
-        const toolResultPayload = {
-          id: call.id,
-          toolCallId: call.id,
-          name: call.name,
-          ok: result.ok,
-          durationMs: result.durationMs
-        };
-        if (result.output !== void 0) toolResultPayload.output = result.output;
-        if (result.error) {
-          toolResultPayload.error = {
-            name: result.error.name,
-            message: result.error.message
-          };
-          if (result.error.stack) toolResultPayload.error.stack = result.error.stack;
+        if (index + 1 >= maxTurns && !finalTurnGranted) {
+          finalTurnGranted = true;
+        } else if (index + 1 >= maxTurns + (finalTurnGranted ? 1 : 0)) {
+          finishReason = "max_turns";
+          break;
         }
-        await session.append("tool-result", toolResultPayload);
-        yield { type: "tool/end", index, call, result };
-        this.ctx.emit("agent/tool-result", { index, call, result });
+        if (toolCalls.length) finishReason = "tool_calls";
+        index += 1;
+        messages = [...nextMessages, ...nextStepMessages];
+        claimedMessages = nextStepMessages.filter((message) => message.role === "user");
       }
-      if (options.signal?.aborted) {
-        finishReason = "cancelled";
-        break;
+    } catch (error) {
+      turnError = error;
+      throw error;
+    } finally {
+      const cancelCause = cancelCauseFromSignal(options.signal);
+      if (currentStepIndex !== void 0) {
+        const cancelled = options.signal?.aborted;
+        await session.append("step/end", {
+          turn,
+          step: currentStepIndex,
+          finishReason: cancelled ? "cancelled" : turnError ? "error" : "interrupted",
+          interrupted: true,
+          ...cancelCause ? { cancelCause } : {},
+          ...turnError ? { error: toToolError(turnError) } : {}
+        });
       }
-      steps.push({
-        index,
-        input: stepInput,
-        completion,
-        toolResults
+      await session.append("turn/end", {
+        turn,
+        finishReason: turnError ? options.signal?.aborted ? "cancelled" : "error" : finishReason,
+        reason: toTurnEndReason({
+          cancelled: options.signal?.aborted ?? false,
+          turnError,
+          finishReason: turnError ? options.signal?.aborted ? "cancelled" : "error" : finishReason,
+          ...cancelCause ? { cancelCause } : {}
+        }),
+        ...cancelCause ? { cancelCause } : {},
+        ...output ? { output } : {},
+        ...steps.length ? { steps: steps.length } : {},
+        ...turnError ? { interrupted: true, error: toToolError(turnError) } : {}
       });
-      if (completion.content) {
-        output = completion.content;
-      }
-      if (!toolCalls.length) {
-        await session.append("message", { role: "assistant", content: completion.content ?? "" });
-      }
-      const nextMessages = this._extendMessages(messages, completion, toolResults);
-      if (toolCalls.length === 0) {
-        finishReason = completion.finishReason === "length" ? "length" : completion.finishReason === "error" ? "error" : "stop";
-        break;
-      }
-      if (index + 1 >= maxTurns && !finalTurnGranted) {
-        finalTurnGranted = true;
-      } else if (index + 1 >= maxTurns + (finalTurnGranted ? 1 : 0)) {
-        finishReason = "max_turns";
-        break;
-      }
-      finishReason = "tool_calls";
-      index += 1;
-      messages = nextMessages;
     }
     const runResult = {
       input: claimed,
       output,
       finishReason,
+      turn,
       steps,
       messages: copyMessages(messages)
     };
@@ -321,9 +1772,113 @@ var AgentService = class {
     });
     return compactMessages.map((message) => copyMessages([message])[0]);
   }
-  _initialMessages(input) {
-    const systemPrompt = this.inbox.injected().get("agentSystem");
-    const systemMessage = typeof systemPrompt === "string" && systemPrompt ? [{ role: "system", content: systemPrompt }] : [];
+  async _persistStepInput(session, request, input, admittedHistory) {
+    const surface = await session.deriveMessages();
+    const owned = admittedHistory.filter((message) => !isUserOrSystemMessage(message));
+    let ownerIndex = 0;
+    for (const message of input) {
+      if (isUserOrSystemMessage(message)) continue;
+      const actual = canonicalMessages([message]);
+      while (ownerIndex < owned.length && canonicalMessages([owned[ownerIndex]]) !== actual) {
+        ownerIndex += 1;
+      }
+      if (ownerIndex === owned.length) {
+        throw new AgentError("request is not reconstructable from session log: unowned or reordered assistant/tool message");
+      }
+      ownerIndex += 1;
+    }
+    const nextHeader = requestHeaderFor(request, input);
+    const previousHeader = session.requestHeader();
+    const isFirstRequest = !this._persistedRequest;
+    const isResume = isFirstRequest && previousHeader !== void 0;
+    this._persistedRequest = true;
+    const changedHeader = previousHeader && (previousHeader.system !== nextHeader.system || JSON.stringify(previousHeader.tools ?? []) !== JSON.stringify(nextHeader.tools ?? []) || JSON.stringify(previousHeader.config ?? {}) !== JSON.stringify(nextHeader.config ?? {}));
+    if (isFirstRequest) {
+      await session.append("request/header", {
+        reason: this._seriesStarted ? "series" : isResume ? "resume" : "initial",
+        ...nextHeader,
+        ...this._seriesStarted ? { startsSeries: true } : {}
+      });
+    } else if (changedHeader) {
+      await session.append("request/header", {
+        reason: this._seriesStarted ? "change-series" : "change",
+        ...nextHeader,
+        startsSeries: true
+      });
+    } else if (this._seriesStarted) {
+      await session.append("request/header", {
+        reason: "series",
+        ...nextHeader,
+        startsSeries: true
+      });
+    }
+    this._seriesStarted = false;
+    const nextContext = {
+      ...request.options.provider ? { provider: request.options.provider } : {},
+      ...request.options.model ? { model: request.options.model } : {}
+    };
+    if (request.options.contextWindow !== void 0) {
+      nextContext.contextWindow = request.options.contextWindow;
+    }
+    const llmService2 = this.ctx.reflect.get("llm", false);
+    const routeCapacity = llmService2?.routeCapacity?.();
+    if (nextContext.contextWindow === void 0 && routeCapacity?.contextWindow !== void 0) {
+      nextContext.contextWindow = routeCapacity.contextWindow;
+    }
+    const previousContext = session.requestContext();
+    if (previousContext?.provider !== nextContext.provider || previousContext?.model !== nextContext.model || previousContext?.contextWindow !== nextContext.contextWindow || previousContext === void 0) {
+      await session.append("request/context", nextContext);
+    }
+    const isSurfacePrefix = (messages) => canonicalMessages(messages.slice(0, surface.length)) === canonicalMessages(surface);
+    const requested = surface.length > 0 && input[0]?.role === "system" && input[0].content === nextHeader.system && isSurfacePrefix(input.slice(1)) ? input.slice(1) : input;
+    const tail = requested.slice(surface.length);
+    if (isSurfacePrefix(requested) && tail.every(isUserOrSystemMessage)) {
+      for (const message of tail) {
+        if (message.role === "user") {
+          await session.append("user/message", {
+            content: message.content,
+            ...message.name ? { name: message.name } : {}
+          });
+        } else {
+          await session.append("system/message", {
+            content: message.content,
+            ...message.name ? { name: message.name } : {}
+          });
+        }
+      }
+      return;
+    }
+    const nodes = await session.surfaceEvents();
+    await session.append("checkpoint", {
+      messages: copyMessages(requested),
+      surfaceOp: { op: "replace", start: nodes[0].seq, end: nodes.at(-1).seq }
+    });
+  }
+  async _assertReplayable(session, request, input) {
+    const reconstructed = await session.deriveMessages();
+    const actual = canonicalMessages(input);
+    const replay = canonicalMessages(reconstructed);
+    const header = session.requestHeader();
+    const headerOwnsPrefix = input[0]?.role === "system" && input[0].content === header?.system && canonicalMessages(input.slice(1)) === replay;
+    if (actual !== replay && !headerOwnsPrefix) {
+      throw new AgentError(
+        `request is not reconstructable from session log: actual=${actual} replay=${replay}`
+      );
+    }
+    const expected = requestHeaderFor(request, input);
+    if (header?.system !== expected.system || JSON.stringify(header?.tools ?? []) !== JSON.stringify(expected.tools ?? []) || JSON.stringify(header?.config ?? {}) !== JSON.stringify(expected.config ?? {})) {
+      throw new AgentError("request envelope is not reconstructable from session log");
+    }
+  }
+  async _claimNextStepMessages() {
+    const inputs = await this.config.claimNextStep?.() ?? [];
+    return inputs.flatMap((input) => input.messages?.length ? copyMessages(input.messages) : input.text ? [{ role: "user", content: input.text }] : input.context !== void 0 ? [{ role: "user", content: stringify2(input.context) }] : []);
+  }
+  async _initialMessages(input) {
+    const promptService = this.ctx.reflect.get("systemPrompt", false);
+    const assembled = promptService ? (await promptService.assemble({}, this.ctx)).text.trim() : void 0;
+    const systemPrompt2 = assembled || this.inbox.injected().get("agentSystem");
+    const systemMessage = typeof systemPrompt2 === "string" && systemPrompt2 ? [{ role: "system", content: systemPrompt2 }] : [];
     if (input.messages?.length) {
       const first = input.messages[0];
       if (first?.role === "system") return copyMessages(input.messages);
@@ -346,10 +1901,10 @@ var AgentService = class {
         arguments: call.arguments
       }));
     }
-    next.push(assistant);
+    if (assistant.content || toolCalls.length) next.push(assistant);
     for (const call of toolCalls) {
       const result = toolResults.find((candidate) => candidate.callId === call.id);
-      const content = result ? result.ok ? stringify(result.output) : `error: ${result.error?.message ?? "unknown"}` : "error: missing tool result";
+      const content = result ? result.ok ? stringify2(result.output) : `error: ${result.error?.message ?? "unknown"}` : "error: missing tool result";
       const message = {
         role: "tool",
         content,
@@ -370,17 +1925,30 @@ var AgentService = class {
     return next;
   }
   _session() {
+    if (this.config.session) return this.config.session;
     const session = this.ctx.session;
     if (!session) throw new AgentError("session service is required");
     return session;
   }
   _tools() {
-    const tools = this.ctx.tools;
+    const scoped = this.ctx.reflect.get("tools", false);
+    const tools = scoped ?? this.ctx.tools;
     if (!tools) throw new AgentError("tools service is required");
     return tools;
   }
+  async _resolveAvailableTools() {
+    const executable = this._tools().list();
+    const promptService = this.ctx.reflect.get("systemPrompt", false);
+    if (!promptService) return executable;
+    const schemas = await promptService.toolSchemas();
+    if (!schemas.length) return executable;
+    const byName = new Map(executable.map((tool) => [tool.schema.name, tool]));
+    return schemas.map((schema) => byName.get(schema.name)).filter((tool) => tool !== void 0);
+  }
   _llm() {
-    return this.config.llm;
+    if (this.config.llm) return this.config.llm;
+    const service = this.ctx.reflect.get("llm", false);
+    return service?.current();
   }
 };
 function defaultContextSummary(messages, usage) {
@@ -506,6 +2074,15 @@ function defineAgent(definition) {
         agentService = ctx.reflect.get("agent");
         if (system) agentService.inbox.inject("agentSystem", system);
       }
+      if (system) {
+        const prompt = ctx.reflect.get("systemPrompt");
+        if (prompt) {
+          ctx.fiber.effect(() => prompt.registerSection({
+            name: `${name2}:persona`,
+            content: system
+          }), `ctx.systemPrompt.section(${JSON.stringify(name2)})`);
+        }
+      }
       for (const tool of definition.tools ?? []) {
         dynamic.tools.register(tool);
       }
@@ -520,12 +2097,2505 @@ function defineAgent(definition) {
     }
   };
 }
+
+// packages/agent/src/live.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+// packages/core/src/utils.ts
+var DisposableList = class {
+  sn = 0;
+  map = /* @__PURE__ */ new Map();
+  weak = /* @__PURE__ */ new WeakMap();
+  get length() {
+    return this.map.size;
+  }
+  push(value) {
+    const sn = ++this.sn;
+    this.map.set(sn, value);
+    this.weak.set(value, sn);
+    return () => this.map.delete(sn);
+  }
+  unshift(value) {
+    const sn = ++this.sn;
+    const entries = [...this.map.entries()];
+    this.map.clear();
+    this.map.set(sn, value);
+    this.weak.set(value, sn);
+    for (const [oldSn, oldValue] of entries) {
+      this.map.set(oldSn, oldValue);
+    }
+    return () => this.map.delete(sn);
+  }
+  delete(value) {
+    const sn = this.weak.get(value);
+    if (!sn) return false;
+    return this.map.delete(sn);
+  }
+  clear() {
+    const values = [...this.map.values()];
+    this.map.clear();
+    return values.reverse();
+  }
+  [Symbol.iterator]() {
+    return this.map.values();
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return [...this];
+  }
+};
+var symbols = {
+  shadow: /* @__PURE__ */ Symbol.for("tnega.shadow"),
+  caller: /* @__PURE__ */ Symbol.for("tnega.caller"),
+  receiver: /* @__PURE__ */ Symbol.for("tnega.receiver"),
+  original: /* @__PURE__ */ Symbol.for("tnega.original"),
+  metadata: /* @__PURE__ */ Symbol.for("tnega.metadata"),
+  initHooks: /* @__PURE__ */ Symbol.for("tnega.initHooks"),
+  checkProto: /* @__PURE__ */ Symbol.for("tnega.checkProto"),
+  effect: /* @__PURE__ */ Symbol.for("tnega.effect"),
+  filter: /* @__PURE__ */ Symbol.for("tnega.filter"),
+  isolate: /* @__PURE__ */ Symbol.for("tnega.isolate"),
+  intercept: /* @__PURE__ */ Symbol.for("tnega.intercept"),
+  init: /* @__PURE__ */ Symbol.for("tnega.init"),
+  check: /* @__PURE__ */ Symbol.for("tnega.check"),
+  config: /* @__PURE__ */ Symbol.for("tnega.config"),
+  invoke: /* @__PURE__ */ Symbol.for("tnega.invoke"),
+  extend: /* @__PURE__ */ Symbol.for("tnega.extend"),
+  tracker: /* @__PURE__ */ Symbol.for("tnega.tracker"),
+  resolveConfig: /* @__PURE__ */ Symbol.for("tnega.resolveConfig")
+};
+var GeneratorFunction = function* () {
+}.constructor;
+var AsyncGeneratorFunction = async function* () {
+}.constructor;
+function isConstructor(func) {
+  if (typeof func !== "function") return false;
+  if (func instanceof GeneratorFunction) return false;
+  if (AsyncGeneratorFunction !== Function && func instanceof AsyncGeneratorFunction) return false;
+  return /^class\s/.test(Function.prototype.toString.call(func));
+}
+function isObject(value) {
+  return !!value && (typeof value === "object" || typeof value === "function");
+}
+function isNullable(value) {
+  return value == null;
+}
+function joinPrototype(proto1, proto2) {
+  if (proto1 === Object.prototype) return proto2;
+  const result = Object.create(joinPrototype(Object.getPrototypeOf(proto1), proto2));
+  for (const key of Reflect.ownKeys(proto1)) {
+    Object.defineProperty(result, key, Reflect.getOwnPropertyDescriptor(proto1, key));
+  }
+  return result;
+}
+function getPropertyDescriptor(target, prop) {
+  let proto = target;
+  while (proto) {
+    const desc = Reflect.getOwnPropertyDescriptor(proto, prop);
+    if (desc) return desc;
+    proto = Object.getPrototypeOf(proto);
+  }
+}
+function getTraceable(ctx, value) {
+  if (!isObject(value)) return value;
+  if (Object.hasOwn(value, symbols.shadow)) {
+    return Object.getPrototypeOf(value);
+  }
+  const tracker = value[symbols.tracker];
+  if (!tracker) return value;
+  return createTraceable(ctx, value, tracker);
+}
+function withProps(target, props) {
+  if (!props) return target;
+  return new Proxy(target, {
+    get: (target2, prop, receiver) => {
+      if (prop in props && prop !== "constructor") return Reflect.get(props, prop, receiver);
+      return Reflect.get(target2, prop, receiver);
+    },
+    set: (target2, prop, value, receiver) => {
+      if (prop in props && prop !== "constructor") return Reflect.set(props, prop, value, receiver);
+      return Reflect.set(target2, prop, value, receiver);
+    }
+  });
+}
+function withProp(target, prop, value) {
+  return withProps(target, Object.defineProperty(/* @__PURE__ */ Object.create(null), prop, {
+    value,
+    writable: false
+  }));
+}
+function createShadow(ctx, target, property, receiver) {
+  if (!property) return receiver;
+  const origin = getPropertyDescriptor(target, property)?.value;
+  if (!origin) return receiver;
+  return withProp(receiver, property, ctx.extend({ [symbols.shadow]: origin }));
+}
+function createShadowMethod(ctx, value, outer, shadow) {
+  const proxy = new Proxy(value, {
+    apply: (target, thisArg, args) => {
+      if (thisArg === outer) thisArg = shadow;
+      return getTraceable(ctx, Reflect.apply(target, thisArg, args));
+    }
+  });
+  return proxy;
+}
+function createTraceable(ctx, value, tracker) {
+  const caller = ctx[symbols.shadow] ?? ctx;
+  if (ctx[symbols.shadow]) {
+    ctx = Object.getPrototypeOf(ctx);
+  }
+  const proxy = new Proxy(value, {
+    get: (target, prop, receiver) => {
+      if (prop === symbols.original) return target;
+      if (prop === symbols.caller) return caller;
+      if (prop === tracker.property) return ctx;
+      if (typeof prop === "symbol") {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (tracker.associate && ctx.reflect.props[`${tracker.associate}.${prop}`]) {
+        return Reflect.get(ctx, `${tracker.associate}.${prop}`, withProp(ctx, symbols.receiver, receiver));
+      }
+      let shadow;
+      let innerValue;
+      const desc = getPropertyDescriptor(target, prop);
+      if (desc?.value !== void 0) {
+        innerValue = desc.value;
+      } else {
+        shadow = createShadow(ctx, target, tracker.property, receiver);
+        innerValue = Reflect.get(target, prop, shadow);
+      }
+      const innerTracker = innerValue?.[symbols.tracker];
+      if (innerTracker) {
+        return createTraceable(ctx, innerValue, innerTracker);
+      } else if (!tracker.noShadow && typeof innerValue === "function") {
+        shadow ??= createShadow(ctx, target, tracker.property, receiver);
+        return createShadowMethod(ctx, innerValue, receiver, shadow);
+      } else {
+        return innerValue;
+      }
+    },
+    set: (target, prop, value2, receiver) => {
+      if (prop === symbols.original || prop === symbols.caller || prop === tracker.property) return false;
+      if (typeof prop === "symbol") {
+        return Reflect.set(target, prop, value2, receiver);
+      }
+      if (tracker.associate && ctx.reflect.props[`${tracker.associate}.${prop}`]) {
+        return Reflect.set(ctx, `${tracker.associate}.${prop}`, value2, withProp(ctx, symbols.receiver, receiver));
+      }
+      const shadow = createShadow(ctx, target, tracker.property, receiver);
+      return Reflect.set(target, prop, value2, shadow);
+    },
+    apply: (target, thisArg, args) => {
+      const receiver = tracker.noShadow ? proxy : createShadow(ctx, target, tracker.property, proxy);
+      return applyTraceable(receiver, target, thisArg, args);
+    }
+  });
+  return proxy;
+}
+function applyTraceable(proxy, value, thisArg, args) {
+  if (!value[symbols.invoke]) return Reflect.apply(value, thisArg, args);
+  return value[symbols.invoke].apply(proxy, args);
+}
+function createCallable(name2, proto, tracker) {
+  const self = function(...args) {
+    const proxy = createTraceable(self.ctx, self, tracker);
+    return Reflect.apply(proxy, this, args);
+  };
+  Object.defineProperty(self, "name", { value: name2, configurable: true, writable: true });
+  return Object.setPrototypeOf(self, proto);
+}
+function handleError(info, reason, getOuterStack) {
+  const innerLines = info.error.stack.split("\n");
+  if (typeof reason?.stack !== "string") {
+    const outerError = new Error(reason);
+    const lines2 = outerError.stack.split("\n");
+    lines2.splice(1, Infinity, ...getOuterStack());
+    outerError.stack = lines2.join("\n");
+    throw outerError;
+  }
+  const lines = reason.stack.split("\n");
+  const index = lines.indexOf(innerLines[2]);
+  if (index === -1) throw reason;
+  lines.splice(index - info.offset, Infinity, ...getOuterStack());
+  reason.stack = lines.join("\n");
+  throw reason;
+}
+function composeError(callback, getOuterStack = buildOuterStack()) {
+  const info = { offset: 1, error: new Error() };
+  try {
+    const result = callback(info);
+    if (isObject(result) && "then" in result) {
+      return result.then(void 0, (reason) => handleError(info, reason, getOuterStack));
+    }
+    return result;
+  } catch (reason) {
+    handleError(info, reason, getOuterStack);
+  }
+}
+function buildOuterStack(offset = 0) {
+  const outerError = new Error();
+  return () => outerError.stack.split("\n").slice(3 + offset);
+}
+
+// packages/core/src/events.ts
+function isBailed(value) {
+  return value !== null && value !== false && value !== void 0;
+}
+var EventsService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    Object.defineProperty(this, symbols.tracker, {
+      value: { property: "ctx", noShadow: true }
+    });
+    this.on("internal/listener", function(name2, listener, options) {
+      if (name2 === "internal/update" && !options.global) {
+        const hooks = this.fiber._hooks["internal/update"] ??= new DisposableList();
+        const method = options.prepend ? "unshift" : "push";
+        return hooks[method](listener);
+      }
+    });
+    this.on("internal/update", function(config, noSave, next) {
+      const cbs = [...this.fiber._hooks["internal/update"] ?? []];
+      const _next = () => {
+        const cb = cbs.shift() ?? next;
+        return cb.call(this, config, noSave, _next);
+      };
+      return _next();
+    }, { global: true, prepend: true });
+  }
+  ctx;
+  _hooks = /* @__PURE__ */ Object.create(null);
+  _resolve(type, args) {
+    const thisArg = typeof args[0] === "object" || typeof args[0] === "function" ? args.shift() : null;
+    const name2 = args.shift();
+    if (!name2.startsWith("internal/") && this._hooks["internal/dispatch"]?.length) {
+      this.emit("internal/dispatch", type, name2, args, thisArg);
+    }
+    const filter = thisArg?.[Context.filter];
+    return [thisArg, (this._hooks[name2] || []).filter((hook) => hook.global || !filter || filter.call(thisArg, hook.ctx)).map((hook) => hook.callback)];
+  }
+  dispatch(type, args) {
+    const [thisArg, callbacks] = this._resolve(type, args);
+    return callbacks.map((callback) => callback.bind(thisArg));
+  }
+  async parallel(...args) {
+    const [thisArg, callbacks] = this._resolve("parallel", args);
+    const results = await Promise.allSettled(callbacks.map(async (callback) => Reflect.apply(callback, thisArg, args)));
+    const errors = results.filter((result) => result.status === "rejected").map((result) => result.reason);
+    if (errors.length) throw new AggregateError(errors);
+  }
+  emit(...args) {
+    const [thisArg, callbacks] = this._resolve("emit", args);
+    for (const callback of callbacks) Reflect.apply(callback, thisArg, args);
+  }
+  async serial(...args) {
+    const [thisArg, callbacks] = this._resolve("serial", args);
+    for (const callback of callbacks) {
+      const result = await Reflect.apply(callback, thisArg, args);
+      if (isBailed(result)) return result;
+    }
+  }
+  bail(...args) {
+    const [thisArg, callbacks] = this._resolve("bail", args);
+    for (const callback of callbacks) {
+      const result = Reflect.apply(callback, thisArg, args);
+      if (isBailed(result)) return result;
+    }
+  }
+  waterfall(...args) {
+    const [thisArg, callbacks] = this._resolve("waterfall", args);
+    const inner = args.pop();
+    const next = () => {
+      const callback = callbacks.shift();
+      return callback ? Reflect.apply(callback, thisArg, args) : inner(...args);
+    };
+    args.push(next);
+    return next();
+  }
+  async waterfallAsync(...args) {
+    const [thisArg, callbacks] = this._resolve("waterfallAsync", args);
+    const inner = args.pop();
+    const next = async () => {
+      const callback = callbacks.shift();
+      return callback ? await Reflect.apply(callback, thisArg, args) : inner(...args);
+    };
+    args.push(next);
+    return next();
+  }
+  register(label, hooks, callback, options) {
+    const method = options.prepend ? "unshift" : "push";
+    return this.ctx.fiber.effect(() => {
+      hooks[method]({ ctx: this.ctx, callback, ...options });
+      return () => this.unregister(hooks, callback);
+    }, label);
+  }
+  unregister(hooks, callback) {
+    const index = hooks.findIndex((hook) => hook.callback === callback);
+    if (index >= 0) {
+      hooks.splice(index, 1);
+      return true;
+    }
+  }
+  on(name2, listener, options = {}) {
+    if (typeof options !== "object") {
+      options = { prepend: options };
+    }
+    this.ctx.fiber.assertActive();
+    listener = this.ctx.reflect.bind(listener);
+    const result = this.bail(this.ctx, "internal/listener", name2, listener, options);
+    if (result) return result;
+    const hooks = this._hooks[name2] ??= [];
+    return this.register(`ctx.on(${JSON.stringify(name2)})`, hooks, listener, options);
+  }
+  once(name2, listener, options = {}) {
+    const dispose = this.on(name2, function(...args) {
+      dispose();
+      return listener.apply(this, args);
+    }, options);
+    return dispose;
+  }
+};
+
+// packages/core/src/fiber.ts
+var INACTIVE = "__INACTIVE__";
+var ValidationError = class extends TypeError {
+  name = "ValidationError";
+  constructor(issues) {
+    super("invalid config:\n" + issues.map((issue) => {
+      if (issue.path) {
+        return `  - ${issue.message} (at ${issue.path.join(".")})`;
+      }
+      return `  - ${issue.message}`;
+    }).join("\n"));
+  }
+};
+function resolveConfig(runtime, config) {
+  if (!runtime.Config) return config;
+  const schema = runtime.Config;
+  if (typeof schema === "function") return schema(config);
+  const validate = schema?.["~standard"]?.validate;
+  if (typeof validate === "function") {
+    const result = validate(config);
+    if ("then" in result) {
+      throw new TypeError("Async config validation is not supported");
+    }
+    if (result.issues) {
+      throw new ValidationError(result.issues);
+    }
+    return result.value;
+  }
+  return config;
+}
+var CordisErrorCode = {
+  INACTIVE_EFFECT: "cannot create effect on inactive context"
+};
+var CordisError = class extends Error {
+  constructor(code, message) {
+    super(message ?? CordisErrorCode[code]);
+    this.code = code;
+  }
+  code;
+};
+var Fiber = class {
+  constructor(parent, config, inject, runtime, getOuterStack) {
+    this.parent = parent;
+    this.inject = inject;
+    this.runtime = runtime;
+    const collect = (dispose) => {
+      this._disposables.push(dispose);
+    };
+    if (runtime) {
+      this.uid = parent.registry.counter;
+      this.ctx = this.context = parent.extend({ fiber: this });
+      const injectEntries = Object.entries(this.inject);
+      if (injectEntries.length) {
+        this.ctx[symbols.intercept] = Object.create(parent[symbols.intercept]);
+        for (const [name2, config2] of injectEntries) {
+          if (isNullable(config2)) continue;
+          this.ctx[symbols.intercept][name2] = config2;
+        }
+      }
+      this._runner = {
+        epoch: INACTIVE,
+        getOuterStack,
+        execute: () => {
+          if (isConstructor(runtime.callback)) {
+            const instance = new runtime.callback(this.ctx, this.config);
+            for (const hook of instance?.[symbols.initHooks] ?? []) {
+              hook();
+            }
+            return instance?.[symbols.init]?.();
+          } else {
+            return runtime.callback(this.ctx, this.config);
+          }
+        },
+        collect
+      };
+      this.context.emit(this, "internal/plugin");
+      for (const name2 of Object.keys(this.inject)) {
+        this._checkImpl(name2);
+      }
+      this.dispose = parent.fiber.effect(() => {
+        const remove = runtime.fibers.push(this);
+        try {
+          this.config = resolveConfig(runtime, config);
+          this._refresh();
+        } catch (error) {
+          this.ctx.logger.error(error);
+          this._error = error;
+        }
+        return async () => {
+          this.uid = null;
+          this.context.emit(this, "internal/plugin");
+          if (this.ctx.registry.has(runtime.callback)) {
+            remove();
+            if (!runtime.fibers.length) {
+              this.ctx.registry.delete(runtime.callback);
+            }
+          }
+          this._setEpoch(INACTIVE);
+          while (this.inertia) {
+            await this.inertia;
+          }
+        };
+      }, "ctx.plugin()");
+    } else {
+      this.uid = 0;
+      this.ctx = this.context = parent;
+      this.state = 2 /* ACTIVE */;
+      this.store = /* @__PURE__ */ Object.create(null);
+      this._runner = {
+        epoch: "",
+        getOuterStack,
+        execute: () => {
+        },
+        collect
+      };
+      this.dispose = () => this.restart();
+    }
+  }
+  parent;
+  inject;
+  runtime;
+  uid;
+  ctx;
+  config;
+  state = 0 /* PENDING */;
+  dispose;
+  store;
+  inertia;
+  _hooks = /* @__PURE__ */ Object.create(null);
+  _disposables = new DisposableList();
+  context;
+  _error = void 0;
+  _runner;
+  _store = /* @__PURE__ */ Object.create(null);
+  _restarting;
+  get name() {
+    if (this.runtime?.name) return this.runtime.name;
+    let fiber = this.parent.fiber;
+    while (fiber !== fiber.parent.fiber) {
+      if (fiber.runtime?.name) return fiber.runtime.name;
+      fiber = fiber.parent.fiber;
+    }
+    return "root";
+  }
+  assertActive() {
+    if (this.uid !== null) return;
+    throw new CordisError("INACTIVE_EFFECT");
+  }
+  _execute(runner) {
+    const oldEpoch = runner.epoch;
+    return composeError((info) => {
+      const safeCollect = (dispose) => {
+        if (typeof dispose === "function") {
+          runner.collect(dispose);
+        } else if (!isNullable(dispose)) {
+          throw new TypeError("Invalid effect");
+        }
+      };
+      const effect = runner.execute.call(this);
+      if (typeof effect === "function") {
+        return runner.collect(effect);
+      } else if (isNullable(effect)) {
+        return;
+      } else if (!isObject(effect)) {
+        throw new TypeError("Invalid effect");
+      } else if ("then" in effect) {
+        return effect.then(safeCollect);
+      } else if (Symbol.iterator in effect) {
+        info.error = new Error();
+        const iter = effect[Symbol.iterator]();
+        while (true) {
+          const result = iter.next();
+          safeCollect(result.value);
+          if (result.done) return;
+        }
+      } else if (Symbol.asyncIterator in effect) {
+        const iter = effect[Symbol.asyncIterator]();
+        return (async () => {
+          await Promise.resolve();
+          info.error = new Error();
+          while (true) {
+            if (runner.epoch !== oldEpoch) return;
+            const result = await iter.next();
+            safeCollect(result.value);
+            if (result.done) return;
+          }
+        })();
+      } else {
+        throw new TypeError("Invalid effect");
+      }
+    }, runner.getOuterStack);
+  }
+  effect(execute, label = "anonymous") {
+    this.assertActive();
+    const disposables = [];
+    const dispose = () => {
+      let task2;
+      for (const dispose2 of disposables.splice(0).reverse()) {
+        if (task2) {
+          task2 = task2.then(dispose2);
+        } else {
+          const result = dispose2();
+          if (isObject(result) && "then" in result) {
+            task2 = result;
+          }
+        }
+      }
+      return task2;
+    };
+    const meta = { label, children: [] };
+    const runner = {
+      execute,
+      epoch: true,
+      collect: (dispose2) => {
+        disposables.push(dispose2);
+        this._disposables.delete(dispose2);
+        if (dispose2[symbols.effect]) {
+          meta.children.push(dispose2[symbols.effect]);
+        }
+      },
+      getOuterStack: buildOuterStack()
+    };
+    let task;
+    try {
+      task = this._execute(runner);
+    } catch (reason) {
+      dispose();
+      throw reason;
+    }
+    task?.catch(dispose).catch((error) => this.ctx.logger.error(error));
+    const wrapper = Object.defineProperty(() => {
+      if (!runner.epoch) return;
+      runner.epoch = false;
+      return task ? task.then(dispose) : dispose();
+    }, symbols.effect, { value: meta });
+    const disposeAsync = () => {
+      if (!runner.epoch) return;
+      runner.epoch = false;
+      return dispose();
+    };
+    wrapper.then = async (onFulfilled, onRejected) => {
+      return Promise.resolve(task).then(() => disposeAsync).then(onFulfilled, onRejected);
+    };
+    disposables.push(this._disposables.push(wrapper));
+    return wrapper;
+  }
+  getEffects() {
+    return [...this._disposables].map((dispose) => dispose[symbols.effect]).filter(Boolean);
+  }
+  _getState() {
+    if (this.uid === null) return 4 /* DISPOSED */;
+    if (this._error) return 3 /* FAILED */;
+    if (this._runner.epoch !== INACTIVE) return 2 /* ACTIVE */;
+    return 0 /* PENDING */;
+  }
+  _updateState(callback) {
+    const oldState = this.state;
+    this.state = callback?.() ?? this._getState();
+    if (oldState === this.state) return;
+    this.context.emit(this, "internal/status", oldState);
+    if (oldState !== 2 /* ACTIVE */ && this.state !== 2 /* ACTIVE */) return;
+    for (const key of Reflect.ownKeys(this.ctx.reflect.store)) {
+      const impl = this.ctx.reflect.store[key];
+      if (!impl) continue;
+      if (impl.fiber !== this) continue;
+      this.ctx.reflect.notify([impl.name]);
+    }
+  }
+  _checkImpl(name2) {
+    const impl = this.ctx.reflect._getImpl(name2, true);
+    if (!impl) return delete this._store[name2];
+    try {
+      if (impl.check && !impl.check.call(getTraceable(this.ctx, impl.value))) {
+        return delete this._store[name2];
+      }
+    } catch (error) {
+      impl.fiber.ctx.logger.error(error);
+      return delete this._store[name2];
+    }
+    this._store[name2] = impl;
+  }
+  _refresh() {
+    let epoch = "";
+    for (const name2 of Object.keys(this.inject)) {
+      const impl = this._store[name2];
+      if (!impl) {
+        epoch = INACTIVE;
+        break;
+      }
+      epoch += ":" + impl.fiber.uid;
+    }
+    this._setEpoch(epoch);
+  }
+  _setEpoch(epoch) {
+    const oldEpoch = this._runner.epoch;
+    if (epoch === oldEpoch) return;
+    this._runner.epoch = epoch;
+    if (this.inertia) return;
+    this._updateState(() => {
+      if (epoch !== INACTIVE && oldEpoch === INACTIVE) {
+        this.inertia = this._reload();
+        return 1 /* LOADING */;
+      } else {
+        this.inertia = this._unload();
+        return 5 /* UNLOADING */;
+      }
+    });
+  }
+  async _reload() {
+    this.store = { ...this._store };
+    const oldEpoch = this._runner.epoch;
+    try {
+      await Promise.resolve();
+      await this._execute(this._runner);
+    } catch (reason) {
+      this.ctx.logger.error(reason);
+      this._error = reason;
+      this._runner.epoch = INACTIVE;
+    }
+    this._updateState(() => {
+      if (this._runner.epoch === oldEpoch) {
+        this.inertia = void 0;
+      } else {
+        this.inertia = this._unload();
+        return 5 /* UNLOADING */;
+      }
+    });
+  }
+  async _unload() {
+    await Promise.all(this._disposables.clear().map(async (dispose) => {
+      try {
+        await composeError(async (info) => {
+          await Promise.resolve();
+          info.error = new Error();
+          await dispose();
+        }, this._runner.getOuterStack);
+      } catch (reason) {
+        this.ctx.logger.error(reason);
+      }
+    }));
+    this.store = void 0;
+    this._updateState(() => {
+      if (this._runner.epoch === INACTIVE) {
+        this.inertia = void 0;
+      } else {
+        this.inertia = this._reload();
+        return 1 /* LOADING */;
+      }
+    });
+  }
+  async await() {
+    while (this.inertia || this._restarting) {
+      await Promise.all([this.inertia, this._restarting].filter((task) => !!task));
+    }
+    if (this._error) throw this._error;
+    return this;
+  }
+  async restart() {
+    const fiber = this.ctx.fiber;
+    fiber.assertActive();
+    if (fiber._restarting) return fiber._restarting.then(() => void 0);
+    let resolve2;
+    const restarting = new Promise((resolvePromise) => {
+      resolve2 = resolvePromise;
+    });
+    fiber._restarting = restarting;
+    try {
+      await this._runRestart(fiber);
+    } finally {
+      fiber._restarting = void 0;
+      resolve2();
+    }
+  }
+  async _runRestart(fiber) {
+    if (fiber.inertia) {
+      fiber._setEpoch(INACTIVE);
+      while (fiber.inertia) await fiber.inertia;
+    }
+    fiber._setEpoch(INACTIVE);
+    fiber._refresh();
+    while (fiber.inertia) await fiber.inertia;
+  }
+  update(config, noSave = false) {
+    const fiber = this.ctx.fiber;
+    fiber.assertActive();
+    config = resolveConfig(fiber.runtime, config);
+    fiber.context.waterfall(fiber.context, "internal/update", config, noSave, () => {
+      fiber.config = config;
+      fiber._error = void 0;
+      return fiber.restart();
+    });
+  }
+};
+
+// packages/core/src/logger.ts
+var Logger = class {
+  constructor(options, service) {
+    this.service = service;
+    this.name = options.name;
+    this.level = options.level;
+    this.error = this._method("error");
+    this.info = this._method("info");
+    this.warn = this._method("warn");
+    this.debug = this._method("debug");
+  }
+  service;
+  name;
+  level;
+  error;
+  info;
+  warn;
+  debug;
+  _method(type) {
+    return (...args) => this.service._log({ name: this.name, type, args });
+  }
+};
+var LoggerService = class {
+  buffer = [];
+  ctx;
+  _snMessage = 0;
+  _snExporter = 0;
+  exporters = /* @__PURE__ */ new Map();
+  constructor(ctx) {
+    const tracker = {
+      property: "ctx",
+      noShadow: true
+    };
+    const self = createCallable("logger", joinPrototype(Object.getPrototypeOf(this), Function.prototype), tracker);
+    Object.assign(self, this);
+    self.ctx = ctx;
+    Object.defineProperty(self, symbols.tracker, { value: tracker });
+    self.exporter({
+      export: (message) => {
+        self.buffer.push(message);
+      }
+    });
+    ctx.reflect.provide("logger", self);
+    return self;
+  }
+  exporter(exporter) {
+    return this.ctx.fiber.effect(() => {
+      const id = ++this._snExporter;
+      this.exporters.set(id, exporter);
+      return () => this.exporters.delete(id);
+    }, "ctx.logger.exporter()");
+  }
+  [symbols.invoke](name2) {
+    const caller = this[symbols.caller];
+    const fiber = (caller ?? this.ctx).fiber;
+    return new Logger({
+      name: name2 ?? fiber.name
+    }, this);
+  }
+  _log(message) {
+    const sn = ++this._snMessage;
+    const ts = Date.now();
+    for (const exporter of this.exporters.values()) {
+      if (exporter.level != null && exporter.level < 0) continue;
+      exporter.export({ sn, ts, ...message });
+    }
+  }
+  error(...args) {
+    return this().error(...args);
+  }
+  info(...args) {
+    return this().info(...args);
+  }
+  warn(...args) {
+    return this().warn(...args);
+  }
+  debug(...args) {
+    return this().debug(...args);
+  }
+};
+
+// packages/core/src/reflect.ts
+function enhanceError(error) {
+  const lines = error.stack.split("\n");
+  lines.splice(0, 2, `Error: ${error.message}`);
+  error.stack = lines.join("\n");
+  return error;
+}
+var RESERVED_WORDS = ["prototype", "then"];
+function isSpecialProperty(prop) {
+  return typeof prop === "symbol" || RESERVED_WORDS.includes(prop) || parseInt(prop).toString() === prop || prop.startsWith("_");
+}
+var ReflectService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    Object.defineProperty(this, symbols.tracker, {
+      value: { property: "ctx", noShadow: true }
+    });
+    this.mixin("reflect", ["get", "set", "provide", "accessor", "mixin"]);
+    this.mixin("fiber", ["runtime", "effect"]);
+    this.mixin("registry", ["inject", "plugin"]);
+    this.mixin("events", [
+      "on",
+      "once",
+      "parallel",
+      "emit",
+      "serial",
+      "bail",
+      "waterfall",
+      "waterfallAsync"
+    ]);
+  }
+  ctx;
+  static handler = {
+    get: (target, prop, ctx) => {
+      if (isSpecialProperty(prop)) {
+        return Reflect.get(target, prop, ctx);
+      }
+      if (Reflect.has(target, prop)) {
+        return getTraceable(ctx, Reflect.get(target, prop, ctx));
+      }
+      const error = new Error(`cannot get property "${String(prop)}" without inject`);
+      try {
+        const def = target.reflect.props[prop];
+        if (def?.type === "accessor") {
+          return def.get.call(ctx, ctx[symbols.receiver], error);
+        }
+        if (!ctx.fiber.runtime) return ctx.reflect.get(prop, false);
+        return ctx.events.waterfall(ctx, "internal/get", prop, error, () => {
+          const key = target[symbols.isolate][prop];
+          let fiber = (ctx[symbols.shadow] ?? ctx).fiber;
+          while (true) {
+            const impl = fiber.store?.[prop];
+            if (impl) return getTraceable(ctx, impl.value);
+            if (prop in fiber.inject) {
+              error.message = `cannot get required service "${String(prop)}" in inactive context`;
+              throw error;
+            }
+            if (!fiber.runtime) throw error;
+            if (fiber.parent[symbols.isolate][prop] !== key) throw error;
+            fiber = fiber.parent.fiber;
+          }
+        });
+      } catch (e) {
+        throw e === error ? enhanceError(e) : e;
+      }
+    },
+    set: (target, prop, value, ctx) => {
+      if (isSpecialProperty(prop)) {
+        return Reflect.set(target, prop, value, ctx);
+      }
+      const error = new Error(`cannot set property "${String(prop)}" without provide`);
+      const def = target.reflect.props[prop];
+      try {
+        if (def?.type === "accessor") {
+          if (!def.set) return false;
+          return def.set.call(ctx, value, ctx[symbols.receiver], error);
+        }
+        if (!def && !ctx.fiber.runtime) {
+          return Reflect.set(target, prop, value, ctx);
+        }
+        return ctx.events.waterfall(ctx, "internal/set", prop, value, error, () => {
+          if (!def) throw error;
+          return ctx.reflect.set(prop, value);
+        });
+      } catch (e) {
+        throw e === error ? enhanceError(e) : e;
+      }
+    },
+    has: (target, prop) => {
+      if (isSpecialProperty(prop)) {
+        return Reflect.has(target, prop);
+      }
+      if (Reflect.has(target, prop)) return true;
+      return !!target.reflect.props[prop];
+    }
+  };
+  store = /* @__PURE__ */ Object.create(null);
+  props = /* @__PURE__ */ Object.create(null);
+  get(name2, strict = true) {
+    return getTraceable(this.ctx, this._getImpl(name2, strict)?.value);
+  }
+  _getImpl(name2, strict = true) {
+    const key = this.ctx[symbols.isolate][name2];
+    const impl = key && this.store[key];
+    if (!impl) return;
+    if (strict && impl.fiber.state !== 2 /* ACTIVE */) return;
+    return impl;
+  }
+  set(name2, value) {
+    const key = this.ctx[symbols.isolate][name2];
+    const impl = key && this.store[key];
+    if (!impl) {
+      throw new Error(`cannot set property "${name2}" without provide`);
+    }
+    if (impl.fiber !== this.ctx.fiber) {
+      throw new Error(`cannot set property "${name2}" in multiple fibers`);
+    }
+    impl.value = value;
+    return true;
+  }
+  provide(name2, value, check) {
+    return this.ctx.fiber.effect(() => {
+      if (!this.props[name2]) {
+        this.props[name2] = { type: "service" };
+      } else if (this.props[name2].type !== "service") {
+        throw new Error(`property "${name2}" is already declared as ${this.props[name2].type}`);
+      }
+      this.props[name2] = { type: "service" };
+      this.ctx.root[symbols.isolate][name2] ??= Symbol(name2);
+      const key = this.ctx[symbols.isolate][name2];
+      const impl = {
+        name: name2,
+        value,
+        fiber: this.ctx.fiber,
+        ...check ? { check } : {}
+      };
+      if (key && this.store[key]) {
+        throw new Error(`service "${name2}" has been registered at <${this.store[key].fiber.name}>`);
+      }
+      this.store[key] = impl;
+      this.ctx.fiber.store[name2] = impl;
+      if (this.ctx.fiber.state === 2 /* ACTIVE */) {
+        this.notify([name2]);
+      }
+      return async () => {
+        delete this.store[key];
+        const fibers = this.notify([name2]);
+        await Promise.allSettled(fibers.map((fiber) => fiber.await()));
+        delete this.ctx.fiber.store[name2];
+      };
+    }, `ctx.provide(${JSON.stringify(name2)})`);
+  }
+  notify(names, filter = (ctx, name2) => ctx[symbols.isolate][name2] === this.ctx[symbols.isolate][name2]) {
+    const fibers = [];
+    for (const runtime of this.ctx.registry.values()) {
+      for (const fiber of runtime.fibers) {
+        let hasUpdate = false;
+        for (const name2 of names) {
+          if (!(name2 in fiber.inject)) continue;
+          if (!filter(fiber.ctx, name2)) continue;
+          hasUpdate = true;
+          fiber._checkImpl(name2);
+        }
+        if (!hasUpdate) continue;
+        fiber._refresh();
+        fibers.push(fiber);
+      }
+    }
+    for (const name2 of names) {
+      const self = Object.create(this.ctx);
+      self[symbols.filter] = (target) => filter(target, name2);
+      this.ctx.events.emit(self, "internal/service", name2, this._getImpl(name2, false)?.value);
+    }
+    return fibers;
+  }
+  accessor(name2, options) {
+    return this.ctx.fiber.effect(() => {
+      if (name2 in this.props) {
+        throw new Error(`property "${name2}" is already declared as ${this.props[name2].type}`);
+      }
+      this.props[name2] = { type: "accessor", ...options };
+      return () => delete this.props[name2];
+    }, `ctx.accessor(${JSON.stringify(name2)})`);
+  }
+  mixin(source, mixins) {
+    return this.ctx.fiber.effect(() => {
+      const entries = Array.isArray(mixins) ? mixins.map((key) => [key, key]) : Object.entries(mixins);
+      const getTarget = (target) => target[source];
+      return entries.map(([key, value]) => {
+        return this.accessor(value, {
+          get(receiver) {
+            const service = getTarget(this);
+            if (service == null) return service;
+            const mixin = receiver ? withProps(receiver, service) : service;
+            const result = Reflect.get(service, key, mixin);
+            if (typeof result !== "function") return result;
+            return result.bind(mixin ?? service);
+          },
+          set(value2, receiver) {
+            const service = getTarget(this);
+            const mixin = receiver ? withProps(receiver, service) : service;
+            return Reflect.set(service, key, value2, mixin);
+          }
+        });
+      });
+    }, `ctx.mixin(${JSON.stringify(source)})`);
+  }
+  trace(value) {
+    return getTraceable(this.ctx, value);
+  }
+  bind(callback) {
+    return new Proxy(callback, {
+      apply: (target, thisArg, args) => {
+        return Reflect.apply(target, this.trace(thisArg), args.map((arg) => this.trace(arg)));
+      },
+      construct: (target, args, newTarget) => {
+        return Reflect.construct(target, args.map((arg) => this.trace(arg)), newTarget);
+      }
+    });
+  }
+};
+
+// packages/core/src/registry.ts
+function isApplicable(object) {
+  return object && typeof object === "object" && typeof object.apply === "function";
+}
+function resolveInject(inject, result = /* @__PURE__ */ Object.create(null)) {
+  if (!inject) return result;
+  if (Array.isArray(inject)) {
+    for (const name2 of inject) {
+      result[name2] = null;
+    }
+  } else if (Reflect.has(inject, symbols.checkProto)) {
+    Object.assign(result, resolveInject(Object.getPrototypeOf(inject)));
+    for (const name2 of Object.keys(inject)) {
+      result[name2] = inject[name2] ?? null;
+    }
+  } else {
+    for (const name2 of Object.keys(inject)) {
+      result[name2] = inject[name2] ?? null;
+    }
+  }
+  return result;
+}
+var RegistryService = class {
+  constructor(ctx) {
+    this.ctx = ctx;
+    Object.defineProperty(this, symbols.tracker, {
+      value: { property: "ctx", noShadow: true }
+    });
+  }
+  ctx;
+  _counter = 0;
+  _internal = /* @__PURE__ */ new Map();
+  get counter() {
+    return ++this._counter;
+  }
+  get size() {
+    return this._internal.size;
+  }
+  resolve(plugin) {
+    try {
+      if (typeof plugin === "function") return plugin;
+      if (isApplicable(plugin)) return plugin.apply;
+    } catch {
+    }
+  }
+  get(plugin) {
+    const key = this.resolve(plugin);
+    return key && this._internal.get(key);
+  }
+  has(plugin) {
+    const key = this.resolve(plugin);
+    return !!key && this._internal.has(key);
+  }
+  delete(plugin) {
+    const key = this.resolve(plugin);
+    const runtime = key && this._internal.get(key);
+    if (!runtime) return;
+    this._internal.delete(key);
+    for (const fiber of [...runtime.fibers]) {
+      fiber.dispose();
+    }
+    return runtime;
+  }
+  keys() {
+    return this._internal.keys();
+  }
+  values() {
+    return this._internal.values();
+  }
+  entries() {
+    return this._internal.entries();
+  }
+  forEach(callback) {
+    return this._internal.forEach(callback);
+  }
+  inject(inject, callback) {
+    const name2 = callback.name || void 0;
+    return this.plugin(Object.assign(
+      { inject, apply: callback },
+      name2 ? { name: name2 } : {}
+    ));
+  }
+  plugin(plugin, config, getOuterStack = buildOuterStack()) {
+    const callback = this.resolve(plugin);
+    if (!callback) throw new Error('invalid plugin, expect function or object with an "apply" method, received ' + typeof plugin);
+    this.ctx.fiber.assertActive();
+    let runtime = this._internal.get(callback);
+    if (!runtime) {
+      let name2 = plugin.name;
+      if (name2 === "apply") name2 = void 0;
+      runtime = {
+        callback,
+        fibers: new DisposableList(),
+        ...name2 ? { name: name2 } : {},
+        ...plugin.Config ? { Config: plugin.Config } : {}
+      };
+      this._internal.set(callback, runtime);
+    }
+    const fiber = new Fiber(this.ctx, config, resolveInject(plugin.inject), runtime, getOuterStack);
+    const wrapped = Object.create(fiber);
+    wrapped.then = (onFulfilled, onRejected) => {
+      return fiber.await().then(onFulfilled, onRejected);
+    };
+    return wrapped;
+  }
+};
+
+// packages/core/src/context.ts
+var Context = class _Context {
+  static effect = symbols.effect;
+  static filter = symbols.filter;
+  static isolate = symbols.isolate;
+  static intercept = symbols.intercept;
+  static marker = /* @__PURE__ */ Symbol.for("tnega.is");
+  static is(value) {
+    return !!value?.[_Context.marker];
+  }
+  static {
+    _Context.prototype[_Context.marker] = true;
+  }
+  constructor() {
+    this[symbols.isolate] = /* @__PURE__ */ Object.create(null);
+    this[symbols.intercept] = /* @__PURE__ */ Object.create(null);
+    const self = new Proxy(this, ReflectService.handler);
+    this.root = self;
+    this.baseUrl = void 0;
+    this.fiber = new Fiber(self, {}, /* @__PURE__ */ Object.create(null), null, () => []);
+    this.reflect = new ReflectService(self);
+    this.registry = new RegistryService(self);
+    this.events = new EventsService(self);
+    this.logger = new LoggerService(self);
+    this.fiber._disposables.clear();
+    return self;
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return `Context <${this.fiber.name}>`;
+  }
+  extend(meta = {}) {
+    const shadow = Reflect.getOwnPropertyDescriptor(this, symbols.shadow)?.value;
+    const self = Object.create(getTraceable(this, this));
+    for (const prop of Reflect.ownKeys(meta)) {
+      Object.defineProperty(self, prop, Reflect.getOwnPropertyDescriptor(meta, prop));
+    }
+    if (!shadow) return self;
+    return Object.assign(Object.create(self), { [symbols.shadow]: shadow });
+  }
+  isolate(name2, label) {
+    const shadow = Object.create(this[symbols.isolate]);
+    shadow[name2] = label ?? Symbol(name2);
+    return this.extend({ [symbols.isolate]: shadow });
+  }
+  intercept(name2, config) {
+    const intercept = Object.create(this[symbols.intercept]);
+    intercept[name2] = config;
+    return this.extend({ [symbols.intercept]: intercept });
+  }
+};
+
+// packages/core/src/service.ts
+var Service = class _Service {
+  constructor(ctx, name2) {
+    this.ctx = ctx;
+    name2 ??= this.constructor.provide;
+    const tracker = {
+      associate: name2,
+      property: "ctx"
+    };
+    const self = this[symbols.invoke] ? createCallable(name2, joinPrototype(Object.getPrototypeOf(this), Function.prototype), tracker) : this;
+    self.ctx = ctx;
+    self.name = name2;
+    Object.defineProperty(self, symbols.tracker, { value: tracker });
+    self.ctx.reflect.provide(name2, self, this[symbols.check]);
+    return self;
+  }
+  ctx;
+  static init = symbols.init;
+  static check = symbols.check;
+  static config = symbols.config;
+  static invoke = symbols.invoke;
+  static extend = symbols.extend;
+  static tracker = symbols.tracker;
+  static resolveConfig = symbols.resolveConfig;
+  name;
+  [symbols.filter](ctx) {
+    return ctx[symbols.isolate][this.name] === this.ctx[symbols.isolate][this.name];
+  }
+  [symbols.extend](props) {
+    let self;
+    if (this[_Service.invoke]) {
+      self = createCallable(this.name, this, this[symbols.tracker]);
+    } else {
+      self = Object.create(this);
+    }
+    return Object.assign(self, props);
+  }
+  [symbols.resolveConfig](base, head) {
+    let intercept = this.ctx[symbols.intercept];
+    const configs = [];
+    while (this.name in intercept) {
+      if (Object.hasOwn(intercept, this.name)) {
+        configs.unshift(intercept[this.name]);
+      }
+      intercept = Object.getPrototypeOf(intercept);
+    }
+    if (base) configs.unshift(base);
+    if (head) configs.push(head);
+    if (this["Config"]?.merge) {
+      return this["Config"].merge(...configs);
+    } else {
+      return Object.assign({}, ...configs);
+    }
+  }
+  static [Symbol.hasInstance](instance) {
+    if (!instance) return false;
+    let constructor = instance.constructor;
+    while (constructor) {
+      constructor = constructor.prototype?.constructor;
+      if (constructor === this) return true;
+      constructor &&= Object.getPrototypeOf(constructor);
+    }
+    return false;
+  }
+};
+
+// packages/agent/src/inbox-durable.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+function contentOf(input) {
+  return input.text ?? "";
+}
+function payloadOf(input) {
+  return input.content !== void 0 ? input.content : void 0;
+}
+var DurableInbox = class _DurableInbox {
+  constructor(_session) {
+    this._session = _session;
+  }
+  _session;
+  _nextTurn = [];
+  _nextStep = [];
+  _operationTail = Promise.resolve();
+  get size() {
+    return this._nextTurn.length + this._nextStep.length;
+  }
+  async insert(input, target = "next-turn") {
+    return this._run(async () => {
+      const message = {
+        id: randomUUID3(),
+        ...input.text !== void 0 ? { text: input.text } : {},
+        ...input.content !== void 0 ? { content: input.content } : {}
+      };
+      const list = target === "next-step" ? this._nextStep : this._nextTurn;
+      const index = list.length;
+      await this._session.append("agent/inbox/spliced", {
+        target,
+        index,
+        inserted: [{
+          id: message.id,
+          content: contentOf(message),
+          ...payloadOf(message) !== void 0 ? { payload: payloadOf(message) } : {}
+        }]
+      });
+      list.push(message);
+      return message;
+    });
+  }
+  async steer(input) {
+    return this._run(async () => {
+      const message = {
+        id: randomUUID3(),
+        ...input.text !== void 0 ? { text: input.text } : {},
+        ...input.content !== void 0 ? { content: input.content } : {}
+      };
+      await this._session.append("agent/inbox/spliced", {
+        target: "next-step",
+        index: this._nextStep.length,
+        inserted: [{
+          id: message.id,
+          content: contentOf(message),
+          ...payloadOf(message) !== void 0 ? { payload: payloadOf(message) } : {},
+          mode: "steer"
+        }]
+      });
+      this._nextStep.push(message);
+      return message;
+    });
+  }
+  async claim() {
+    return this._run(async () => {
+      const steered = this._nextStep[0];
+      if (steered) {
+        await this._session.append("agent/inbox/spliced", {
+          target: "next-step",
+          index: 0,
+          deleteCount: 1
+        });
+        this._nextStep.shift();
+        return steered;
+      }
+      const next = this._nextTurn[0];
+      if (next) {
+        await this._session.append("agent/inbox/spliced", {
+          target: "next-turn",
+          index: 0,
+          deleteCount: 1
+        });
+        this._nextTurn.shift();
+        return next;
+      }
+      return void 0;
+    });
+  }
+  /**
+   * Claim the complete proposed step batch: every pending next-step input plus
+   * one next-turn message at a turn boundary. Returns an empty array when
+   * nothing is pending.
+   */
+  async claimBatch() {
+    return this._run(async () => {
+      const claimed = [...this._nextStep];
+      const nextTurn = this._nextTurn[0];
+      if (nextTurn) claimed.push(nextTurn);
+      if (!claimed.length) return [];
+      const deleteCounts = { nextStep: this._nextStep.length, nextTurn: nextTurn ? 1 : 0 };
+      await this._session.append("agent/inbox/spliced", { target: "all", deleteCounts });
+      this._nextStep.splice(0, deleteCounts.nextStep);
+      this._nextTurn.splice(0, deleteCounts.nextTurn);
+      return claimed;
+    });
+  }
+  /** Claim every input waiting for the next step, without consuming a turn. */
+  async claimNextStep() {
+    return this._run(async () => {
+      if (!this._nextStep.length) return [];
+      const claimed = [...this._nextStep];
+      await this._session.append("agent/inbox/spliced", {
+        target: "next-step",
+        index: 0,
+        deleteCount: claimed.length
+      });
+      this._nextStep.splice(0, claimed.length);
+      return claimed;
+    });
+  }
+  async clear() {
+    return this._run(async () => {
+      if (!this._nextTurn.length && !this._nextStep.length) return;
+      await this._session.append("agent/inbox/spliced", {
+        target: "all"
+      });
+      this._nextTurn = [];
+      this._nextStep = [];
+    });
+  }
+  /** Insert a message at an explicit target/index boundary. */
+  async insertAt(input, target, index, mode = "followup") {
+    return this._run(async () => {
+      const message = {
+        id: randomUUID3(),
+        ...input.text !== void 0 ? { text: input.text } : {},
+        ...input.content !== void 0 ? { content: input.content } : {}
+      };
+      const list = target === "next-step" ? this._nextStep : this._nextTurn;
+      const safeIndex = Math.max(0, Math.min(index, list.length));
+      await this._session.append("agent/inbox/spliced", {
+        target,
+        index: safeIndex,
+        inserted: [{
+          id: message.id,
+          content: contentOf(message),
+          ...payloadOf(message) !== void 0 ? { payload: payloadOf(message) } : {},
+          mode
+        }]
+      });
+      list.splice(safeIndex, 0, message);
+      return message;
+    });
+  }
+  /**
+   * Replace one pending message by id. The old message is emitted as
+   * discarded and the new one as inserted, matching the DSH inbox contract.
+   */
+  async replace(messageId, input) {
+    return this._run(async () => {
+      const entry = this._find(messageId);
+      if (!entry) return void 0;
+      const replacement = {
+        id: randomUUID3(),
+        ...input.text !== void 0 ? { text: input.text } : {},
+        ...input.content !== void 0 ? { content: input.content } : {}
+      };
+      const target = entry.target;
+      const index = entry.index;
+      await this._session.append("agent/inbox/spliced", {
+        target,
+        index,
+        deleteCount: 1,
+        inserted: [{
+          id: replacement.id,
+          content: contentOf(replacement),
+          ...payloadOf(replacement) !== void 0 ? { payload: payloadOf(replacement) } : {}
+        }]
+      });
+      entry.list.splice(index, 1, replacement);
+      return replacement;
+    });
+  }
+  /** Remove one pending message by id. */
+  async remove(messageId) {
+    return this._run(async () => {
+      const entry = this._find(messageId);
+      if (!entry) return void 0;
+      await this._session.append("agent/inbox/spliced", {
+        target: entry.target,
+        index: entry.index,
+        deleteCount: 1
+      });
+      entry.list.splice(entry.index, 1);
+      return entry.message;
+    });
+  }
+  /** Return the first pending message by id across both queues. */
+  get(messageId) {
+    return this._find(messageId)?.message;
+  }
+  snapshot() {
+    return {
+      nextTurn: [...this._nextTurn],
+      nextStep: [...this._nextStep]
+    };
+  }
+  /** Keep the entire read → append → apply transition ordered, including claims. */
+  _run(operation) {
+    const result = this._operationTail.then(operation);
+    this._operationTail = result.then(() => void 0, () => void 0);
+    return result;
+  }
+  _find(messageId) {
+    for (const target of ["next-step", "next-turn"]) {
+      const list = target === "next-step" ? this._nextStep : this._nextTurn;
+      const index = list.findIndex((message) => message.id === messageId);
+      if (index >= 0) return { list, target, index, message: list[index] };
+    }
+    return void 0;
+  }
+  static async restore(session) {
+    const inbox = new _DurableInbox(session);
+    inbox._applyAll(await session.read());
+    return inbox;
+  }
+  _applyAll(events) {
+    for (const event of events) {
+      if (event.type !== "agent/inbox/spliced") continue;
+      const payload = event.payload;
+      if (payload.target === "all") {
+        this._nextTurn.splice(0, payload.deleteCounts?.nextTurn ?? this._nextTurn.length);
+        this._nextStep.splice(0, payload.deleteCounts?.nextStep ?? this._nextStep.length);
+        continue;
+      }
+      const list = payload.target === "next-step" ? this._nextStep : this._nextTurn;
+      const count = payload.deleteCount ?? 0;
+      if (count === Number.POSITIVE_INFINITY) {
+        list.length = 0;
+      } else if (count > 0 && payload.index === 0) {
+        list.splice(0, Math.min(count, list.length));
+      } else if (count > 0 && payload.index !== void 0) {
+        list.splice(payload.index, Math.min(count, list.length - payload.index));
+      }
+      let insertedOffset = 0;
+      for (const item of payload.inserted ?? []) {
+        const message = {
+          id: item.id,
+          ...item.content !== void 0 ? { text: item.content } : {},
+          ...item.payload !== void 0 ? { content: item.payload } : {}
+        };
+        if (item.mode === "steer") {
+          list.unshift(message);
+        } else {
+          const at = payload.index === void 0 ? list.length : Math.min(list.length, payload.index + insertedOffset);
+          list.splice(at, 0, message);
+          insertedOffset += 1;
+        }
+      }
+    }
+  }
+};
+
+// packages/agent/src/live.ts
+function createAgentRuntimeContext(agentCtx) {
+  const runtimeCtx = agentCtx.extend();
+  Object.defineProperty(runtimeCtx, Context.filter, {
+    value: (target) => {
+      const targetScope = target[symbols.isolate].agentScope;
+      let ancestor = agentCtx;
+      while (true) {
+        if (targetScope === ancestor[symbols.isolate].agentScope) return true;
+        if (ancestor.fiber.parent.fiber === ancestor.fiber) return false;
+        ancestor = ancestor.fiber.parent;
+      }
+    }
+  });
+  const events = agentCtx.events;
+  for (const method of ["emit", "parallel", "serial", "bail", "waterfall", "waterfallAsync"]) {
+    Object.defineProperty(runtimeCtx, method, {
+      value: (...args) => events[method](runtimeCtx, ...args)
+    });
+  }
+  return runtimeCtx;
+}
+var LiveAgentImpl = class {
+  constructor(_ctx, _agentCtx, _service, id, inbox, session, durable, meta, manualStreaming = false, wakeReserved = false) {
+    this._ctx = _ctx;
+    this._agentCtx = _agentCtx;
+    this._service = _service;
+    this.id = id;
+    this.inbox = inbox;
+    this.session = session;
+    this.meta = meta;
+    this._durable = durable;
+    this._manualStreaming = manualStreaming;
+    this._wakeReserved = wakeReserved;
+  }
+  _ctx;
+  _agentCtx;
+  _service;
+  id;
+  inbox;
+  session;
+  meta;
+  _status = "idle";
+  _disposed = false;
+  _controller;
+  _drainPromise;
+  _busy = false;
+  _writeTail = Promise.resolve();
+  _pendingWrite;
+  _sessionStarted = false;
+  _maintenance;
+  _maintenanceBusy = false;
+  _setupDisposers = [];
+  _scopeClosed = false;
+  _durable;
+  _manualStreaming = false;
+  _wakeReserved = false;
+  _loop;
+  get agentType() {
+    return this.meta.agentType;
+  }
+  get mode() {
+    return this.meta.mode;
+  }
+  get owner() {
+    return this.meta.owner;
+  }
+  get parentSessionId() {
+    return this.meta.parentSessionId;
+  }
+  get agentCtx() {
+    return this._agentCtx;
+  }
+  trackSetupDispose(dispose) {
+    if (this._scopeClosed) void dispose();
+    else this._setupDisposers.push(dispose);
+  }
+  get status() {
+    return this._status;
+  }
+  get ctx() {
+    return this._ctx;
+  }
+  followup(input) {
+    return this._send(input, "followup");
+  }
+  setLoop(loop) {
+    this._loop = loop;
+  }
+  async _closeCustomTurn(turn, run) {
+    const events = await this.session.read();
+    if (events.some((event) => event.type === "turn/end" && event.payload.turn === turn)) return;
+    const reason = run.finishReason === "length" ? { kind: "max-tokens" } : run.finishReason === "max_steps" ? { kind: "max-steps" } : run.finishReason === "max_turns" ? { kind: "max-turns" } : run.finishReason === "cancelled" ? { kind: "interrupted" } : run.finishReason === "error" ? { kind: "interrupted" } : { kind: "completed" };
+    await this.session.append("turn/end", {
+      turn,
+      finishReason: run.finishReason,
+      reason,
+      ...run.output ? { output: run.output } : {},
+      ...run.steps.length ? { steps: run.steps.length } : {}
+    });
+  }
+  async _closeFailedCustomTurn(turn, error) {
+    const events = await this.session.read();
+    if (events.some((event) => event.type === "turn/end" && event.payload.turn === turn)) return;
+    const failure = error instanceof Error ? { name: error.name, message: error.message, ...error.stack ? { stack: error.stack } : {} } : { name: "Error", message: String(error) };
+    await this.session.append("turn/end", {
+      turn,
+      finishReason: "error",
+      reason: { kind: "error", error: failure },
+      interrupted: true,
+      error: failure
+    });
+  }
+  /** Replace one pending inbox message by durable message id. */
+  replaceMessage(messageId, input) {
+    return this._mutatePending(async () => {
+      const previous = this._durable.get(messageId);
+      const target = this._findTarget(messageId);
+      if (!previous || !target) return;
+      const replacement = await this._durable.replace(messageId, {
+        text: input.text ?? "",
+        ...input.messages !== void 0 || input.context !== void 0 ? { content: input.messages ?? input.context } : {}
+      });
+      if (!replacement) return;
+      this._ctx.emit("agent/inbox/discarded", {
+        id: this.id,
+        agent: this,
+        message: previous
+      });
+      const event = {
+        id: this.id,
+        agent: this,
+        target,
+        input: replacement,
+        inboxSeq: this._durable.size
+      };
+      this._ctx.emit("agent/inbox/inserted", event);
+    });
+  }
+  /** Remove one pending inbox message by durable message id. */
+  removeMessage(messageId) {
+    return this._mutatePending(async () => {
+      const removed = await this._durable.remove(messageId);
+      if (!removed) return;
+      this._ctx.emit("agent/inbox/discarded", {
+        id: this.id,
+        agent: this,
+        message: removed
+      });
+    });
+  }
+  steer(input) {
+    return this._send(input, "steer");
+  }
+  inject(input) {
+    return this._send(input, "inject");
+  }
+  send(input, options = {}) {
+    return this._send(input, options.mode === "steer" ? "steer" : "followup");
+  }
+  _send(input, target) {
+    const text = input.text ?? "";
+    const content = input.messages ?? input.context;
+    const steeredAfterAbort = target === "steer" && this._controller?.signal.aborted === true;
+    return this._mutatePending(async () => {
+      const message = target === "followup" ? await this._durable.insert({ text, ...content !== void 0 ? { content } : {} }) : target === "steer" ? steeredAfterAbort ? await this._durable.insert({ text, ...content !== void 0 ? { content } : {} }) : await this._durable.steer({ text, ...content !== void 0 ? { content } : {} }) : await this._durable.insert({ text, ...content !== void 0 ? { content } : {} }, "next-step");
+      if (target !== "inject") this._wakeReserved = true;
+      const event = {
+        id: this.id,
+        agent: this,
+        target,
+        input: message,
+        inboxSeq: this._durable.size
+      };
+      this._ctx.emit("agent/inbox/inserted", event);
+    }, target !== "inject");
+  }
+  _mutatePending(task, wakes = false, allowDisposed = false) {
+    if (this._disposed && !allowDisposed) {
+      return Promise.reject(new Error(`agent disposed: ${this.id}`));
+    }
+    const result = this._writeTail.then(task);
+    const recovered = result.catch((error) => {
+      try {
+        this._ctx.emit("agent/error", { id: this.id, error });
+      } catch {
+      }
+    });
+    this._writeTail = recovered;
+    this._pendingWrite = recovered;
+    void result.then(
+      () => {
+        if (this._pendingWrite === recovered) this._pendingWrite = void 0;
+        if (wakes) queueMicrotask(() => this._wake());
+      },
+      () => {
+        if (this._pendingWrite === recovered) this._pendingWrite = void 0;
+      }
+    );
+    return result;
+  }
+  _findTarget(messageId) {
+    const snapshot = this._durable.snapshot();
+    if (snapshot.nextStep.some((message) => message.id === messageId)) return "next-step";
+    if (snapshot.nextTurn.some((message) => message.id === messageId)) return "next-turn";
+    return void 0;
+  }
+  cancel(cause, options = {}) {
+    if (!options.keepInbox) {
+      void this._mutatePending(async () => {
+        const before = this._durable.snapshot();
+        await this._durable.clear();
+        for (const message of [...before.nextStep, ...before.nextTurn]) {
+          this._ctx.emit("agent/inbox/discarded", { id: this.id, message });
+        }
+        this._wakeReserved = false;
+      }, false, true);
+    }
+    this._controller?.abort(cause);
+    this._maintenance?.controller.abort(cause);
+  }
+  async whenIdle() {
+    while (true) {
+      while (this._pendingWrite) await this._pendingWrite;
+      const maintenance = this._maintenance;
+      if (maintenance) {
+        await maintenance.promise.catch(() => void 0);
+        continue;
+      }
+      const drain = this._drainPromise;
+      if (drain) {
+        await drain.catch(() => void 0);
+        continue;
+      }
+      if (!this._hasQueuedWork()) break;
+      await new Promise((resolve2) => setTimeout(resolve2, 0));
+    }
+  }
+  /** Run one non-turn maintenance task from the true idle phase. */
+  runMaintenance(task) {
+    if (this._disposed) throw new Error(`agent disposed: ${this.id}`);
+    if (this._maintenanceBusy || this._drainPromise || this._pendingWrite) {
+      throw new Error("agent is busy; maintenance can only run while idle");
+    }
+    this._maintenanceBusy = true;
+    const controller = new AbortController();
+    const result = Promise.resolve().then(async () => {
+      const value = await task(controller.signal);
+      return value;
+    }).finally(() => {
+      this._maintenanceBusy = false;
+      if (this._maintenance?.controller === controller) {
+        this._maintenance = void 0;
+      }
+      queueMicrotask(() => this._wake());
+    });
+    this._maintenance = { promise: result.then(() => void 0, () => void 0), controller };
+    return result;
+  }
+  async dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this.cancel({ type: "disposed" });
+    await this._writeTail.catch(() => void 0);
+    await this._drainPromise?.catch(() => void 0);
+    if (this._maintenance) this._maintenance.controller.abort({ type: "disposed" });
+    await this._maintenance?.promise.catch(() => void 0);
+    if (!this._scopeClosed) {
+      this._scopeClosed = true;
+      await Promise.all([...this._setupDisposers].reverse().map((dispose) => dispose()));
+    }
+    const writeTail = this._writeTail;
+    if (writeTail !== this._drainPromise && this._pendingWrite) {
+      this._pendingWrite = void 0;
+      await writeTail.catch(() => void 0);
+    }
+    await this.session.close();
+    this._setStatus("idle");
+  }
+  /** Publish the agent lifecycle session-start notification once. */
+  async publishSessionStart(source = "startup") {
+    if (this._sessionStarted) return;
+    this._sessionStarted = true;
+    this._ctx.emit("agent/session-start", {
+      id: this.id,
+      agent: this,
+      source
+    });
+  }
+  /** Current durable turn number for a newly claimed inbox item. */
+  async _nextTurnNumber() {
+    const events = await this.session.read();
+    let max = 0;
+    for (const event of events) {
+      if (event.type === "turn/start") max = Math.max(max, event.payload.turn);
+    }
+    return max + 1;
+  }
+  /** Start draining currently pending durable work without a new input. */
+  wakeNow() {
+    this._wake();
+  }
+  _wake() {
+    if (this._disposed || this._manualStreaming || this._drainPromise || this._busy || this._maintenanceBusy) return;
+    const task = this._drainAll();
+    this._drainPromise = task;
+    void task.then(
+      () => {
+        if (this._drainPromise === task) this._drainPromise = void 0;
+        if (this._hasQueuedWork()) queueMicrotask(() => this._wake());
+      },
+      (error) => {
+        if (this._drainPromise === task) this._drainPromise = void 0;
+        try {
+          this._ctx.emit("agent/error", { id: this.id, agent: this, error });
+        } catch {
+        }
+      }
+    );
+  }
+  async _drainAll() {
+    await this._writeTail.catch(() => void 0);
+    if (this._hasQueuedWork()) {
+      for await (const _ of this._streamTurns()) void _;
+    }
+  }
+  /** Public drain over queued durable work (manual-streaming mode). */
+  async *runTurns(signal) {
+    if (this._manualStreaming) await this._writeTail.catch(() => void 0);
+    if (this._busy || this._disposed) return;
+    yield* this._streamTurns(signal);
+  }
+  async *_streamTurns(signal) {
+    if (this._busy || this._disposed) return;
+    this._busy = true;
+    this._setStatus("running");
+    try {
+      while (!this._disposed) {
+        const snapshot = this._durable.snapshot();
+        if (!snapshot.nextTurn.length && !this._wakeReserved) break;
+        const turn = await this._nextTurnNumber();
+        await this.session.append("turn/start", { turn, reason: "user" });
+        const batch = await this._durable.claimBatch();
+        this._wakeReserved = false;
+        const input = batch.length ? await this._inputForBatch(batch, true) : { text: "" };
+        for (const message of batch) {
+          this._ctx.emit("agent/inbox/claimed", {
+            id: this.id,
+            agent: this,
+            message,
+            input: { text: message.text ?? "" },
+            turn
+          });
+        }
+        const controller = new AbortController();
+        this._controller = controller;
+        const forward = () => controller.abort(signal?.reason);
+        if (signal?.aborted) controller.abort(signal.reason);
+        else signal?.addEventListener("abort", forward, { once: true });
+        try {
+          if (this._manualStreaming) {
+            if (this._loop) {
+              const run = await this._loop(input, { signal: controller.signal, turn });
+              await this._closeCustomTurn(turn, run);
+              yield { type: "run/end", run };
+            } else {
+              yield* this._service.runStream(input, { signal: controller.signal, turn });
+            }
+          } else {
+            if (this._loop) {
+              const run = await this._loop(input, { signal: controller.signal, turn });
+              await this._closeCustomTurn(turn, run);
+            } else await this._service.run(input, { signal: controller.signal, turn });
+          }
+        } catch (error) {
+          if (this._loop) await this._closeFailedCustomTurn(turn, error);
+          if (!controller.signal.aborted) {
+            const step = await this._failedStep();
+            this._ctx.emit("agent/error", {
+              id: this.id,
+              agent: this,
+              error,
+              ...step !== void 0 ? { turn, step } : {}
+            });
+            if (this._manualStreaming) throw error;
+          }
+        } finally {
+          signal?.removeEventListener("abort", forward);
+          if (this._controller === controller) this._controller = void 0;
+        }
+      }
+    } finally {
+      this._busy = false;
+      if (!this._durable.size) this._wakeReserved = false;
+      this._setStatus("idle");
+    }
+  }
+  _hasQueuedWork() {
+    const snapshot = this._durable.snapshot();
+    return snapshot.nextTurn.length > 0 || this._wakeReserved && snapshot.nextStep.length > 0;
+  }
+  async _inputForBatch(batch, includeHistory) {
+    const history = includeHistory ? await this.session.deriveMessages() : [];
+    const messages = batch.flatMap((message) => message.content !== void 0 ? Array.isArray(message.content) ? message.content : [{ role: "user", content: String(message.content ?? "") }] : message.text !== void 0 ? [{ role: "user", content: message.text }] : []);
+    if (history.length || messages.length > 1) return { messages: [...history, ...messages] };
+    return { text: messages[0]?.content ?? "" };
+  }
+  async claimNextStepInputs() {
+    await this._writeTail;
+    const batch = await this._durable.claimNextStep();
+    this._wakeReserved = false;
+    if (batch.length) {
+      const turn = await this._nextTurnNumber() - 1;
+      for (const message of batch) {
+        this._ctx.emit("agent/inbox/claimed", {
+          id: this.id,
+          agent: this,
+          message,
+          input: { text: message.text ?? "" },
+          turn
+        });
+      }
+    }
+    return batch.length ? [await this._inputForBatch(batch, false)] : [];
+  }
+  _setStatus(status) {
+    const previous = this._status;
+    if (previous === status) return;
+    this._status = status;
+    this._ctx.emit("agent/status", { id: this.id, status, previous });
+  }
+  async _failedStep() {
+    const events = await this.session.read();
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      const event = events[index];
+      if (event?.type === "step/end" && (event.payload.finishReason === "error" || event.payload.interrupted === true)) {
+        return event.payload.step;
+      }
+    }
+    return void 0;
+  }
+};
+var AgentRegistry = class {
+  constructor(_ctx) {
+    this._ctx = _ctx;
+  }
+  _ctx;
+  _agents = /* @__PURE__ */ new Map();
+  _owners = /* @__PURE__ */ new Map();
+  _factory;
+  setFactory(factory) {
+    this._factory = factory;
+    return () => {
+      if (this._factory === factory) this._factory = void 0;
+    };
+  }
+  async create(options) {
+    if (!this._factory) throw new Error("no agent factory registered");
+    const id = options.id ?? options.sessionId ?? randomUUID4();
+    if (this._agents.has(id)) throw new Error(`agent already registered: ${id}`);
+    const handle = await this._factory.create({ ...options, id });
+    this._agents.set(id, handle.agent);
+    this._owners.set(id, handle.agent.owner);
+    this._ctx.emit("agent/created", { id, agent: handle.agent });
+    return {
+      agent: handle.agent,
+      dispose: () => this._dispose(id, handle)
+    };
+  }
+  async resume(options) {
+    if (!this._factory) throw new Error("no agent factory registered");
+    if (!options.id && !options.sessionId) {
+      throw new AgentError("agent resume requires a stable session id");
+    }
+    const id = options.id ?? options.sessionId;
+    if (this._agents.has(id)) throw new Error(`agent already registered: ${id}`);
+    const handle = await this._factory.resume({ ...options, id });
+    this._agents.set(id, handle.agent);
+    this._owners.set(id, handle.agent.owner);
+    this._ctx.emit("agent/created", { id, agent: handle.agent });
+    return {
+      agent: handle.agent,
+      dispose: () => this._dispose(id, handle)
+    };
+  }
+  get(id) {
+    return this._agents.get(id);
+  }
+  list() {
+    return [...this._agents.values()];
+  }
+  roots() {
+    return this.list().filter((agent2) => this._owners.get(agent2.id) === void 0);
+  }
+  isOwnedBy(id, owner) {
+    return this._owners.get(id) === owner;
+  }
+  async _dispose(id, handle) {
+    const agent2 = this._agents.get(id);
+    if (!agent2) return;
+    await handle.dispose();
+    this._agents.delete(id);
+    this._owners.delete(id);
+    this._ctx.emit("agent/disposed", { id });
+  }
+};
+async function buildHandle(ctx, options, resume = false) {
+  const fileMeta = await readAgentMeta(options.file);
+  if (resume && !fileMeta) {
+    throw new AgentError(`no agent session meta found for resume: ${options.file}`);
+  }
+  const requestedId = options.id ?? options.sessionId ?? randomUUID4();
+  if (fileMeta?.agentId && fileMeta.agentId !== requestedId) {
+    throw new AgentError(
+      `agent id mismatch: session belongs to ${fileMeta.agentId}, requested ${requestedId}`
+    );
+  }
+  const agentId = fileMeta?.agentId ?? requestedId;
+  if (!agentId) throw new AgentError("agent requires a stable identity");
+  let agentCtx;
+  const agentScope = await ctx.inject([], (scopeCtx) => {
+    agentCtx = scopeCtx.isolate("agentScope").isolate("llm").isolate("tools").isolate("systemPrompt");
+    agentCtx.provide("agentScope", agentCtx);
+  });
+  await agentScope;
+  const runtimeCtx = createAgentRuntimeContext(agentCtx);
+  const log = new SessionLog(options.file, void 0, runtimeCtx);
+  try {
+    await log.init();
+    const fileEvents = await log.read();
+    const durableMeta = readDurableAgentMeta(fileEvents);
+    if (durableMeta) {
+      if (durableMeta.agentId !== agentId) {
+        throw new AgentError(
+          `agent id mismatch: session belongs to ${durableMeta.agentId}, requested ${agentId}`
+        );
+      }
+      if (options.agentType && durableMeta.agentType !== options.agentType) {
+        throw new AgentError(
+          `agent type mismatch: session is ${durableMeta.agentType ?? "untyped"}, requested ${options.agentType}`
+        );
+      }
+      if (options.mode && durableMeta.mode !== options.mode) {
+        throw new AgentError(
+          `agent mode mismatch: session is ${durableMeta.mode ?? "unset"}, requested ${options.mode}`
+        );
+      }
+    }
+    const boundMeta = {
+      ...fileMeta,
+      ...durableMeta ?? {},
+      ...options.title ? { title: options.title } : {},
+      ...options.owner ? { owner: options.owner } : {},
+      ...options.parentSessionId ? { parentSessionId: options.parentSessionId } : {},
+      ...options.forkedAtMessageId ? { forkedAtMessageId: options.forkedAtMessageId } : {},
+      agentId
+    };
+    const resolvedAgentType = options.agentType ?? durableMeta?.agentType;
+    if (resolvedAgentType) boundMeta.agentType = resolvedAgentType;
+    const resolvedMode = options.mode ?? durableMeta?.mode;
+    if (resolvedMode) boundMeta.mode = resolvedMode;
+    if (!durableMeta) {
+      await log.append("meta", {
+        kind: "agent",
+        agentId,
+        ...boundMeta.agentType ? { agentType: boundMeta.agentType } : {},
+        ...boundMeta.mode ? { mode: boundMeta.mode } : {},
+        ...boundMeta.title ? { title: boundMeta.title } : {},
+        ...boundMeta.owner ? { owner: boundMeta.owner } : {},
+        ...boundMeta.parentSessionId ? { parentSessionId: boundMeta.parentSessionId } : {},
+        ...boundMeta.forkedAtMessageId ? { forkedAtMessageId: boundMeta.forkedAtMessageId } : {},
+        ...boundMeta.createdAt !== void 0 ? { createdAt: boundMeta.createdAt } : {}
+      });
+    }
+    const durable = resume ? await DurableInbox.restore(log) : new DurableInbox(log);
+    const restoredWakeReservation = resume && hasRestoredWakeReservation(fileEvents);
+    const injected = new AgentInbox();
+    const inboxView = {
+      get size() {
+        return durable.size;
+      },
+      snapshot: () => durable.snapshot()
+    };
+    let claimNextStep = async () => [];
+    const service = new AgentService(runtimeCtx, {
+      session: log,
+      inbox: injected,
+      ...options.llm ? { llm: options.llm } : {},
+      ...options.maxTurns !== void 0 ? { maxTurns: options.maxTurns } : {},
+      ...options.maxSteps !== void 0 ? { maxSteps: options.maxSteps } : {},
+      ...options.contextBudget ? { contextBudget: options.contextBudget } : {},
+      ...options.hooks ? { hooks: options.hooks } : {},
+      claimNextStep: () => claimNextStep()
+    });
+    if (options.system) injected.inject("agentSystem", options.system);
+    const agent2 = new LiveAgentImpl(
+      runtimeCtx,
+      agentCtx,
+      service,
+      agentId,
+      inboxView,
+      log,
+      durable,
+      boundMeta,
+      options.manualStreaming === true,
+      restoredWakeReservation
+    );
+    claimNextStep = () => agent2.claimNextStepInputs();
+    agent2.trackSetupDispose(() => agentScope.dispose());
+    let setupResult;
+    try {
+      setupResult = await options.setup?.(agentCtx);
+      for (const name2 of ["llm", "systemPrompt"]) {
+        if (agentCtx.reflect.get(name2, false) !== void 0) continue;
+        const inherited = ctx.reflect.get(name2, false);
+        if (inherited !== void 0) agentCtx.provide(name2, inherited);
+      }
+      const loop = agentCtx.reflect.get("agentLoop", false);
+      agent2.setLoop(loop);
+      setupResult?.commit();
+    } catch (error) {
+      await agent2.dispose().catch(() => void 0);
+      await log.close().catch(() => void 0);
+      throw error;
+    }
+    await agent2.publishSessionStart(resume ? "resume" : "startup");
+    for (const input of options.initial ?? []) {
+      if (!resume) await durable.insert({ text: input.text ?? "" });
+    }
+    if (resume && (durable.snapshot().nextTurn.length || restoredWakeReservation) && options.manualStreaming !== true) {
+      setTimeout(() => agent2.wakeNow(), 0);
+    }
+    return { agent: agent2, dispose: () => agent2.dispose() };
+  } catch (error) {
+    await Promise.resolve().then(() => agentScope.dispose()).catch(() => void 0);
+    throw error;
+  }
+}
+function hasRestoredWakeReservation(events) {
+  const nextTurn = [];
+  const nextStep = [];
+  for (const event of events) {
+    if (event.type !== "agent/inbox/spliced") continue;
+    const payload = event.payload;
+    if (payload.target === "all") {
+      nextTurn.splice(0, payload.deleteCounts?.nextTurn ?? nextTurn.length);
+      nextStep.splice(0, payload.deleteCounts?.nextStep ?? nextStep.length);
+      continue;
+    }
+    const list = payload.target === "next-step" ? nextStep : nextTurn;
+    const count = payload.deleteCount ?? 0;
+    if (count === Number.POSITIVE_INFINITY) {
+      list.length = 0;
+    } else if (count > 0 && payload.index !== void 0) {
+      list.splice(payload.index, count);
+    }
+    let insertedOffset = 0;
+    for (const inserted of payload.inserted ?? []) {
+      const entry = { wakes: payload.target === "next-step" && inserted.mode === "steer" };
+      if (inserted.mode === "steer") {
+        list.unshift(entry);
+      } else {
+        const index = payload.index === void 0 ? list.length : Math.min(list.length, payload.index + insertedOffset);
+        list.splice(index, 0, entry);
+        insertedOffset += 1;
+      }
+    }
+  }
+  return nextStep.some((entry) => entry.wakes);
+}
+async function readAgentMeta(file) {
+  const lines = await import("node:fs/promises").then((fs) => fs.readFile(file, "utf8")).catch((error) => {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  });
+  if (lines === void 0) return void 0;
+  for (const line of lines.split("\n")) {
+    if (!line.trim()) continue;
+    let record;
+    try {
+      const parsed = JSON.parse(line);
+      record = parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      continue;
+    }
+    if (record.type !== "meta") continue;
+    const payload = record.payload;
+    if (!payload || payload.kind !== "agent") continue;
+    return {
+      ...typeof payload.agentId === "string" ? { agentId: payload.agentId } : {},
+      ...typeof payload.createdAt === "number" ? { createdAt: payload.createdAt } : {}
+    };
+  }
+  return void 0;
+}
+function readDurableAgentMeta(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (event?.type !== "meta") continue;
+    const payload = event.payload;
+    if (payload.kind !== "agent") continue;
+    const meta = {
+      agentId: typeof payload.agentId === "string" ? payload.agentId : ""
+    };
+    if (payload.agentType === "general" || payload.agentType === "coding") {
+      meta.agentType = payload.agentType;
+    }
+    if (payload.mode === "auto" || payload.mode === "plan" || payload.mode === "execute") {
+      meta.mode = payload.mode;
+    }
+    if (typeof payload.title === "string") meta.title = payload.title;
+    if (typeof payload.owner === "string") meta.owner = payload.owner;
+    if (typeof payload.parentSessionId === "string") {
+      meta.parentSessionId = payload.parentSessionId;
+    }
+    if (typeof payload.forkedAtMessageId === "string") {
+      meta.forkedAtMessageId = payload.forkedAtMessageId;
+    }
+    if (typeof payload.createdAt === "number") meta.createdAt = payload.createdAt;
+    return meta;
+  }
+  return void 0;
+}
+var agents = {
+  name: "agents",
+  inject: ["tools"],
+  apply: (ctx) => {
+    const registry = new AgentRegistry(ctx);
+    ctx.provide("agents", registry);
+    registry.setFactory({
+      create: (options) => buildHandle(ctx, options),
+      resume: (options) => buildHandle(ctx, options, true)
+    });
+    return () => {
+      for (const agent2 of registry.list()) {
+        void agent2.dispose();
+      }
+    };
+  }
+};
+
+// packages/agent/src/prompt.ts
+var SystemPromptService = class {
+  _sections = /* @__PURE__ */ new Map();
+  _toolProviders = [];
+  _variables = /* @__PURE__ */ new Map();
+  _contexts = [];
+  _ctx;
+  constructor(ctx) {
+    this._ctx = ctx;
+  }
+  registerSection(section) {
+    const name2 = section.name.trim();
+    if (!name2) throw new TypeError("prompt section requires a non-empty name");
+    if (this._sections.has(name2)) {
+      throw new Error(`prompt section already registered: ${name2}`);
+    }
+    this._sections.set(name2, { ...section, name: name2 });
+    this._emitChange();
+    return () => {
+      this._sections.delete(name2);
+      this._emitChange();
+    };
+  }
+  sections() {
+    return [...this._sections.values()].sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
+  }
+  registerTools(provider) {
+    if (typeof provider !== "function") throw new TypeError("tool provider must be a function");
+    this._toolProviders.push(provider);
+    this._emitChange();
+    return () => {
+      const index = this._toolProviders.indexOf(provider);
+      if (index >= 0) this._toolProviders.splice(index, 1);
+      this._emitChange();
+    };
+  }
+  async toolSchemas(options = {}) {
+    const seen = /* @__PURE__ */ new Set();
+    const tools = [];
+    for (const provider of this._toolProviders) {
+      for (const schema of await provider(options)) {
+        if (!seen.has(schema.name)) {
+          seen.add(schema.name);
+          tools.push(schema);
+        }
+      }
+    }
+    return tools;
+  }
+  registerVariable(name2, provider) {
+    const key = name2.trim();
+    if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(key)) {
+      throw new TypeError(`invalid prompt variable name: ${name2}`);
+    }
+    if (typeof provider !== "function") throw new TypeError("variable provider must be a function");
+    if (this._variables.has(key)) throw new Error(`prompt variable already registered: ${key}`);
+    this._variables.set(key, provider);
+    this._emitChange();
+    return () => {
+      this._variables.delete(key);
+      this._emitChange();
+    };
+  }
+  registerContext(context) {
+    const name2 = context.name.trim();
+    if (!name2) throw new TypeError("prompt context requires a non-empty name");
+    if (this._contexts.some((entry) => entry.name === name2)) {
+      throw new Error(`prompt context already registered: ${name2}`);
+    }
+    this._contexts.push({ ...context, name: name2 });
+    this._emitChange();
+    return () => {
+      this._contexts = this._contexts.filter((entry) => entry.name !== name2);
+      this._emitChange();
+    };
+  }
+  async assemble(options = {}, ctx) {
+    const activeCtx = ctx ?? this._ctx;
+    const sections = this.sections();
+    const variables = await this._resolveVariables(options);
+    const renderedSections = sections.map((section) => ({
+      ...section,
+      content: renderTemplate(section.content, variables)
+    }));
+    const dynamicContexts = await this._resolveContexts(options);
+    const contextText = dynamicContexts.map((context) => renderTemplate(context.content, variables)).filter(Boolean);
+    const base = {
+      sections: renderedSections,
+      text: [
+        ...renderedSections.map((section) => section.content).filter(Boolean),
+        ...contextText
+      ].join("\n\n"),
+      ...Object.keys(variables).length ? { variables } : {},
+      ...Object.keys(options).length ? { context: options } : {}
+    };
+    const tools = await this.toolSchemas(options);
+    if (tools.length) base.tools = tools;
+    if (!activeCtx) return base;
+    const resolved = await activeCtx.waterfallAsync(
+      "system-prompt/assemble",
+      base,
+      async (assembly) => assembly
+    );
+    return resolved ?? base;
+  }
+  async _resolveVariables(options) {
+    const result = {};
+    for (const [name2, provider] of this._variables) {
+      const value = await provider(options);
+      if (value !== void 0) result[name2] = value;
+    }
+    return result;
+  }
+  async _resolveContexts(options) {
+    const contexts = this._contexts.slice().sort((left, right) => (left.order ?? 0) - (right.order ?? 0));
+    const result = [];
+    for (const context of contexts) {
+      const value = await context.content(options);
+      if (value) result.push({ name: context.name, content: value });
+    }
+    return result;
+  }
+  _emitChange() {
+    this._ctx?.emit("system-prompt/change");
+  }
+};
+function renderTemplate(text, variables) {
+  return text.replace(/\$\{([a-zA-Z][a-zA-Z0-9_]*)\}/g, (match, name2) => {
+    return variables[name2] ?? match;
+  });
+}
+var systemPrompt = {
+  name: "system-prompt",
+  apply: (ctx) => {
+    const service = new SystemPromptService(ctx);
+    ctx.provide("systemPrompt", service);
+    return () => {
+    };
+  }
+};
+
+// packages/agent/src/llm-service.ts
+var LlmService = class {
+  _adapters = /* @__PURE__ */ new Map();
+  _current;
+  _defaultName;
+  register(name2, adapter) {
+    const key = name2.trim();
+    if (!key) throw new TypeError("llm provider requires a non-empty name");
+    if (this._adapters.has(key)) throw new Error(`llm provider already registered: ${key}`);
+    this._adapters.set(key, adapter);
+    if (!this._current) {
+      this._current = adapter;
+      this._defaultName = key;
+    }
+    return () => {
+      this._adapters.delete(key);
+      if (this._defaultName === key) {
+        this._defaultName = void 0;
+        this._current = this._adapters.values().next().value;
+      }
+    };
+  }
+  setCurrent(name2) {
+    const adapter = this._adapters.get(name2.trim());
+    if (!adapter) throw new Error(`llm provider not found: ${name2}`);
+    this._current = adapter;
+    this._defaultName = name2.trim();
+    return adapter;
+  }
+  current() {
+    return this._current;
+  }
+  list() {
+    return [...this._adapters.entries()].map(([name2, adapter]) => ({ name: name2, adapter }));
+  }
+  /**
+   * Report provider/model/contextWindow for the current route. The adapter
+   * may be registered with an optional capacity provider by callers that own
+   * the model catalog (for example the CLI runtime).
+   */
+  routeCapacity() {
+    if (!this._current || !this._defaultName) return void 0;
+    const provider = this._defaultName;
+    const model = this._current.model;
+    const contextWindow = this._capacityFor?.(model);
+    const result = { provider, model: model ?? "" };
+    if (contextWindow !== void 0) result.contextWindow = contextWindow;
+    return result;
+  }
+  _capacityFor;
+  /** Install a catalog-backed contextWindow resolver (optional). */
+  setCapacityResolver(resolver) {
+    this._capacityFor = resolver;
+  }
+};
+var llmService = {
+  name: "llm-service",
+  apply: (ctx) => {
+    ctx.provide("llm", new LlmService());
+    return () => {
+    };
+  }
+};
 export {
   AgentError,
   AgentInbox,
+  AgentRegistry,
   AgentService,
+  DurableInbox,
+  LlmService,
+  SystemPromptService,
   agent,
+  agents,
   defineAgent,
-  name
+  llmService,
+  name,
+  systemPrompt
 };
 //# sourceMappingURL=agent.js.map