tnega 0.1.0 → 0.3.0

package/dist/agent.js

@@ -0,0 +1,2907 @@
+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 checkSessionInvariants(events) {
+  return [
+    ...checkBalancedTurns(events),
+    ...checkBalancedSteps(events),
+    ...checkBalancedToolCalls(events),
+    ...checkMonotonicSeq(events)
+  ];
+}
+
+// packages/session/src/index.ts
+var SESSION_FORMAT_VERSION = 7;
+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) {
+    tokens += Math.ceil(message.content.length / 4);
+    for (const call of message.tool_calls ?? []) {
+      const raw = JSON.stringify(call.arguments ?? {}) ?? "";
+      tokens += Math.ceil(raw.length / 4);
+    }
+  }
+  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":
+      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 {
+    tokens,
+    limit,
+    ratio: limit > 0 ? tokens / limit : 0
+  };
+}
+var SessionLog = class {
+  constructor(file, _broadcast) {
+    this.file = file;
+    this._broadcast = _broadcast;
+  }
+  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.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 {
+  name = "AgentError";
+};
+var AgentInbox = class {
+  _queue = [];
+  _steerQueue = [];
+  _injected = /* @__PURE__ */ new Map();
+  get size() {
+    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._steerQueue.shift() ?? this._queue.shift();
+  }
+  peek() {
+    return this._steerQueue[0] ?? this._queue[0];
+  }
+  inject(key, value) {
+    this._injected.set(key, value);
+  }
+  injected() {
+    return new Map(this._injected);
+  }
+};
+function copyMessages(messages) {
+  return messages.map((message) => {
+    const copy = {
+      role: message.role,
+      content: message.content
+    };
+    if (message.name) copy.name = message.name;
+    if (message.tool_call_id) copy.tool_call_id = message.tool_call_id;
+    if (message.toolOk !== void 0) copy.toolOk = message.toolOk;
+    if (message.toolError) copy.toolError = { ...message.toolError };
+    if (message.tool_calls) {
+      copy.tool_calls = message.tool_calls.map((call) => ({
+        id: call.id,
+        name: call.name,
+        arguments: call.arguments
+      }));
+    }
+    return copy;
+  });
+}
+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);
+  } catch {
+    return String(value);
+  }
+}
+function copyCompletion(completion) {
+  const copy = {
+    finishReason: completion.finishReason
+  };
+  if (completion.content !== void 0) copy.content = completion.content;
+  if (completion.toolCalls) {
+    copy.toolCalls = completion.toolCalls.map((call) => ({
+      id: call.id,
+      name: call.name,
+      arguments: call.arguments
+    }));
+  }
+  return copy;
+}
+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 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 AgentService = class {
+  constructor(ctx, config = {}) {
+    this.ctx = ctx;
+    this.config = config;
+    this.inbox = config.inbox ?? new AgentInbox();
+  }
+  ctx;
+  config;
+  inbox;
+  _seriesStarted = false;
+  _persistedRequest = false;
+  /** 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, false));
+  }
+  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) {
+    const claimed = input ?? this.inbox.claim();
+    if (!claimed) throw new AgentError("no agent input available");
+    await this.config.hooks?.beforeRun?.(claimed, options);
+    const session = this._session();
+    const tools = this._tools();
+    const llm = this._llm();
+    if (!llm) throw new AgentError("no LLM adapter available");
+    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 = await this._initialMessages(claimed);
+    const steps = [];
+    let output = "";
+    let finishReason = "stop";
+    this.ctx.emit("agent/turn-start", {
+      input: claimed,
+      messages: copyMessages(messages),
+      injected
+    });
+    const turn = await session.nextTurn();
+    await session.append("turn/start", {
+      turn,
+      input: claimed.text ?? claimed,
+      reason: "user"
+    });
+    let index = 0;
+    let finalTurnGranted = false;
+    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 = this.ctx.waterfall("agent/pre-step", {
+          index,
+          turn,
+          step: index,
+          messages: stepInput,
+          ...options.signal ? { signal: options.signal } : {}
+        }, (payload) => payload);
+        if (!preStep || !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);
+        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;
+        const request = this.ctx.waterfall("agent/request", {
+          index,
+          messages: requestedInput,
+          tools: availableTools,
+          options: completeOptions
+        }, (payload) => payload);
+        if (!request || !request.options || !request.tools) {
+          throw new AgentError("agent/request must return a request payload");
+        }
+        let llmMessages = copyMessages(requestedInput);
+        let completion;
+        const streamMethod = useStream ? llm.stream : void 0;
+        let attempt = 0;
+        let persistedStepInput = false;
+        while (true) {
+          if (options.signal?.aborted) {
+            finishReason = "cancelled";
+            break;
+          }
+          const streamEvents = [];
+          try {
+            if (streamMethod) {
+              const streamRequest = {
+                index,
+                messages: llmMessages,
+                tools: request.tools,
+                options: request.options
+              };
+              const stream = await this.ctx.waterfallAsync(
+                "llm/stream",
+                streamRequest,
+                async (payload) => {
+                  if (!streamMethod) {
+                    throw new AgentError("llm.stream is required for streaming runs");
+                  }
+                  return streamMethod(payload.messages, payload.tools, payload.options);
+                }
+              );
+              if (!stream || typeof stream[Symbol.asyncIterator] !== "function") {
+                throw new AgentError("llm/stream must return an async iterable stream");
+              }
+              llmMessages = copyMessages(streamRequest.messages);
+              if (!persistedStepInput) {
+                await this._persistStepInput(session, request, llmMessages);
+                if (this.config.assertReplayable) {
+                  await this._assertReplayable(session, llmMessages);
+                }
+                persistedStepInput = true;
+              }
+              let chunkIndex = 0;
+              for await (const event of stream) {
+                streamEvents.push(event);
+                if (event.type === "message_delta") {
+                  await session.append("assistant/chunk", {
+                    id: event.id,
+                    content: event.delta,
+                    index: chunkIndex
+                  });
+                  chunkIndex += 1;
+                }
+                yield event;
+              }
+              completion = completionFromStreamEvents(streamEvents);
+            } else {
+              if (!persistedStepInput) {
+                await this._persistStepInput(session, request, llmMessages);
+                if (this.config.assertReplayable) {
+                  await this._assertReplayable(session, llmMessages);
+                }
+                persistedStepInput = true;
+              }
+              completion = await llm.complete(llmMessages, request.tools, request.options);
+            }
+            break;
+          } catch (error) {
+            const content = partialStreamContent(streamEvents);
+            if (content) {
+              await session.append("assistant/message", {
+                content,
+                interrupted: true
+              });
+              llmMessages = await session.deriveMessages();
+            }
+            if (options.signal?.aborted) {
+              finishReason = "cancelled";
+              break;
+            }
+            attempt += 1;
+            const failure = toToolError(error);
+            const decision = await this.ctx.waterfallAsync(
+              "agent/request-error",
+              {
+                index,
+                turn,
+                step: index,
+                messages: copyMessages(llmMessages),
+                tools: request.tools,
+                options: request.options,
+                attempt,
+                error,
+                failure,
+                ...request.options.provider ? { provider: request.options.provider } : {},
+                ...request.options.model ? { model: request.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 (options.signal?.aborted) break;
+        if (!completion) throw new AgentError("LLM adapter did not produce a completion");
+        const toolCalls = completion.toolCalls ?? [];
+        if (finalTurnGranted && toolCalls.length) {
+          finishReason = "max_turns";
+          break;
+        }
+        const toolResults = [];
+        if (toolCalls.length) {
+          await session.append("assistant/message", {
+            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;
+          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;
+        }
+        steps.push({
+          index,
+          input: copyMessages(llmMessages),
+          completion,
+          toolResults
+        });
+        if (completion.content) {
+          output = completion.content;
+        }
+        if (!toolCalls.length) {
+          await session.append("assistant/message", { content: completion.content ?? "" });
+        }
+        await session.append("step/end", {
+          turn,
+          step: index,
+          finishReason: completion.finishReason,
+          toolCalls: toolCalls.length
+        });
+        currentStepIndex = void 0;
+        const nextMessages = this._extendMessages(llmMessages, completion, toolResults);
+        const concludesTurn = toolResults.some((result) => result.concludesTurn === true);
+        if (concludesTurn) {
+          finishReason = "stop";
+          break;
+        }
+        if (toolCalls.length === 0) {
+          finishReason = completion.finishReason === "length" ? "length" : completion.finishReason === "error" ? "error" : "stop";
+          const keepGoing = await this.ctx.serial("agent/turn-stopping", {
+            index,
+            turn,
+            steps: copySteps(steps),
+            finishReason
+          });
+          if (!keepGoing) break;
+        }
+        if (index + 1 >= maxTurns && !finalTurnGranted) {
+          finalTurnGranted = true;
+        } else if (index + 1 >= maxTurns + (finalTurnGranted ? 1 : 0)) {
+          finishReason = "max_turns";
+          break;
+        }
+        if (toolCalls.length) finishReason = "tool_calls";
+        index += 1;
+        messages = nextMessages;
+      }
+    } 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) } : {}
+        });
+      }
+      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) } : {}
+      });
+    }
+    const runResult = {
+      input: claimed,
+      output,
+      finishReason,
+      turn,
+      steps,
+      messages: copyMessages(messages)
+    };
+    this.ctx.emit("agent/turn-end", {
+      input: claimed,
+      steps: copySteps(steps),
+      messages: copyMessages(messages),
+      output,
+      finishReason
+    });
+    this.ctx.emit("agent/end", {
+      input: claimed,
+      steps: copySteps(steps),
+      messages: copyMessages(messages),
+      output,
+      finishReason
+    });
+    await this.config.hooks?.afterRun?.(runResult, options);
+    yield { type: "run/end", run: runResult };
+    return runResult;
+  }
+  async _enforceContextBudget(session, budget, messages) {
+    const limit = budget.limit ?? DEFAULT_CONTEXT_LIMIT;
+    const compactRatio = budget.compactRatio ?? 0.9;
+    if (limit <= 0 || compactRatio <= 0 || compactRatio > 1) {
+      throw new AgentError("invalid context budget: limit must be positive and compactRatio must be in (0, 1]");
+    }
+    const usage = estimateContextUsage(messages, limit);
+    if (usage.ratio < compactRatio) return copyMessages(messages);
+    const keepTokens = budget.keepTokens ?? Math.max(1, Math.floor(limit * 0.5));
+    const compactMessages = budget.summarize ? await budget.summarize(messages, usage) : [{ role: "system", content: defaultContextSummary(messages, usage) }];
+    const summary = compactMessages.map((message) => `${message.role}: ${message.content}`).join("\n");
+    await session.compact({
+      keepTokens,
+      summary,
+      tokensBefore: usage.tokens,
+      messages: compactMessages.map((message) => copyMessages([message])[0])
+    });
+    this.ctx.emit("agent/context-compact", {
+      type: "agent/context-compact",
+      messagesBefore: messages.length,
+      tokensBefore: usage.tokens,
+      limit,
+      keepTokens,
+      messagesAfter: compactMessages.length
+    });
+    return compactMessages.map((message) => copyMessages([message])[0]);
+  }
+  async _persistStepInput(session, 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 } : {}
+    };
+    const nextHeader = {
+      ...Object.keys(config).length ? { config } : {},
+      ...system !== void 0 ? { system } : {},
+      ...tools.length ? { tools } : {}
+    };
+    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 } : {}
+    };
+    const llmService2 = this.ctx.reflect.get("llm", false);
+    const routeCapacity = llmService2?.routeCapacity?.();
+    if (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 requested = input.filter(isUserOrSystemMessage);
+    const surface = await session.deriveMessages();
+    const appendDurable = async (messages) => {
+      for (const message of messages) {
+        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 } : {}
+          });
+        }
+      }
+    };
+    if (surface.length === 0) {
+      await appendDurable(requested);
+      return;
+    }
+    const durableUsers = surface.filter((message) => message.role === "user").length;
+    let seenUsers = 0;
+    const newTail = [];
+    for (const message of requested) {
+      if (message.role === "user") seenUsers += 1;
+      if (seenUsers <= durableUsers) continue;
+      newTail.push(message);
+    }
+    await appendDurable(newTail);
+  }
+  async _assertReplayable(session, input) {
+    const reconstructed = await session.deriveMessages();
+    const canonical = (messages) => messages.filter((message) => message.role !== "system").map((message) => ({
+      role: message.role,
+      content: message.content,
+      ...message.tool_call_id ? { tool_call_id: message.tool_call_id } : {},
+      ...message.name ? { name: message.name } : {},
+      ...message.tool_calls?.length ? { tool_calls: message.tool_calls.map((call) => ({
+        id: call.id,
+        name: call.name,
+        args: JSON.stringify(call.arguments ?? {})
+      })) } : {}
+    }));
+    const actual = canonical(input);
+    const replay = canonical(reconstructed);
+    if (JSON.stringify(actual) !== JSON.stringify(replay)) {
+      throw new AgentError(
+        `request is not reconstructable from session log: actual=${JSON.stringify(actual)} replay=${JSON.stringify(replay)}`
+      );
+    }
+  }
+  async _initialMessages(input) {
+    const promptService = this.ctx.reflect.get("systemPrompt", false);
+    const assembled = promptService ? (await promptService.assemble()).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);
+      return [...systemMessage, ...copyMessages(input.messages)];
+    }
+    if (input.text) return [...systemMessage, { role: "user", content: input.text }];
+    return systemMessage;
+  }
+  _extendMessages(messages, completion, toolResults) {
+    const next = copyMessages(messages);
+    const assistant = {
+      role: "assistant",
+      content: completion.content ?? ""
+    };
+    const toolCalls = completion.toolCalls ?? [];
+    if (toolCalls.length) {
+      assistant.tool_calls = toolCalls.map((call) => ({
+        id: call.id,
+        name: call.name,
+        arguments: call.arguments
+      }));
+    }
+    next.push(assistant);
+    for (const call of toolCalls) {
+      const result = toolResults.find((candidate) => candidate.callId === call.id);
+      const content = result ? result.ok ? stringify2(result.output) : `error: ${result.error?.message ?? "unknown"}` : "error: missing tool result";
+      const message = {
+        role: "tool",
+        content,
+        tool_call_id: call.id
+      };
+      message.name = result?.name ?? call.name;
+      if (result && !result.ok) {
+        message.toolOk = false;
+        if (result.error) {
+          message.toolError = {
+            name: result.error.name,
+            message: result.error.message
+          };
+        }
+      }
+      next.push(message);
+    }
+    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;
+    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() {
+    if (this.config.llm) return this.config.llm;
+    const service = this.ctx.reflect.get("llm", false);
+    return service?.current();
+  }
+};
+function defaultContextSummary(messages, usage) {
+  const latest = messages.at(-1);
+  const latestText = latest ? `${latest.role}: ${latest.content}` : "none";
+  return [
+    "Earlier context was compacted.",
+    `Messages before compaction: ${messages.length}.`,
+    `Tokens before compaction: ${usage.tokens}.`,
+    `Latest message: ${latestText}`
+  ].join(" ");
+}
+function copySteps(steps) {
+  return steps.map((step) => ({
+    index: step.index,
+    input: copyMessages(step.input),
+    completion: copyCompletion(step.completion),
+    toolResults: step.toolResults.map((result) => ({ ...result }))
+  }));
+}
+function toToolError(error) {
+  if (error instanceof Error) {
+    const result = {
+      name: error.name,
+      message: error.message
+    };
+    if (error.stack) result.stack = error.stack;
+    return result;
+  }
+  return {
+    name: "ToolExecutionError",
+    message: String(error)
+  };
+}
+function completionFromStreamEvents(events) {
+  let content = "";
+  const calls = /* @__PURE__ */ new Map();
+  let finishReason = "error";
+  for (const event of events) {
+    if (event.type === "message_delta") {
+      content += event.delta;
+    } else if (event.type === "toolcall_end") {
+      calls.set(event.index, {
+        id: event.id,
+        name: event.name,
+        arguments: event.arguments
+      });
+    } else if (event.type === "message_stop") {
+      finishReason = event.finishReason;
+    }
+  }
+  const completion = { finishReason };
+  if (content) completion.content = content;
+  if (calls.size) completion.toolCalls = [...calls.values()];
+  return completion;
+}
+async function consumeAgentStream(stream) {
+  const iterator = stream[Symbol.asyncIterator]();
+  while (true) {
+    const next = await iterator.next();
+    if (next.done) return next.value;
+  }
+}
+var agent = {
+  name: "agent",
+  inject: ["session", "tools"],
+  apply: (ctx, config = {}) => {
+    const service = new AgentService(ctx, config);
+    ctx.provide("agent", service);
+    ctx.provide("agentLoop", (input, options) => service.run(input, options));
+    ctx.provide("inbox", service.inbox);
+    return () => {
+    };
+  }
+};
+var name = "@tnega/agent";
+
+// packages/agent/src/definition.ts
+function resolveSystemPrompt(ctx, system) {
+  if (!system) return void 0;
+  return typeof system === "function" ? system(ctx) : system;
+}
+function withSystemPrompt(input, system) {
+  if (!system) return input;
+  const messages = [
+    { role: "system", content: system },
+    ...input?.messages ?? []
+  ];
+  if (input?.text) messages.push({ role: "user", content: input.text });
+  return { ...input ?? {}, messages };
+}
+function defineAgent(definition) {
+  const name2 = definition.name.trim();
+  if (!name2) throw new TypeError("agent definition requires a non-empty name");
+  return {
+    name: `agent:${name2}`,
+    inject: ["session", "tools"],
+    apply: async (ctx, config = {}) => {
+      const dynamic = ctx;
+      const system = resolveSystemPrompt(ctx, definition.system);
+      let agentService;
+      if (definition.loop) {
+        const loop = async (input, options) => {
+          await definition.hooks?.beforeRun?.(input ?? {}, options ?? {});
+          const result = await definition.loop(
+            withSystemPrompt(input, system),
+            options
+          );
+          await definition.hooks?.afterRun?.(result, options ?? {});
+          return result;
+        };
+        ctx.provide("agentLoop", loop);
+      } else {
+        const agentConfig = {};
+        if (definition.hooks) agentConfig.hooks = definition.hooks;
+        if (config.llm) agentConfig.llm = config.llm;
+        if (config.maxTurns !== void 0) agentConfig.maxTurns = config.maxTurns;
+        if (config.maxSteps !== void 0) agentConfig.maxSteps = config.maxSteps;
+        if (config.inbox) agentConfig.inbox = config.inbox;
+        if (config.contextBudget) agentConfig.contextBudget = config.contextBudget;
+        const agentFiber = ctx.plugin(agent, agentConfig);
+        await agentFiber;
+        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);
+      }
+      ctx.provide("agentDefinition", definition);
+      ctx.provide("agentSystem", system);
+      ctx.emit("agent/definition", {
+        name: name2,
+        version: definition.version,
+        system,
+        toolCount: (definition.tools ?? []).length
+      });
+    }
+  };
+}
+
+// packages/agent/src/live.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+
+// 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 = [];
+  get size() {
+    return this._nextTurn.length + this._nextStep.length;
+  }
+  async insert(input, target = "next-turn") {
+    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;
+    list.push(message);
+    await this._session.append("agent/inbox/spliced", {
+      target,
+      index: list.length - 1,
+      inserted: [{
+        id: message.id,
+        content: contentOf(message),
+        ...payloadOf(message) !== void 0 ? { payload: payloadOf(message) } : {}
+      }]
+    });
+    return message;
+  }
+  async steer(input) {
+    const message = {
+      id: randomUUID3(),
+      ...input.text !== void 0 ? { text: input.text } : {},
+      ...input.content !== void 0 ? { content: input.content } : {}
+    };
+    this._nextStep.unshift(message);
+    await this._session.append("agent/inbox/spliced", {
+      target: "next-step",
+      index: 0,
+      inserted: [{
+        id: message.id,
+        content: contentOf(message),
+        ...payloadOf(message) !== void 0 ? { payload: payloadOf(message) } : {},
+        mode: "steer"
+      }]
+    });
+    return message;
+  }
+  async claim() {
+    const steered = this._nextStep.shift();
+    if (steered) {
+      await this._session.append("agent/inbox/spliced", {
+        target: "next-step",
+        index: 0,
+        deleteCount: 1
+      });
+      return steered;
+    }
+    const next = this._nextTurn.shift();
+    if (next) {
+      await this._session.append("agent/inbox/spliced", {
+        target: "next-turn",
+        index: 0,
+        deleteCount: 1
+      });
+      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() {
+    const claimed = [];
+    if (this._nextStep.length) {
+      const removed = this._nextStep.splice(0);
+      claimed.push(...removed);
+      await this._session.append("agent/inbox/spliced", {
+        target: "next-step",
+        index: 0,
+        deleteCount: removed.length
+      });
+    }
+    const nextTurn = this._nextTurn.shift();
+    if (nextTurn) {
+      claimed.push(nextTurn);
+      await this._session.append("agent/inbox/spliced", {
+        target: "next-turn",
+        index: 0,
+        deleteCount: 1
+      });
+    }
+    return claimed;
+  }
+  async clear() {
+    if (this._nextTurn.length) {
+      this._nextTurn = [];
+      await this._session.append("agent/inbox/spliced", {
+        target: "next-turn",
+        index: 0,
+        deleteCount: Number.POSITIVE_INFINITY
+      });
+    }
+    if (this._nextStep.length) {
+      this._nextStep = [];
+      await this._session.append("agent/inbox/spliced", {
+        target: "next-step",
+        index: 0,
+        deleteCount: Number.POSITIVE_INFINITY
+      });
+    }
+  }
+  /** Insert a message at an explicit target/index boundary. */
+  async insertAt(input, target, index, mode = "followup") {
+    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));
+    list.splice(safeIndex, 0, message);
+    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
+      }]
+    });
+    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) {
+    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;
+    entry.list.splice(index, 1, replacement);
+    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) } : {}
+      }]
+    });
+    return replacement;
+  }
+  /** Remove one pending message by id. */
+  async remove(messageId) {
+    const entry = this._find(messageId);
+    if (!entry) return void 0;
+    entry.list.splice(entry.index, 1);
+    await this._session.append("agent/inbox/spliced", {
+      target: entry.target,
+      index: entry.index,
+      deleteCount: 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]
+    };
+  }
+  _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;
+      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
+var LiveAgentImpl = class {
+  constructor(_ctx, _agentCtx, _service, id, inbox, session, durable, meta, manualStreaming = 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;
+  }
+  _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;
+  _agentSystem;
+  _manualStreaming = false;
+  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) {
+    this._send(input, "followup");
+  }
+  /** Replace one pending inbox message by durable message id. */
+  replaceMessage(messageId, input) {
+    this._mutatePending(async () => {
+      const previous = this._durable.get(messageId);
+      if (!previous) 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
+      });
+      this._ctx.emit("agent/inbox/inserted", {
+        id: this.id,
+        agent: this,
+        target: this._findTarget(messageId) ?? "next-turn",
+        input: replacement,
+        inboxSeq: this._durable.size
+      });
+    });
+  }
+  /** Remove one pending inbox message by durable message id. */
+  removeMessage(messageId) {
+    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) {
+    this._send(input, "steer");
+  }
+  inject(key, value) {
+    if (key === "agentSystem" && typeof value === "string") {
+      this._agentSystem = value;
+    }
+  }
+  send(input, options = {}) {
+    this._send(input, options.mode === "steer" ? "steer" : "followup");
+  }
+  _send(input, target) {
+    if (this._disposed) throw new Error(`agent disposed: ${this.id}`);
+    const text = input.text ?? "";
+    const content = input.messages ?? input.context;
+    const task = this._writeTail.then(async () => {
+      const message = target === "steer" ? await this._durable.steer({ text, ...content !== void 0 ? { content } : {} }) : await this._durable.insert({ text, ...content !== void 0 ? { content } : {} });
+      this._ctx.emit("agent/inbox/inserted", {
+        id: this.id,
+        target,
+        input: message,
+        inboxSeq: this._durable.size
+      });
+    }).catch((error) => {
+      this._ctx.emit("agent/error", { id: this.id, error });
+    });
+    this._writeTail = task;
+    this._pendingWrite = task;
+    task.finally(() => {
+      if (this._pendingWrite === task) this._pendingWrite = void 0;
+      queueMicrotask(() => this._wake());
+    });
+  }
+  _mutatePending(task) {
+    if (this._disposed) throw new Error(`agent disposed: ${this.id}`);
+    const chained = this._writeTail.then(task).catch((error) => {
+      this._ctx.emit("agent/error", { id: this.id, error });
+    });
+    this._writeTail = chained;
+    this._pendingWrite = chained;
+    chained.finally(() => {
+      if (this._pendingWrite === chained) this._pendingWrite = void 0;
+    });
+  }
+  _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) {
+      const task = this._writeTail.then(async () => {
+        const before = this._durable.snapshot();
+        for (const message of [...before.nextStep, ...before.nextTurn]) {
+          this._ctx.emit("agent/inbox/discarded", { id: this.id, message });
+        }
+        await this._durable.clear();
+      }).catch((error) => {
+        this._ctx.emit("agent/error", { id: this.id, error });
+      });
+      this._writeTail = task;
+      this._pendingWrite = task;
+      task.finally(() => {
+        if (this._pendingWrite === task) this._pendingWrite = void 0;
+      });
+    }
+    this._controller?.abort(cause);
+    this._maintenance?.controller.abort(cause);
+  }
+  async whenIdle() {
+    while (this._pendingWrite) await this._pendingWrite;
+    while (true) {
+      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._durable.size) 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);
+    }
+    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;
+    task.finally(() => {
+      if (this._drainPromise === task) this._drainPromise = void 0;
+    });
+  }
+  async _drainAll() {
+    await this._writeTail.catch(() => void 0);
+    if (this._durable.size) {
+      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 batch = await this._durable.claimBatch();
+        if (!batch.length) break;
+        const input = await this._inputForBatch(batch);
+        const turn = await this._nextTurnNumber();
+        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) {
+            yield* this._service.runStream(input, { signal: controller.signal });
+          } else {
+            await this._service.run(input, { signal: controller.signal });
+          }
+        } catch (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;
+      this._setStatus("idle");
+    }
+  }
+  async _inputForBatch(batch) {
+    const history = await this.session.deriveMessages();
+    const structured = batch.filter((message) => message.content !== void 0);
+    const plain = batch.filter((message) => message.content === void 0);
+    const plainMessages = plain.filter((message) => message.text !== void 0).map((message) => ({ role: "user", content: message.text ?? "" }));
+    if (structured.length) {
+      return {
+        messages: [
+          ...history,
+          ...structured.flatMap((message) => Array.isArray(message.content) ? message.content : [{ role: "user", content: String(message.content ?? "") }])
+        ]
+      };
+    }
+    if (history.length || batch.length > 1) {
+      return { messages: [...history, ...plainMessages] };
+    }
+    return { text: plainMessages[0]?.content ?? "" };
+  }
+  _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");
+  const log = new SessionLog(
+    options.file,
+    (type, payload) => {
+      if (type === "event") ctx.emit("session/event", payload);
+      else ctx.emit("session/flush", payload);
+    }
+  );
+  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 injected = new AgentInbox();
+  const inboxView = {
+    get size() {
+      return durable.size;
+    },
+    snapshot: () => durable.snapshot()
+  };
+  const service = new AgentService(ctx, {
+    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 } : {}
+  });
+  if (options.system) injected.inject("agentSystem", options.system);
+  const agentScope = await ctx.inject([], (scopeCtx) => {
+    scopeCtx.isolate("agentScope").provide("agentScope", scopeCtx);
+  });
+  await agentScope;
+  const agentCtx = agentScope.ctx;
+  const agent2 = new LiveAgentImpl(
+    ctx,
+    agentCtx,
+    service,
+    agentId,
+    inboxView,
+    log,
+    durable,
+    boundMeta,
+    options.manualStreaming === true
+  );
+  agent2.trackSetupDispose(() => agentScope.dispose());
+  if (options.system) agent2.inject("agentSystem", options.system);
+  let setupResult;
+  try {
+    setupResult = await options.setup?.(agentCtx);
+    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.size && options.manualStreaming !== true) {
+    setTimeout(() => agent2.wakeNow(), 0);
+  }
+  return { agent: agent2, dispose: () => agent2.dispose() };
+}
+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,
+  llmService,
+  name,
+  systemPrompt
+};
+//# sourceMappingURL=agent.js.map