@tekmidian/pai 0.48.0 → 0.49.0

package/dist/cli/index.mjs

@@ -7,7 +7,7 @@ import "../helpers-crDEr6S2.mjs";
 import "../sync-Btcb6xA4.mjs";
 import "../embeddings-DvRKcQyt.mjs";
 import "../search-B69cQwDB.mjs";
-import { n as drainStdio, t as buildProgram } from "../program-Bgv1lFFA.mjs";
+import { n as drainStdio, t as buildProgram } from "../program-D9-wfmkZ.mjs";
 import "../context-handover-cache-B9NKSjwR.mjs";
 import "../config-DCu8THKi.mjs";
 import "../config-DxMZjpvY.mjs";

package/dist/cli/program.mjs

@@ -6,7 +6,7 @@ import "../helpers-crDEr6S2.mjs";
 import "../sync-Btcb6xA4.mjs";
 import "../embeddings-DvRKcQyt.mjs";
 import "../search-B69cQwDB.mjs";
-import { t as buildProgram } from "../program-Bgv1lFFA.mjs";
+import { t as buildProgram } from "../program-D9-wfmkZ.mjs";
 import "../context-handover-cache-B9NKSjwR.mjs";
 import "../config-DCu8THKi.mjs";
 import "../config-DxMZjpvY.mjs";

package/dist/{program-Bgv1lFFA.mjs → program-D9-wfmkZ.mjs}

@@ -10222,6 +10222,272 @@ function totalUsageTokens(totals) {
 	return totals.cache_read_input_tokens + totals.cache_creation_input_tokens + totals.input_tokens + totals.output_tokens;
 }
 
+//#endregion
+//#region src/audit/first-turn.ts
+/**
+* first-turn.ts — where a turn's context actually comes from, attributed
+* line by line from the transcript.
+*
+* The API reports one number per assistant turn (cache_read + cache_creation
+* + input). The transcript holds the pieces Claude Code injected since the
+* previous turn: SessionStart / UserPromptSubmit hook output, the skill
+* listing, the deferred-tool name list, MCP server instructions, the human
+* prompt, any isMeta expansion (a skill body, a pasted slash-command result),
+* tool results, and the previous turn's own visible output (re-sent as
+* context on every later turn). Each of those is counted in cl100k here;
+* what is left over is the system prompt, the built-in tool schemas, agents
+* and memory files, which never appear in the transcript.
+*
+* Only the live lineage counts. Lines chain by parentUuid, and a prompt the
+* user abandoned before a reply (Escape, re-submit) leaves a dead branch
+* whose lines were never sent — run 9 measured a session whose first
+* /Name was abandoned and read 24k where the true baseline is 30k, because
+* the 3.5k-token skill listing sat on the dead branch.
+*
+* `type:"system"` lines with subtype local_command hold a slash command's
+* raw stdout, and the model receives it verbatim in addition to the isMeta
+* markdown copy — run 11 measured both present on the same turn, so both are
+* counted.
+*/
+function parseLines(path) {
+	const lines = [];
+	for (const raw of readFileSync(path, "utf8").split("\n")) {
+		if (!raw.trim()) continue;
+		try {
+			lines.push(JSON.parse(raw));
+		} catch {}
+	}
+	return lines;
+}
+function classify(line) {
+	if (line.type === "attachment") {
+		const a = line.attachment ?? {};
+		switch (a.type) {
+			case "hook_success": {
+				const name = a.hookName ?? "";
+				return {
+					kind: name.startsWith("SessionStart") ? "hook:SessionStart" : name.startsWith("UserPromptSubmit") ? "hook:UserPromptSubmit" : "hook:other",
+					tokens: countTokens(a.stdout ?? a.content ?? ""),
+					label: name
+				};
+			}
+			case "skill_listing": return {
+				kind: "skill_listing",
+				tokens: countTokens(a.content ?? ""),
+				label: "skill_listing"
+			};
+			case "deferred_tools_delta": return {
+				kind: "deferred_tools",
+				tokens: countTokens((a.addedNames ?? []).join("\n")),
+				label: "deferred_tools_delta"
+			};
+			case "mcp_instructions_delta": return {
+				kind: "mcp_instructions",
+				tokens: countTokens(JSON.stringify(a.instructions ?? a.addedInstructions ?? a)),
+				label: "mcp_instructions_delta"
+			};
+			default: return {
+				kind: "attachment:other",
+				tokens: countTokens(JSON.stringify(a)),
+				label: a.type ?? "attachment"
+			};
+		}
+	}
+	if (line.type === "user") {
+		const c = line.message?.content;
+		const isToolResult = Array.isArray(c) && c.some((b) => b?.type === "tool_result");
+		const text = typeof c === "string" ? c : JSON.stringify(c ?? "");
+		return {
+			kind: isToolResult ? "tool_result" : line.isMeta ? "prompt:meta" : "prompt",
+			tokens: countTokens(text),
+			label: text.slice(0, 40).replace(/\s+/g, " ")
+		};
+	}
+	if (line.type === "system") return {
+		kind: line.subtype === "local_command" ? "prompt:local_command" : "system:display-only",
+		tokens: countTokens(line.content ?? ""),
+		label: line.subtype ?? "system"
+	};
+	return null;
+}
+function apiContextOf(usage) {
+	if (!usage) return null;
+	return (usage.cache_read_input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.input_tokens ?? 0);
+}
+/**
+* Attribute API call `turn`'s context growth to the transcript lines
+* injected since the previous call. Turn numbering matches
+* session-usage.ts's `turnIndex`: several assistant lines sharing one
+* message.id (one line per streamed content block) are one call. Returns
+* null if the transcript has fewer than `turn` calls.
+*/
+function turnBreakdown(path, turn) {
+	if (!existsSync(path)) return null;
+	const lines = parseLines(path);
+	const byUuid = /* @__PURE__ */ new Map();
+	for (const l of lines) if (l.uuid) byUuid.set(l.uuid, l);
+	const seen = /* @__PURE__ */ new Set();
+	let n = 0;
+	let target = null;
+	for (const l of lines) if (l.type === "assistant" && l.message?.usage) {
+		const id = l.message.id ?? l.uuid ?? "";
+		if (!seen.has(id)) {
+			seen.add(id);
+			n++;
+			if (n === turn) {
+				target = l;
+				break;
+			}
+		}
+	}
+	if (!target) return null;
+	const rawChain = [];
+	let prevLine = null;
+	let cur = target.parentUuid ? byUuid.get(target.parentUuid) : void 0;
+	while (cur) {
+		if (cur.type === "assistant" && cur.message?.usage) {
+			prevLine = cur;
+			break;
+		}
+		rawChain.unshift(cur);
+		cur = cur.parentUuid ? byUuid.get(cur.parentUuid) : void 0;
+	}
+	const items = [];
+	for (const l of rawChain) {
+		const item = classify(l);
+		if (item) items.push(item);
+	}
+	let prevApiContext = 0;
+	let prevOutputTokens = 0;
+	if (prevLine) {
+		prevApiContext = apiContextOf(prevLine.message?.usage) ?? 0;
+		prevOutputTokens = prevLine.message?.usage?.output_tokens ?? 0;
+		const prevId = prevLine.message?.id ?? prevLine.uuid ?? "";
+		const prevBlocks = [prevLine];
+		let cur2 = prevLine.parentUuid ? byUuid.get(prevLine.parentUuid) : void 0;
+		while (cur2 && cur2.type === "assistant" && (cur2.message?.id ?? cur2.uuid ?? "") === prevId) {
+			prevBlocks.unshift(cur2);
+			cur2 = cur2.parentUuid ? byUuid.get(cur2.parentUuid) : void 0;
+		}
+		let prevText = "";
+		let thinkingCount = 0;
+		for (const b of prevBlocks) {
+			const content = b.message?.content;
+			if (!Array.isArray(content)) continue;
+			for (const block of content) if (block?.type === "text") prevText += block.text ?? "";
+			else if (block?.type === "tool_use") prevText += JSON.stringify(block.input ?? {});
+			else if (block?.type === "thinking") thinkingCount++;
+		}
+		const label = thinkingCount > 0 ? `previous call output (${thinkingCount} thinking block(s) redacted)` : "previous call output";
+		items.push({
+			kind: "assistant:prev",
+			tokens: countTokens(prevText),
+			label
+		});
+	}
+	const byKind = {};
+	let transcriptTokens = 0;
+	let prevVisibleTokens = 0;
+	for (const item of items) {
+		if (item.kind === "system:display-only") continue;
+		if (item.kind === "assistant:prev") {
+			prevVisibleTokens = item.tokens;
+			continue;
+		}
+		transcriptTokens += item.tokens;
+		byKind[item.kind] = (byKind[item.kind] ?? 0) + item.tokens;
+	}
+	const apiContext = apiContextOf(target.message?.usage);
+	const billedDelta = apiContext === null ? null : apiContext - prevApiContext;
+	const residual = billedDelta === null ? null : billedDelta - transcriptTokens - prevOutputTokens;
+	return {
+		path,
+		turn,
+		apiContext,
+		prevApiContext,
+		billedDelta,
+		prevOutputTokens,
+		items,
+		transcriptTokens,
+		byKind,
+		prevVisibleTokens,
+		residual
+	};
+}
+/** Attribute the first assistant turn's context to the transcript lines on its live lineage. */
+function firstTurnBreakdown(path) {
+	const empty = {
+		path,
+		apiContext: null,
+		items: [],
+		transcriptTokens: 0,
+		byKind: {},
+		remainder: null,
+		deadBranchTokens: 0,
+		deadBranchLines: 0
+	};
+	if (!existsSync(path)) return empty;
+	const tb = turnBreakdown(path, 1);
+	if (!tb) return empty;
+	const lines = parseLines(path);
+	const byUuid = /* @__PURE__ */ new Map();
+	let firstIndex = -1;
+	for (let i = 0; i < lines.length; i++) {
+		const l = lines[i];
+		if (l.uuid) byUuid.set(l.uuid, l);
+		if (l.type === "assistant" && l.message?.usage && firstIndex < 0) firstIndex = i;
+	}
+	if (firstIndex < 0) return empty;
+	const first = lines[firstIndex];
+	const live = /* @__PURE__ */ new Set();
+	let cur = first.parentUuid ? byUuid.get(first.parentUuid) : void 0;
+	while (cur && !live.has(cur)) {
+		live.add(cur);
+		cur = cur.parentUuid ? byUuid.get(cur.parentUuid) : void 0;
+	}
+	let deadBranchTokens = 0;
+	let deadBranchLines = 0;
+	for (let i = 0; i < firstIndex; i++) {
+		const l = lines[i];
+		if (!l.uuid || live.has(l)) continue;
+		const item = classify(l);
+		if (!item || item.kind === "system:display-only") continue;
+		deadBranchLines++;
+		deadBranchTokens += item.tokens;
+	}
+	return {
+		path,
+		apiContext: tb.apiContext,
+		items: tb.items,
+		transcriptTokens: tb.transcriptTokens,
+		byKind: tb.byKind,
+		remainder: tb.residual,
+		deadBranchTokens,
+		deadBranchLines
+	};
+}
+/** One-line evidence string for the combined report's first-turn finding. */
+function firstTurnEvidence(b) {
+	const parts = [];
+	for (const k of [
+		"skill_listing",
+		"mcp_instructions",
+		"deferred_tools",
+		"hook:SessionStart",
+		"hook:UserPromptSubmit",
+		"hook:other",
+		"prompt:meta",
+		"prompt:local_command",
+		"prompt",
+		"attachment:other"
+	]) {
+		const v = b.byKind[k];
+		if (v) parts.push(`${k} ${v}`);
+	}
+	const dead = b.deadBranchTokens > 0 ? `; dead-branch ${b.deadBranchTokens} not sent` : "";
+	return `transcript-side ${b.transcriptTokens} (${parts.join(", ")}), remainder ${b.remainder ?? "n/a"}${dead}`;
+}
+
 //#endregion
 //#region src/audit/session.ts
 /**
@@ -10275,7 +10541,8 @@ async function auditSession(path, threshold) {
 	return {
 		...report,
 		totalTokens: total,
-		percentages
+		percentages,
+		firstTurn: firstTurnBreakdown(target)
 	};
 }
 /**
@@ -11143,10 +11410,11 @@ function buildFindings(input) {
 	});
 	if (input.session) {
 		const first = input.session.firstTurnContext ?? 0;
+		const evidence = typeof input.session.firstTurn?.apiContext === "number" ? `${first} tokens: ${firstTurnEvidence(input.session.firstTurn)} (${input.session.path})` : `${first} tokens (${input.session.path})`;
 		findings.push({
 			finding: "first-turn context size",
 			severity: first > FIRST_TURN_CONTEXT_LIMIT ? "AMBER" : "GREEN",
-			evidence: `${first} tokens (${input.session.path})`
+			evidence
 		});
 	}
 	const rate = input.daemon.kgParseFailureRate;
@@ -11789,6 +12057,23 @@ function printSession(report) {
 		"share"
 	], rows));
 	console.log(`context on first turn: ${report.firstTurnContext ?? "n/a"}`);
+	if (report.firstTurn && report.firstTurn.apiContext !== null) {
+		const ft = report.firstTurn;
+		console.log(header("first-turn breakdown (live lineage, cl100k)"));
+		const ftRows = ft.items.filter((i) => i.tokens > 0).map((i) => [
+			i.kind,
+			String(i.tokens),
+			i.label
+		]);
+		console.log(renderTable([
+			"kind",
+			"tokens",
+			"label"
+		], ftRows));
+		console.log(`transcript-side: ${ft.transcriptTokens}`);
+		console.log(`remainder (system prompt + tool schemas + agents + memory): ${ft.remainder}`);
+		console.log(`dead-branch: ${ft.deadBranchTokens} tokens on ${ft.deadBranchLines} lines, persisted but never sent`);
+	}
 	console.log(`context on last turn:  ${report.lastTurnContext ?? "n/a"}`);
 	console.log(`cache_creation split: ephemeral_5m=${report.cacheCreationSplit.ephemeral5m}, ephemeral_1h=${report.cacheCreationSplit.ephemeral1h}`);
 	console.log(dim$1(`models: ${JSON.stringify(report.models)}`));
@@ -11802,6 +12087,24 @@ function printSession(report) {
 		for (const f of report.fallbacks) console.log(dim$1(`  ${f.from} -> ${f.to} before turn ${f.turnIndex}: ${f.category} (${f.scope})`));
 	}
 }
+function printTurnBreakdown(tb) {
+	console.log(header(`turn ${tb.turn} attribution (live lineage, cl100k)`));
+	const rows = tb.items.filter((i) => i.tokens > 0).map((i) => [
+		String(i.tokens),
+		i.kind,
+		i.label.replace(/\s+/g, " ").slice(0, 60)
+	]);
+	console.log(renderTable([
+		"tokens",
+		"kind",
+		"label"
+	], rows));
+	console.log(`transcript-side ${tb.transcriptTokens}`);
+	console.log(`billed delta ${tb.billedDelta ?? "n/a"} (context ${tb.apiContext ?? "n/a"} after ${tb.prevApiContext})`);
+	console.log(`previous call output ${tb.prevOutputTokens} (includes thinking, re-sent on tool turns)`);
+	console.log(`previous call visible output ${tb.prevVisibleTokens} (cl100k, listed as assistant:prev, not in transcript-side)`);
+	console.log(`residual ${tb.residual ?? "n/a"}: positive = cl100k undercount vs the billing tokenizer (1.2-1.45x measured on tool output and markdown tables); negative = the previous call's thinking was not re-sent (only re-sent inside a tool loop)`);
+}
 function printSessionHistory(rows) {
 	console.log(header("Session history (newest first)"));
 	const tableRows = rows.map((r) => [
@@ -11829,6 +12132,23 @@ async function cmdSession(path, opts) {
 		printSessionHistory(rows);
 		return;
 	}
+	if (opts.turn !== void 0) {
+		const target = path ?? newestSessionLog();
+		if (!target) {
+			console.error(err("  No session transcript found."));
+			process.exitCode = 1;
+			return;
+		}
+		const tb = turnBreakdown(target, parseInt(opts.turn, 10));
+		if (!tb) {
+			console.error(err(`  Turn ${opts.turn} not found in ${target}.`));
+			process.exitCode = 1;
+			return;
+		}
+		if (opts.json) return printJson(tb);
+		printTurnBreakdown(tb);
+		return;
+	}
 	const report = await auditSession(path, opts.ctxThreshold ? parseInt(opts.ctxThreshold, 10) : void 0);
 	if (!report) {
 		console.error(err("  No session transcript found."));
@@ -12312,7 +12632,7 @@ function registerAuditCommands(auditCmd) {
 		await cmdFiles(paths, jsonOpt());
 	});
 	tokensCmd.command("hooks").description("Token cost of every SessionStart / UserPromptSubmit hook").action(() => cmdHooks(jsonOpt()));
-	tokensCmd.command("session").description("Cache/input/output token split for a session transcript (default: newest)").argument("[path]", "Session JSONL path (default: newest under ~/.claude/projects)").option("--ctx-threshold <n>", "Per-turn context size above which a turn counts as 'above threshold' (default 200000)").option("--history [n]", "List first-turn context of the newest n sessions in this project's transcript directory (default 20)").action(async (path, opts) => {
+	tokensCmd.command("session").description("Cache/input/output token split for a session transcript (default: newest)").argument("[path]", "Session JSONL path (default: newest under ~/.claude/projects)").option("--ctx-threshold <n>", "Per-turn context size above which a turn counts as 'above threshold' (default 200000)").option("--history [n]", "List first-turn context of the newest n sessions in this project's transcript directory (default 20)").option("--turn <n>", "Attribute API call n's context growth to the transcript lines injected since the previous call").action(async (path, opts) => {
 		await cmdSession(path, {
 			...jsonOpt(),
 			...opts
@@ -20190,4 +20510,4 @@ claude() {
 
 //#endregion
 export { drainStdio as n, buildProgram as t };
-//# sourceMappingURL=program-Bgv1lFFA.mjs.map
+//# sourceMappingURL=program-D9-wfmkZ.mjs.map