pi-crew 0.9.53 → 0.9.55

package/src/runtime/coalesce-tasks.ts

@@ -0,0 +1,268 @@
+/**
+ * coalesce-tasks.ts — micro-task coalescing for scheduler batching (M6).
+ *
+ * Implements the workflow-level `coalesceMicroTasks` opt-in (plan §11
+ * decision #7): default = false; when true, multiple ready tasks sharing
+ * `role` and `cwd` are grouped into a single "coalesced task group" so the
+ * scheduler dispatches ONE worker call instead of N. Trades individual task
+ * observability for fewer cold-starts when many small tasks of the same kind
+ * are queued simultaneously.
+ *
+ * Safety guards (per plan §5 M6):
+ *   - Only groups tasks that share role + cwd (so the grouped worker can use
+ *     a single worker prompt without per-task permission prompts).
+ *   - Tasks that declare a non-false `output` are NEVER coalesced with
+ *     another task that has the same write path (write-write conflict).
+ *   - When the flag is off or the list is empty, returns the input list
+ *     unchanged (no-op for production; zero overhead).
+ *
+ * Real-dispatch (v0.9.17+ follow-up, see m6-real-dispatch-design.md):
+ *   - MVP only coalesces READ_ONLY roles (permissionForRole === "read_only").
+ *     This eliminates write-path conflicts, worktree concerns, and mutation
+ *     guards. Use case: parallel-research with 4 explorers → 1 worker.
+ *   - MVP rejects coalescing when any step has: worktree: true, preStepScript,
+ *     verify: true, or non-false output. These are per-step concerns that
+ *     don't compose in a single multi-task worker.
+ *   - maxGroupSize cap (default 5) prevents context-budget overflow when
+ *     grouping many micro-tasks into one worker prompt.
+ */
+
+import type { TeamTaskState } from "../state/types.ts";
+import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
+import { permissionForRole } from "./role-permission.ts";
+
+/** Default cap on group size to prevent context-budget overflow. */
+export const DEFAULT_MAX_GROUP_SIZE = 5;
+
+/** Default cap on combined estimated prompt size (bytes). Conservative
+ *  estimate — real prompt includes the stable prefix (~5KB) plus per-task
+ *  sections. 100KB matches the budget heuristic in the design doc
+ *  (m6-real-dispatch-design.md §R4). */
+export const DEFAULT_MAX_GROUP_BYTES = 100_000;
+
+export interface CoalescedGroup {
+	/** Stable id derived from the group membership; deterministic for tests. */
+	id: string;
+	role: string;
+	cwd: string;
+	/** Tasks to be coalesced into one worker invocation, in input order. */
+	tasks: TeamTaskState[];
+}
+
+/**
+ * Group ready tasks by (role, cwd) while respecting write-path safety.
+ *
+ * Returns an array of `CoalescedGroup`. Each group contains tasks that:
+ *   - share the same role and cwd
+ *   - have NO write-path conflict with any other task in the group
+ *
+ * Singletons (groups with one task) are preserved — the caller can decide
+ * whether to dispatch them as-is or skip the coalesce entirely.
+ *
+ * If `enabled` is false, returns `[]` (signal to the caller to skip
+ * coalescing — use the original list).
+ */
+export function planCoalescedGroups(
+	readyTaskIds: string[],
+	tasks: TeamTaskState[],
+	workflow: WorkflowConfig,
+	enabled: boolean,
+	maxGroupSize: number = DEFAULT_MAX_GROUP_SIZE,
+	maxGroupBytes: number = DEFAULT_MAX_GROUP_BYTES,
+): CoalescedGroup[] {
+	if (!enabled || readyTaskIds.length === 0) return [];
+	const taskById = new Map<string, TeamTaskState>(tasks.map((task) => [task.id, task]));
+	const stepById = new Map<string, WorkflowStep>(workflow.steps.map((step) => [step.id, step]));
+
+	// Bucket: key = `${role}\0${cwd}` → task list preserving input order
+	const buckets = new Map<string, TeamTaskState[]>();
+	for (const taskId of readyTaskIds) {
+		const task = taskById.get(taskId);
+		if (!task?.stepId) continue;
+		const step = stepById.get(task.stepId);
+		if (!step) continue;
+
+		// MVP constraint (real-dispatch safety): only coalesce READ_ONLY roles.
+		// Writing roles (executor, writer, implementer) require per-step hooks
+		// (worktree, preStepScript, verify) that don't compose in one worker.
+		if (permissionForRole(task.role) !== "read_only") continue;
+
+		// MVP constraint: reject if step has any per-step concern that
+		// doesn't compose in a multi-task worker. These flags set up side
+		// effects per-task that can't be combined.
+		if (step.worktree) continue;
+		if (step.preStepScript) continue;
+		if (step.verify) continue;
+		if (step.output !== undefined && step.output !== false && step.output !== "") continue;
+
+		const key = `${task.role}\0${task.cwd}`;
+		const list = buckets.get(key);
+		if (list) list.push(task);
+		else buckets.set(key, [task]);
+	}
+
+	// Within each bucket, split further by write-path safety (groups of tasks
+	// that all have distinct write outputs), cap at maxGroupSize, AND cap
+	// combined estimated prompt size at maxGroupBytes. This addresses
+	// design-doc risk R4 (context-budget overflow): a worker handling N
+	// micro-tasks with large dependency contexts could exceed the model's
+	// context window. The byte cap is a heuristic, not a guarantee — the
+	// actual prompt includes rendered workspace trees and skill blocks too.
+	const groups: CoalescedGroup[] = [];
+	for (const [key, bucketTasks] of buckets) {
+		const [role, cwd] = key.split("\0");
+		const subgroups = splitByWriteSafety(bucketTasks, stepById);
+		for (const subgroup of subgroups) {
+			// Chunk by BOTH count and bytes. Greedy: keep adding tasks while
+			// adding the next one wouldn't exceed either limit. When a
+			// single task exceeds the byte limit by itself (rare), include
+			// it anyway as a singleton group so it's at least eligible.
+			let chunkStart = 0;
+			let chunkBytes = 0;
+			for (let i = 0; i < subgroup.length; i += 1) {
+				const task = subgroup[i]!;
+				const step = task.stepId ? stepById.get(task.stepId) : undefined;
+				const taskSize = estimateTaskPromptSize(task, step);
+				const wouldBeCount = i - chunkStart + 1;
+				const wouldBeBytes = chunkBytes + taskSize;
+				const overCount = wouldBeCount > maxGroupSize;
+				const overBytes = i > chunkStart && wouldBeBytes > maxGroupBytes;
+				if ((overCount || overBytes) && i > chunkStart) {
+					// Flush current chunk as a group.
+					const slice = subgroup.slice(chunkStart, i);
+					groups.push(buildGroup(slice, role, cwd));
+					chunkStart = i;
+					chunkBytes = taskSize;
+				} else {
+					chunkBytes += taskSize;
+				}
+			}
+			// Flush final chunk.
+			if (chunkStart < subgroup.length) {
+				const slice = subgroup.slice(chunkStart);
+				groups.push(buildGroup(slice, role, cwd));
+			}
+		}
+	}
+	return groups;
+}
+
+function buildGroup(tasks: TeamTaskState[], role: string, cwd: string): CoalescedGroup {
+	return {
+		id: tasks.length === 1 ? tasks[0]!.id : tasks.map((t) => t.id).join("+"),
+		role,
+		cwd,
+		tasks,
+	};
+}
+
+/**
+ * Estimate the prompt-bytes contribution of a single task within a
+ * coalesced group. The actual prompt is much larger (workspace tree,
+ * skill block, dependency context) but the task-specific contribution
+ * is roughly proportional to the step's task text + a fixed per-task
+ * overhead for delimiters and headers.
+ */
+function estimateTaskPromptSize(task: TeamTaskState, step: WorkflowStep | undefined): number {
+	const taskText = step?.task?.length ?? 0;
+	const packetEstimate = 500; // task packet / scope / verification estimate
+	const delimiterOverhead = 200; // `<<<TASK_RESULT:id>>>` + section header
+	return taskText + packetEstimate + delimiterOverhead;
+}
+
+/**
+ * Split a bucket of tasks into write-safe subgroups: a subgroup may include
+ * tasks only if no two of them have the same `step.output`.
+ *
+ * Greedy: first task always goes to current group; subsequent tasks join the
+ * current group only if they don't conflict with any already-in-group member.
+ * Otherwise, they start (and extend) the next subgroup.
+ */
+function splitByWriteSafety(bucketTasks: TeamTaskState[], stepById: Map<string, WorkflowStep>): TeamTaskState[][] {
+	const result: TeamTaskState[][] = [];
+	for (const task of bucketTasks) {
+		const step = task.stepId ? stepById.get(task.stepId) : undefined;
+		const writePath = step?.output;
+		let placed = false;
+		for (const group of result) {
+			let conflict = false;
+			for (const other of group) {
+				const otherStep = other.stepId ? stepById.get(other.stepId) : undefined;
+				if (typeof writePath === "string" && typeof otherStep?.output === "string" && writePath === otherStep.output) {
+					conflict = true;
+					break;
+				}
+			}
+			if (!conflict) {
+				group.push(task);
+				placed = true;
+				break;
+			}
+		}
+		if (!placed) result.push([task]);
+	}
+	return result;
+}
+
+/**
+ * Flatten a list of `CoalescedGroup` back into a flat task-id list (one entry
+ * per group). For a group of N tasks, this returns N task IDs in order. When
+ * M6 is enabled upstream, the caller can use this to count "effective ready
+ * units" (groups vs raw tasks).
+ */
+export function flattenGroupIds(groups: CoalescedGroup[]): string[] {
+	return groups.flatMap((group) => group.tasks.map((task) => task.id));
+}
+
+/**
+ * Find the coalesced group that contains the given task ID.
+ * Returns undefined if the task is not in any group (e.g., it was excluded
+ * by MVP constraints or wasn't part of the coalesced set).
+ *
+ * Used by the team-runner dispatch loop to look up a task's group metadata
+ * (role, cwd, group ID, sibling task IDs) when iterating the flat ready
+ * list and discovering which tasks should be batched together.
+ */
+export function findGroupContainingTask(groups: CoalescedGroup[], taskId: string): CoalescedGroup | undefined {
+	for (const group of groups) {
+		if (group.tasks.some((task) => task.id === taskId)) return group;
+	}
+	return undefined;
+}
+
+/**
+ * Expand a list of task IDs into a list of dispatch units, where each unit
+ * is either a single task (for singletons / non-coalescable tasks) or a
+ * CoalescedGroup (for multi-task batches). The returned units can be fed
+ * directly into mapConcurrent.
+ *
+ * Tasks not present in any coalesced group are returned as singleton units.
+ */
+export type DispatchUnit = { kind: "singleton"; taskId: string } | { kind: "group"; group: CoalescedGroup };
+
+export function buildDispatchUnits(readyTaskIds: string[], coalescedGroups: CoalescedGroup[]): DispatchUnit[] {
+	const groupByTaskId = new Map<string, CoalescedGroup>();
+	for (const group of coalescedGroups) {
+		if (group.tasks.length < 2) continue; // singletons handled separately
+		for (const task of group.tasks) {
+			groupByTaskId.set(task.id, group);
+		}
+	}
+	const visited = new Set<string>();
+	const units: DispatchUnit[] = [];
+	// First pass: emit groups (one unit per group, in input order)
+	for (const taskId of readyTaskIds) {
+		const group = groupByTaskId.get(taskId);
+		if (!group) continue;
+		if (visited.has(group.id)) continue;
+		visited.add(group.id);
+		for (const t of group.tasks) visited.add(t.id);
+		units.push({ kind: "group", group });
+	}
+	// Second pass: emit singletons (and tasks whose group is size 1)
+	for (const taskId of readyTaskIds) {
+		if (visited.has(taskId)) continue;
+		units.push({ kind: "singleton", taskId });
+	}
+	return units;
+}

package/src/runtime/code-summary.ts

@@ -0,0 +1,292 @@
+/**
+ * Structural code summary — regex-based summarizer that elides function bodies,
+ * long arrays, block comments, and import groups, keeping signatures.
+ * Pure TypeScript fallback (no tree-sitter / Rust native dependency).
+ */
+
+// ── Public types ──
+
+export interface SummarySegment {
+	kind: "kept" | "elided";
+	startLine: number;
+	endLine: number;
+	/** Verbatim text for kept segments; absent for elided */
+	text?: string;
+}
+
+export interface SummaryResult {
+	language: string | null;
+	totalLines: number;
+	elided: boolean;
+	segments: SummarySegment[];
+	rendered: string;
+}
+
+export interface SummaryOptions {
+	minBodyLines?: number; // default 4
+	minCommentLines?: number; // default 6
+}
+
+// ── Language detection ──
+
+const EXT_MAP: ReadonlyMap<string, string> = new Map([
+	[".ts", "typescript"],
+	[".tsx", "typescript"],
+	[".js", "javascript"],
+	[".jsx", "javascript"],
+	[".mjs", "javascript"],
+	[".cjs", "javascript"],
+	[".py", "python"],
+	[".rs", "rust"],
+]);
+
+export function detectLanguage(filePath: string): string | null {
+	const dot = filePath.lastIndexOf(".");
+	if (dot === -1) return null;
+	return EXT_MAP.get(filePath.slice(dot).toLowerCase()) ?? null;
+}
+
+// ── Internal range helpers ──
+
+interface Range {
+	start: number;
+	end: number;
+}
+
+function mergeRanges(ranges: Range[]): Range[] {
+	if (ranges.length === 0) return [];
+	const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end);
+	const merged: Range[] = [sorted[0]];
+	for (let i = 1; i < sorted.length; i++) {
+		const last = merged[merged.length - 1];
+		if (sorted[i].start <= last.end + 1) last.end = Math.max(last.end, sorted[i].end);
+		else merged.push({ ...sorted[i] });
+	}
+	return merged;
+}
+
+// ── Brace-based elision (TS/JS/Rust) ──
+// NOTE: This is a regex heuristic, not a parser. Braces inside string literals,
+// template strings, regex, and comments are counted, which can produce incorrect
+// elision for edge cases like `const s = "{...}"` or `${expr}`. Acceptable for
+// summaries; do not use for correctness-sensitive parsing.
+
+function findBraceRanges(lines: string[], openPattern: RegExp, minBody: number): Range[] {
+	const ranges: Range[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		if (!openPattern.test(lines[i])) continue;
+		let depth = 0;
+		let foundOpen = false;
+		const start = i;
+		for (let j = i; j < lines.length; j++) {
+			for (const ch of lines[j]) {
+				if (ch === "{") {
+					depth++;
+					foundOpen = true;
+				} else if (ch === "}") {
+					depth--;
+				}
+			}
+			if (foundOpen && depth <= 0) {
+				if (j - start - 1 >= minBody) ranges.push({ start: start + 1, end: j - 1 });
+				break;
+			}
+		}
+	}
+	return ranges;
+}
+
+// ── TypeScript / JavaScript ──
+
+const TS_FN_SIG =
+	/^\s*(export\s+)?(async\s+)?function\s|^\s*(export\s+)?(static\s+|get\s+|set\s+|private\s+|public\s+|protected\s+|readonly\s+)*\*?\s*\w+\s*[(<]/;
+const TS_CLASS_SIG = /^\s*(export\s+)?(default\s+)?(abstract\s+)?class\s/;
+const TS_STRUCT_SIG = /^\s*(export\s+)?(default\s+)?(const|let|var)\s+\w+\s*=\s*(\[[\s]*$|\{[\s]*$)/;
+
+function tsRanges(lines: string[], minBody: number): Range[] {
+	return [
+		...findBraceRanges(lines, TS_FN_SIG, minBody),
+		...findBraceRanges(lines, TS_CLASS_SIG, minBody),
+		...findBraceRanges(lines, TS_STRUCT_SIG, minBody),
+	];
+}
+
+// ── Block comments ──
+
+function blockCommentRanges(lines: string[], minComment: number): Range[] {
+	const ranges: Range[] = [];
+	let i = 0;
+	while (i < lines.length) {
+		const idx = lines[i].indexOf("/*");
+		if (idx === -1 || lines[i].includes("*/", idx + 2)) {
+			i++;
+			continue;
+		}
+		const openLine = i;
+		let j = i + 1;
+		while (j < lines.length && !lines[j].includes("*/")) j++;
+		if (j < lines.length && j - openLine - 1 >= minComment) ranges.push({ start: openLine + 1, end: j - 1 });
+		i = j + 1;
+	}
+	return ranges;
+}
+
+// ── Import groups ──
+
+const IMPORT_RE = /^\s*import\s/;
+const PY_IMPORT_RE = /^\s*(import\s|from\s+\S+\s+import\s)/;
+
+function importGroupRanges(lines: string[], pattern: RegExp): Range[] {
+	const groups: Array<{ start: number; end: number }> = [];
+	let gs = -1,
+		last = -1;
+	for (let i = 0; i < lines.length; i++) {
+		if (pattern.test(lines[i])) {
+			if (gs === -1) gs = i;
+			last = i;
+		} else if (gs !== -1 && i > last) {
+			groups.push({ start: gs, end: last });
+			gs = -1;
+			last = -1;
+		}
+	}
+	if (gs !== -1) groups.push({ start: gs, end: last });
+	const ranges: Range[] = [];
+	for (const g of groups) {
+		if (g.end - g.start >= 2) ranges.push({ start: g.start + 1, end: g.end - 1 });
+	}
+	return ranges;
+}
+
+// ── Python ──
+
+function pythonRanges(lines: string[], minBody: number): Range[] {
+	const ranges: Range[] = [];
+	for (let i = 0; i < lines.length; i++) {
+		const m = /^(\s*)(async\s+)?def\s/.exec(lines[i]) || /^(\s*)class\s/.exec(lines[i]);
+		if (!m) continue;
+		const base = m[1].length;
+		let bs = -1,
+			be = -1;
+		for (let j = i + 1; j < lines.length; j++) {
+			if (lines[j].trim() === "") continue;
+			const indent = lines[j].length - lines[j].trimStart().length;
+			if (indent <= base) break;
+			if (bs === -1) bs = j;
+			be = j;
+		}
+		if (bs !== -1 && be - bs + 1 >= minBody) ranges.push({ start: bs, end: be });
+	}
+	ranges.push(...importGroupRanges(lines, PY_IMPORT_RE));
+	return ranges;
+}
+
+// ── Rust ──
+
+const RS_FN_SIG = /^\s*(pub\s+)?(async\s+)?(unsafe\s+)?fn\s/;
+const RS_STRUCT_SIG = /^\s*(pub\s+)?struct\s+\w+.*\{$/;
+const RS_ENUM_SIG = /^\s*(pub\s+)?enum\s+\w+.*\{$/;
+const RS_MOD_SIG = /^\s*(pub\s+)?mod\s+\w+.*\{$/;
+
+function rustRanges(lines: string[], minBody: number): Range[] {
+	return [
+		...findBraceRanges(lines, RS_FN_SIG, minBody),
+		...findBraceRanges(lines, RS_STRUCT_SIG, minBody),
+		...findBraceRanges(lines, RS_ENUM_SIG, minBody),
+		...findBraceRanges(lines, RS_MOD_SIG, minBody),
+	];
+}
+
+// ── Main entry ──
+
+function fullResult(language: string | null, totalLines: number, code: string): SummaryResult {
+	return {
+		language,
+		totalLines,
+		elided: false,
+		segments: [{ kind: "kept", startLine: 1, endLine: totalLines, text: code }],
+		rendered: code,
+	};
+}
+
+export function summarizeCode(code: string, language: string | null, options?: SummaryOptions): SummaryResult {
+	const minBody = options?.minBodyLines ?? 4;
+	const minComment = options?.minCommentLines ?? 6;
+
+	if (!code || code.trim() === "") {
+		return {
+			language,
+			totalLines: 0,
+			elided: false,
+			segments: [],
+			rendered: "",
+		};
+	}
+
+	const lines = code.split("\n");
+	const totalLines = lines.length;
+
+	if (!language) return fullResult(null, totalLines, code);
+
+	const rawRanges: Range[] = [];
+	switch (language) {
+		case "typescript":
+		case "javascript":
+			rawRanges.push(...tsRanges(lines, minBody), ...blockCommentRanges(lines, minComment), ...importGroupRanges(lines, IMPORT_RE));
+			break;
+		case "python":
+			rawRanges.push(...pythonRanges(lines, minBody));
+			break;
+		case "rust":
+			rawRanges.push(...rustRanges(lines, minBody), ...blockCommentRanges(lines, minComment));
+			break;
+		default:
+			return fullResult(language, totalLines, code);
+	}
+
+	const ranges = mergeRanges(rawRanges);
+	if (ranges.length === 0) return fullResult(language, totalLines, code);
+
+	// Build segments
+	const segments: SummarySegment[] = [];
+	let cursor = 0;
+	for (const r of ranges) {
+		if (cursor < r.start) {
+			segments.push({
+				kind: "kept",
+				startLine: cursor + 1,
+				endLine: r.start,
+				text: lines.slice(cursor, r.start).join("\n"),
+			});
+		}
+		segments.push({
+			kind: "elided",
+			startLine: r.start + 1,
+			endLine: r.end + 1,
+		});
+		cursor = r.end + 1;
+	}
+	if (cursor < totalLines) {
+		segments.push({
+			kind: "kept",
+			startLine: cursor + 1,
+			endLine: totalLines,
+			text: lines.slice(cursor).join("\n"),
+		});
+	}
+
+	// Render
+	const parts: string[] = [];
+	for (const seg of segments) {
+		if (seg.kind === "kept") parts.push(seg.text ?? "");
+		else parts.push(`  ... ${seg.endLine - seg.startLine + 1} lines elided ...`);
+	}
+
+	return {
+		language,
+		totalLines,
+		elided: true,
+		segments,
+		rendered: parts.join("\n"),
+	};
+}

package/src/runtime/command-trace.ts

@@ -0,0 +1,105 @@
+/**
+ * T10 — Verbatim command-trace extraction from tool-call history.
+ *
+ * Ported from pi-agent-flow's `generateCommandsFromHistory` technique (see
+ * `research-findings/pi-ecosystem-distillation.md` T10): workers routinely
+ * PARAPHRASE commands in their self-reports ("I ran the tests" instead of the
+ * exact `npm test -- --grep foo`). The orchestrator/user wants the VERBATIM
+ * command trace. pi-crew already records each executed tool in
+ * `CrewAgentProgress.recentTools` (capped at 25, args previewed at ≤240 chars),
+ * so the factual trace is available — this module distills it.
+ *
+ * Design notes:
+ *  - Reads only the recorded `{tool, args, endedAt}` tuples — never trusts any
+ *    LLM-emitted command string. This is the whole point: mechanical, factual.
+ *  - Recognizes bash/shell tools and extracts their `command` arg, sanitized to
+ *    a single line (newlines → ⏎) so a multi-line script shows as one trace row.
+ *  - Non-shell tools (write/edit/read) are counted but not inlined (their args
+ *    are file paths, not commands; the task result already lists changed files).
+ *  - Caps the returned command list to keep the status line / summary bounded.
+ */
+
+export interface ToolCallRecord {
+	tool: string;
+	args?: string;
+	endedAt?: string;
+}
+
+export interface CommandTrace {
+	/** Total number of recorded tool calls (all tool kinds). */
+	totalTools: number;
+	/** Count of recognized command-executing tools (bash/shell). */
+	commandTools: number;
+	/** Verbatim command strings (sanitized to one line), most-recent-last. */
+	commands: string[];
+	/** One-line summary suitable for a status/dashboard row, e.g. "cmd=8 (3 bash)". */
+	summary: string;
+}
+
+const COMMAND_TOOL_NAMES = new Set(["bash", "shell", "execute_bash", "run_command", "terminal"]);
+const MAX_COMMANDS = 12;
+const MAX_COMMAND_LEN = 160;
+
+/**
+ * Extract a verbatim command trace from recorded tool calls. Pure function —
+ * safe to call with any subset of recentTools. Returns an empty trace for
+ * empty/missing input.
+ */
+export function extractCommandTrace(recentTools: readonly ToolCallRecord[] | undefined | null): CommandTrace {
+	const tools = Array.isArray(recentTools) ? recentTools : [];
+	// Only count well-formed records (string tool name) — malformed entries
+	// are skipped entirely so a corrupt/transient record can't inflate totals.
+	const valid = tools.filter((call) => call && typeof call.tool === "string");
+	const totalTools = valid.length;
+	const commands: string[] = [];
+	let commandTools = 0;
+	for (const call of valid) {
+		const toolName = call.tool.toLowerCase();
+		if (!COMMAND_TOOL_NAMES.has(toolName)) continue;
+		commandTools += 1;
+		const cmd = extractCommandArg(call.args);
+		if (cmd) commands.push(sanitizeCommand(cmd));
+	}
+	const trimmed = commands.slice(-MAX_COMMANDS);
+	return {
+		totalTools,
+		commandTools,
+		commands: trimmed,
+		summary: formatSummary(totalTools, commandTools),
+	};
+}
+
+/** Pull the `command` field out of an args preview (JSON string or raw). */
+function extractCommandArg(args: string | undefined): string | undefined {
+	if (!args) return undefined;
+	const raw = args.trim();
+	if (!raw) return undefined;
+	// Args is a JSON-stringified object like {"command":"ls -la"} (previewArgs
+	// JSON.stringifies objects). Try to parse and read .command / .cmd.
+	if (raw.startsWith("{")) {
+		try {
+			const parsed = JSON.parse(raw) as Record<string, unknown>;
+			const cmd = parsed.command ?? parsed.cmd ?? parsed.script ?? parsed.input;
+			if (typeof cmd === "string" && cmd.trim()) return cmd;
+		} catch {
+			// Not valid JSON — fall through to treat raw as the command.
+		}
+	}
+	// Otherwise treat the whole preview as the command text.
+	return raw;
+}
+
+/** Sanitize a command to a single bounded line for compact display. */
+function sanitizeCommand(cmd: string): string {
+	const oneLine = cmd.replace(/\s*\r?\n\s*/g, " ⏎ ").trim();
+	if (oneLine.length <= MAX_COMMAND_LEN) return oneLine;
+	return `${oneLine.slice(0, MAX_COMMAND_LEN - 1)}…`;
+}
+
+function formatSummary(totalTools: number, commandTools: number): string {
+	if (totalTools === 0) return "";
+	// "cmd=8" always; append "(3 bash)" only when there's a mix worth showing.
+	if (commandTools === 0) return `cmd=${totalTools}`;
+	if (commandTools === totalTools) return `cmd=${totalTools}`;
+	return `cmd=${totalTools} (${commandTools} bash)`;
+}