@zaly/agent 0.1.1 → 0.3.0

package/dist/{session-C8zqqbPE.mjs → session-C5ra-Hi1.mjs}

@@ -1,4 +1,4 @@
-import { n as __exportAll } from "./rolldown-runtime-DYf_mQCB.mjs";
+import { n as __exportAll } from "./rolldown-runtime-BVN1G_yT.mjs";
 import { r as uuidv7 } from "./uuid-rfbQ9ad2.mjs";
 import { n as JsonlStore } from "./jsonl-BGt7eqPK.mjs";
 import { Emitter, normPath } from "@zaly/shared";
@@ -81,6 +81,7 @@ var Session = class Session extends Emitter {
 	#started = false;
 	#path;
 	#head;
+	#mutations;
 	constructor(opts) {
 		super();
 		this.#opts = opts;
@@ -154,28 +155,37 @@ var Session = class Session extends Emitter {
 		};
 	}
 	async update(settings, opts) {
-		return this.#commit({
+		return this.#mutate(() => this.#commit({
 			settings,
 			type: "session-settings"
-		}, opts);
+		}, opts));
 	}
 	/** Lazily emits `session-start` on a fresh session or `session-resume`
 	*  on a hydrated one. Called from `#commit` before the first non-marker
 	*  node lands so the start/resume marker always heads the chain. */
 	async #autostart() {
-		if (!this.#started) await this.start();
+		if (!this.#started) await this.#start();
 	}
 	/** Explicitly mark the session as started — writes a `session-start`
 	*  marker on a fresh session, `session-resume` on a hydrated one.
 	*  Idempotent; subsequent calls are no-ops. Optional `meta` is
 	*  applied via `update()` after the marker lands. */
 	async start(settings) {
-		if (this.#started) return settings ? this.update(settings) : this.#store.root?.uuid;
+		return this.#mutate(() => this.#start(settings));
+	}
+	async #start(settings) {
+		if (this.#started) return settings ? this.#commit({
+			settings,
+			type: "session-settings"
+		}) : this.#store.root?.uuid;
 		this.#started = true;
 		const type = this.messages.length > 0 ? "session-resume" : "session-start";
 		await this.#commit({ type });
 		this.emit(type);
-		await this.update(settings ?? {});
+		await this.#commit({
+			settings: settings ?? {},
+			type: "session-settings"
+		});
 		return this.#store.root?.uuid;
 	}
 	/** Look up the decorated view for a node id — raw node plus the
@@ -218,46 +228,61 @@ var Session = class Session extends Emitter {
 			id: uuid,
 			ts
 		};
-		return this.#commit({
+		return this.#mutate(() => this.#commit({
 			message: m,
 			type: "message"
-		});
+		}));
 	}
-	/** Mark a compaction boundary. Subsequent `add()` calls land after
-	*  this node; their messages form the new active conversation. The
-	*  pre-compact chain stays in the store but is no longer part of
-	*  `messages`. Also commits a fresh `session-meta` snapshot right
-	*  after the compact so post-compact lazy walks always have a nearby
-	*  meta anchor. */
+	/** Summarize an active prefix through a message ID, preserving everything
+	*  appended after it. Boundary validation and tail calculation share the
+	*  serialized commit with the new summary. Legacy tail-only calls remain
+	*  supported. Original history stays in the store; a fresh settings anchor
+	*  follows the compact node for reconstruction. */
 	async compact(opts) {
-		const node = {
-			durationMs: opts.durationMs,
-			parentUuid: this.#store.root?.uuid,
-			preTokens: opts.preTokens,
-			summary: opts.summary,
-			tail: opts.tail,
-			trigger: opts.trigger ?? "manual",
-			ts: Date.now(),
-			type: "compact",
-			uuid: uuidv7()
-		};
-		const compactUuid = await this.#commit(node);
-		await this.update({}, { force: true });
-		await this.#rebuild();
-		this.emit("compact", { node });
-		return compactUuid;
+		return this.#mutate(async () => {
+			opts.signal?.throwIfAborted();
+			let tail = opts.tail;
+			if (opts.to !== void 0) {
+				const index = this.messages.findIndex((m) => m.id === opts.to);
+				if (index === -1 || opts.from !== void 0 && this.messages[0]?.id !== opts.from) throw new Error("Compaction snapshot is no longer part of the active history");
+				tail = this.messages.length - index - 1;
+			}
+			if (tail === void 0 || !Number.isInteger(tail) || tail < 0) throw new Error("Compaction requires a message boundary or a non-negative integer tail");
+			const compactUuid = await this.#commit({
+				durationMs: opts.durationMs,
+				from: opts.from,
+				preTokens: opts.preTokens,
+				summary: opts.summary,
+				tail,
+				to: opts.to,
+				trigger: opts.trigger ?? "manual",
+				type: "compact"
+			});
+			await this.#commit({
+				settings: {},
+				type: "session-settings"
+			}, { force: true });
+			await this.#rebuild();
+			const node = this.#view.compact;
+			this.emit("compact", { node });
+			return compactUuid;
+		});
 	}
 	async addMaskCheckpoint(opts) {
-		this.#view.maskCheckpoint = opts;
-		return this.#commit({
-			...opts,
-			type: "mask-checkpoint"
+		return this.#mutate(async () => {
+			this.#view.maskCheckpoint = opts;
+			return this.#commit({
+				...opts,
+				type: "mask-checkpoint"
+			});
 		});
 	}
 	async checkout(uuid) {
-		if (this.#closed) throw new Error("Session is closed");
-		this.#head = uuid;
-		await this.#rebuild();
+		return this.#mutate(async () => {
+			if (this.#closed) throw new Error("Session is closed");
+			this.#head = uuid;
+			await this.#rebuild();
+		});
 	}
 	/** Pre-active history of the current chain — messages from before
 	*  the most recent compact (and earlier compacts), in chronological
@@ -274,9 +299,20 @@ var Session = class Session extends Emitter {
 	}
 	/** Flush + close the underlying store. Subsequent writes throw. */
 	async close() {
-		if (this.#closed) return;
-		this.#closed = true;
-		await this.#store.close?.();
+		return this.#mutate(async () => {
+			if (this.#closed) return;
+			this.#closed = true;
+			await this.#store.close?.();
+		});
+	}
+	#mutate(fn) {
+		const pending = this.#mutations ? this.#mutations.then(fn) : fn();
+		const settled = pending.then(() => {}, () => {});
+		this.#mutations = settled;
+		settled.then(() => {
+			if (this.#mutations === settled) this.#mutations = void 0;
+		});
+		return pending;
 	}
 	/** Atomically commit a node: register it in the store, update active
 	*  messages, persist, and emit. Single chokepoint for all mutations. */
@@ -284,8 +320,8 @@ var Session = class Session extends Emitter {
 		let node = {
 			...n,
 			parentUuid: this.head,
-			ts: Date.now(),
-			uuid: uuidv7()
+			ts: n.type === "message" ? n.message.ts ?? Date.now() : Date.now(),
+			uuid: n.type === "message" ? n.message.id ?? uuidv7() : uuidv7()
 		};
 		if (!this.#started && node.type !== "session-start" && node.type !== "session-resume") await this.#autostart();
 		if (this.#closed) throw new Error("Session is closed");
@@ -363,8 +399,7 @@ var Session = class Session extends Emitter {
 			if (node.type === "mask-checkpoint" && !compact && !maskCheckpoint) maskCheckpoint = node;
 			if (node.type === "message") messageNodes.push(node);
 			if (node.type === "compact" && (opts.active ?? true)) {
-				if (compact) break;
-				compact = node;
+				compact ??= node;
 				limit = Math.min(limit, messageNodes.length + node.tail);
 			}
 			if (opts.stop?.(node)) break;
@@ -445,4 +480,4 @@ var Session = class Session extends Emitter {
 };
 export { session_exports as n, MemoryStore as r, Session as t };
 
-//# sourceMappingURL=session-C8zqqbPE.mjs.map
+//# sourceMappingURL=session-C5ra-Hi1.mjs.map

package/dist/session-C5ra-Hi1.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-C5ra-Hi1.mjs","names":[],"sources":["../src/session/memory.ts","../src/session/session.ts"],"sourcesContent":["import type { SessionStore } from \"./store.ts\"\nimport type { SessionNode } from \"./types.ts\"\n\n/**\n * In-memory `SessionStore` — a `Map<uuid, SessionNode>` plus a `root`\n * pointer. No persistence. Construction takes optional initial nodes\n * for tests, replay tools, and the Claude session importer.\n */\nexport class MemoryStore implements SessionStore {\n  readonly #nodes: Map<string, SessionNode>\n  #root?: SessionNode\n\n  constructor(nodes?: Iterable<SessionNode>) {\n    this.#nodes = new Map()\n    if (nodes) {\n      for (const node of nodes) {\n        this.#nodes.set(node.uuid, node)\n        this.#root = node\n      }\n    }\n  }\n\n  get root(): SessionNode | undefined {\n    return this.#root\n  }\n\n  async get(id: string): Promise<SessionNode | undefined> {\n    return this.#nodes.get(id)\n  }\n\n  async write(node: SessionNode): Promise<void> {\n    this.#nodes.set(node.uuid, node)\n    this.#root = node\n  }\n\n  *all(): Iterable<SessionNode> {\n    yield* this.#nodes.values()\n  }\n}\n","import type { Message } from \"@zaly/ai\"\nimport type { SessionStore } from \"./store.ts\"\nimport type {\n  MaskCheckpoint,\n  PartialNode,\n  SessionEvents,\n  SessionInit,\n  SessionMessage,\n  SessionNode,\n  SessionNodeView,\n  SessionOptions,\n  SessionSettings,\n  SessionUpdate,\n  SessionView,\n} from \"./types.ts\"\n\nimport { Emitter, normPath } from \"@zaly/shared\"\nimport { zalyPaths } from \"@zaly/shared/paths\"\nimport { isDeepStrictEqual } from \"node:util\"\nimport { join } from \"pathe\"\nimport { uuidv7 } from \"../utils/uuid.ts\"\nimport { JsonlStore } from \"./jsonl.ts\"\nimport { MemoryStore } from \"./memory.ts\"\n\nconst VERSION = 2\n\n/**\n * Conversation primitive. Owns a DAG of message + compaction + meta\n * nodes via a `SessionStore` backend; the *active* message list is\n * whatever you get by walking `parentUuid` backwards from the store's\n * root until you hit a `compact` node (or the start).\n *\n * **Meta is snapshot-based.** `session-meta` nodes carry the full\n * cumulative meta as of their commit time. Other node types (start,\n * resume, message, compact) don't carry meta — `Session` reconstructs\n * the cumulative meta at any point by finding the most recent\n * `session-meta` ancestor in a forward pass over the chain. Public\n * APIs return `SessionNodeView` (raw node + decorated `meta`).\n *\n * Designed so the loop, the persistor, the TUI, and any replay tool\n * all read from one source of truth and never mutate the DAG behind\n * each other's backs:\n *\n * - **Run loop** (`Agent`) calls `add()` on each new message and\n *   `compact()` on overflow.\n * - **TUI** subscribes to the `node` event for streaming render.\n * - **Persistor** is the `SessionStore` — `MemoryStore` for ephemeral\n *   sessions, `JsonlStore` for file-backed.\n *\n * Construction:\n *   - Use `await Session.load(opts)` for the recommended path — picks\n *     the right store (Memory if no path, JSONL if path).\n *   - For tests / direct embedding, `new Session({ store })` works with\n *     any pre-built store.\n */\nexport class Session<T extends SessionStore = SessionStore> extends Emitter<SessionEvents> {\n  readonly #store: T\n  #opts: SessionInit<T>\n  #id: string\n  #dir: string\n  #settings: SessionSettings = {}\n  #view: SessionView = { messages: [], nodes: new Map() }\n  #closed = false\n  #started = false\n  #path?: string\n  #head?: string\n  #mutations?: Promise<void>\n\n  protected constructor(opts: SessionInit<T>) {\n    super()\n    this.#opts = opts\n    this.#path = opts.path\n    this.#store = opts.store\n    this.#id = opts.defaults?.sessionId ?? uuidv7()\n    this.#dir = normPath(opts.dir ?? join(zalyPaths.env.tmp, \"sessions\", this.#id))\n  }\n\n  /** Recommended one-step path: pick the right store backend, hydrate\n   *  if applicable, return a ready-to-use session.\n   *\n   *  - `path` provided → `JsonlStore` (file-backed, hydrates from disk\n   *    if the file exists, opens for append either way).\n   *  - No `path` → `MemoryStore` (ephemeral, no persistence). */\n  static async load<T extends SessionStore = SessionStore>(\n    opts: SessionOptions<T> & { store: T }\n  ): Promise<Session<T>>\n  static async load(opts: SessionOptions & { path: string }): Promise<Session<JsonlStore>>\n  static async load(opts?: SessionOptions & {}): Promise<Session<MemoryStore>>\n  static async load(opts: SessionOptions = {}): Promise<Session> {\n    const session = await Session.create(opts)\n    await session.#rebuild()\n    return session\n  }\n\n  private static async create(opts: SessionOptions = {}): Promise<Session> {\n    const path = opts.path ? normPath(opts.path) : undefined\n    const store: SessionStore =\n      opts.store ?? (path ? await JsonlStore.load(path) : new MemoryStore())\n    const init: SessionInit = { ...opts, path, store }\n    return new Session(init)\n  }\n\n  /** Efficiently fetch the most recent user message by walking backward until we hit\n   * a user message, without reconstructing the full chain. Useful for a session picker. */\n  static async lastMessage(opts: SessionOptions = {}): Promise<Message<\"user\"> | undefined> {\n    const session = await Session.create(opts)\n    let ret: Message<\"user\"> | undefined\n    await session.#chain({\n      stop: (node) => {\n        if (node.type === \"message\" && node.message.role === \"user\") {\n          ret = node.message\n          return true\n        }\n        return false\n      },\n    })\n    void session.close()\n    return ret\n  }\n\n  async #rebuild(): Promise<void> {\n    const chain = await this.#chain()\n    this.#view = chain\n    this.#settings = chain.settings\n    this.#id = chain.settings.sessionId ?? this.#id\n  }\n\n  // ── Read ──────────────────────────────────────────────────────────────\n\n  /** Active conversation — chain from current head back to the most\n   *  recent compact (exclusive), in chronological order. This is what\n   *  the agent sees on the next request. */\n  get messages(): readonly Message[] {\n    return this.#view.messages\n  }\n\n  get maskCheckpoint(): MaskCheckpoint | undefined {\n    return this.#view.maskCheckpoint\n  }\n\n  get id(): string {\n    return this.#id\n  }\n\n  get dir(): string {\n    return this.#dir\n  }\n\n  get path(): string | undefined {\n    return this.#path\n  }\n\n  get started(): boolean {\n    return this.#started\n  }\n\n  /** Current session settings, merged with defaults. */\n  get settings(): SessionSettings {\n    return { ...this.#opts.defaults, ...this.#settings }\n  }\n\n  async update(settings: SessionUpdate, opts?: { force?: boolean }): Promise<string> {\n    return this.#mutate(() => this.#commit({ settings, type: \"session-settings\" }, opts))\n  }\n\n  /** Lazily emits `session-start` on a fresh session or `session-resume`\n   *  on a hydrated one. Called from `#commit` before the first non-marker\n   *  node lands so the start/resume marker always heads the chain. */\n  async #autostart(): Promise<void> {\n    if (!this.#started) await this.#start()\n  }\n\n  /** Explicitly mark the session as started — writes a `session-start`\n   *  marker on a fresh session, `session-resume` on a hydrated one.\n   *  Idempotent; subsequent calls are no-ops. Optional `meta` is\n   *  applied via `update()` after the marker lands. */\n  async start(settings?: SessionUpdate): Promise<string | undefined> {\n    return this.#mutate(() => this.#start(settings))\n  }\n\n  async #start(settings?: SessionUpdate): Promise<string | undefined> {\n    if (this.#started)\n      return settings\n        ? this.#commit({ settings, type: \"session-settings\" })\n        : this.#store.root?.uuid\n    this.#started = true\n    const type = this.messages.length > 0 ? (\"session-resume\" as const) : (\"session-start\" as const)\n    await this.#commit({ type })\n    void this.emit(type)\n    await this.#commit({ settings: settings ?? {}, type: \"session-settings\" })\n    return this.#store.root?.uuid\n  }\n\n  /** Look up the decorated view for a node id — raw node plus the\n   *  cumulative meta as of that node's position. Returns the\n   *  message-typed view, or `undefined` if the id doesn't refer to a\n   *  message in this session. */\n  async node(id?: string | Message): Promise<(SessionNodeView & { type: \"message\" }) | undefined> {\n    const m = typeof id === \"string\" ? { id } : id\n    if (!m?.id) return undefined\n    const ret = this.#view.nodes.get(m.id)\n    return ret?.type === \"message\" ? ret : undefined\n  }\n\n  /** Current head uuid — the root of the store, which is the most\n   *  recently appended node. */\n  get head(): string | undefined {\n    return this.#head ?? this.#store.root?.uuid\n  }\n\n  /** Full DAG iterator — backed by `store.all()`. Yields raw nodes\n   *  (no meta decoration). */\n  nodes(): Iterable<SessionNode> | AsyncIterable<SessionNode> {\n    return this.#store.all?.() ?? []\n  }\n\n  get root(): SessionNode | undefined {\n    return this.#store.root\n  }\n\n  // ── Mutate ────────────────────────────────────────────────────────────\n\n  /** Append a message. The new node is parented to the current head,\n   *  head advances, and a `node` event fires. Optional `meta` carries\n   *  usage / model / finish info — populate it for assistant turns\n   *  the agent commits after a step. Returns the assigned uuid.\n   *\n   *  If `message.id` / `message.ts` are set (e.g. round-tripped from a\n   *  prior load), they're used as the node's uuid / timestamp; otherwise\n   *  fresh values are generated. The committed message always carries\n   *  both — `m.id === node.uuid` and `m.ts === node.ts`. */\n  async add(message: Message): Promise<string> {\n    const uuid = message.id ?? uuidv7()\n    const ts = message.ts ?? Date.now()\n    const m = { ...message, id: uuid, ts }\n    return this.#mutate(() => this.#commit({ message: m, type: \"message\" }))\n  }\n\n  /** Summarize an active prefix through a message ID, preserving everything\n   *  appended after it. Boundary validation and tail calculation share the\n   *  serialized commit with the new summary. Legacy tail-only calls remain\n   *  supported. Original history stays in the store; a fresh settings anchor\n   *  follows the compact node for reconstruction. */\n  async compact(opts: {\n    trigger?: \"manual\" | \"auto\"\n    preTokens?: number\n    durationMs?: number\n    /** Cancel a queued compaction before its commit begins. */\n    signal?: AbortSignal\n    /** Prefer an explicit boundary; tail-only calls remain supported. */\n    to?: string\n    /** Expected first message of the snapshot, including a prior summary if present. */\n    from?: string\n    tail?: number\n    summary: Message<\"system\">\n  }): Promise<string> {\n    return this.#mutate(async () => {\n      opts.signal?.throwIfAborted()\n      let tail = opts.tail\n      if (opts.to !== undefined) {\n        const index = this.messages.findIndex((m) => m.id === opts.to)\n        if (index === -1 || (opts.from !== undefined && this.messages[0]?.id !== opts.from)) {\n          throw new Error(\"Compaction snapshot is no longer part of the active history\")\n        }\n        tail = this.messages.length - index - 1\n      }\n      if (tail === undefined || !Number.isInteger(tail) || tail < 0) {\n        throw new Error(\"Compaction requires a message boundary or a non-negative integer tail\")\n      }\n      const compactUuid = await this.#commit({\n        durationMs: opts.durationMs,\n        from: opts.from,\n        preTokens: opts.preTokens,\n        summary: opts.summary,\n        tail,\n        to: opts.to,\n        trigger: opts.trigger ?? \"manual\",\n        type: \"compact\",\n      })\n      await this.#commit({ settings: {}, type: \"session-settings\" }, { force: true })\n      await this.#rebuild()\n      const node = this.#view.compact!\n      void this.emit(\"compact\", { node })\n      return compactUuid\n    })\n  }\n\n  async addMaskCheckpoint(opts: MaskCheckpoint): Promise<string> {\n    return this.#mutate(async () => {\n      this.#view.maskCheckpoint = opts\n      return this.#commit({ ...opts, type: \"mask-checkpoint\" })\n    })\n  }\n\n  async checkout(uuid: string): Promise<void> {\n    return this.#mutate(async () => {\n      if (this.#closed) throw new Error(\"Session is closed\")\n      this.#head = uuid\n      await this.#rebuild()\n    })\n  }\n\n  /** Pre-active history of the current chain — messages from before\n   *  the most recent compact (and earlier compacts), in chronological\n   *  order. Useful for TUI scrollback that wants to render context the\n   *  agent itself no longer sees.\n   *\n   *  `limit` truncates from the front (oldest), so the most recent\n   *  history messages always make it through. */\n  async history(limit?: number): Promise<readonly Message[]> {\n    const chain = await this.#chain({ active: false, limit })\n    return chain.messages\n  }\n\n  /** Flush + close the underlying store. Subsequent writes throw. */\n  async close(): Promise<void> {\n    return this.#mutate(async () => {\n      if (this.#closed) return\n      this.#closed = true\n      await this.#store.close?.()\n    })\n  }\n\n  // ── Internals ────────────────────────────────────────────────────────\n\n  // Keep commits and view rebuilds together so appends cannot race a compaction.\n  #mutate<R>(fn: () => Promise<R>): Promise<R> {\n    const pending = this.#mutations ? this.#mutations.then(fn) : fn()\n    const settled = pending.then(\n      () => {},\n      () => {}\n    )\n    this.#mutations = settled\n    void settled.then(() => {\n      if (this.#mutations === settled) this.#mutations = undefined\n    })\n    return pending\n  }\n\n  /** Atomically commit a node: register it in the store, update active\n   *  messages, persist, and emit. Single chokepoint for all mutations. */\n  async #commit(n: PartialNode, opts: { force?: boolean } = {}): Promise<string> {\n    let node: SessionNode = {\n      ...n,\n      parentUuid: this.head,\n      ts: n.type === \"message\" ? (n.message.ts ?? Date.now()) : Date.now(),\n      uuid: n.type === \"message\" ? (n.message.id ?? uuidv7()) : uuidv7(),\n    }\n\n    if (!this.#started && node.type !== \"session-start\" && node.type !== \"session-resume\") {\n      await this.#autostart()\n    }\n    if (this.#closed) throw new Error(\"Session is closed\")\n\n    const next: SessionSettings = {\n      ...this.#opts.defaults,\n      ...this.#settings,\n      ...(node.type === \"session-settings\" ? node.settings : {}),\n      sessionId: this.#id,\n      version: VERSION,\n    }\n    if (next.cwd) next.cwd = normPath(next.cwd)\n    if (next.workspace) next.workspace = normPath(next.workspace)\n\n    if (node.type === \"session-settings\") {\n      if (!opts.force && isDeepStrictEqual(this.#settings, next)) return this.#store.root!.uuid\n      node = { ...node, settings: next }\n    }\n\n    node = { ...node, parentUuid: this.head }\n    await this.#store.write(node)\n    this.#head = undefined // invalidate head cache so it reflects the store's root on next read\n\n    // Decorate the new node with cumulative meta and append to the\n    // active chain view\n    this.#view.nodes.set(node.uuid, { ...node, settings: next })\n    if (node.type === \"message\") this.#view.messages.push(node.message)\n\n    // cwd / meta event signaling\n    if (node.type === \"session-settings\") {\n      const prev = this.#settings\n      this.#settings = next\n      this.#emitChanges(prev)\n    }\n\n    void this.emit(\"node\", { node })\n    return node.uuid\n  }\n\n  #emitChanges(prev: SessionSettings): void {\n    const next = this.#settings\n    if (next.cwd && next.cwd !== prev.cwd) void this.emit(\"cwd\", { cwd: next.cwd, prev: prev.cwd })\n    if (next.modelId && next.modelId !== prev.modelId)\n      void this.emit(\"model\", { model: next.modelId, prev: prev.modelId })\n    if (next.reasoning && next.reasoning !== prev.reasoning)\n      void this.emit(\"reasoning\", { effort: next.reasoning, prev: prev.reasoning })\n  }\n\n  /** Walk `parentUuid` from the given node back toward the root,\n   *  returning the chain as decorated views (each with cumulative meta).\n   *  The `active` flag controls what counts:\n   *    - `true`      — only the active chain (stops at first compact /\n   *                    session-start, with the kept tail spliced in via\n   *                    the compact's `tail` field, summary substituted\n   *                    in place of the compact node).\n   *    - `false`     — includes everything back to the root\n   *  Returns chronological order. */\n  async #chain(\n    opts: {\n      active?: boolean\n      limit?: number\n      uuid?: string\n      stop?: (node: SessionNode) => boolean\n    } = {}\n  ): Promise<SessionView & { settings: SessionSettings }> {\n    // Backward pass: collect raw nodes (new to old)\n    const reverse: SessionNode[] = []\n    let cursor = opts.uuid ?? this.head\n    let limit = opts.limit ?? Infinity\n    let compact: SessionNode<\"compact\"> | undefined\n    const messageNodes: SessionNode<\"message\">[] = []\n    let maskCheckpoint: SessionNode<\"mask-checkpoint\"> | undefined\n\n    // Walk backward from the head until we hit a compact or the start, collecting nodes.\n    while (cursor) {\n      // eslint-disable-next-line no-await-in-loop\n      const node = await this.#store.get(cursor)\n      if (!node || (node.type === \"message\" && messageNodes.length + 1 > limit)) break\n      cursor = node.parentUuid\n      reverse.push(node)\n      // Keep track if the last mask-checkpoint, until we hit a compaction.\n      if (node.type === \"mask-checkpoint\" && !compact && !maskCheckpoint) maskCheckpoint = node\n      if (node.type === \"message\") messageNodes.push(node)\n      if (node.type === \"compact\" && (opts.active ?? true)) {\n        compact ??= node\n        // Earlier compactions may contain part of the kept tail. Walk through\n        // their preserved messages, but never resurrect their summarized history.\n        limit = Math.min(limit, messageNodes.length + node.tail)\n      }\n      if (opts.stop?.(node)) break\n    }\n\n    // Forward pass: decorate with cumulative meta. session-meta nodes\n    // redefine the meta; everything else inherits the running snapshot.\n    const nodes = new Map<string, SessionNodeView>()\n    let settings: SessionSettings = {}\n    for (const n of reverse.toReversed()) {\n      if (n.type === \"session-settings\") settings = n.settings\n      nodes.set(n.uuid, { ...n, settings })\n    }\n\n    this.#migrate(nodes)\n\n    const messages: SessionMessage[] = []\n    for (const n of messageNodes) {\n      // add `id`, `ts` and `modelId` (if assistant turn) to the message\n      const m = { ...n.message, id: n.uuid, ts: n.ts }\n      if (m.role === \"assistant\") {\n        // Add missing modelId to assistant messages if not present\n        const s = nodes.get(n.uuid)?.settings ?? {}\n        m.meta = { ...m.meta, modelId: m.meta?.modelId ?? s.modelId }\n      }\n      n.message = m\n      messages.push(m)\n    }\n\n    // Add compaction summary as the first message\n    if (compact) {\n      messages.push({ ...compact.summary, id: compact.uuid, ts: compact.ts })\n      nodes.set(compact.uuid, {\n        message: compact.summary,\n        parentUuid: compact.parentUuid,\n        settings: nodes.get(compact.uuid)?.settings ?? {},\n        ts: compact.ts,\n        type: \"message\",\n        uuid: compact.uuid,\n      })\n    }\n\n    return {\n      compact,\n      maskCheckpoint,\n      messages: messages.toReversed(),\n      nodes,\n      settings,\n    }\n  }\n\n  #migrate(nodes: Map<string, SessionNodeView>) {\n    for (const n of nodes.values()) {\n      const version = n.settings.version ?? 0\n      if (version === VERSION) continue\n      n.settings = { ...n.settings, version: VERSION }\n\n      if (n.type === \"compact\") {\n        n.summary.meta = { kind: \"compaction-summary\", ...n.summary.meta }\n        continue\n      }\n\n      if (n.type !== \"message\") continue\n      const m = n.message\n\n      if (\n        m.role === \"system\" &&\n        Array.isArray(m.content) &&\n        m.content[0].type === \"meta\" &&\n        m.content[0].tag === \"task\"\n      ) {\n        // Missing task meta data kind\n        m.meta = { kind: \"task\", ...m.meta }\n      }\n\n      n.message = m\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/{session-Cq52cam5.d.mts → session-WtXqtAaq.d.mts}

@@ -1,5 +1,5 @@
-import { Emitter } from "@zaly/shared";
 import { Message, ReasoningEffort } from "@zaly/ai";
+import { Emitter } from "@zaly/shared";
 /** A single node in the session DAG. Same shape on disk (JSONL) as in
  *  memory — what we persist *is* what we navigate. Session settings live ONLY on
  *  `session-settings` nodes as a full snapshot of the cumulative session
@@ -35,7 +35,11 @@ type SessionN = {
   preTokens?: number;
   /** How long the compactor took, ms. */
   durationMs?: number;
-  /** Number of message from before compaction that will be preserved */
+  /** Last active message covered by the summary. Absent on legacy entries. */
+  to?: string;
+  /** First active message in the summarized snapshot, used to reject stale summaries. */
+  from?: string;
+  /** Number of messages after the summary boundary at commit time. */
   tail: number;
   /** Frozen summary message that becomes the head of the active
    *  chain reconstruction. The full Message (not just text) so the
@@ -306,17 +310,22 @@ declare class Session<T extends SessionStore = SessionStore> extends Emitter<Ses
    *  fresh values are generated. The committed message always carries
    *  both — `m.id === node.uuid` and `m.ts === node.ts`. */
   add(message: Message): Promise<string>;
-  /** Mark a compaction boundary. Subsequent `add()` calls land after
-   *  this node; their messages form the new active conversation. The
-   *  pre-compact chain stays in the store but is no longer part of
-   *  `messages`. Also commits a fresh `session-meta` snapshot right
-   *  after the compact so post-compact lazy walks always have a nearby
-   *  meta anchor. */
+  /** Summarize an active prefix through a message ID, preserving everything
+   *  appended after it. Boundary validation and tail calculation share the
+   *  serialized commit with the new summary. Legacy tail-only calls remain
+   *  supported. Original history stays in the store; a fresh settings anchor
+   *  follows the compact node for reconstruction. */
   compact(opts: {
     trigger?: "manual" | "auto";
     preTokens?: number;
     durationMs?: number;
-    tail: number;
+    /** Cancel a queued compaction before its commit begins. */
+    signal?: AbortSignal;
+    /** Prefer an explicit boundary; tail-only calls remain supported. */
+    to?: string;
+    /** Expected first message of the snapshot, including a prior summary if present. */
+    from?: string;
+    tail?: number;
     summary: Message<"system">;
   }): Promise<string>;
   addMaskCheckpoint(opts: MaskCheckpoint): Promise<string>;
@@ -333,4 +342,4 @@ declare class Session<T extends SessionStore = SessionStore> extends Emitter<Ses
   close(): Promise<void>;
 }
 export { SessionStore as a, SessionEvents as c, SessionNode as d, SessionNodeView as f, SessionView as g, SessionUpdate as h, JsonlStore as i, SessionInit as l, SessionSettings as m, MemoryStore as n, MaskCheckpoint as o, SessionOptions as p, JsonlReader as r, PartialNode as s, Session as t, SessionMessage as u };
-//# sourceMappingURL=session-Cq52cam5.d.mts.map
+//# sourceMappingURL=session-WtXqtAaq.d.mts.map

package/dist/session-WtXqtAaq.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-WtXqtAaq.d.mts","names":[],"sources":["../src/session/types.ts","../src/session/store.ts","../src/session/jsonl.ts","../src/session/memory.ts","../src/session/session.ts"],"mappings":";;;;;;;;;KAYK;EACH;;EAEA;;EAEA;;EAEI;;EACA;;EACA;EAA0B,UAAU;;EACpC;EAAiB,SAAS;;EAC1B;EAAyB;EAAmB;;EAE5C;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;EAKA,SAAS;;KAGV,kBAAkB;KAEX;EAAmB;EAAmB;;KAEtC,iBAAiB;EAAY;EAAY;;KAEzC,YAAY,UAAU,kBAAkB,mBAAmB,QACrE;EACE,MAAM;;;;;KAME,kBAAkB;EAAgB,UAAU;;KAE5C;EACV,UAAU;EACV,OAAO,YAAY;EACnB,UAAU;EACV,iBAAiB;;KAGP;EACV;EACA;EACA;EACA;EACA;EACA,YAAY;;KAGF,gBAAgB,KAAK;KAE5B,iBAAiB,GAAG,UAAU,eAAe,oBAAoB,KAAK,GAAG;KAElE,cAAc,iBAAiB;;;KAM/B;EACV;IAAQ,MAAM;;EACd;IAAY;IAA0B,mBAAmB;;EACzD;IAAW,MAAM;;EAEjB;IAAO;IAAa;;EACpB;IAAS;IAAe;;EACxB;IAAa,QAAQ;IAAiB,OAAO;;EAE7C;EACA;;KAKU,eAAe,UAAU,eAAe;EAClD,QAAQ;;;;;EAKR;;;;;EAKA;;;EAGA,WAAW,KAAK;;KAGN,YAAY,UAAU,eAAe,gBAAgB;;;EAG/D,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;UCjGQ;;;WAGN,MAAM;;EAGf,MAAM,eAAe,QAAQ;;;;EAK7B,QAAQ,MAAM,gBAAgB;;EAG9B,cAAc;;;;EAKd,YAAY,SAAS,eAAe,cAAc;;;;;;;;;;;;;;cCvBvC,sBAAsB;;WACxB;EAKT,YAAY;;;;SAQC,KAAK,eAAe,QAAQ;MAmBrC,QAAQ;EAIN,IAAI,aAAa,QAAQ;EAIzB,MAAM,MAAM,cAAc;EAS1B,SAAS;EAIR,OAAO,cAAc;;cAMjB,YAAY;;WAMF;EAArB,YAAqB;UAsBN;EAgCT,QAAQ,QAAQ;EAMhB,SAAK;;;;;;;cC3IA,uBAAuB;;EAIlC,YAAY,QAAQ,SAAS;MAUzB,QAAQ;EAIN,IAAI,aAAa,QAAQ;EAIzB,MAAM,MAAM,cAAc;EAK/B,OAAO,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCoBN,QAAQ,UAAU,eAAe,sBAAsB,QAAQ;;YAajE,YAAa,MAAM,YAAY;;;;;;;SAe3B,KAAK,UAAU,eAAe,cACzC,MAAM,eAAe;IAAO,OAAO;MAClC,QAAQ,QAAQ;SACN,KAAK,MAAM;IAAmB;MAAiB,QAAQ,QAAQ;SAC/D,KAAK,OAAO,sBAAsB,QAAQ,QAAQ;iBAO1C;;;SAUR,YAAY,OAAM,iBAAsB,QAAQ;;;;MA4BzD,qBAAqB;MAIrB,kBAAkB;MAIlB;MAIA;MAIA;MAIA;;MAKA,YAAY;EAIV,OAAO,UAAU,eAAe;IAAS;MAAoB;;;;;EAe7D,MAAM,WAAW,gBAAgB;;;;;EAqBjC,KAAK,cAAc,UAAU,SAAS;IAAoB;;;;MAS5D;;;EAMJ,SAAS,SAAS,eAAe,cAAc;MAI3C,QAAQ;;;;;;;;;;EAeN,IAAI,SAAS,UAAU;;;;;;EAYvB,QAAQ;IACZ;IACA;IACA;;IAEA,SAAS;;IAET;;IAEA;IACA;IACA,SAAS;MACP;EAgCE,kBAAkB,MAAM,iBAAiB;EAOzC,SAAS,eAAe;;;;;;;;EAexB,QAAQ,iBAAiB,iBAAiB;;EAM1C,SAAS"}

package/dist/session.d.mts

@@ -1,4 +1,4 @@
-import { a as SessionStore, c as SessionEvents, d as SessionNode, f as SessionNodeView, g as SessionView, h as SessionUpdate, i as JsonlStore, l as SessionInit, m as SessionSettings, n as MemoryStore, o as MaskCheckpoint, p as SessionOptions, r as JsonlReader, s as PartialNode, t as Session, u as SessionMessage } from "./session-Cq52cam5.mjs";
+import { a as SessionStore, c as SessionEvents, d as SessionNode, f as SessionNodeView, g as SessionView, h as SessionUpdate, i as JsonlStore, l as SessionInit, m as SessionSettings, n as MemoryStore, o as MaskCheckpoint, p as SessionOptions, r as JsonlReader, s as PartialNode, t as Session, u as SessionMessage } from "./session-WtXqtAaq.mjs";
 import { Stats } from "node:fs";
 export type SessionInfo = {
   /** uuidv7 session id. Absent for non-managed external paths until the

package/dist/session.mjs

@@ -1,6 +1,6 @@
 import { n as isUuidv7Like, r as uuidv7 } from "./uuid-rfbQ9ad2.mjs";
+import { r as MemoryStore, t as Session } from "./session-C5ra-Hi1.mjs";
 import { n as JsonlStore, t as JsonlReader } from "./jsonl-BGt7eqPK.mjs";
-import { r as MemoryStore, t as Session } from "./session-C8zqqbPE.mjs";
 import { decodePath, encodePath, normPath, safeStatAsync } from "@zaly/shared";
 import { basename, dirname, join, relative } from "pathe";
 import { glob } from "@zaly/shared/glob";

package/dist/{src-C04Qk9KE.mjs → src-Di-H3Oya.mjs}

@@ -1,22 +1,18 @@
-import { n as __exportAll } from "./rolldown-runtime-DYf_mQCB.mjs";
-import { n as parseBash, t as TOOLS } from "./tools-DmoUYORG.mjs";
-import "./registry-CntkeXlo.mjs";
+import { n as __exportAll } from "./rolldown-runtime-BVN1G_yT.mjs";
+import "./registry-7mJQhyBA.mjs";
+import { n as parseBash, t as TOOLS } from "./tools-Ca7VsMg3.mjs";
+import { AiError, ContentTransform, attachmentToMeta, defineTool, errorToMeta, extractToolCalls, extractToolResults, metaToText, resolveReasoning, safeParseToolParams, sanitizeText, stringifyContent, toXml } from "@zaly/ai";
 import { Emitter, formatDuration, isInstance, normPath, prettyPath, safeReadFile, safeStatAsync, safeStringify, toError } from "@zaly/shared";
 import { LazyCache } from "@zaly/shared/cache";
 import { BaseCollection } from "@zaly/shared/collection";
 import { createRegistry } from "@zaly/shared/registry";
 import { basename, dirname } from "pathe";
-import { AiError, ContentTransform, attachmentToMeta, defineTool, errorToMeta, extractToolCalls, extractToolResults, metaToText, safeParseToolParams, sanitizeText, stringifyContent, toXml } from "@zaly/ai";
 import { glob } from "@zaly/shared/glob";
 import { readFile } from "node:fs/promises";
 import { isDeepStrictEqual } from "node:util";
 import { Type } from "typebox";
 // src/ctx.ts
-var ctx_exports = /* @__PURE__ */ __exportAll({
-	AgentContext: () => AgentContext,
-	createAgent: () => createAgent,
-	createAgentContext: () => createAgentContext
-});
+var ctx_exports = /* @__PURE__ */ __exportAll({ createAgent: () => createAgent });
 var AgentContext = class extends Emitter {
 	#agent;
 	#opts;
@@ -32,7 +28,7 @@ var AgentContext = class extends Emitter {
 		super();
 		this.#opts = opts;
 		this.#cwd = normPath(opts.cwd);
-		this.#reasoning = opts.request?.reasoning?.effort ?? "medium";
+		this.#reasoning = opts.request?.reasoning ?? "medium";
 		this.#session = opts.session;
 		this.#model = opts.model;
 		this.#skills = opts.skills;
@@ -98,14 +94,15 @@ var AgentContext = class extends Emitter {
 		return this.#agent;
 	}
 	get reasoning() {
-		return this.#reasoning;
+		return this.#model ? resolveReasoning(this.#model.spec, this.#reasoning) ?? "off" : this.#reasoning;
 	}
 	set reasoning(r) {
 		if (r === this.#reasoning) return;
-		const prev = this.#reasoning;
+		const prev = this.reasoning;
 		this.#reasoning = r;
-		this.emit("reasoning", {
-			effort: r,
+		const effort = this.reasoning;
+		if (effort !== prev) this.emit("reasoning", {
+			effort,
 			prev
 		});
 	}
@@ -141,11 +138,16 @@ var AgentContext = class extends Emitter {
 	set model(m) {
 		if (m === this.#model) return;
 		const prev = this.#model;
+		const reasoning = this.reasoning;
 		this.#model = m;
 		this.emit("model", {
 			model: m,
 			prev
 		});
+		if (this.reasoning !== reasoning) this.emit("reasoning", {
+			effort: this.reasoning,
+			prev: reasoning
+		});
 	}
 	set tools(tools) {
 		this.#tools = tools;
@@ -181,13 +183,13 @@ var AgentContext = class extends Emitter {
 	}
 	async masker() {
 		return this.#cache.want("masker", async (opts) => {
-			const { Masker } = await import("./masker-DEgR_ntk.mjs");
+			const { Masker } = await import("./masker-DWuL2Fjs.mjs");
 			return new Masker(this.agent, opts);
 		}, this.#opts.mask);
 	}
 	async permissions() {
 		return this.#cache.need("permissions", async (opts) => {
-			const { PermissionManager } = await import("./manager-1zEE5WiA.mjs");
+			const { PermissionManager } = await import("./manager-CEociHy_.mjs");
 			return new PermissionManager({
 				...opts,
 				cwd: this.cwd
@@ -198,7 +200,7 @@ var AgentContext = class extends Emitter {
 async function loadSession(spec) {
 	if (isInstance(spec)) return spec;
 	else {
-		const { Session } = await import("./session-C8zqqbPE.mjs").then((n) => n.n);
+		const { Session } = await import("./session-C5ra-Hi1.mjs").then((n) => n.n);
 		return await Session.load({ ...spec });
 	}
 }
@@ -210,7 +212,7 @@ async function createAgentContext(opts) {
 	});
 }
 async function createAgent(opts) {
-	const [{ Agent }, ctx] = await Promise.all([import("./agent-BRENvuvx.mjs"), createAgentContext(opts)]);
+	const [{ Agent }, ctx] = await Promise.all([import("./agent-GXRF7DUP.mjs"), createAgentContext(opts)]);
 	return new Agent(ctx);
 }
 const promptRegistry = createRegistry("prompt").from({
@@ -257,19 +259,19 @@ async function promptCollection() {
 const toolRegistry = createRegistry("tool").from({
 	agent_send: () => import("./swarm-D823Yumk.mjs").then((m) => m.agentSendTool),
 	agent_spawn: () => import("./swarm-D823Yumk.mjs").then((m) => m.agentSpawnTool),
-	bash: () => import("./bash-DSy03sAj.mjs").then((m) => m.bashTool),
-	edit: () => import("./edit-DT672zIy.mjs").then((m) => m.editTool),
-	fetch: () => import("./fetch-BrtIqrid.mjs").then((m) => m.fetchTool),
-	find: () => import("./find-B-vvdlHu.mjs").then((m) => m.findTool),
-	grep: () => import("./grep-rvZ5S319.mjs").then((m) => m.grepTool),
-	read: () => import("./read-C5keKntU.mjs").then((m) => m.readTool),
+	bash: () => import("./bash-CB_VXpyd.mjs").then((m) => m.bashTool),
+	edit: () => import("./edit-gkb6MCW-.mjs").then((m) => m.editTool),
+	fetch: () => import("./fetch-D_GzL2yy.mjs").then((m) => m.fetchTool),
+	find: () => import("./find-DlrYUTXT.mjs").then((m) => m.findTool),
+	grep: () => import("./grep-BI8Rou2q.mjs").then((m) => m.grepTool),
+	read: () => import("./read-DLtNq4XJ.mjs").then((m) => m.readTool),
 	search: () => import("./search-B-89W3SM.mjs").then((m) => m.searchTool),
-	subagent: () => import("./subagent-BbcxLzgC.mjs").then((m) => m.subagentTool),
-	task_list: () => import("./tasks-Dgsiuh0Q.mjs").then((m) => m.taskListTool),
-	task_poll: () => import("./tasks-Dgsiuh0Q.mjs").then((m) => m.taskPollTool),
-	task_stop: () => import("./tasks-Dgsiuh0Q.mjs").then((m) => m.taskStopTool),
+	subagent: () => import("./subagent-BOK4GFd4.mjs").then((m) => m.subagentTool),
+	task_list: () => import("./tasks-BUFqFoh6.mjs").then((m) => m.taskListTool),
+	task_poll: () => import("./tasks-BUFqFoh6.mjs").then((m) => m.taskPollTool),
+	task_stop: () => import("./tasks-BUFqFoh6.mjs").then((m) => m.taskStopTool),
 	wakeup: () => import("./wakeup-CFr1nu_L.mjs").then((m) => m.wakeupTool),
-	write: () => import("./write-BRQFfWAn.mjs").then((m) => m.writeTool)
+	write: () => import("./write-y93TC5ng.mjs").then((m) => m.writeTool)
 });
 var ToolCollection = class extends BaseCollection {
 	list() {
@@ -803,9 +805,34 @@ function fromText(text) {
 function sumTokens(stats) {
 	return stats.reduce((sum, s) => sum + s.tokens, 0);
 }
-function estimatePart(p) {
+function estimateReasoning(part, ctx) {
+	let reasoning = ctx.reasoning;
+	if (ctx.model) {
+		let requested = "medium";
+		if (typeof reasoning === "string") requested = reasoning;
+		else if (reasoning === false) requested = "off";
+		reasoning = resolveReasoning(ctx.model, requested);
+	}
+	if (!(reasoning !== "off" && reasoning !== false && (!ctx.model || ctx.model.reasoning === true))) return 0;
+	if (ctx.message?.role === "assistant") {
+		if (ctx.model && ctx.message.meta?.modelId !== ctx.model.id) return 0;
+		const parts = Array.isArray(ctx.message.content) ? ctx.message.content.filter((p) => p.type === "reasoning") : [];
+		if (!parts.includes(part)) throw new Error("Reasoning part not found in message content");
+		const signed = parts.filter((p) => p.signature);
+		const reported = ctx.message.meta?.usage?.reasoning;
+		if (signed.length && reported !== void 0 && Number.isFinite(reported) && reported >= 0) {
+			if (part !== signed.at(0)) return 0;
+			return reported;
+		}
+	}
+	return fromText(part.text);
+}
+function estimatePart(p, ctx = {}) {
 	switch (p.type) {
-		case "reasoning":
+		case "reasoning": return {
+			tokens: estimateReasoning(p, ctx),
+			type: p.type
+		};
 		case "text": return {
 			tokens: fromText(p.text),
 			type: p.type
@@ -816,7 +843,7 @@ function estimatePart(p) {
 			type: p.type
 		};
 		case "tool-result": {
-			const children = estimateContent(p.content);
+			const children = estimateContent(p.content, ctx);
 			return {
 				children,
 				kind: p.name,
@@ -832,7 +859,7 @@ function estimatePart(p) {
 			type: p.type
 		};
 		case "meta": return {
-			children: p.content ? estimateContent(p.content) : void 0,
+			children: p.content ? estimateContent(p.content, ctx) : void 0,
 			kind: p.tag,
 			tokens: fromText(stringifyContent(p)),
 			type: p.type
@@ -844,7 +871,7 @@ function estimatePart(p) {
 		default: throw new Error(`Unknown part type: ${p.type}`);
 	}
 }
-function estimateContent(content) {
+function estimateContent(content, ctx) {
 	if (typeof content === "string") return [{
 		tokens: fromText(content),
 		type: "text"
@@ -852,15 +879,18 @@ function estimateContent(content) {
 	let tokens = 0;
 	const children = [];
 	for (const p of content) {
-		const partStats = estimatePart(p);
+		const partStats = estimatePart(p, ctx);
 		tokens += partStats.tokens;
 		children.push(partStats);
 	}
 	return children;
 }
-function estimateMessage(m) {
+function estimateMessage(m, ctx) {
 	const type = m.role;
-	const children = estimateContent(m.content);
+	const children = estimateContent(m.content, {
+		...ctx,
+		message: m
+	});
 	return {
 		children,
 		kind: m.role === "system" ? m.meta?.kind : void 0,
@@ -876,7 +906,7 @@ function estimatePrompt(prompt, tools) {
 	}));
 	children.push(...tools?.map((t) => ({
 		kind: t.name,
-		tokens: fromText(t.name) + fromText(JSON.stringify(t.params ?? {})),
+		tokens: fromText(t.name) + fromText(t.desc ?? "") + fromText(JSON.stringify(t.params ?? {})),
 		type: "tool-schema"
 	})) ?? []);
 	return {
@@ -914,8 +944,8 @@ function tokenStats(msgs, opts = {}) {
 		tokens: 0
 	};
 	const counts = [];
-	if (opts.prompt) counts.push(estimatePrompt(opts.prompt, opts.tools));
-	counts.push(...msgs.map(estimateMessage));
+	if (opts.prompt || opts.tools) counts.push(estimatePrompt(opts.prompt ?? [], opts.tools));
+	counts.push(...msgs.map((message) => estimateMessage(message, opts)));
 	for (const stats of counts) {
 		root.tokens += stats.tokens;
 		root.count++;
@@ -946,4 +976,4 @@ function fmt(n) {
 }
 export { ctx_exports as _, extractConversation as a, formatFileUsage as c, Commands as d, toolCollection as f, createAgent as g, promptRegistry as h, extractBashUsage as i, messageTail as l, promptCollection as m, formatTokenStats as n, extractFileUsage as o, toolRegistry as p, tokenStats as r, formatBashUsage as s, estimatePart as t, Skills as u };
 
-//# sourceMappingURL=src-C04Qk9KE.mjs.map
+//# sourceMappingURL=src-Di-H3Oya.mjs.map