@tekmidian/pai 0.47.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-BxpeczCx.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-BxpeczCx.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-BxpeczCx.mjs → program-D9-wfmkZ.mjs}

@@ -10076,6 +10076,24 @@ function parseCompactionEvent(line, turnIndex) {
 	};
 }
 /**
+* `type:"system"` `subtype:"model_refusal_fallback"` lines mark an
+* automatic model switch fired by an API safety refusal (e.g. "cyber"
+* category), not a user or config choice — worth flagging separately since
+* it can rebuild the whole prompt cache mid-session.
+*/
+function isModelFallback(line) {
+	return line.type === "system" && line.subtype === "model_refusal_fallback";
+}
+function parseFallbackEvent(line, turnIndex) {
+	return {
+		turnIndex,
+		from: line.originalModel ?? "unknown",
+		to: line.fallbackModel ?? "unknown",
+		category: line.apiRefusalCategory ?? "unknown",
+		scope: line.scope ?? "unknown"
+	};
+}
+/**
 * Fold one already-parsed JSONL line into a report being accumulated.
 * Exported separately so both the streaming file reader below and tests
 * (which build fixtures as arrays of objects, not files) share one path.
@@ -10098,13 +10116,24 @@ function foldAssistantLine(report, seenIds, line, threshold) {
 		if (typeof v === "number") report.totals[key] += v;
 	}
 	const context = (Number(usage.cache_read_input_tokens) || 0) + (Number(usage.cache_creation_input_tokens) || 0) + (Number(usage.input_tokens) || 0);
-	if (report.firstTurnContext === null) report.firstTurnContext = context;
+	if (report.firstTurnContext === null) {
+		report.firstTurnContext = context;
+		report.firstTurnAt = line.timestamp ?? null;
+	}
 	report.lastTurnContext = context;
 	report.maxContext = report.maxContext === null ? context : Math.max(report.maxContext, context);
 	if (context > threshold) report.turnsAboveThreshold++;
 	if ((Number(usage.cache_creation_input_tokens) || 0) > 2e4) report.cacheRebuildTurns++;
 	const model = message?.model ?? "unknown";
 	report.models[model] = (report.models[model] ?? 0) + 1;
+	if (report.lastModel !== null && report.lastModel !== model) report.modelSwitches.push({
+		turnIndex: report.turns,
+		from: report.lastModel,
+		to: model,
+		cacheRead: Number(usage.cache_read_input_tokens) || 0,
+		cacheCreation: Number(usage.cache_creation_input_tokens) || 0
+	});
+	report.lastModel = model;
 	const split = usage.cache_creation;
 	if (split) {
 		report.cacheCreationSplit.ephemeral5m += Number(split.ephemeral_5m_input_tokens) || 0;
@@ -10120,6 +10149,8 @@ function foldAssistantLine(report, seenIds, line, threshold) {
 */
 function isRealUserPrompt(line) {
 	if (line.type !== "user") return false;
+	if (line.isMeta) return false;
+	if (line.origin?.kind && line.origin.kind !== "human") return false;
 	const content = line.message?.content;
 	if (typeof content === "string") return true;
 	if (Array.isArray(content)) return !content.some((block) => block?.type === "tool_result");
@@ -10145,7 +10176,11 @@ async function parseSessionUsage(path, threshold = 2e5) {
 		cacheRebuildTurns: 0,
 		userPrompts: 0,
 		promptExposure: 0,
-		compactions: []
+		compactions: [],
+		firstTurnAt: null,
+		lastModel: null,
+		modelSwitches: [],
+		fallbacks: []
 	};
 	const seenIds = /* @__PURE__ */ new Set();
 	let contextSum = 0;
@@ -10170,6 +10205,10 @@ async function parseSessionUsage(path, threshold = 2e5) {
 			if (event) report.compactions.push(event);
 			continue;
 		}
+		if (isModelFallback(obj)) {
+			report.fallbacks.push(parseFallbackEvent(obj, report.turns));
+			continue;
+		}
 		const context = foldAssistantLine(report, seenIds, obj, threshold);
 		if (context !== null) {
 			contextSum += context;
@@ -10183,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
 /**
@@ -10236,9 +10541,48 @@ async function auditSession(path, threshold) {
 	return {
 		...report,
 		totalTokens: total,
-		percentages
+		percentages,
+		firstTurn: firstTurnBreakdown(target)
 	};
 }
+/**
+* First-turn context of every session transcript in this project's
+* `~/.claude/projects/<encoded-cwd>` directory, newest first — the readings
+* needed to see when a step change (model switch, hook growth) happened
+* across sessions without an ad-hoc script.
+*/
+async function sessionHistory(cwd, limit = 20) {
+	const dir = join(homedir(), ".claude", "projects", encodeDir(cwd));
+	let entries;
+	try {
+		entries = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+	} catch {
+		return [];
+	}
+	const rows = [];
+	for (const entry of entries) {
+		const path = join(dir, entry);
+		const report = await parseSessionUsage(path);
+		if (report.turns === 0) continue;
+		rows.push({
+			path,
+			sessionId: entry.replace(/\.jsonl$/, ""),
+			firstTurnAt: report.firstTurnAt,
+			firstTurnContext: report.firstTurnContext,
+			turns: report.turns,
+			models: report.models,
+			switches: report.modelSwitches.length,
+			fallbacks: report.fallbacks.length
+		});
+	}
+	rows.sort((a, b) => {
+		if (a.firstTurnAt === null && b.firstTurnAt === null) return 0;
+		if (a.firstTurnAt === null) return 1;
+		if (b.firstTurnAt === null) return -1;
+		return b.firstTurnAt.localeCompare(a.firstTurnAt);
+	});
+	return rows.slice(0, limit);
+}
 
 //#endregion
 //#region src/audit/spawn.ts
@@ -11026,6 +11370,7 @@ const FIRST_TURN_CONTEXT_LIMIT = 3e4;
 const DAEMON_FAILURE_RATE_LIMIT = .05;
 const CONTEXT_GROWTH_AVG_RED = 1e5;
 const CONTEXT_GROWTH_MAX_AMBER = 15e4;
+const MODEL_SWITCH_REBUILD_LIMIT = 2e4;
 const SEVERITY_RANK = {
 	RED: 0,
 	AMBER: 1,
@@ -11065,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;
@@ -11152,6 +11498,22 @@ function buildFindings(input) {
 			severity: overshoots.length > 0 ? "RED" : "GREEN",
 			evidence: overshoots.length > 0 ? `override not honoured: ${overshoots.map((c) => `preTokens=${c.preTokens}`).join(", ")} vs configured ${input.ctxThreshold}` : compactions.length === 0 ? `0 compactions in ${input.session.turns} turns` : `${compactions.length} compaction(s), all within 25% of configured ${input.ctxThreshold}`
 		});
+		const switches = input.session.modelSwitches;
+		const fallbacks = input.session.fallbacks;
+		const rebuilds = switches.filter((s) => s.cacheCreation > MODEL_SWITCH_REBUILD_LIMIT);
+		const short = (model) => model.replace(/^claude-/, "");
+		let switchEvidence;
+		if (switches.length === 0) switchEvidence = `0 switches in ${input.session.turns} turns, models ${JSON.stringify(input.session.models)}`;
+		else {
+			const list = switches.map((s) => `${short(s.from)}->${short(s.to)} at turn ${s.turnIndex} (cache_read ${s.cacheRead}, cache_creation ${s.cacheCreation})`).join("; ");
+			switchEvidence = `${switches.length} switch(es): ${list}`;
+			if (fallbacks.length > 0) switchEvidence += `; ${fallbacks.length} safeguard fallback(s): ${fallbacks.map((f) => f.category).join(",")}`;
+		}
+		findings.push({
+			finding: "mid-session model switches",
+			severity: switches.length === 0 ? "GREEN" : rebuilds.length > 0 ? "RED" : "AMBER",
+			evidence: switchEvidence
+		});
 	}
 	return sortFindings(findings);
 }
@@ -11695,14 +12057,98 @@ 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)}`));
 	console.log(`avg context: ${report.avgContext ?? "n/a"}, max context: ${report.maxContext ?? "n/a"}, turns above threshold: ${report.turnsAboveThreshold}, cache-rebuild turns: ${report.cacheRebuildTurns}, user prompts: ${report.userPrompts}, prompt exposure: ${report.promptExposure}`);
 	console.log(`compactions: ${report.compactions.length}`);
 	for (const c of report.compactions) console.log(dim$1(`  ${c.trigger} at turn ${c.turnIndex}: preTokens=${c.preTokens}`));
+	console.log(`model switches: ${report.modelSwitches.length}`);
+	for (const s of report.modelSwitches) console.log(dim$1(`  ${s.from} -> ${s.to} at turn ${s.turnIndex}: cache_read=${s.cacheRead}, cache_creation=${s.cacheCreation}`));
+	if (report.fallbacks.length > 0) {
+		console.log(`safeguard fallbacks: ${report.fallbacks.length}`);
+		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) => [
+		r.firstTurnAt ?? "n/a",
+		r.sessionId,
+		r.firstTurnContext === null ? "n/a" : String(r.firstTurnContext),
+		String(r.turns),
+		String(r.switches),
+		Object.entries(r.models).map(([name, count]) => `${name}:${count}`).join(",")
+	]);
+	console.log(renderTable([
+		"first turn (UTC)",
+		"session",
+		"first-turn ctx",
+		"turns",
+		"switches",
+		"models"
+	], tableRows));
 }
 async function cmdSession(path, opts) {
+	if (opts.history !== void 0) {
+		const limit = typeof opts.history === "string" ? parseInt(opts.history, 10) : 20;
+		const rows = await sessionHistory(process.cwd(), limit);
+		if (opts.json) return printJson(rows);
+		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."));
@@ -12186,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)").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
@@ -20064,4 +20510,4 @@ claude() {
 
 //#endregion
 export { drainStdio as n, buildProgram as t };
-//# sourceMappingURL=program-BxpeczCx.mjs.map
+//# sourceMappingURL=program-D9-wfmkZ.mjs.map