@parallelworks/ui 0.18.0 → 0.19.1

package/dist/ai/agent/permissions.d.ts

@@ -0,0 +1,11 @@
+declare const REQUESTABLE_PERMISSION_MODES: readonly ['read-only', 'accept-edits', 'bypass-permissions'];
+export declare const NAMED_PERMISSION_MODES: readonly ["read-only", "accept-edits", "bypass-permissions", "plan"];
+export type PermissionMode = (typeof REQUESTABLE_PERMISSION_MODES)[number];
+export type NamedPermissionMode = (typeof NAMED_PERMISSION_MODES)[number];
+export declare const DEFAULT_PERMISSION_MODE: PermissionMode;
+export declare function isNamedPermissionMode(mode: string | undefined): mode is NamedPermissionMode;
+/** The daemon clamps a remote request to its owner's remoteMaxPermissionMode,
+ *  so a menu offers only what that machine will honour. */
+export declare function permissionModesUpTo(ceiling: string | undefined): PermissionMode[];
+export declare function clampPermissionMode(mode: PermissionMode, ceiling: string | undefined): PermissionMode;
+export {};

package/dist/ai/agent/permissions.js

@@ -0,0 +1,29 @@
+//#region src/ai/agent/permissions.ts
+var REQUESTABLE_PERMISSION_MODES = [
+	"read-only",
+	"accept-edits",
+	"bypass-permissions"
+];
+var NAMED_PERMISSION_MODES = [...REQUESTABLE_PERMISSION_MODES, "plan"];
+var DEFAULT_PERMISSION_MODE = "accept-edits";
+var PERMISSION_RANK = {
+	"read-only": 0,
+	plan: 1,
+	"accept-edits": 2,
+	"bypass-permissions": 3
+};
+function isNamedPermissionMode(mode) {
+	return NAMED_PERMISSION_MODES.some((m) => m === mode);
+}
+/** The daemon clamps a remote request to its owner's remoteMaxPermissionMode,
+*  so a menu offers only what that machine will honour. */
+function permissionModesUpTo(ceiling) {
+	const max = isNamedPermissionMode(ceiling) ? PERMISSION_RANK[ceiling] : PERMISSION_RANK[DEFAULT_PERMISSION_MODE];
+	return REQUESTABLE_PERMISSION_MODES.filter((m) => PERMISSION_RANK[m] <= max);
+}
+function clampPermissionMode(mode, ceiling) {
+	const offered = permissionModesUpTo(ceiling);
+	return offered.includes(mode) ? mode : offered[offered.length - 1] ?? "read-only";
+}
+//#endregion
+export { DEFAULT_PERMISSION_MODE, NAMED_PERMISSION_MODES, clampPermissionMode, isNamedPermissionMode, permissionModesUpTo };

package/dist/ai/agent/toolfmt.d.ts

@@ -0,0 +1,18 @@
+export interface ToolHeader {
+    label: string;
+    arg?: string;
+}
+export declare function toolHeaderFor(name: string): ToolHeader;
+export declare function clip(s: string, max: number): string;
+export declare function sanitizeLabel(s: string): string;
+export declare function sanitizePanelText(s: string): string;
+export declare function summarizeToolArgs(primary: string | undefined, argsJSON: string): string;
+export declare function fullToolArgs(primary: string | undefined, argsJSON: string): string;
+export declare function plural(n: number, noun: string): string;
+export declare function resultFailed(name: string, result: string): boolean;
+export declare function bashExitCode(body: string): [string, number, boolean];
+export declare function toolSummary(name: string, args: string, result: string, isError: boolean, editSummaryFn?: (toolName: string, argsJSON: string) => string): string;
+export declare function isGroupableTool(name: string): boolean;
+export declare function rollupSentence(names: string[]): string;
+export declare const AGENT_COLOR_NAMES: readonly ['blue', 'green', 'yellow', 'purple', 'cyan', 'orange', 'pink', 'red'];
+export declare function agentColorHex(name: string | undefined): string | null;

package/dist/ai/agent/toolfmt.js

@@ -0,0 +1,383 @@
+//#region src/ai/agent/toolfmt.ts
+var TOOL_HEADERS = {
+	Bash: {
+		label: "Bash",
+		arg: "command"
+	},
+	ReadFile: {
+		label: "Read",
+		arg: "path"
+	},
+	WriteFile: {
+		label: "Write",
+		arg: "path"
+	},
+	EditFile: {
+		label: "Update",
+		arg: "path"
+	},
+	GlobSearch: {
+		label: "Glob",
+		arg: "pattern"
+	},
+	GrepSearch: {
+		label: "Grep",
+		arg: "pattern"
+	},
+	WebFetch: {
+		label: "WebFetch",
+		arg: "url"
+	},
+	Task: {
+		label: "Task",
+		arg: "description"
+	},
+	Skill: {
+		label: "Skill",
+		arg: "name"
+	},
+	SendMessage: {
+		label: "SendMessage",
+		arg: "to"
+	},
+	AskUserQuestion: {
+		label: "AskUserQuestion",
+		arg: "question"
+	},
+	TodoWrite: { label: "TodoWrite" }
+};
+function toolHeaderFor(name) {
+	return TOOL_HEADERS[name] ?? { label: name };
+}
+function clip(s, max) {
+	const r = [...s];
+	if (r.length <= max) return s;
+	if (max <= 3) return r.slice(0, max).join("");
+	return r.slice(0, max - 3).join("") + "...";
+}
+function sanitizeLabel(s) {
+	let out = "";
+	for (const ch of s) {
+		const c = ch.codePointAt(0) ?? 0;
+		if (ch === "\n" || ch === "	") out += " ";
+		else if (c < 32 || c === 127) {} else out += ch;
+	}
+	return out;
+}
+function sanitizePanelText(s) {
+	let out = "";
+	for (const ch of s) {
+		const c = ch.codePointAt(0) ?? 0;
+		if (ch === "	") out += " ";
+		else if (ch === "\n") out += ch;
+		else if (c < 32 || c === 127) {} else out += ch;
+	}
+	return out;
+}
+var SALIENT_ARG_ORDER = [
+	"command",
+	"pattern",
+	"path",
+	"file_path",
+	"glob",
+	"url",
+	"query",
+	"output_mode",
+	"question",
+	"header"
+];
+var ELIDED_ARGS = /* @__PURE__ */ new Set([
+	"content",
+	"new_string",
+	"old_string",
+	"edits",
+	"options"
+]);
+function clipArg(s, style) {
+	const flat = s.replaceAll("\n", " ");
+	if (style.valueClip <= 0) return flat;
+	return clip(flat, style.valueClip);
+}
+function displayArg(v, style) {
+	return sanitizeLabel(clipArg((typeof v === "string" ? v : JSON.stringify(v)) ?? "", style));
+}
+function formatToolArgs(primary, argsJSON, style) {
+	let m;
+	try {
+		m = JSON.parse(argsJSON);
+	} catch {
+		return "";
+	}
+	if (!m || typeof m !== "object" || Object.keys(m).length === 0) return "";
+	const seen = /* @__PURE__ */ new Set();
+	const parts = [];
+	const add = (k) => {
+		if (!(k in m) || seen.has(k)) return;
+		seen.add(k);
+		const v = m[k];
+		const rendered = typeof v === "string" ? `${k}: "${clipArg(sanitizeLabel(v), style)}"` : `${k}: ${displayArg(v, style)}`;
+		parts.push(rendered);
+	};
+	if (primary && primary in m) {
+		seen.add(primary);
+		parts.push(displayArg(m[primary], style));
+	}
+	for (const k of SALIENT_ARG_ORDER) add(k);
+	const rest = Object.keys(m).filter((k) => !ELIDED_ARGS.has(k) && !seen.has(k)).sort();
+	for (const k of rest) add(k);
+	const joined = parts.join(", ");
+	if (style.totalClip <= 0) return joined;
+	return clip(joined, style.totalClip);
+}
+function summarizeToolArgs(primary, argsJSON) {
+	return formatToolArgs(primary, argsJSON, {
+		valueClip: 50,
+		totalClip: 100
+	});
+}
+function fullToolArgs(primary, argsJSON) {
+	return formatToolArgs(primary, argsJSON, {
+		valueClip: 0,
+		totalClip: 0
+	});
+}
+function plural(n, noun) {
+	return `${n} ${pluralNoun(n, noun)}`;
+}
+function pluralNoun(n, noun) {
+	if (n === 1) return noun;
+	if (/(?:s|x|ch|sh)$/.test(noun)) return `${noun}es`;
+	return `${noun}s`;
+}
+var TOOL_OUTPUT_TRUNCATION_MARKER = "\n\n... output truncated to ";
+function trimToolOutputNotice(body) {
+	const i = body.lastIndexOf(TOOL_OUTPUT_TRUNCATION_MARKER);
+	if (i >= 0) return [body.slice(0, i).replace(/\n+$/, ""), true];
+	return [body, false];
+}
+function summarizeToolResult(result) {
+	const trimmed = result.replace(/\n+$/, "");
+	if (trimmed.trim() === "") return "(no output)";
+	const lines = trimmed.split("\n");
+	const first = clip((lines[0] ?? "").trim(), 100);
+	if (lines.length > 1) return `${first}  (+${lines.length - 1} lines)`;
+	return first;
+}
+function isErrorResult(text) {
+	return text.trim().startsWith("Error:");
+}
+var RIPGREP_ERROR_PREFIX = "ripgrep error (exit ";
+function resultFailed(name, result) {
+	const body = result.trim();
+	switch (name) {
+		case "Bash":
+			if (bashExitCode(body)[2]) return true;
+			return isErrorResult(body) && !body.includes("\n");
+		case "WebFetch": return webFetchFailed(body);
+		case "GrepSearch": return body.startsWith(RIPGREP_ERROR_PREFIX) || isErrorResult(body);
+		default: return isErrorResult(body);
+	}
+}
+function webFetchFailed(body) {
+	if (body.startsWith("Error ")) return true;
+	const m = body.match(/^HTTP (\d+)/);
+	if (m) return Number(m[1]) >= 400;
+	return false;
+}
+function trailingNote(body) {
+	const i = body.lastIndexOf("\n");
+	const last = body.slice(i + 1);
+	if (last.startsWith("... (")) return [body.slice(0, Math.max(i, 0)), last];
+	return [body, ""];
+}
+function contentLines(body) {
+	const [rest, note] = trailingNote(body);
+	if (rest === "") return [[], note];
+	return [rest.split("\n"), note];
+}
+function readFileSummary(body) {
+	if (body === "(empty file)") return "Empty file";
+	if (body.startsWith("Read image ")) return "Read image";
+	const [lines, note] = contentLines(body);
+	let more = 0;
+	const m = note.match(/^\.\.\. \(truncated, (\d+) more lines\)/);
+	if (m) more = Number(m[1]);
+	if (more > 0) return `Read ${plural(lines.length, "line")} (${more} more)`;
+	return `Read ${plural(lines.length, "line")}`;
+}
+var GREP_CONTENT_PATH = /^(.+?):\d+:/;
+function grepMatchPath(line, lineNums) {
+	if (!lineNums) {
+		const i = line.indexOf(":");
+		return i >= 0 ? line.slice(0, i) : null;
+	}
+	const m = GREP_CONTENT_PATH.exec(line);
+	return m ? m[1] ?? null : null;
+}
+function grepSearchSummary(argsJSON, body) {
+	if (body === "No matches found." || body === "No results after applying offset.") return "No matches";
+	if (body.startsWith(RIPGREP_ERROR_PREFIX)) return summarizeToolResult(body);
+	const [lines, note] = contentLines(body);
+	let outputMode = "";
+	let lineNums = true;
+	try {
+		const a = JSON.parse(argsJSON);
+		outputMode = a.output_mode ?? "";
+		if (typeof a.n === "boolean") lineNums = a.n;
+	} catch {}
+	let s;
+	if (outputMode === "content") {
+		const files = /* @__PURE__ */ new Set();
+		let matches = 0;
+		for (const l of lines) {
+			const path = grepMatchPath(l, lineNums);
+			if (path === null) continue;
+			matches++;
+			files.add(path);
+		}
+		s = `Found ${plural(matches, "match")} in ${plural(files.size, "file")}`;
+	} else if (outputMode === "count") {
+		let total = 0;
+		for (const l of lines) {
+			const i = l.lastIndexOf(":");
+			const tail = i >= 0 ? l.slice(i + 1) : l;
+			const n = Number.parseInt(tail, 10);
+			if (!Number.isNaN(n)) total += n;
+		}
+		s = `Found ${plural(total, "match")} in ${plural(lines.length, "file")}`;
+	} else s = `Found ${plural(lines.length, "file")}`;
+	if (note !== "") s += " (truncated)";
+	return s;
+}
+function globSearchSummary(body) {
+	if (body === "No files matched the pattern.") return "No files matched";
+	const [lines, note] = contentLines(body);
+	let s = `Found ${plural(lines.length, "file")}`;
+	if (note !== "") s += " (truncated)";
+	return s;
+}
+function bashExitCode(body) {
+	let i = body.lastIndexOf("\nExit code: ");
+	if (i < 0) {
+		if (!body.startsWith("Exit code: ")) return [
+			body,
+			0,
+			false
+		];
+		i = 0;
+	}
+	const m = body.slice(i).replace(/^\n/, "").match(/^Exit code: (\d+)/);
+	const code = m ? Number(m[1]) : 0;
+	return [
+		body.slice(0, i).replace(/\n+$/, ""),
+		code,
+		true
+	];
+}
+function bashSummary(body) {
+	if (body === "(no output)") return "(no output)";
+	const [out, code, ok] = bashExitCode(body);
+	if (!ok) return summarizeToolResult(body);
+	if (out === "") return `Exit ${code}`;
+	return `Exit ${code} · ${plural(out.split("\n").length, "line")}`;
+}
+function webFetchSummary(body) {
+	const m = body.match(/^HTTP (\d+)/);
+	if (!m) return summarizeToolResult(body);
+	const status = Number(m[1]);
+	const sep = body.indexOf("\n\n");
+	if (sep < 0) return clip(body.split("\n")[0] ?? "", 100);
+	return `HTTP ${status} · ${plural(body.slice(sep + 2).split("\n").length, "line")}`;
+}
+function toolSummary(name, args, result, isError, editSummaryFn) {
+	const [body, spilled] = trimToolOutputNotice(result.replace(/\n+$/, ""));
+	if (isError || body.trim() === "" || isErrorResult(body)) return summarizeToolResult(result);
+	let s;
+	switch (name) {
+		case "EditFile":
+		case "WriteFile": {
+			const e = editSummaryFn?.(name, args) ?? "";
+			return e !== "" ? e : summarizeToolResult(result);
+		}
+		case "ReadFile":
+			s = readFileSummary(body);
+			break;
+		case "GrepSearch":
+			s = grepSearchSummary(args, body);
+			break;
+		case "GlobSearch":
+			s = globSearchSummary(body);
+			break;
+		case "Bash":
+			s = bashSummary(body);
+			break;
+		case "WebFetch":
+			s = webFetchSummary(body);
+			break;
+		default: return summarizeToolResult(result);
+	}
+	if (spilled) s += " (output truncated)";
+	return s;
+}
+var ROLLUP_CATEGORIES = [
+	[(n) => n === "GrepSearch" || n === "GlobSearch", (n) => `searched for ${plural(n, "pattern")}`],
+	[(n) => n === "ReadFile", (n) => `read ${plural(n, "file")}`],
+	[(n) => n === "Bash", (n) => `ran ${plural(n, "shell command")}`],
+	[(n) => n === "WebFetch", (n) => `fetched ${plural(n, "URL")}`],
+	[(n) => n === "Skill", (n) => `loaded ${plural(n, "skill")}`],
+	[(n) => n === "SendMessage", (n) => `sent ${plural(n, "message")}`],
+	[(n) => n.startsWith("mcp__"), (n) => `called ${plural(n, "MCP tool")}`],
+	[() => true, (n) => `ran ${plural(n, "tool")}`]
+];
+var NON_GROUPABLE_TOOLS = /* @__PURE__ */ new Set([
+	"EditFile",
+	"WriteFile",
+	"TodoWrite",
+	"Task"
+]);
+function isGroupableTool(name) {
+	return !NON_GROUPABLE_TOOLS.has(name);
+}
+function rollupSentence(names) {
+	const counts = ROLLUP_CATEGORIES.map(() => 0);
+	for (const name of names) for (let i = 0; i < ROLLUP_CATEGORIES.length; i++) if (ROLLUP_CATEGORIES[i]?.[0](name)) {
+		counts[i] = (counts[i] ?? 0) + 1;
+		break;
+	}
+	const parts = [];
+	for (let i = 0; i < counts.length; i++) {
+		const n = counts[i] ?? 0;
+		if (n > 0) {
+			const cat = ROLLUP_CATEGORIES[i];
+			if (cat) parts.push(cat[1](n));
+		}
+	}
+	if (parts.length === 0) return "";
+	const s = parts.join(", ");
+	return s.charAt(0).toUpperCase() + s.slice(1);
+}
+var AGENT_COLOR_NAMES = [
+	"blue",
+	"green",
+	"yellow",
+	"purple",
+	"cyan",
+	"orange",
+	"pink",
+	"red"
+];
+var AGENT_COLOR_HEX = {
+	red: "#ef4444",
+	blue: "#3b82f6",
+	green: "#22c55e",
+	yellow: "#eab308",
+	purple: "#a855f7",
+	orange: "#f97316",
+	pink: "#ec4899",
+	cyan: "#06b6d4"
+};
+function agentColorHex(name) {
+	return name ? AGENT_COLOR_HEX[name] ?? null : null;
+}
+//#endregion
+export { AGENT_COLOR_NAMES, agentColorHex, bashExitCode, clip, fullToolArgs, isGroupableTool, plural, resultFailed, rollupSentence, sanitizeLabel, sanitizePanelText, summarizeToolArgs, toolHeaderFor, toolSummary };

package/dist/ai/agent/transcript.d.ts

@@ -0,0 +1,38 @@
+export declare function hiddenTranscriptTool(name: string): boolean;
+export declare function askQuestionFromArgs(argsJSON: string): string;
+export declare function planFromArgs(argsJSON: string): string;
+/** A Task call's display label the way the tool itself picks it: the
+ *  description, else the clipped prompt, plus its custom agent type. */
+export declare function taskCallFromArgs(argsJSON: string): {
+    description: string;
+    agentType: string;
+};
+/** The built-in "default" type is the same general-purpose agent an untyped
+ *  Task spawns, so naming it would only add noise. */
+export declare function agentTypeLabel(t: string): string;
+/** The first line when the model wrote it as a heading ("# Title" or
+ *  "**Title**"), the way reasoning summaries open, so a folded thought says
+ *  what it was about. Prose gets no label of its own. */
+export declare function thinkingHeading(raw: string): string;
+/** How a turn cut short reads, whether replayed or watched live. */
+export declare const INTERRUPTED_NOTICE: string;
+/** The line the daemon files as the assistant's when a turn is cut short;
+ *  it is a status, not something the model said. */
+export declare function interruptionNotice(text: string): string | null;
+export declare function firstNonEmptyLine(text: string, max: number): string;
+export interface SubagentNotice {
+    id: string;
+    description: string;
+    preview: string;
+    /** The report itself, without the closing line addressed to the model. */
+    body: string;
+    interim: boolean;
+    /** The interrupted form is written for the model alone; the child's own
+     *  block already reads interrupted, so no line is drawn for it. */
+    silent: boolean;
+}
+/** Reads a "[Background subagent <id> (<desc>) completed]" header; null for
+ *  any other notice, which keeps its full text. */
+export declare function parseSubagentNotice(text: string): SubagentNotice | null;
+/** The line that marks a child's report entering the main conversation. */
+export declare function subagentDeliveryLine(n: SubagentNotice): string;

package/dist/ai/agent/transcript.js

@@ -0,0 +1,127 @@
+import { clip, sanitizeLabel } from "./toolfmt.js";
+//#region src/ai/agent/transcript.ts
+var HIDDEN_TRANSCRIPT_TOOLS = /* @__PURE__ */ new Set([
+	"AskUserQuestion",
+	"TodoWrite",
+	"ExitPlanMode"
+]);
+function hiddenTranscriptTool(name) {
+	return HIDDEN_TRANSCRIPT_TOOLS.has(name);
+}
+function parseArgs(argsJSON) {
+	try {
+		const parsed = JSON.parse(argsJSON);
+		return parsed && typeof parsed === "object" ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function str(v) {
+	return typeof v === "string" ? v : "";
+}
+function askQuestionFromArgs(argsJSON) {
+	return str(parseArgs(argsJSON)["question"]);
+}
+function planFromArgs(argsJSON) {
+	return str(parseArgs(argsJSON)["plan"]);
+}
+/** A Task call's display label the way the tool itself picks it: the
+*  description, else the clipped prompt, plus its custom agent type. */
+function taskCallFromArgs(argsJSON) {
+	const a = parseArgs(argsJSON);
+	const description = str(a["description"]) || clip(str(a["prompt"]), 40);
+	return {
+		description: sanitizeLabel(description),
+		agentType: agentTypeLabel(str(a["subagent_type"]))
+	};
+}
+/** The built-in "default" type is the same general-purpose agent an untyped
+*  Task spawns, so naming it would only add noise. */
+function agentTypeLabel(t) {
+	return t === "default" ? "" : sanitizeLabel(t);
+}
+/** The first line when the model wrote it as a heading ("# Title" or
+*  "**Title**"), the way reasoning summaries open, so a folded thought says
+*  what it was about. Prose gets no label of its own. */
+function thinkingHeading(raw) {
+	const first = raw.trim().split("\n")[0]?.trim() ?? "";
+	let line;
+	if (first.startsWith("#")) line = first.replace(/^#+/, "").trim();
+	else if (first.length > 4 && first.startsWith("**") && first.endsWith("**")) line = first.slice(2, -2).trim();
+	else return "";
+	return clip(sanitizeLabel(line), 60);
+}
+var INTERRUPTED_MARKER = "[Request interrupted by the user.]";
+/** How a turn cut short reads, whether replayed or watched live. */
+var INTERRUPTED_NOTICE = INTERRUPTED_MARKER.slice(1, -1);
+/** The line the daemon files as the assistant's when a turn is cut short;
+*  it is a status, not something the model said. */
+function interruptionNotice(text) {
+	return text.trim() === INTERRUPTED_MARKER ? INTERRUPTED_NOTICE : null;
+}
+function firstNonEmptyLine(text, max) {
+	for (const line of text.split("\n")) {
+		const s = line.trim();
+		if (s !== "") return clip(s, max);
+	}
+	return "";
+}
+var SUBAGENT_NOTICE_HEADS = /* @__PURE__ */ new Set(["Background subagent", "Message from subagent"]);
+/** Reads a "[Background subagent <id> (<desc>) completed]" header; null for
+*  any other notice, which keeps its full text. */
+function parseSubagentNotice(text) {
+	const trimmed = text.trim();
+	const nl = trimmed.indexOf("\n");
+	let head = nl === -1 ? trimmed : trimmed.slice(0, nl);
+	let body = nl === -1 ? "" : trimmed.slice(nl + 1);
+	if (!head.startsWith("[") || !head.endsWith("]")) return null;
+	head = head.slice(1, -1);
+	let shell = false;
+	let kind;
+	let rest;
+	const sub = head.indexOf(" subagent ");
+	if (sub !== -1 && SUBAGENT_NOTICE_HEADS.has(`${head.slice(0, sub)} subagent`)) {
+		kind = head.slice(0, sub);
+		rest = head.slice(sub + 10);
+	} else {
+		const cmd = head.indexOf(" command ");
+		if (cmd === -1 || head.slice(0, cmd) !== "Background") return null;
+		kind = "Background";
+		rest = head.slice(cmd + 9);
+		shell = true;
+	}
+	const open = rest.indexOf(" (");
+	if (open === -1) return null;
+	const id = rest.slice(0, open);
+	rest = rest.slice(open + 2);
+	const end = rest.lastIndexOf(")");
+	if (end === -1) return null;
+	const tail = rest.slice(end + 1);
+	const notice = {
+		id,
+		description: rest.slice(0, end),
+		interim: kind === "Message from",
+		silent: tail.includes("was interrupted"),
+		preview: "",
+		body: ""
+	};
+	if (shell) {
+		notice.preview = tail.trim();
+		return notice;
+	}
+	const lines = body.split("\n");
+	const last = lines[lines.length - 1] ?? "";
+	if (lines.length > 0 && last.trim().startsWith("(pass ")) body = lines.slice(0, -1).join("\n");
+	notice.body = body.trim();
+	notice.preview = firstNonEmptyLine(body, 70);
+	return notice;
+}
+/** The line that marks a child's report entering the main conversation. */
+function subagentDeliveryLine(n) {
+	const name = n.description ? `${n.id} (${n.description})` : n.id;
+	let label = n.interim ? `↳ message from ${name}` : `↳ ${name} reported back`;
+	if (n.preview) label += `: ${sanitizeLabel(n.preview)}`;
+	return label;
+}
+//#endregion
+export { INTERRUPTED_NOTICE, agentTypeLabel, askQuestionFromArgs, firstNonEmptyLine, hiddenTranscriptTool, interruptionNotice, parseSubagentNotice, planFromArgs, subagentDeliveryLine, taskCallFromArgs, thinkingHeading };