@zaly/agent 0.0.3

package/dist/index.mjs

@@ -0,0 +1,948 @@
+import { i as __exportAll, n as parseBash, t as TOOLS } from "./tools-DW1dbcCz.mjs";
+import { t as handlerRegistry } from "./registry-CFmR5G3J.mjs";
+import { n as isUuidv7Like, r as uuidv7, t as isUuidv7 } from "./uuid-ByXP5SO5.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-Bv9KjkDF.mjs");
+			return new Masker(this.agent, opts);
+		}, this.#opts.mask);
+	}
+	async permissions() {
+		return this.#cache.need("permissions", async (opts) => {
+			const { PermissionManager } = await import("./manager-D-lWBTHG.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-CUUdWFC5.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-GDLdDc2w.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-BaD2kax9.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-QNMTQ1PD.mjs").then((m) => m.bashTool),
+	edit: () => import("./edit-Qxl4w1C2.mjs").then((m) => m.editTool),
+	fetch: () => import("./fetch-D8cmmA3E.mjs").then((m) => m.fetchTool),
+	find: () => import("./find-Bah9SKWX.mjs").then((m) => m.findTool),
+	grep: () => import("./grep-B2Ax7ewy.mjs").then((m) => m.grepTool),
+	read: () => import("./read-Djsx2NZl.mjs").then((m) => m.readTool),
+	search: () => import("./search-CRw247ES.mjs").then((m) => m.searchTool),
+	subagent: () => import("./subagent-baqzjRMc.mjs").then((m) => m.subagentTool),
+	task_list: () => import("./tasks-D8rARHZ1.mjs").then((m) => m.taskListTool),
+	task_poll: () => import("./tasks-D8rARHZ1.mjs").then((m) => m.taskPollTool),
+	task_stop: () => import("./tasks-D8rARHZ1.mjs").then((m) => m.taskStopTool),
+	wakeup: () => import("./wakeup-BYqTnfSp.mjs").then((m) => m.wakeupTool),
+	write: () => import("./write-D3L-92vj.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 text = stringifyContent(transform.runSync(parts)).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;
+	}
+	return toXml(blocks.join("\n").replace(/^\s+$/gm, "").trim(), "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}`);
+	return toXml(lines.join("\n"), "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}`);
+	}
+	return toXml(lines.join("\n"), "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 { Commands, Skills, createAgent, estimatePart, extractBashUsage, extractConversation, extractFileUsage, formatBashUsage, formatFileUsage, formatTokenStats, handlerRegistry, isUuidv7, isUuidv7Like, messageTail, promptCollection, promptRegistry, ctx_exports as t, tokenStats, toolCollection, toolRegistry, uuidv7 };
+
+//# sourceMappingURL=index.mjs.map