@zaly/agent 0.0.6 → 0.0.10

package/dist/src-fK6DL2bg.mjs

@@ -0,0 +1,953 @@
+import { i as __exportAll, n as parseBash, t as TOOLS } from "./tools-wvkkuXWH.mjs";
+import "./registry-L9GDccS0.mjs";
+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";
+//#region src/ctx.ts
+var ctx_exports = /* @__PURE__ */ __exportAll({
+	AgentContext: () => AgentContext,
+	createAgent: () => createAgent,
+	createAgentContext: () => createAgentContext
+});
+var AgentContext = class extends Emitter {
+	#agent;
+	#opts;
+	#model;
+	#session;
+	#reasoning;
+	#cwd;
+	#cache = new LazyCache();
+	#tools;
+	#skills;
+	#prompt;
+	constructor(opts) {
+		super();
+		this.#opts = opts;
+		this.#cwd = normPath(opts.cwd);
+		this.#reasoning = opts.request?.reasoning?.effort ?? "medium";
+		this.#session = opts.session;
+		this.#model = opts.model;
+		this.#skills = opts.skills;
+		this.#prompt = opts.prompt ?? [];
+		this.#tools = opts.tools ?? [];
+		this.onEmitError = (error) => this.#opts.logger?.child("context").error(error);
+		this.on("model", async ({ model }) => {
+			if (!this.#session.started) return;
+			if (model) await this.session.update({ modelId: model.id });
+		}).on("reasoning", async ({ effort }) => {
+			if (!this.#session.started) return;
+			await this.session.update({ reasoning: effort });
+		}).on("cwd", ({ cwd }) => {
+			if (!this.#session.started) return;
+			this.#cache.forget("permissions");
+			this.session.update({ cwd });
+		});
+	}
+	async start() {
+		const [_masker, notifier] = await Promise.all([this.masker(), this.notifier()]);
+		if (!this.model) throw new Error("model is required to start agent session");
+		if (notifier) notifier.attach(this.agent);
+		await this.session.start({
+			cwd: this.cwd,
+			modelId: this.model.id,
+			reasoning: this.reasoning
+		});
+		for (const m of this.#opts.messages ?? []) await this.session.add(m);
+	}
+	attach(agent) {
+		if (this.#agent === agent) return;
+		if (this.#agent) throw new Error("agent already attached to context");
+		if (agent.started) throw new Error("cannot attach agent that has already started");
+		this.#agent = agent;
+		agent.once("start", () => this.start());
+	}
+	get messages() {
+		return this.session.messages;
+	}
+	get status() {
+		return this.#agent?.status;
+	}
+	get opts() {
+		return this.#opts;
+	}
+	get cwd() {
+		return this.#cwd;
+	}
+	set cwd(c) {
+		if (c === this.#cwd) return;
+		const prev = this.#cwd;
+		this.#cwd = normPath(c);
+		this.emit("cwd", {
+			cwd: this.#cwd,
+			prev
+		});
+	}
+	get signal() {
+		return this.#agent?.signal;
+	}
+	get agent() {
+		if (!this.#agent) throw new Error("agent not attached to context");
+		return this.#agent;
+	}
+	get reasoning() {
+		return this.#reasoning;
+	}
+	set reasoning(r) {
+		if (r === this.#reasoning) return;
+		const prev = this.#reasoning;
+		this.#reasoning = r;
+		this.emit("reasoning", {
+			effort: r,
+			prev
+		});
+	}
+	get session() {
+		return this.#session;
+	}
+	async useSession(s) {
+		const prev = this.#session;
+		this.#session = s;
+		const modelId = s.settings.modelId;
+		if (modelId && modelId !== this.model?.id) {
+			if (this.#opts.loadModel) this.model = await this.#opts.loadModel(modelId);
+			else {
+				const { loadModel } = await import("@zaly/ai");
+				this.model = await loadModel(modelId);
+			}
+		}
+		this.cwd = s.settings.cwd ?? this.cwd;
+		this.reasoning = s.settings.reasoning ?? this.reasoning;
+		await this.emit("session", {
+			prev,
+			session: s
+		});
+		if (this.#agent?.started) await s.start({
+			cwd: this.cwd,
+			modelId: this.model?.id,
+			reasoning: this.reasoning
+		});
+	}
+	get model() {
+		return this.#model;
+	}
+	set model(m) {
+		if (m === this.#model) return;
+		const prev = this.#model;
+		this.#model = m;
+		this.emit("model", {
+			model: m,
+			prev
+		});
+	}
+	set tools(tools) {
+		this.#tools = tools;
+	}
+	get tools() {
+		return [...this.#tools, ...this.skills?.tool ? [this.skills.tool] : []];
+	}
+	get prompt() {
+		return this.#prompt;
+	}
+	set prompt(p) {
+		this.#prompt = p;
+	}
+	async swarm() {
+		return this.#cache.need("swarm", async () => {
+			const { Swarm } = await import("./swarm-BJ3gQA1Z.mjs");
+			return new Swarm();
+		}, this.#opts.swarm);
+	}
+	set skills(s) {
+		if (s === this.#skills) return;
+		this.#skills = s;
+		this.emit("skills", { skills: s });
+	}
+	get skills() {
+		return this.#skills;
+	}
+	async notifier() {
+		return this.#cache.want("notifier", async (opts) => {
+			const { Notifier } = await import("./notify-DpG_m9iP.mjs");
+			return new Notifier(opts);
+		}, this.#opts.notify);
+	}
+	async masker() {
+		return this.#cache.want("masker", async (opts) => {
+			const { Masker } = await import("./masker-DRFztUwc.mjs");
+			return new Masker(this.agent, opts);
+		}, this.#opts.mask);
+	}
+	async permissions() {
+		return this.#cache.need("permissions", async (opts) => {
+			const { PermissionManager } = await import("./manager-BqlbCGYV.mjs");
+			return new PermissionManager({
+				...opts,
+				cwd: this.cwd
+			});
+		}, this.#opts.permissions);
+	}
+};
+async function loadSession(spec) {
+	if (isInstance(spec)) return spec;
+	else {
+		const { Session } = await import("./session-BSvUrr12.mjs").then((n) => n.n);
+		return await Session.load({ ...spec });
+	}
+}
+async function createAgentContext(opts) {
+	const session = await loadSession(opts.session);
+	return new AgentContext({
+		...opts,
+		session
+	});
+}
+async function createAgent(opts) {
+	const [{ Agent }, ctx] = await Promise.all([import("./agent-D3wVIibN.mjs"), createAgentContext(opts)]);
+	return new Agent(ctx);
+}
+const promptRegistry = createRegistry("prompt").from({
+	"AGENTS.md": (ctx) => import("./markdown-Bv4J8cg3.mjs").then((m) => m.agentsMdPrompt(ctx)),
+	"MEMORY.md": (ctx) => import("./markdown-Bv4J8cg3.mjs").then((m) => m.memoryMdPrompt(ctx)),
+	agent: () => import("./agent-B7cQOuMZ.mjs").then((m) => m.agentPrompt),
+	env: (ctx) => import("./env-UUFv5Mye.mjs").then((m) => m.prompt(ctx)),
+	model: (ctx) => import("./model-_3ZA2xqm.mjs").then((m) => m.prompt(ctx))
+});
+var PromptCollection = class extends BaseCollection {
+	list() {
+		const ret = /* @__PURE__ */ new Map();
+		for (const k of promptRegistry.keys()) ret.set(k, {
+			name: k,
+			text: (ctx) => promptRegistry.load(k, ctx)
+		});
+		for (const r of this.registered) ret.set(r.name, r);
+		return [...ret.values()];
+	}
+	async render(ctx) {
+		const all = new Map(this.list().map((p) => [p.name, p]));
+		return (await Promise.all((ctx.prompts ?? this.active).map(async (p) => {
+			const def = all.get(p);
+			if (!def) throw new Error(`Unknown prompt: ${p}`);
+			return {
+				name: def.name,
+				text: typeof def.text === "string" ? def.text : await def.text(ctx)
+			};
+		}))).map((p) => ({
+			name: p.name,
+			text: p.text.trim()
+		})).filter((p) => p.text.length > 0);
+	}
+};
+async function promptCollection() {
+	return new PromptCollection([
+		"agent",
+		"env",
+		"model",
+		"AGENTS.md",
+		"MEMORY.md"
+	]);
+}
+const toolRegistry = createRegistry("tool").from({
+	agent_send: () => import("./swarm-BuFx_xeY.mjs").then((m) => m.agentSendTool),
+	agent_spawn: () => import("./swarm-BuFx_xeY.mjs").then((m) => m.agentSpawnTool),
+	bash: () => import("./bash-COgq4W7U.mjs").then((m) => m.bashTool),
+	edit: () => import("./edit-D4yaBK1K.mjs").then((m) => m.editTool),
+	fetch: () => import("./fetch-VKhSWdEh.mjs").then((m) => m.fetchTool),
+	find: () => import("./find-CimUGn-L.mjs").then((m) => m.findTool),
+	grep: () => import("./grep-6O3mjSvV.mjs").then((m) => m.grepTool),
+	read: () => import("./read-CSL_8nAk.mjs").then((m) => m.readTool),
+	search: () => import("./search-CRw247ES.mjs").then((m) => m.searchTool),
+	subagent: () => import("./subagent-C8XCEecM.mjs").then((m) => m.subagentTool),
+	task_list: () => import("./tasks-BA-PCeGa.mjs").then((m) => m.taskListTool),
+	task_poll: () => import("./tasks-BA-PCeGa.mjs").then((m) => m.taskPollTool),
+	task_stop: () => import("./tasks-BA-PCeGa.mjs").then((m) => m.taskStopTool),
+	wakeup: () => import("./wakeup-BYqTnfSp.mjs").then((m) => m.wakeupTool),
+	write: () => import("./write-DwGiDNeG.mjs").then((m) => m.writeTool)
+});
+var ToolCollection = class extends BaseCollection {
+	list() {
+		const ret = new Set(toolRegistry.keys());
+		for (const r of this.registered) ret.add(r.name);
+		return [...ret];
+	}
+	async load(tools) {
+		const load = async (t) => this.registered.findLast((r) => r.name === t) ?? toolRegistry.load(t);
+		return await Promise.all((tools ?? this.active).map((t) => load(t)));
+	}
+};
+async function toolCollection() {
+	return new ToolCollection([]);
+}
+//#endregion
+//#region src/commands.ts
+const BASH_RE = /^!`(.*)`$/;
+var Commands = class {
+	#opts;
+	catalog = /* @__PURE__ */ new Map();
+	#logger;
+	constructor(opts = {}) {
+		this.#opts = opts;
+		this.#logger = opts.logger;
+	}
+	async load() {
+		const paths = this.#opts.paths ?? [];
+		await Promise.all(paths.map(async (path) => await this.add(path)));
+		return this;
+	}
+	async add(path) {
+		path = normPath(path);
+		const name = basename(path, ".md");
+		const { parseFrontmatter } = await import("@zaly/shared/yaml");
+		try {
+			const content = await safeReadFile(path);
+			if (!content) throw new Error(`Failed to read command file at ${path}`);
+			const { fm, body } = await parseFrontmatter(content);
+			const args = {};
+			const fmArgs = fm.args ?? {};
+			for (const [o, opt] of Object.entries(fmArgs)) {
+				if (opt.type === "boolean") opt.default ??= false;
+				else if (opt.type === "string") opt.required ??= opt.default === void 0;
+				else {
+					this.#logger?.warn(`Unsupported argument type for \`--${o}\` in command **${name}** at \`${prettyPath(path)}\`\nOnly \`string\` and \`boolean\` are supported. Skipping this argument.`);
+					continue;
+				}
+				args[o] = opt;
+			}
+			const cmd = {
+				...fm,
+				args,
+				body,
+				name,
+				path
+			};
+			if (this.catalog.has(name)) return;
+			this.catalog.set(name, cmd);
+		} catch (error) {
+			this.#logger?.error(`Error loading **command** from ${path}: ${error.message}`);
+		}
+	}
+	get(name) {
+		return this.catalog.get(name);
+	}
+	async format(input, cmd) {
+		let args;
+		if (typeof input === "string") {
+			const { argsParse } = await import("@zaly/shared/args");
+			args = await argsParse(input, cmd.args);
+		} else args = input;
+		const { createTemplate } = await import("@zaly/shared/template");
+		const rendered = createTemplate(cmd.body, {
+			expr: this.#opts.expr,
+			format: (value) => {
+				if (value === args._) return args._.join(" ");
+			},
+			name: cmd.name
+		})({
+			...args,
+			args: args._,
+			raw: args.$
+		});
+		if (this.#opts.bash === false) return rendered;
+		const bash = Array.isArray(this.#opts.bash) ? this.#opts.bash : ["bash"];
+		const lines = rendered.split("\n");
+		const ret = [];
+		for (const token of this.#tokenize(lines, cmd)) {
+			let text;
+			if (token.type === "script") text = await exec(token.value, { bash });
+			else if (token.type === "block" && /^bash\s*!$/.test(token.lang ?? "")) text = await exec(token.body, { bash });
+			ret.push(text ?? token.value);
+		}
+		return ret.join("\n");
+	}
+	*#tokenize(lines, cmd) {
+		let block = [];
+		let marker = void 0;
+		let lang = void 0;
+		for (const line of lines) {
+			const m = line.match(/^\s*(`{3,}|~{3,})(.*)$/);
+			const script = line.match(BASH_RE);
+			if (marker && line.match(marker)) {
+				block.push(line);
+				yield {
+					body: block.slice(1, -1).join("\n"),
+					lang,
+					type: "block",
+					value: block.join("\n")
+				};
+				marker = void 0;
+			} else if (!marker && m) {
+				marker = new RegExp(`^\\s*${m[1]}\\s*$`);
+				lang = m[2].trim() || void 0;
+				block = [line];
+			} else if (marker) block.push(line);
+			else if (script) yield {
+				type: "script",
+				value: script[1]
+			};
+			else yield {
+				type: "text",
+				value: line
+			};
+		}
+		if (marker) throw new Error(`Unclosed code block in command **${cmd.name}**`);
+	}
+};
+async function exec(script, opts = {}) {
+	if (!script.trim()) return;
+	const { spawnCmd } = await import("@zaly/shared/process");
+	let result;
+	try {
+		result = (await spawnCmd(script, {
+			bash: opts.bash ?? true,
+			throw: true
+		}))?.trim() ?? "";
+	} catch (error) {
+		result = toError(error).message.trim();
+	}
+	const md = [];
+	if (script.includes("\n")) {
+		md.push("```bash");
+		md.push(script);
+		md.push("```");
+		md.push("");
+		md.push("```shellsession");
+		md.push(result);
+		md.push("```");
+	} else {
+		md.push("```shellsession");
+		md.push(`$ ${script}`);
+		md.push(result);
+		md.push("```");
+	}
+	md.push("");
+	return md.join("\n");
+}
+//#endregion
+//#region src/skills.ts
+var Skills = class Skills {
+	catalog = /* @__PURE__ */ new Map();
+	#tool;
+	#opts;
+	constructor(opts = {}) {
+		this.#opts = opts;
+	}
+	static async load(opts) {
+		return new Skills(opts).reload();
+	}
+	/** (Re)scan project + user `.agent/skills/` directories. Wipes the
+	*  current catalog and the cached tool, then repopulates. Safe to
+	*  call mid-session — agent uses `this.tool` per-step so the next
+	*  request after reload picks up the change. */
+	async reload() {
+		this.catalog.clear();
+		this.#tool = void 0;
+		const paths = this.#opts.paths ?? [];
+		const skills = await Promise.all(paths.map(async (path) => await this.#load(path)));
+		for (const skill of skills) if (skill && !this.catalog.has(skill.name)) this.catalog.set(skill.name, skill);
+		return this;
+	}
+	async #load(path) {
+		if (!path.endsWith("SKILL.md")) return;
+		const dir = dirname(path);
+		try {
+			const { meta, mtime, body } = await readSkill(path);
+			if (!meta.name || !meta.description || this.catalog.has(meta.name)) return;
+			return {
+				body,
+				desc: meta.description,
+				dir,
+				mtime,
+				name: meta.name,
+				path
+			};
+		} catch {}
+	}
+	async #update(entry) {
+		const updated = await this.#load(entry.path) ?? entry;
+		if (isDeepStrictEqual(updated, entry)) return entry;
+		this.catalog.set(entry.name, updated);
+		this.#tool = void 0;
+		return updated;
+	}
+	/** Skill base directories — pass each to `agent.permissions.addWorkspace`
+	*  so the model can read bundled `references/` files without tripping
+	*  permission asks. */
+	get dirs() {
+		return [...this.catalog.values()].map((s) => s.dir);
+	}
+	/** The activation tool. Returns `undefined` when the catalog is empty
+	*  (the agent then omits skills entirely from the model's tool list,
+	*  per the spec). Lazily built on first access; invalidated by
+	*  `load()`. */
+	get tool() {
+		if (this.catalog.size === 0) return void 0;
+		return this.#tool ??= this.#buildTool();
+	}
+	#buildTool() {
+		const names = [...this.catalog.keys()];
+		return defineTool({
+			name: "skill",
+			desc: this.#buildCatalogDesc(),
+			parallel: true,
+			params: Type.Object({ name: Type.Union(names.map((n) => Type.Literal(n)), { description: "Name of the skill to activate. The full SKILL.md instructions are loaded as the tool result; bundled files in the skill's directory are listed but not read — fetch them via the `read` tool when the skill's instructions require them." }) }),
+			call: (args, ctx) => this.#call(args.name, ctx)
+		});
+	}
+	async #call(requested, ctx) {
+		let skill = this.catalog.get(requested);
+		if (!skill) {
+			const available = [...this.catalog.keys()];
+			throw new AiError({
+				code: "UNKNOWN_SKILL",
+				data: {
+					available,
+					name: requested
+				},
+				message: `no skill named "${requested}". Available: ${available.join(", ")}`
+			});
+		}
+		skill = await this.#update(skill);
+		ctx.meta = {
+			desc: skill.desc,
+			mtime: skill.mtime,
+			name: skill.name,
+			path: skill.path
+		};
+		if (await this.isActivated(skill, ctx)) {
+			ctx.meta.unchanged = true;
+			return [{
+				content: `skill "${skill.name}" unchanged since last read: ${skill.path}`,
+				tag: "unchanged",
+				type: "meta"
+			}];
+		}
+		const references = await listReferences(skill.dir);
+		return [{
+			data: {
+				dir: skill.dir,
+				name: skill.name,
+				references
+			},
+			tag: "skill",
+			type: "meta"
+		}, {
+			text: skill.body,
+			type: "text"
+		}];
+	}
+	async isActivated(skill, ctx) {
+		const messages = ctx.messages ?? [];
+		for (const { m, $p, p } of extractToolResults(messages, ["skill"])) {
+			const id = m.id;
+			if (!id || !p.meta || ctx.isMasked?.(id, $p)) continue;
+			if (p.meta.unchanged) continue;
+			if (p.meta.name === skill.name) return p.meta.mtime === skill.mtime;
+		}
+		return false;
+	}
+	async activate(name, agent) {
+		const ret = await agent.useTool("skill", { name }, `Skill "${name}" was activated by the user.`);
+		if (ret.result.meta?.unchanged) return;
+		return ret;
+	}
+	#buildCatalogDesc() {
+		return `Activate one of the available skills below. The skill's full SKILL.md instructions are loaded as the tool result; the model should follow them directly. Bundled files are listed in the result but not eagerly read — fetch the ones the skill's instructions reference via the \`read\` tool.\n\nAvailable skills:\n${[...this.catalog.values()].map((s) => `- ${s.name}: ${s.desc}`).join("\n")}`;
+	}
+};
+async function readSkill(path) {
+	const s = await safeStatAsync(path);
+	if (!s?.isFile()) throw new Error(`Skill file not found at ${path}`);
+	const raw = await readFile(path, "utf8");
+	const { parseFrontmatter } = await import("@zaly/shared/yaml");
+	const { fm, body } = await parseFrontmatter(raw);
+	return {
+		body,
+		meta: fm,
+		mtime: s.mtimeMs
+	};
+}
+async function listReferences(dir) {
+	const out = [];
+	for await (const rel of glob("**", {
+		cwd: dir,
+		depth: 4,
+		type: "file"
+	})) {
+		if (rel === "SKILL.md" || rel.endsWith("/SKILL.md")) continue;
+		out.push(rel);
+		if (out.length >= 200) break;
+	}
+	return out.toSorted();
+}
+//#endregion
+//#region src/compaction/utils.ts
+const LAMBDA = Math.LN2 / 60;
+const KIND_WEIGHTS = {
+	edit: 2,
+	read: 1,
+	write: 3
+};
+const sorters = {
+	count: (a, b) => b[1].count - a[1].count,
+	key: (a, b) => a[0].localeCompare(b[0]),
+	score: (a, b) => b[1].score - a[1].score
+};
+function turnInfo(messages) {
+	const weights = [];
+	const turns = [];
+	let turn = 0;
+	for (let i = messages.length - 1; i >= 0; i--) {
+		if (messages[i].role === "assistant") turn++;
+		weights[i] = Math.exp(-LAMBDA * turn);
+		turns[i] = turn;
+	}
+	return {
+		turns,
+		weights
+	};
+}
+function toolStats(map, opts = {}) {
+	const limit = opts.limit ?? 50;
+	const sorter = sorters[opts.sort ?? "score"];
+	return [...map.entries()].toSorted(sorter).map(([, stat]) => stat).filter((stat) => stat.count >= (opts.minCount ?? 1)).filter((stat) => stat.score >= (opts.minScore ?? 0)).slice(0, limit);
+}
+/** Walk assistant tool-calls for `read` / `write` / `edit` and tally
+*  per-path activity with frecency-weighted scoring. Returns the top-N
+*  by score. Each entry carries the per-kind breakdown so the
+*  summarizer can describe the *kind* of activity ("heavily edited",
+*  "read once, then written", "iteratively refined").
+*
+*  Paths are canonicalized via the cwd recorded on each call's session
+*  node — relative paths are resolved against the cwd that was active
+*  when the call ran, and `~` is expanded. Calls under different cwds
+*  that target the same file thus collapse into one bucket. */
+function extractFileUsage(messages, opts = {}) {
+	opts = {
+		minScore: .5,
+		...opts
+	};
+	const map = /* @__PURE__ */ new Map();
+	const { turns, weights } = turnInfo(messages);
+	for (const { m, p, $m: idx } of extractToolResults(messages, [
+		"read",
+		"write",
+		"edit"
+	])) {
+		const path = p.meta?.path;
+		if (!path) continue;
+		const entry = map.get(path) ?? {
+			count: 0,
+			edits: 0,
+			lastTs: 0,
+			lastTurn: Infinity,
+			path,
+			reads: 0,
+			score: 0,
+			writes: 0
+		};
+		if (p.name === "read") entry.reads++;
+		else if (p.name === "write") entry.writes++;
+		else entry.edits++;
+		entry.count++;
+		entry.score += weights[idx] * KIND_WEIGHTS[p.name];
+		if (turns[idx] < entry.lastTurn) entry.lastTurn = turns[idx];
+		if (m.ts && m.ts > entry.lastTs) entry.lastTs = m.ts;
+		map.set(path, entry);
+	}
+	return toolStats(map, opts);
+}
+/** Walk assistant tool-calls for `bash`, parse each command line, and
+*  tally per-command frecency. Plumbing commands (cat, head, grep, awk,
+*  sed, …) are filtered out — they dominate raw counts but carry no
+*  operational signal a summarizer would describe. Returns the top-N
+*  by frecency `score`. */
+function extractBashUsage(messages, opts = {}) {
+	opts = {
+		minCount: 2,
+		minScore: .5,
+		...opts
+	};
+	const { turns, weights } = turnInfo(messages);
+	const map = /* @__PURE__ */ new Map();
+	for (const { m, p, $m: idx } of extractToolCalls(messages, ["bash"])) {
+		const cmd = safeParseToolParams(p.params)?.command;
+		if (!cmd) continue;
+		const result = parseBash(cmd);
+		if (!result.ok) continue;
+		const w = weights[idx] ?? 0;
+		const t = turns[idx] ?? Infinity;
+		for (const seg of result.segments) {
+			if (TOOLS[seg.cmd]) continue;
+			const key = `${seg.cmd} ${seg.args.join(" ")}`;
+			if (key.includes("\n")) continue;
+			const entry = map.get(key) ?? {
+				command: key,
+				count: 0,
+				lastTs: 0,
+				lastTurn: Infinity,
+				score: 0
+			};
+			entry.count++;
+			entry.score += w;
+			if (t < entry.lastTurn) entry.lastTurn = t;
+			if (m.ts && m.ts > entry.lastTs) entry.lastTs = m.ts;
+			map.set(key, entry);
+		}
+	}
+	return toolStats(map, opts);
+}
+function truncate(text, len) {
+	return text.length <= len ? text : `${text.slice(0, len)}…`;
+}
+/** Flatten a list of messages into a single tagged transcript. */
+function extractConversation(messages, opts = {}) {
+	const transform = ContentTransform.create().drop("reasoning").map("tool-call", (part) => ({
+		content: [{
+			text: `${part.name}(${safeStringify(part.params)})`,
+			type: "text"
+		}],
+		tag: "tool-call",
+		type: "meta"
+	})).map("tool-result", (part) => {
+		const text = truncate(stringifyContent(part.content), opts.maxToolResultLen ?? 2e3);
+		return {
+			content: text === "" ? void 0 : [{
+				text,
+				type: "text"
+			}],
+			data: {
+				tool: part.name,
+				...part.isError ? { error: true } : {}
+			},
+			tag: "tool-result",
+			type: "meta"
+		};
+	}).pipe(attachmentToMeta("image", "pdf", "audio", "video")).pipe(errorToMeta()).pipe(metaToText()).pipe(sanitizeText());
+	const blocks = [];
+	let role = void 0;
+	for (const m of messages) {
+		const parts = typeof m.content === "string" ? [{
+			text: m.content,
+			type: "text"
+		}] : m.content;
+		const transformed = transform.runSync(parts);
+		const text = stringifyContent(transformed).trim();
+		if (!text) continue;
+		let currentRole = m.role.charAt(0).toUpperCase() + m.role.slice(1);
+		currentRole = currentRole === "Tool" ? "Assistant" : currentRole;
+		blocks.push(role === currentRole ? text : `\n[${currentRole}]: ${text}`);
+		role = currentRole;
+	}
+	const text = blocks.join("\n").replace(/^\s+$/gm, "").trim();
+	return toXml(text, "conversation", { indent: false });
+}
+function messageTail(messages, opts) {
+	const maxTokens = opts.keepTokens ?? 2e4;
+	messages = messages.toReversed();
+	const tail = [];
+	const queue = [];
+	let used = 0;
+	let last = void 0;
+	for (const m of messages) {
+		queue.unshift(m);
+		const usage = m.role === "assistant" ? m.meta?.usage : void 0;
+		if (!usage) continue;
+		const current = usage.input + usage.output + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
+		const delta = Math.max(0, (last ?? current) - current);
+		if (used + delta > maxTokens) break;
+		used += delta;
+		last = current;
+		tail.unshift(...queue.splice(0));
+	}
+	return tail;
+}
+const lastCol = (lastTurn, lastTs) => {
+	return `${lastTurn === Infinity ? "?" : `${lastTurn}t`} / ${lastTs > 0 ? formatDuration(lastTs) : "?"}`;
+};
+function formatBashUsage(commands) {
+	if (commands.length === 0) return "(no bash commands found)";
+	const lines = [];
+	lines.push("=== Top bash commands (sorted by frecency) ===");
+	lines.push(`  ${"score".padStart(7)}  ${"count".padStart(5)}  ${"last".padEnd(14)}  command`);
+	for (const c of commands) lines.push(`  ${c.score.toFixed(2).padStart(7)}  ${String(c.count).padStart(5)}  ${lastCol(c.lastTurn, c.lastTs).padEnd(14)}  ${c.command}`);
+	const text = lines.join("\n");
+	return toXml(text, "bash-commands", { indent: false });
+}
+function formatFileUsage(files) {
+	if (files.length === 0) return "(no file ops found)";
+	const lines = [];
+	lines.push("=== Top files touched (sorted by frecency) ===");
+	lines.push(`  ${"score".padStart(7)}  ${"total".padStart(5)}  r/w/e         ${"last".padEnd(14)}  path`);
+	for (const f of files) {
+		const rwe = `${f.reads}/${f.writes}/${f.edits}`.padEnd(12);
+		lines.push(`  ${f.score.toFixed(2).padStart(7)}  ${String(f.count).padStart(5)}  ${rwe}  ${lastCol(f.lastTurn, f.lastTs).padEnd(14)}  ${f.path}`);
+	}
+	const text = lines.join("\n");
+	return toXml(text, "files", { indent: false });
+}
+//#endregion
+//#region src/context/tokens.ts
+const CHARS_PER_TOKEN = 4;
+const ATTACHMENT_TOKENS = {
+	audio: 3e3,
+	image: 1500,
+	pdf: 8e3,
+	video: 5e3
+};
+function fromText(text) {
+	return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function sumTokens(stats) {
+	return stats.reduce((sum, s) => sum + s.tokens, 0);
+}
+function estimatePart(p) {
+	switch (p.type) {
+		case "reasoning":
+		case "text": return {
+			tokens: fromText(p.text),
+			type: p.type
+		};
+		case "tool-call": return {
+			kind: p.name,
+			tokens: fromText(p.name) + fromText(JSON.stringify(p.params ?? {})),
+			type: p.type
+		};
+		case "tool-result": {
+			const children = estimateContent(p.content);
+			return {
+				children,
+				kind: p.name,
+				tokens: fromText(p.name) + sumTokens(children),
+				type: p.type
+			};
+		}
+		case "image":
+		case "pdf":
+		case "audio":
+		case "video": return {
+			tokens: ATTACHMENT_TOKENS[p.type],
+			type: p.type
+		};
+		case "meta": return {
+			children: p.content ? estimateContent(p.content) : void 0,
+			kind: p.tag,
+			tokens: fromText(stringifyContent(p)),
+			type: p.type
+		};
+		case "error": return {
+			tokens: fromText(stringifyContent(p)),
+			type: p.type
+		};
+		default: throw new Error(`Unknown part type: ${p.type}`);
+	}
+}
+function estimateContent(content) {
+	if (typeof content === "string") return [{
+		tokens: fromText(content),
+		type: "text"
+	}];
+	let tokens = 0;
+	const children = [];
+	for (const p of content) {
+		const partStats = estimatePart(p);
+		tokens += partStats.tokens;
+		children.push(partStats);
+	}
+	return children;
+}
+function estimateMessage(m) {
+	const type = m.role;
+	const children = estimateContent(m.content);
+	return {
+		children,
+		kind: m.role === "system" ? m.meta?.kind : void 0,
+		tokens: sumTokens(children),
+		type
+	};
+}
+function estimatePrompt(prompt, tools) {
+	const children = prompt.map((p) => ({
+		kind: typeof p === "string" ? void 0 : p.name,
+		tokens: fromText(typeof p === "string" ? p : p.text),
+		type: "prompt"
+	}));
+	children.push(...tools?.map((t) => ({
+		kind: t.name,
+		tokens: fromText(t.name) + fromText(JSON.stringify(t.params ?? {})),
+		type: "tool-schema"
+	})) ?? []);
+	return {
+		children,
+		tokens: sumTokens(children),
+		type: "system-prompt"
+	};
+}
+function addCount(stat, parent, expand) {
+	const keys = stat.kind ? [stat.type, stat.kind] : [stat.type];
+	let child;
+	for (const key of keys) {
+		parent.children ??= /* @__PURE__ */ new Map();
+		child = parent.children.get(key);
+		if (!child) {
+			child = {
+				children: /* @__PURE__ */ new Map(),
+				count: 0,
+				key,
+				tokens: 0
+			};
+			parent.children.set(key, child);
+		}
+		child.tokens += stat.tokens;
+		child.count++;
+		parent = child;
+	}
+	if (stat.children && child && (!expand || expand(stat))) for (const c of stat.children) addCount(c, child, expand);
+}
+function tokenStats(msgs, opts = {}) {
+	const root = {
+		children: /* @__PURE__ */ new Map(),
+		count: 0,
+		key: "TOTAL",
+		tokens: 0
+	};
+	const counts = [];
+	if (opts.prompt) counts.push(estimatePrompt(opts.prompt, opts.tools));
+	counts.push(...msgs.map(estimateMessage));
+	for (const stats of counts) {
+		root.tokens += stats.tokens;
+		root.count++;
+		addCount(stats, root, opts.expand);
+	}
+	return root;
+}
+function fmtStats(s, indent = 0) {
+	return `${("  ".repeat(indent) + s.key).padEnd(28)} ${fmt(s.count).padStart(6)}x ${fmt(s.tokens).padStart(14)}`;
+}
+function formatTokenStats(s, indent = 0) {
+	const ret = [];
+	const children = s.children ? [...s.children.values()].toSorted((a, b) => b.tokens - a.tokens) : [];
+	for (const c of children) {
+		ret.push(fmtStats(c, indent));
+		if (c.children?.size) ret.push(formatTokenStats(c, indent + 1));
+		if (indent === 0) ret.push("─".repeat(51));
+	}
+	if (indent === 0) {
+		ret.unshift("─".repeat(51));
+		ret.push(fmtStats(s, indent));
+		ret.push("─".repeat(51));
+	}
+	return ret.join("\n");
+}
+function fmt(n) {
+	return n.toLocaleString("en-US").replace(/,/g, "_");
+}
+//#endregion
+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-fK6DL2bg.mjs.map