tnega 0.1.0 → 0.3.0

package/dist/session.js

@@ -0,0 +1,1045 @@
+import { createRequire as __tnegaCreateRequire } from 'node:module'; const require = __tnegaCreateRequire(import.meta.url);
+
+// 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 projectEvents(events) {
+  const messages = [];
+  for (const event of events) {
+    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 isAppendSurfaceEvent(event) {
+  return isSurfaceEventType(event.type) && event.surfaceOp === "append";
+}
+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 transcriptEvents(events) {
+  const bySeq = new Map(events.map((event) => [event.seq, event]));
+  const { nodes, replacements } = foldSurface(events);
+  const shadowedOf = /* @__PURE__ */ new Map();
+  for (const replacement of replacements) {
+    shadowedOf.set(replacement.seq, replacement.shadowedSeqs.map((seq) => bySeq.get(seq)).filter((event) => event !== void 0));
+  }
+  const isVisible = (event) => event.type !== "system/message" && isSurfaceEventType(event.type);
+  const skeleton = [];
+  const appendHistory = (checkpointSeq) => {
+    for (const shadowed of shadowedOf.get(checkpointSeq) ?? []) {
+      if (shadowed.type === "checkpoint") appendHistory(shadowed.seq);
+      else if (isVisible(shadowed)) skeleton.push(shadowed);
+    }
+  };
+  for (const seq of nodes) {
+    const event = bySeq.get(seq);
+    if (!event) continue;
+    if (event.type === "checkpoint") appendHistory(event.seq);
+    skeleton.push(event);
+  }
+  const declaredCalls = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (event.type === "assistant/message") {
+      for (const call of event.payload.toolCalls ?? []) declaredCalls.add(call.id);
+    }
+  }
+  const inSkeleton = new Set(skeleton.map((event) => event.id));
+  const structure = events.filter((event) => !inSkeleton.has(event.id)).filter((event) => event.type !== "compaction/start" && event.type !== "compaction/end").filter((event) => event.type !== "checkpoint").filter((event) => !(event.type === "tool/call" && declaredCalls.has(event.payload.id)));
+  const ordered = [...skeleton];
+  for (const event of structure) {
+    let index = ordered.length;
+    for (let cursor = ordered.length - 1; cursor >= 0; cursor -= 1) {
+      if (ordered[cursor].seq <= event.seq) {
+        index = cursor + 1;
+        break;
+      }
+    }
+    ordered.splice(index, 0, event);
+  }
+  return ordered;
+}
+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 foldMetaFromLog(log) {
+  return log.read().then(foldSessionMeta);
+}
+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 safeCompactSplit(events, splitIndex) {
+  const index = Math.max(0, Math.min(splitIndex, events.length));
+  const first = events[index];
+  if (first?.type === "tool/result") {
+    const callId = first.payload.toolCallId;
+    for (let cursor = index - 1; cursor >= 0; cursor -= 1) {
+      const candidate = events[cursor];
+      if (candidate?.type === "tool/call" && candidate.payload.id === callId) {
+        return cursor;
+      }
+    }
+  }
+  let openCalls = 0;
+  for (let cursor = 0; cursor <= events.length; cursor += 1) {
+    if (cursor >= index && openCalls === 0) return cursor;
+    const event = events[cursor];
+    if (!event) continue;
+    if (event.type === "tool/call") openCalls += 1;
+    if (event.type === "tool/result") openCalls = Math.max(0, openCalls - 1);
+  }
+  return index;
+}
+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;
+  }
+};
+var session = {
+  name: "session",
+  apply: async (ctx, config) => {
+    const log = new SessionLog(config.file, config.broadcast ?? ((type, payload) => {
+      if (type === "event") ctx.emit("session/event", payload);
+      else ctx.emit("session/flush", payload);
+    }));
+    await log.init();
+    ctx.provide("session", log);
+    return () => log.close();
+  }
+};
+var name = "@tnega/session";
+export {
+  DEFAULT_CONTEXT_LIMIT,
+  SESSION_FORMAT_VERSION,
+  SessionFormatError,
+  SessionLog,
+  checkBalancedSteps,
+  checkBalancedToolCalls,
+  checkBalancedTurns,
+  checkMonotonicSeq,
+  checkSessionInvariants,
+  checkpointShadowRange,
+  deriveEventMessage,
+  deriveSurfaceMessages,
+  estimateContextUsage,
+  estimateEventTokens,
+  estimateMessageTokens,
+  foldMetaFromLog,
+  foldRequestContext,
+  foldRequestHeader,
+  foldSessionMeta,
+  foldSurface,
+  isAppendSurfaceEvent,
+  isSurfaceEventType,
+  name,
+  projectEvents,
+  repairUnclosed,
+  resolveCompactKeep,
+  safeCompactSplit,
+  session,
+  suffixStartIndexForTokens,
+  transcriptEvents
+};
+//# sourceMappingURL=session.js.map