topchester-ai 0.11.0 → 0.13.0

package/dist/cli.mjs

@@ -382,6 +382,9 @@ const findFileTool = defineTool({
 	description: "Find files by fuzzy name inside the workspace. Results are file paths, not file contents; use read_file next when the user needs contents.",
 	prompt: "find_file: find existing files by fuzzy path or filename inside the workspace; matches may appear in the middle of a filename, and results are file paths, not file contents. To use it, reply with only JSON: {\"tool\":\"find_file\",\"args\":{\"query\":\"runtime\"}}",
 	argsSchema: findFileArgsSchema,
+	parallelSafe: true,
+	mutatesWorkspace: false,
+	resourceKeys: (args) => [`find:${args.path}`],
 	execute: (context, args) => findWorkspaceFilesByName(context.workspaceRoot, args, {
 		pathEnv: context.pathEnv,
 		logger: context.logger
@@ -918,6 +921,9 @@ const gitStatusTool = defineTool({
 	description: "Inspect structured Git branch and changed-file status inside the workspace.",
 	prompt: "git_status: inspect branch, head, clean state, staged, unstaged, and untracked files without parsing shell output. To use it, reply with only JSON: {\"tool\":\"git_status\",\"args\":{\"path\":\".\",\"include_untracked\":true}}",
 	argsSchema: gitStatusArgsSchema,
+	parallelSafe: true,
+	mutatesWorkspace: false,
+	resourceKeys: (args) => [`git-status:${args.path}`],
 	execute: (context, args) => inspectGitStatus(context, args)
 });
 const gitDiffTool = defineTool({
@@ -925,6 +931,9 @@ const gitDiffTool = defineTool({
 	description: "Inspect bounded Git diffs for staged, unstaged, and optionally untracked files.",
 	prompt: "git_diff: inspect a bounded Git diff; use scope \"all\", \"unstaged\", or \"staged\", and include_untracked:true only when untracked file patches are needed. To use it, reply with only JSON: {\"tool\":\"git_diff\",\"args\":{\"scope\":\"all\",\"include_untracked\":true}}",
 	argsSchema: gitDiffArgsSchema,
+	parallelSafe: true,
+	mutatesWorkspace: false,
+	resourceKeys: (args) => [`git-diff:${args.path ?? "."}:${args.scope}`],
 	execute: (context, args) => inspectGitDiff(context, args)
 });
 const gitLogTool = defineTool({
@@ -932,6 +941,9 @@ const gitLogTool = defineTool({
 	description: "Inspect recent Git commits as bounded structured summaries.",
 	prompt: "git_log: inspect recent commits without parsing shell output. To use it, reply with only JSON: {\"tool\":\"git_log\",\"args\":{\"limit\":10,\"path\":\"src/agent/runtime.ts\"}}",
 	argsSchema: gitLogArgsSchema,
+	parallelSafe: true,
+	mutatesWorkspace: false,
+	resourceKeys: (args) => [`git-log:${args.path ?? "."}`],
 	execute: (context, args) => inspectGitLog(context, args)
 });
 const gitAddTool = defineTool({
@@ -1346,6 +1358,9 @@ const grepTool = defineTool({
 		pattern: z.string(),
 		path: z.string().optional()
 	}),
+	parallelSafe: true,
+	mutatesWorkspace: false,
+	resourceKeys: (args) => [`grep:${args.path ?? "."}`],
 	execute: (context, args) => grepWorkspace(context.workspaceRoot, args, {
 		pathEnv: context.pathEnv,
 		logger: context.logger
@@ -2320,6 +2335,9 @@ const listFilesTool = defineTool({
 		recursive: z.boolean().optional().default(false),
 		limit: z.number().int().min(1).max(2e3).optional().default(500)
 	}),
+	parallelSafe: true,
+	mutatesWorkspace: false,
+	resourceKeys: (args) => [`dir:${args.path}`],
 	execute: (context, args) => listWorkspaceFiles(context.workspaceRoot, args)
 });
 async function listWorkspaceFiles(workspaceRoot, args) {
@@ -2634,7 +2652,7 @@ function truncateText(text, width) {
 const planTodoTool = defineTool({
 	name: "plan_todo",
 	description: "Replace the visible session task plan for multi-step work.",
-	prompt: "plan_todo: replace the visible session task plan for non-trivial multi-step work; keep 2-6 short items, exactly one in_progress item while work remains, and use [] only to clear. To use it, reply with only JSON: {\"tool\":\"plan_todo\",\"args\":{\"items\":[{\"text\":\"Inspect relevant files\",\"status\":\"in_progress\"},{\"text\":\"Implement focused change\",\"status\":\"pending\"}]}}",
+	prompt: "plan_todo: replace the visible session task plan for non-trivial multi-step work; keep 2-6 short items, exactly one in_progress item while work remains, and use [] only to clear. Do not use plan_todo just to report completed work before a final answer. To use it, reply with only JSON: {\"tool\":\"plan_todo\",\"args\":{\"items\":[{\"text\":\"Inspect relevant files\",\"status\":\"in_progress\"},{\"text\":\"Implement focused change\",\"status\":\"pending\"}]}}",
 	argsSchema: planTodoArgsSchema,
 	async execute(context, args) {
 		if (!context.taskPlan) throw new Error("plan_todo requires runtime task-plan state.");
@@ -2653,6 +2671,9 @@ const readFileTool = defineTool({
 	description: "Read a UTF-8 file inside the workspace.",
 	prompt: "read_file: read a UTF-8 file inside the workspace. To use it, reply with only JSON: {\"tool\":\"read_file\",\"args\":{\"path\":\"package.json\"}}",
 	argsSchema: z.object({ path: z.string() }),
+	parallelSafe: true,
+	mutatesWorkspace: false,
+	resourceKeys: (args) => [`file:${args.path}`],
 	execute: (context, args) => readWorkspaceFile(context.workspaceRoot, args.path)
 });
 async function readWorkspaceFile(workspaceRoot, path) {
@@ -2669,6 +2690,42 @@ async function readWorkspaceFile(workspaceRoot, path) {
 		hash: `sha256:${createHash("sha256").update(bytes).digest("hex")}`
 	};
 }
+const taskTool = defineTool({
+	name: "task",
+	description: "Delegate a focused prompt to a constrained child agent session.",
+	prompt: "task: delegate focused read-only research or isolated analysis to a child agent session. Use it when parallel context gathering would help. To use it, reply with only JSON: {\"tool\":\"task\",\"args\":{\"description\":\"Inspect runtime event flow\",\"prompt\":\"Read the runtime and summarize how events are emitted.\",\"subagent_type\":\"explore\"}}",
+	argsSchema: z.object({
+		description: z.string().min(1),
+		prompt: z.string().min(1),
+		subagent_type: z.string().optional(),
+		task_id: z.string().optional()
+	}),
+	async execute(context, args) {
+		if (!context.subagents) throw new Error("task requires a runtime subagent manager.");
+		const result = await context.subagents.runTask({
+			description: args.description,
+			prompt: args.prompt,
+			subagentType: args.subagent_type,
+			taskId: args.task_id,
+			parentToolCallId: context.toolCallId ?? args.task_id ?? "task",
+			eventSink: context.eventSink,
+			abortSignal: context.abortSignal
+		});
+		return {
+			tool: "task",
+			childSessionId: result.sessionId,
+			status: result.status,
+			profileId: result.profileId,
+			content: [
+				`Task ${result.status}: ${args.description}`,
+				`child_session: ${result.sessionId}`,
+				`profile: ${result.profileId}`,
+				"",
+				result.result
+			].join("\n")
+		};
+	}
+});
 const writeFileTool = defineTool({
 	name: "write_file",
 	description: "Create a new UTF-8 file inside the workspace, or explicitly replace one. For overwrite:true, expected_current_hash must be the current/pre-write hash from read_file, never a predicted post-write hash.",
@@ -2881,6 +2938,7 @@ function isNodeError$2(error) {
 //#endregion
 //#region src/agent/tools/registry.ts
 const toolRegistry = {
+	[taskTool.name]: taskTool,
 	[planTodoTool.name]: planTodoTool,
 	[readFileTool.name]: readFileTool,
 	[listFilesTool.name]: listFilesTool,
@@ -2901,8 +2959,16 @@ function isToolName(name) {
 function getToolDefinition(name) {
 	return toolRegistry[name];
 }
-function getToolPromptLines() {
-	return Object.values(toolRegistry).map((tool) => tool.prompt);
+function getToolPromptLines(filter) {
+	return getToolDefinitionsForPermissions(filter).map((tool) => tool.prompt);
+}
+function getToolDefinitionsForPermissions(filter) {
+	return Object.entries(toolRegistry).filter(([name]) => filter?.(name) ?? true).map(([, tool]) => tool);
+}
+function isParallelSafeToolName(name) {
+	if (!isToolName(name)) return false;
+	const definition = toolRegistry[name];
+	return Boolean(definition.parallelSafe && !definition.mutatesWorkspace && !definition.requiresExclusiveWorkspace);
 }
 //#endregion
 //#region src/agent/tools/xml-parser.ts
@@ -2991,7 +3057,7 @@ function parseToolCallWithSource(text, allowedSources = ["text-json", "text-xml"
 	if (allowedSources.includes("text-json")) {
 		const json = parseJsonToolCall(text);
 		if (json) return {
-			call: json,
+			...json,
 			source: "text-json"
 		};
 	}
@@ -2999,7 +3065,8 @@ function parseToolCallWithSource(text, allowedSources = ["text-json", "text-xml"
 		const xml = parseXmlToolCall(text);
 		if (xml) return {
 			call: xml,
-			source: "text-xml"
+			source: "text-xml",
+			remainder: ""
 		};
 	}
 }
@@ -3014,12 +3081,16 @@ function parseNativeToolCall(toolName, args) {
 	};
 }
 function parseJsonToolCall(text) {
-	const trimmed = extractToolJsonCandidate(stripJsonFence(text.trim()));
+	const { json, remainder } = extractToolJsonCandidate(stripJsonFence(text.trim()));
 	let value;
 	try {
-		value = JSON.parse(trimmed);
+		value = JSON.parse(json);
 	} catch {
-		return;
+		try {
+			value = JSON.parse(escapeControlCharactersInJsonStrings(json));
+		} catch {
+			return;
+		}
 	}
 	if (!isRecord$1(value) || typeof value.tool !== "string") return;
 	if (!isToolName(value.tool)) return;
@@ -3027,17 +3098,29 @@ function parseJsonToolCall(text) {
 	const parsed = definition.argsSchema.safeParse(value.args);
 	if (!parsed.success) return;
 	return {
-		tool: definition.name,
-		args: parsed.data
+		call: {
+			tool: definition.name,
+			args: parsed.data
+		},
+		remainder: remainder.trim()
 	};
 }
 function stripJsonFence(text) {
 	return text.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i)?.[1] ?? text;
 }
 function extractToolJsonCandidate(text) {
-	if (!text.startsWith("{")) return text;
+	if (!text.startsWith("{")) return {
+		json: text,
+		remainder: ""
+	};
 	const endIndex = findJsonObjectEnd(text);
-	return endIndex === void 0 ? text : text.slice(0, endIndex + 1);
+	return endIndex === void 0 ? {
+		json: text,
+		remainder: ""
+	} : {
+		json: text.slice(0, endIndex + 1),
+		remainder: text.slice(endIndex + 1)
+	};
 }
 function findJsonObjectEnd(text) {
 	let depth = 0;
@@ -3059,6 +3142,39 @@ function findJsonObjectEnd(text) {
 		}
 	}
 }
+function escapeControlCharactersInJsonStrings(text) {
+	let result = "";
+	let inString = false;
+	let escaped = false;
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (!inString) {
+			result += char;
+			if (char === "\"") inString = true;
+			continue;
+		}
+		if (escaped) {
+			result += char;
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			result += char;
+			escaped = true;
+			continue;
+		}
+		if (char === "\"") {
+			result += char;
+			inString = false;
+			continue;
+		}
+		if (char === "\n") result += "\\n";
+		else if (char === "\r") result += "\\r";
+		else if (char === "	") result += "\\t";
+		else result += char;
+	}
+	return result;
+}
 function isRecord$1(value) {
 	return typeof value === "object" && value !== null;
 }
@@ -3112,6 +3228,7 @@ var ModelGateway = class ModelGateway {
 			model: resolved.model,
 			system: request.system,
 			prompt: request.prompt,
+			providerOptions: buildProviderOptions(resolved.providerId, resolved.providerConfig),
 			abortSignal: request.abortSignal
 		});
 		const usage = normalizeUsage(result.usage, {
@@ -3131,9 +3248,17 @@ var ModelGateway = class ModelGateway {
 		const resolved = this.resolveModel(request.purpose ?? "agent.primary");
 		const override = request.toolProtocol ?? resolved.modelConfig.toolProtocol ?? resolved.providerConfig.toolProtocol ?? "auto";
 		const attempts = [];
+		if (override === "auto" && shouldUseTextProtocolForOpenRouterStreaming(request, resolved)) {
+			attempts.push({
+				protocol: "native-openai-compatible",
+				status: "skipped",
+				reason: "openrouter streaming auto uses text-json"
+			});
+			return this.generateTextAgentStep(request, resolved, attempts, "openrouter streaming auto uses text JSON protocol", false, ["text-json"]);
+		}
 		if (override === "native" || override === "auto") try {
 			const result = await this.generateNativeAgentStep(request, resolved, attempts);
-			if (result.toolCalls.length > 0 || override === "native") return result;
+			if (result.toolCalls.length > 0) return result;
 			const parsedTextCall = parseToolCallWithSource(result.text);
 			if (parsedTextCall) {
 				const fallbackProtocol = parsedTextCall.source === "text-xml" ? "text-xml" : "text-json";
@@ -3174,17 +3299,19 @@ var ModelGateway = class ModelGateway {
 		return this.generateTextAgentStep(request, resolved, attempts, override === "text-xml" ? "forced text XML protocol" : "forced text JSON protocol", false, override === "text-xml" ? ["text-xml"] : ["text-json"]);
 	}
 	async *streamText(request) {
+		const resolved = this.resolveModel(request.purpose);
 		yield* streamText({
-			model: this.resolveModel(request.purpose).model,
+			model: resolved.model,
 			system: request.system,
 			prompt: request.prompt,
+			providerOptions: buildProviderOptions(resolved.providerId, resolved.providerConfig),
 			abortSignal: request.abortSignal
 		}).textStream;
 	}
 	async generateNativeAgentStep(request, resolved, attempts) {
 		const providerOptions = buildNativeProviderOptions(resolved.providerId, resolved.providerConfig);
 		const openRouterRoutingApplied = hasOpenRouterRoutingOptions(providerOptions, resolved.providerId);
-		const result = await generateText({
+		const result = request.onReasoning ? await this.streamNativeAgentStep(request, resolved, providerOptions) : await generateText({
 			model: resolved.model,
 			system: request.system,
 			prompt: request.prompt,
@@ -3227,10 +3354,11 @@ var ModelGateway = class ModelGateway {
 		};
 	}
 	async generateTextAgentStep(request, resolved, attempts, fallbackReason, providerRejectedTools, allowedSources) {
-		const result = await generateText({
+		const result = request.onReasoning ? await this.streamTextAgentStep(request, resolved) : await generateText({
 			model: resolved.model,
 			system: request.system,
 			prompt: request.prompt,
+			providerOptions: buildProviderOptions(resolved.providerId, resolved.providerConfig),
 			abortSignal: request.abortSignal
 		});
 		const usage = normalizeUsage(result.usage, {
@@ -3266,25 +3394,178 @@ var ModelGateway = class ModelGateway {
 			openRouterRoutingApplied: false
 		};
 	}
+	async streamNativeAgentStep(request, resolved, providerOptions) {
+		const result = streamText({
+			model: resolved.model,
+			system: request.system,
+			prompt: request.prompt,
+			tools: toAiSdkToolSet(request.tools),
+			toolChoice: "auto",
+			providerOptions,
+			abortSignal: request.abortSignal,
+			includeRawChunks: true
+		});
+		guardStreamTextResultRejections(result);
+		let rawUsageBody;
+		let sawReasoningDelta = false;
+		let reasoningText;
+		let text;
+		let toolCalls;
+		let usage;
+		let warnings;
+		let response;
+		try {
+			({rawUsageBody, sawReasoningDelta} = await consumeReasoningStream(result.fullStream, request.onReasoning));
+			[text, toolCalls, usage, warnings, response, reasoningText] = await Promise.all([
+				result.text,
+				result.toolCalls,
+				result.usage,
+				result.warnings,
+				result.response,
+				result.reasoningText
+			]);
+		} catch (error) {
+			await settleRejectedStreamTextResult(result);
+			throw error;
+		}
+		await emitReasoningSummary(request.onReasoning, sawReasoningDelta, reasoningText);
+		return {
+			text,
+			toolCalls,
+			usage,
+			warnings,
+			response: withRawUsageBody(response, rawUsageBody)
+		};
+	}
+	async streamTextAgentStep(request, resolved) {
+		const result = streamText({
+			model: resolved.model,
+			system: request.system,
+			prompt: request.prompt,
+			providerOptions: buildProviderOptions(resolved.providerId, resolved.providerConfig),
+			abortSignal: request.abortSignal,
+			includeRawChunks: true
+		});
+		guardStreamTextResultRejections(result);
+		let rawUsageBody;
+		let sawReasoningDelta = false;
+		let reasoningText;
+		let text;
+		let usage;
+		let warnings;
+		let response;
+		try {
+			({rawUsageBody, sawReasoningDelta} = await consumeReasoningStream(result.fullStream, request.onReasoning));
+			[text, usage, warnings, response, reasoningText] = await Promise.all([
+				result.text,
+				result.usage,
+				result.warnings,
+				result.response,
+				result.reasoningText
+			]);
+		} catch (error) {
+			await settleRejectedStreamTextResult(result);
+			throw error;
+		}
+		await emitReasoningSummary(request.onReasoning, sawReasoningDelta, reasoningText);
+		return {
+			text,
+			usage,
+			warnings,
+			response: withRawUsageBody(response, rawUsageBody)
+		};
+	}
 };
+function guardStreamTextResultRejections(result) {
+	for (const promise of [
+		result.text,
+		result.toolCalls,
+		result.usage,
+		result.warnings,
+		result.response,
+		result.reasoningText
+	]) if (promise) Promise.resolve(promise).catch(() => {});
+}
+async function settleRejectedStreamTextResult(result) {
+	await Promise.allSettled([
+		result.text,
+		result.toolCalls,
+		result.usage,
+		result.warnings,
+		result.response,
+		result.reasoningText
+	].filter((promise) => promise !== void 0).map((promise) => Promise.resolve(promise)));
+}
+async function consumeReasoningStream(stream, onReasoning) {
+	let sawReasoningDelta = false;
+	let rawUsageBody;
+	for await (const part of stream) {
+		if (!part || typeof part !== "object") continue;
+		const typedPart = part;
+		if (typedPart.type === "error") throw typedPart.error;
+		if (typedPart.type === "raw" && hasUsageCostBody(typedPart.rawValue)) {
+			rawUsageBody = typedPart.rawValue;
+			continue;
+		}
+		if (typedPart.type !== "reasoning-delta") continue;
+		const text = typeof typedPart.text === "string" ? typedPart.text : typedPart.delta;
+		if (typeof text !== "string" || text.trim().length === 0) continue;
+		sawReasoningDelta = true;
+		await onReasoning?.({
+			type: "delta",
+			text
+		});
+	}
+	return rawUsageBody === void 0 ? { sawReasoningDelta } : {
+		sawReasoningDelta,
+		rawUsageBody
+	};
+}
+async function emitReasoningSummary(onReasoning, sawReasoningDelta, reasoningText) {
+	if (sawReasoningDelta || !reasoningText || reasoningText.trim().length === 0) return;
+	await onReasoning?.({
+		type: "summary",
+		text: reasoningText
+	});
+}
+function hasUsageCostBody(value) {
+	return Boolean(value && typeof value === "object" && "usage" in value && value.usage && typeof value.usage === "object");
+}
+function withRawUsageBody(response, rawUsageBody) {
+	return rawUsageBody === void 0 ? response : {
+		...response,
+		body: rawUsageBody
+	};
+}
 function resolveApiKey(config) {
 	if (config.apiKey !== void 0) return config.apiKey;
 	if (config.apiKeyEnv === void 0) return;
 	return process.env[config.apiKeyEnv];
 }
+function buildProviderOptions(providerId, config) {
+	const options = {};
+	if (config.service_tier !== void 0) options.service_tier = config.service_tier;
+	return { [providerId]: options };
+}
 function buildNativeProviderOptions(providerId, config) {
-	const options = { parallel_tool_calls: false };
+	const options = {
+		...buildProviderOptions(providerId, config)[providerId],
+		parallel_tool_calls: false
+	};
 	if (shouldApplyOpenRouterRoutingOptions(providerId, config)) options.provider = { require_parameters: true };
 	return { [providerId]: options };
 }
 function shouldApplyOpenRouterRoutingOptions(providerId, config) {
 	if (config.openRouterToolRouting === "force") return true;
 	if (config.openRouterToolRouting === "off") return false;
-	return isOpenRouterProvider(providerId, config);
+	return isOpenRouterProvider$1(providerId, config);
 }
-function isOpenRouterProvider(providerId, config) {
+function isOpenRouterProvider$1(providerId, config) {
 	return providerId.toLowerCase().includes("openrouter") || config.baseURL.toLowerCase().includes("openrouter.ai");
 }
+function shouldUseTextProtocolForOpenRouterStreaming(request, resolved) {
+	return request.onReasoning !== void 0 && isOpenRouterProvider$1(resolved.providerId, resolved.providerConfig);
+}
 function hasOpenRouterRoutingOptions(providerOptions, providerId) {
 	const options = providerOptions[providerId];
 	return Boolean(options && typeof options === "object" && "provider" in options);
@@ -3298,7 +3579,7 @@ function extractWarningMessages(warnings) {
 	return warnings.map((warning) => formatErrorMessage$2(warning));
 }
 function normalizeUsage(usage, context) {
-	const costUsd = context && isOpenRouterProvider(context.providerId, context.providerConfig) ? extractOpenRouterCost(context.responseBody) : void 0;
+	const costUsd = context && isOpenRouterProvider$1(context.providerId, context.providerConfig) ? extractOpenRouterCost(context.responseBody) : void 0;
 	if (!usage) return costUsd === void 0 ? void 0 : { costUsd };
 	const normalized = {
 		...typeof usage.inputTokens === "number" ? { inputTokens: usage.inputTokens } : {},
@@ -3334,6 +3615,10 @@ const toolProtocolSchema = z.enum([
 	"text-json",
 	"text-xml"
 ]);
+const openRouterAttributionHeaders = {
+	"HTTP-Referer": "https://topchester.com",
+	"X-Title": "Topchester"
+};
 const providerSchema = z.object({
 	type: z.literal("openai-compatible"),
 	baseURL: z.string().url(),
@@ -3341,6 +3626,7 @@ const providerSchema = z.object({
 	apiKey: z.string().optional(),
 	headers: z.record(z.string(), z.string()).optional(),
 	supportsStructuredOutputs: z.boolean().optional(),
+	service_tier: z.enum(["flex", "priority"]).optional(),
 	toolProtocol: toolProtocolSchema.optional(),
 	openRouterToolRouting: z.enum([
 		"auto",
@@ -3395,10 +3681,19 @@ const rawTopchesterConfigSchema = z.object({
 	models: rawModelsSchema.optional(),
 	ignore: z.object({ paths: z.array(ignorePathSchema).optional() }).optional()
 });
+function getGlobalTopchesterConfigDir() {
+	return join(homedir(), ".config", "topchester");
+}
+function ensureGlobalTopchesterConfigDir() {
+	const dir = getGlobalTopchesterConfigDir();
+	mkdirSync(dir, { recursive: true });
+	return dir;
+}
 function loadTopchesterConfig(options) {
+	const globalConfigDir = getGlobalTopchesterConfigDir();
 	const paths = [
-		join(homedir(), ".config/topchester/config.yaml"),
-		join(homedir(), ".config/topchester/config.jsonc"),
+		join(globalConfigDir, "config.yaml"),
+		join(globalConfigDir, "config.jsonc"),
 		join(options.workspaceRoot, "topchester.yaml"),
 		join(options.workspaceRoot, "topchester.jsonc"),
 		join(options.workspaceRoot, ".topchester/config.local.yaml"),
@@ -3506,10 +3801,7 @@ function ensureKnownProvider(providers, provider) {
 		baseURL: "https://openrouter.ai/api/v1",
 		apiKeyEnv: "OPENROUTER_API_KEY",
 		supportsStructuredOutputs: true,
-		headers: {
-			"HTTP-Referer": "https://topchester.com",
-			"X-Title": "Topchester"
-		}
+		headers: { ...openRouterAttributionHeaders }
 	};
 }
 function applyKnownProviderDefaults(providers) {
@@ -3519,8 +3811,15 @@ function applyKnownProviderDefaults(providers) {
 			provider.supportsStructuredOutputs ??= true;
 			provider.toolProtocol ??= "native";
 		}
+		if (isOpenRouterProvider(providerId, provider.baseURL)) provider.headers = {
+			...openRouterAttributionHeaders,
+			...isPlainObject(provider.headers) ? provider.headers : {}
+		};
 	}
 }
+function isOpenRouterProvider(providerId, baseURL) {
+	return providerId.toLowerCase().includes("openrouter") || baseURL.toLowerCase().includes("openrouter.ai");
+}
 function isOpenAIProvider(providerId, baseURL) {
 	const normalizedProvider = providerId.toLowerCase();
 	const normalizedBaseURL = baseURL.toLowerCase();
@@ -3609,6 +3908,7 @@ function normalizeLogLevel(level) {
 //#endregion
 //#region src/app/context.ts
 function createAppContext(options) {
+	ensureGlobalTopchesterConfigDir();
 	const config = loadTopchesterConfig(options);
 	const modelGateway = new ModelGateway(normalizeModelGatewayConfig(config));
 	const loggerInfo = createTopchesterLogger(options.workspaceRoot);
@@ -5519,6 +5819,12 @@ function agentMessage(text, meta) {
 		meta
 	};
 }
+function thinkingMessage(text) {
+	return {
+		kind: "thinking",
+		text
+	};
+}
 function toolCallMessage(call, label, resultSummary) {
 	return resultSummary === void 0 ? {
 		kind: "tool_call",
@@ -5531,6 +5837,12 @@ function toolCallMessage(call, label, resultSummary) {
 		resultSummary
 	};
 }
+function subagentMessage(message) {
+	return {
+		kind: "subagent",
+		...message
+	};
+}
 function modalMessage(message) {
 	return {
 		kind: "modal",
@@ -5540,6 +5852,8 @@ function modalMessage(message) {
 function renderChatMessage(message, options = {}) {
 	if (message.kind === "modal") return renderChatModal(message, options.selectedActionIndex);
 	if (message.kind === "tool_call") return renderToolCallMessage(message);
+	if (message.kind === "subagent") return renderSubagentMessage(message);
+	if (message.kind === "thinking") return message.text.split("\n").map((line) => ui.muted(line));
 	if (message.text.length === 0) return [""];
 	const lines = message.kind === "agent" && options.width !== void 0 ? renderMarkdown(message.text, Math.max(1, options.width - getPrefix(message.kind).length)) : message.text.split("\n");
 	if (message.kind === "user") return renderUserMessage(lines);
@@ -5572,6 +5886,18 @@ function renderToolCallMessage(message) {
 	const visibleLabel = message.resultSummary && !message.label.includes(message.resultSummary) ? `${message.label} ${message.resultSummary}` : message.label;
 	return [`   ${ui.muted(expandTabs(visibleLabel))}`];
 }
+function renderSubagentMessage(message) {
+	const label = message.title ?? shortSessionId(message.sessionId);
+	switch (message.status) {
+		case "running": return [`   ${ui.muted(`↳ task: ${label} (running)`)}`];
+		case "event": return message.text ? [`   ${ui.muted(`↳ task: ${label}: ${message.text}`)}`] : [];
+		case "completed": return [`   ${ui.muted(`↳ task: ${label} (completed)`)}`, ...message.text ? [`     ${message.text}`] : []];
+		case "failed": return [`   ${ui.warn(`↳ task: ${label} (failed)`)}`, ...message.text ? [`     ${message.text}`] : []];
+	}
+}
+function shortSessionId(sessionId) {
+	return sessionId.length <= 8 ? sessionId : sessionId.slice(0, 8);
+}
 function expandTabs(line) {
 	let column = 0;
 	let expanded = "";
@@ -5640,11 +5966,21 @@ const jsonValueSchema = z.lazy(() => z.union([
 const sessionMetadataSchema = z.object({
 	version: z.literal(1),
 	sessionId: z.string(),
+	rootSessionId: z.string().optional(),
+	parentSessionId: z.string().optional(),
+	parentToolCallId: z.string().optional(),
+	source: z.enum(["user", "subagent"]).optional(),
+	agentProfileId: z.string().optional(),
+	title: z.string().optional(),
 	workspaceRoot: z.string().min(1),
 	createdAt: isoTimestampSchema,
 	updatedAt: isoTimestampSchema,
 	lastEventId: z.number().int().min(0)
-});
+}).transform((metadata) => ({
+	...metadata,
+	rootSessionId: metadata.rootSessionId ?? metadata.sessionId,
+	source: metadata.source ?? "user"
+}));
 const eventEnvelopeSchema = z.object({
 	version: z.literal(1),
 	id: z.number().int().positive(),
@@ -5696,15 +6032,74 @@ const choicePayloadSchema = z.object({
 		value: z.string().optional()
 	}))
 });
+const subagentLifecycleBasePayloadSchema = z.object({
+	sessionId: z.string(),
+	parentSessionId: z.string(),
+	parentToolCallId: z.string()
+});
+const subagentStartedPayloadSchema = subagentLifecycleBasePayloadSchema.extend({
+	kind: z.literal("subagent_started"),
+	agentProfileId: z.string().optional(),
+	title: z.string().optional()
+});
+const subagentEventPayloadSchema = subagentLifecycleBasePayloadSchema.extend({
+	kind: z.literal("subagent_event"),
+	event: z.record(z.string(), jsonValueSchema)
+});
+const subagentCompletedPayloadSchema = subagentLifecycleBasePayloadSchema.extend({
+	kind: z.literal("subagent_completed"),
+	result: z.string().optional()
+});
+const subagentFailedPayloadSchema = subagentLifecycleBasePayloadSchema.extend({
+	kind: z.literal("subagent_failed"),
+	error: z.string()
+});
 const sessionEventPayloadSchema = z.discriminatedUnion("kind", [
 	messagePayloadSchema,
 	toolCallPayloadSchema,
 	taskPlanPayloadSchema,
 	statusPayloadSchema,
 	knowledgeStatusPayloadSchema,
-	choicePayloadSchema
+	choicePayloadSchema,
+	subagentStartedPayloadSchema,
+	subagentEventPayloadSchema,
+	subagentCompletedPayloadSchema,
+	subagentFailedPayloadSchema
 ]);
 const sessionEventSchema = z.intersection(eventEnvelopeSchema, sessionEventPayloadSchema);
+const sessionEventPayload = {
+	subagentStarted(reference, options = {}) {
+		return {
+			kind: "subagent_started",
+			...reference,
+			...options
+		};
+	},
+	subagentEvent(reference, event) {
+		return {
+			kind: "subagent_event",
+			...reference,
+			event
+		};
+	},
+	subagentCompleted(reference, result) {
+		return result === void 0 ? {
+			kind: "subagent_completed",
+			...reference
+		} : {
+			kind: "subagent_completed",
+			...reference,
+			result
+		};
+	},
+	subagentFailed(reference, error) {
+		return {
+			kind: "subagent_failed",
+			...reference,
+			error
+		};
+	}
+};
 //#endregion
 //#region src/session/store.ts
 const SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
@@ -5720,6 +6115,8 @@ async function createSession(workspaceRoot) {
 	const metadata = {
 		version: 1,
 		sessionId,
+		rootSessionId: sessionId,
+		source: "user",
 		workspaceRoot,
 		createdAt,
 		updatedAt: createdAt,
@@ -5730,6 +6127,41 @@ async function createSession(workspaceRoot) {
 	await writeFile(eventsPath, "", { flag: "wx" });
 	return buildHandle(sessionDir, metadata);
 }
+async function createChildSession(workspaceRoot, options) {
+	validateSessionId(options.parent.sessionId);
+	const sessionId = generateSessionId();
+	const sessionDir = join(getTopchesterSessionsPath(workspaceRoot), sessionId);
+	const metadataPath = join(sessionDir, "metadata.json");
+	const eventsPath = join(sessionDir, "events.jsonl");
+	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+	const metadata = {
+		version: 1,
+		sessionId,
+		rootSessionId: options.parent.metadata.rootSessionId,
+		parentSessionId: options.parent.sessionId,
+		parentToolCallId: options.parentToolCallId,
+		source: "subagent",
+		...options.agentProfileId === void 0 ? {} : { agentProfileId: options.agentProfileId },
+		...options.title === void 0 ? {} : { title: options.title },
+		workspaceRoot,
+		createdAt,
+		updatedAt: createdAt,
+		lastEventId: 0
+	};
+	await mkdir(sessionDir, { recursive: true });
+	await writeMetadata(metadataPath, metadata);
+	await writeFile(eventsPath, "", { flag: "wx" });
+	const child = buildHandle(sessionDir, metadata);
+	if (options.recordParentEvent ?? true) await options.parent.append(sessionEventPayload.subagentStarted({
+		sessionId: child.sessionId,
+		parentSessionId: options.parent.sessionId,
+		parentToolCallId: options.parentToolCallId
+	}, {
+		...options.agentProfileId === void 0 ? {} : { agentProfileId: options.agentProfileId },
+		...options.title === void 0 ? {} : { title: options.title }
+	}));
+	return child;
+}
 async function loadSessionForAppend(workspaceRoot, sessionId) {
 	const loaded = await loadSession(workspaceRoot, sessionId);
 	return buildHandle(loaded.sessionDir, loaded.metadata);
@@ -5803,6 +6235,10 @@ function rehydrateSession(events) {
 			};
 			break;
 		case "knowledge_status": break;
+		case "subagent_started":
+		case "subagent_event":
+		case "subagent_completed":
+		case "subagent_failed": break;
 		case "choice":
 			messages.push({
 				kind: "modal",
@@ -6101,19 +6537,25 @@ var BusyIndicator = class {
 			this.tui.requestRender();
 		}, 80);
 	}
-	stop() {
+	stop(options = {}) {
 		if (this.timer) {
 			clearInterval(this.timer);
 			this.timer = void 0;
 		}
 		this.app.setPromptHint(void 0);
-		this.app.setEphemeralLine(void 0);
+		if (options.clearEphemeralLine ?? true) this.app.setEphemeralLine(void 0);
 	}
 	setActivity(activity) {
 		this.activityOverride = activity;
 		this.render();
 		this.tui.requestRender();
 	}
+	clearActivity() {
+		if (!this.activityOverride) return;
+		this.activityOverride = void 0;
+		this.render();
+		this.tui.requestRender();
+	}
 	render() {
 		if (this.activityOverride) {
 			this.app.setEphemeralLine(`${this.frames[this.index]} ${this.activityOverride}`);
@@ -6124,6 +6566,33 @@ var BusyIndicator = class {
 		this.app.setEphemeralLine(`${this.frames[this.index]} ${this.options.activities[activityIndex]}`);
 	}
 };
+var ReasoningTailBuffer = class {
+	text = "";
+	get hasText() {
+		return this.text.length > 0;
+	}
+	get value() {
+		return this.text;
+	}
+	append(delta) {
+		const normalized = normalizeReasoningText(`${this.text}${delta}`);
+		if (!normalized) return;
+		this.text = normalized;
+		return this.text;
+	}
+	replace(summary) {
+		const normalized = normalizeReasoningText(summary);
+		if (!normalized) return;
+		this.text = normalized;
+		return this.text;
+	}
+	clear() {
+		this.text = "";
+	}
+};
+function normalizeReasoningText(text) {
+	return text.replace(/\s+/gu, " ").trim();
+}
 //#endregion
 //#region src/agent/commands.ts
 const slashCommandSuggestions = [
@@ -6254,6 +6723,31 @@ const agentEvent = {
 			type: "choice",
 			...options
 		};
+	},
+	subagentStarted(options) {
+		return {
+			type: "subagent_started",
+			...options
+		};
+	},
+	subagentEvent(options, event) {
+		return {
+			type: "subagent_event",
+			...options,
+			event
+		};
+	},
+	subagentCompleted(options) {
+		return {
+			type: "subagent_completed",
+			...options
+		};
+	},
+	subagentFailed(options) {
+		return {
+			type: "subagent_failed",
+			...options
+		};
 	}
 };
 function choiceAction(label, value) {
@@ -6579,7 +7073,9 @@ var ChatLayout = class {
 					text: message.text
 				}];
 				case "system":
+				case "thinking":
 				case "tool_call":
+				case "subagent":
 				case "modal": return [];
 			}
 		});
@@ -7100,6 +7596,73 @@ function isAbortError(error) {
 	return error.name === "AbortError" || error.message.toLowerCase().includes("aborted");
 }
 //#endregion
+//#region src/agent/profiles.ts
+const READ_ONLY_TOOLS = [
+	"read_file",
+	"list_files",
+	"grep",
+	"find_file",
+	"git_status",
+	"git_diff",
+	"git_log"
+];
+const PRIMARY_AGENT_PROFILE = {
+	id: "primary",
+	displayName: "Primary",
+	mode: "primary",
+	promptAdditions: [],
+	modelPurpose: "agent.primary",
+	toolPermissionDefault: "allow",
+	allowedTools: [],
+	deniedTools: []
+};
+const AGENT_PROFILES = [PRIMARY_AGENT_PROFILE, ...[{
+	id: "explore",
+	displayName: "Explore",
+	mode: "subagent",
+	promptAdditions: ["You are running as a read-only exploration subagent. Inspect the workspace and return concise findings to the parent agent."],
+	modelPurpose: "agent.fast",
+	toolPermissionDefault: "deny",
+	allowedTools: READ_ONLY_TOOLS,
+	deniedTools: ["task", "plan_todo"]
+}, {
+	id: "general",
+	displayName: "General",
+	mode: "subagent",
+	promptAdditions: ["You are running as a constrained subagent. Work only on the delegated prompt and return a concise result."],
+	modelPurpose: "agent.primary",
+	toolPermissionDefault: "allow",
+	allowedTools: [],
+	deniedTools: ["task", "plan_todo"]
+}]];
+function resolveAgentProfile(profileId = PRIMARY_AGENT_PROFILE.id) {
+	const profile = AGENT_PROFILES.find((candidate) => candidate.id === profileId);
+	if (!profile) throw new Error(`Unknown agent profile "${profileId}".`);
+	return profile;
+}
+function createToolPermissionView(profile, parent = {}) {
+	const deniedTools = new Set(profile.deniedTools);
+	for (const tool of parent.deniedTools ?? []) deniedTools.add(tool);
+	return {
+		profileId: profile.id,
+		defaultPermission: profile.toolPermissionDefault,
+		allowedTools: new Set(profile.allowedTools),
+		deniedTools
+	};
+}
+function isToolAllowed(permissionView, toolName) {
+	if (!isRegisteredToolName(toolName)) return false;
+	if (permissionView.deniedTools.has(toolName)) return false;
+	if (permissionView.defaultPermission === "deny") return permissionView.allowedTools.has(toolName);
+	return true;
+}
+function getProfileToolDefinitions(permissionView) {
+	return getToolDefinitionsForPermissions((toolName) => isToolAllowed(permissionView, toolName));
+}
+function isRegisteredToolName(toolName) {
+	return toolName in toolRegistry;
+}
+//#endregion
 //#region src/agent/tools/executor.ts
 async function executeToolCall(workspaceRoot, call, options = {}) {
 	const startedAt = Date.now();
@@ -7107,9 +7670,17 @@ async function executeToolCall(workspaceRoot, call, options = {}) {
 		workspaceRoot,
 		pathEnv: options.pathEnv,
 		logger: options.logger,
-		taskPlan: options.taskPlan
+		taskPlan: options.taskPlan,
+		profile: options.profile,
+		permissions: options.permissions,
+		subagents: options.subagents,
+		eventSink: options.eventSink,
+		abortSignal: options.abortSignal,
+		toolCallId: options.toolCallId
 	};
 	try {
+		if (!isToolName(call.tool)) throw new Error(`Unknown tool "${call.tool}".`);
+		if (options.permissions && !isToolAllowed(options.permissions, call.tool)) throw new Error(`Tool "${call.tool}" is not allowed for agent profile "${options.permissions.profileId}".`);
 		const definition = getToolDefinition(call.tool);
 		const parsedCall = {
 			...call,
@@ -7263,11 +7834,17 @@ function formatErrorMessage(error) {
 }
 //#endregion
 //#region src/agent/prompts.ts
-function getChatSystemPrompt() {
+function getChatSystemPrompt(options = {}) {
+	const profile = options.profile ?? PRIMARY_AGENT_PROFILE;
+	const canUseTool = (toolName) => options.permissions ? isToolAllowed(options.permissions, toolName) : true;
+	const toolPromptLines = options.permissions ? getToolPromptLines((toolName) => canUseTool(toolName)) : getToolPromptLines();
 	return [
 		"You are Topchester, a plain-spoken terminal coding agent for software engineering work.",
 		"Your job is to turn ordinary user requests into concrete repository work: inspect the codebase, make focused changes when tools allow it, verify the result when possible, and report the outcome clearly.",
 		"",
+		`Agent profile: ${profile.displayName} (${profile.id}).`,
+		...profile.promptAdditions,
+		"",
 		"Working style:",
 		"- Start by understanding the user's intent and the surrounding code before proposing or changing anything non-trivial.",
 		"- Prefer local project evidence over assumptions. Use search and read tools to find relevant files, examples, tests, commands, and conventions.",
@@ -7280,41 +7857,183 @@ function getChatSystemPrompt() {
 		"- Ask a clarifying question only when the missing information blocks useful progress or the safe interpretation is genuinely unclear.",
 		"",
 		"You have these tools available:",
-		...getToolPromptLines(),
+		...toolPromptLines,
 		"",
 		"Tool use:",
 		"- When using a tool, output exactly one tool JSON object and no prose, markdown, or additional JSON. After the tool result, either output the next single tool JSON object or a final plain-text answer.",
 		"- You already have permission to use the available tools to handle the user's request. Do not ask the user to provide tool results or permission to use an available tool.",
 		"- Do not claim to have read, created, edited, staged, committed, or run anything unless a tool result in this turn confirms it.",
-		"- Use plan_todo for non-trivial multi-step work before the first substantive repository tool call.",
-		"- Keep plan_todo items short, user-safe, and usually 2 to 6 items. Maintain exactly one in_progress item while work remains, update it after major progress changes, and clear it only when abandoning the plan or when no visible plan is useful.",
-		"- Do not use plan_todo for simple one-step answers, tiny reads, or trivial edits.",
-		"- Use read/search tools when the user asks about files, code, symbols, usages, tests, or project behavior.",
-		"- Use find_file for path or filename lookup. Use grep for text inside files. If grep output mentions another path, treat that mentioned path as content until find_file or read_file confirms it exists.",
-		"- Use list_files, grep, find_file, and read_file for exact file listing, search, lookup, and reading tasks.",
-		"- Use git_status, git_diff, and git_log for Git state, diffs, and history. Prefer these over inspect_command for Git workflow inspection.",
-		"- Use git_add and git_commit only when the user explicitly asks to stage or commit. Never stage unrelated files, never stage '.', and never commit unless staged paths exactly match the user's request.",
-		"- Use inspect_command only for quick read-only repo orientation when a short familiar command chain is clearer than several dedicated tool calls.",
-		"- inspect_command is not a shell. Unsafe commands, shell expansion, scripts, installs, builds, tests, network access, and file mutation are not available through it.",
-		"- Use read_file before editing a file so your edit is based on current file content and hash metadata.",
-		"- When passing expected_current_hash to edit_file or write_file, use the current pre-edit/pre-write hash from the latest read_file result for that exact file. Never invent it and never use a predicted after-edit or after-write hash.",
-		"- Use edit_file for targeted edits to existing files. Make multiple disjoint edits for the same file in one call when possible.",
-		"- Use write_file to create new files by default. It fails when the file already exists unless you are replacing the whole file with overwrite:true and expected_current_hash from read_file.",
-		"- When the user asks you to create a new file, call write_file. Do not answer that the file was created until write_file succeeds.",
-		"- Pass write_file create_parent_dirs:true only when the user intent clearly includes creating that folder path.",
-		"- Do not use inspect_command for file creation or file mutation.",
-		"- Keep edit_file old_text small but unique. Do not include line labels or grep prefixes in old_text; use exact file text only.",
-		"- Use edit/write tools when they are available and the user asks you to implement, fix, add, update, or refactor code.",
-		"- Use command/test tools when they are available and you need to inspect the environment, run tests, format, lint, typecheck, or verify behavior.",
+		...canUseTool("plan_todo") ? [
+			"- Use plan_todo for non-trivial multi-step work before the first substantive repository tool call.",
+			"- Keep plan_todo items short, user-safe, and usually 2 to 6 items. Maintain exactly one in_progress item while work remains, update it after major progress changes, and clear it only when abandoning the plan or when no visible plan is useful.",
+			"- Do not use plan_todo for simple one-step answers, tiny reads, or trivial edits.",
+			"- Do not call plan_todo only to summarize completed work before a final answer. If no visible plan is active and the work is done, answer directly."
+		] : [],
+		...canUseTool("read_file") || canUseTool("grep") || canUseTool("find_file") || canUseTool("list_files") ? ["- Use read/search tools when the user asks about files, code, symbols, usages, tests, or project behavior."] : [],
+		...canUseTool("find_file") && canUseTool("grep") && canUseTool("read_file") ? ["- Use find_file for path or filename lookup. Use grep for text inside files. If grep output mentions another path, treat that mentioned path as content until find_file or read_file confirms it exists."] : [],
+		...canUseTool("list_files") && canUseTool("grep") && canUseTool("find_file") && canUseTool("read_file") ? ["- Use list_files, grep, find_file, and read_file for exact file listing, search, lookup, and reading tasks."] : [],
+		...canUseTool("git_status") && canUseTool("git_diff") && canUseTool("git_log") ? ["- Use git_status, git_diff, and git_log for Git state, diffs, and history. Prefer these over inspect_command for Git workflow inspection."] : [],
+		...canUseTool("git_add") && canUseTool("git_commit") ? ["- Use git_add and git_commit only when the user explicitly asks to stage or commit. Never stage unrelated files, never stage '.', and never commit unless staged paths exactly match the user's request."] : [],
+		...canUseTool("inspect_command") ? ["- Use inspect_command only for quick read-only repo orientation when a short familiar command chain is clearer than several dedicated tool calls.", "- inspect_command is not a shell. Unsafe commands, shell expansion, scripts, installs, builds, tests, network access, and file mutation are not available through it."] : [],
+		...canUseTool("edit_file") && canUseTool("read_file") ? ["- Use read_file before editing a file so your edit is based on current file content and hash metadata."] : [],
+		...canUseTool("read_file") && (canUseTool("edit_file") || canUseTool("write_file")) ? ["- When passing expected_current_hash to edit_file or write_file, use the current pre-edit/pre-write hash from the latest read_file result for that exact file. Never invent it and never use a predicted after-edit or after-write hash."] : [],
+		...canUseTool("edit_file") ? ["- Use edit_file for targeted edits to existing files. Make multiple disjoint edits for the same file in one call when possible."] : [],
+		...canUseTool("write_file") && canUseTool("read_file") ? [
+			"- Use write_file to create new files by default. It fails when the file already exists unless you are replacing the whole file with overwrite:true and expected_current_hash from read_file.",
+			"- When the user asks you to create a new file, call write_file. Do not answer that the file was created until write_file succeeds.",
+			"- Pass write_file create_parent_dirs:true only when the user intent clearly includes creating that folder path."
+		] : [],
+		...canUseTool("write_file") && !canUseTool("read_file") ? [
+			"- Use write_file to create new files by default. It fails when the file already exists unless overwrite:true is available with verified current content.",
+			"- When the user asks you to create a new file, call write_file. Do not answer that the file was created until write_file succeeds.",
+			"- Pass write_file create_parent_dirs:true only when the user intent clearly includes creating that folder path."
+		] : [],
+		...canUseTool("inspect_command") ? ["- Do not use inspect_command for file creation or file mutation."] : [],
+		...canUseTool("edit_file") ? ["- Keep edit_file old_text small but unique. Do not include line labels or grep prefixes in old_text; use exact file text only."] : [],
+		...canUseTool("edit_file") || canUseTool("write_file") ? ["- Use edit/write tools when they are available and the user asks you to implement, fix, add, update, or refactor code."] : [],
+		...canUseTool("inspect_command") ? ["- Use command/test tools when they are available and you need to inspect the environment, run tests, format, lint, typecheck, or verify behavior."] : [],
 		"- After each tool result, decide the next useful action from the new evidence. Continue until the request is handled or blocked.",
 		"Do not make up file contents or search results."
 	].join("\n");
 }
 //#endregion
+//#region src/session/runtime-payloads.ts
+function runtimeEventToSessionPayload(event) {
+	switch (event.type) {
+		case "message": return {
+			kind: "message",
+			role: event.role,
+			text: event.text,
+			...event.meta === void 0 ? {} : { meta: event.meta }
+		};
+		case "tool_call": return {
+			kind: "tool_call",
+			label: event.label,
+			call: event.call
+		};
+		case "task_plan": return {
+			kind: "task_plan",
+			items: event.plan.items,
+			updatedAt: event.plan.updatedAt
+		};
+		case "knowledge_status": return;
+		case "choice": return {
+			kind: "choice",
+			tone: event.tone,
+			title: event.title,
+			...event.body === void 0 ? {} : { body: event.body },
+			actions: event.actions
+		};
+		case "subagent_started": return {
+			kind: "subagent_started",
+			sessionId: event.sessionId,
+			parentSessionId: event.parentSessionId,
+			parentToolCallId: event.parentToolCallId,
+			...event.agentProfileId === void 0 ? {} : { agentProfileId: event.agentProfileId },
+			...event.title === void 0 ? {} : { title: event.title }
+		};
+		case "subagent_event": return {
+			kind: "subagent_event",
+			sessionId: event.sessionId,
+			parentSessionId: event.parentSessionId,
+			parentToolCallId: event.parentToolCallId,
+			event: event.event
+		};
+		case "subagent_completed": return {
+			kind: "subagent_completed",
+			sessionId: event.sessionId,
+			parentSessionId: event.parentSessionId,
+			parentToolCallId: event.parentToolCallId,
+			...event.result === void 0 ? {} : { result: event.result }
+		};
+		case "subagent_failed": return {
+			kind: "subagent_failed",
+			sessionId: event.sessionId,
+			parentSessionId: event.parentSessionId,
+			parentToolCallId: event.parentToolCallId,
+			error: event.error
+		};
+		case "status": return {
+			kind: "status",
+			status: event.status
+		};
+	}
+}
+//#endregion
+//#region src/agent/subagents.ts
+var SubagentManager = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async runTask(options) {
+		const parentSession = this.options.parentSession;
+		if (!parentSession) throw new Error("task requires an active persisted session.");
+		const profile = resolveAgentProfile(options.subagentType ?? "explore");
+		if (profile.mode !== "subagent" && profile.mode !== "all") throw new Error(`Agent profile "${profile.id}" cannot be used for subagent tasks.`);
+		const child = await createChildSession(this.options.context.workspaceRoot, {
+			parent: parentSession,
+			parentToolCallId: options.parentToolCallId,
+			agentProfileId: profile.id,
+			title: options.description,
+			recordParentEvent: false
+		});
+		const reference = {
+			sessionId: child.sessionId,
+			parentSessionId: parentSession.sessionId,
+			parentToolCallId: options.parentToolCallId
+		};
+		await options.eventSink?.(agentEvent.subagentStarted({
+			...reference,
+			agentProfileId: profile.id,
+			title: options.description
+		}));
+		const childRuntime = this.options.createRuntime({
+			profile,
+			parentPermissions: this.options.parentPermissions,
+			session: child
+		});
+		let finalResponse = "";
+		try {
+			for await (const childEvent of childRuntime.submitMessageStream([], options.prompt, options.abortSignal, { session: child })) {
+				const payload = runtimeEventToSessionPayload(childEvent);
+				if (payload) await child.append(payload);
+				if (childEvent.type === "message" && childEvent.role === "assistant") finalResponse = childEvent.text;
+				await options.eventSink?.(agentEvent.subagentEvent(reference, childEvent));
+			}
+			const result = finalResponse.trim() || "Subagent completed without an assistant response.";
+			await options.eventSink?.(agentEvent.subagentCompleted({
+				...reference,
+				result
+			}));
+			return {
+				sessionId: child.sessionId,
+				status: "completed",
+				result,
+				profileId: profile.id
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			await options.eventSink?.(agentEvent.subagentFailed({
+				...reference,
+				error: message
+			}));
+			return {
+				sessionId: child.sessionId,
+				status: "failed",
+				result: message,
+				profileId: profile.id
+			};
+		}
+	}
+};
+//#endregion
 //#region src/agent/runtime.ts
 const MAX_TOOL_CALLS_PER_TURN = 75;
-var TopchesterAgentRuntime = class {
+const DEFAULT_TASK_CONCURRENCY = 3;
+var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 	context;
+	options;
 	taskPlan = createTaskPlanController();
 	/**
 	* Holds the shared application context for one runtime instance.
@@ -7322,8 +8041,9 @@ var TopchesterAgentRuntime = class {
 	* workspace, model gateway, logger, config, and task-plan state that
 	* are passed in by the CLI or TUI layer.
 	*/
-	constructor(context) {
+	constructor(context, options = {}) {
 		this.context = context;
+		this.options = options;
 	}
 	/**
 	* Performs the lightweight startup model check used by the interactive
@@ -7348,34 +8068,46 @@ var TopchesterAgentRuntime = class {
 		return getKnowledgeStatusEvents(await this.getKnowledgeStatusWithNonCleanFileCount());
 	}
 	/**
-	* Runs one user chat turn through the agent loop. It builds the model
+	* Streams one user chat turn through the agent loop. It builds the model
 	* prompt with relevant KB context, calls the model, executes any requested
 	* tools, feeds tool results back into the next prompt, and repeats until
 	* the model returns a normal assistant message or the loop hits its safety
 	* limit.
 	*
-	* Events are accumulated for the caller and optionally streamed through
-	* `onEvent` as soon as tool calls, task-plan updates, choices, or final
-	* messages are available. The method also enforces visible task-plan
-	* closure before a final answer when the model leaves an open plan.
+	* This is the primary runtime execution contract. Compatibility wrappers
+	* can collect the stream, but the runtime's own turn loop only knows about
+	* ordered events.
 	*/
-	async submitMessage(conversation, message, abortSignal, onEvent) {
-		const prompt = await this.buildPromptWithKnowledgeContext(buildConversationPrompt(conversation, message), message);
-		const events = [];
-		const emit = async (...nextEvents) => {
-			events.push(...nextEvents);
-			if (!onEvent) return;
-			for (const event of nextEvents) await onEvent(event);
-		};
-		let nextPrompt = prompt;
+	async *submitMessageStream(conversation, message, abortSignal, options = {}) {
+		let nextPrompt = await this.buildPromptWithKnowledgeContext(buildConversationPrompt(conversation, message), message);
 		let totalDurationMs = 0;
+		const tokenUsageTotals = {};
+		const profile = this.options.profile ?? PRIMARY_AGENT_PROFILE;
+		const permissions = createToolPermissionView(profile, { deniedTools: this.options.parentPermissions?.deniedTools });
+		const tools = getProfileToolDefinitions(permissions);
+		const session = options.session ?? this.options.session;
+		const subagents = new SubagentManager({
+			context: this.context,
+			parentSession: session,
+			parentProfile: profile,
+			parentPermissions: permissions,
+			createRuntime: ({ profile: childProfile, parentPermissions, session: childSession }) => new TopchesterAgentRuntime(this.context, {
+				...this.options,
+				profile: childProfile,
+				parentPermissions,
+				session: childSession
+			})
+		});
 		let lastModelId = "model";
 		let afterTool;
 		let toolProtocolOverride = readToolProtocolEnvOverride();
 		let requestedPlanClosure = false;
 		for (let toolCalls = 0; toolCalls <= MAX_TOOL_CALLS_PER_TURN; toolCalls += 1) {
 			const startedAt = Date.now();
-			const system = getChatSystemPrompt();
+			const system = getChatSystemPrompt({
+				profile,
+				permissions
+			});
 			this.context.logger.debug({
 				event: "model_prompt",
 				purpose: "agent.primary",
@@ -7391,12 +8123,15 @@ var TopchesterAgentRuntime = class {
 				system,
 				prompt: nextPrompt,
 				abortSignal,
-				toolProtocol: toolProtocolOverride
+				toolProtocol: toolProtocolOverride,
+				onReasoning: options.onReasoning,
+				tools
 			});
 			const durationMs = Date.now() - startedAt;
 			const toolCall = result.toolCalls[0];
 			totalDurationMs += durationMs;
 			lastModelId = result.modelId;
+			addTokenUsageTotals(tokenUsageTotals, result.usage);
 			this.context.logger.debug({
 				event: "model_response",
 				purpose: "agent.primary",
@@ -7429,37 +8164,112 @@ var TopchesterAgentRuntime = class {
 			if (result.providerRejectedTools && result.toolProtocol === "text-json") toolProtocolOverride = "text-json";
 			else if (result.providerRejectedTools && result.toolProtocol === "text-xml") toolProtocolOverride = "text-xml";
 			if (!toolCall) {
-				if (hasOpenTaskPlan(this.taskPlan.get())) {
+				const plan = this.taskPlan.get();
+				const finalText = stripSuppressiblePlanTodoPrefix(result.text, plan) ?? result.text;
+				if (hasOpenTaskPlan(plan)) {
 					if (!requestedPlanClosure) {
 						requestedPlanClosure = true;
-						nextPrompt = `${nextPrompt}\n\n${formatOpenPlanClosureInstruction(result.text, result.toolProtocol)}`;
+						nextPrompt = `${nextPrompt}\n\n${formatOpenPlanClosureInstruction(finalText, result.toolProtocol)}`;
 						continue;
 					}
-					await emit(agentEvent.taskPlan(this.taskPlan.update({ items: [] })));
+					yield agentEvent.taskPlan(this.taskPlan.update({ items: [] }));
 				}
-				await emit(agentEvent.assistantMessage(result.text.trim() || "I got an empty response from the model.", formatAgentMessageMeta(result.modelId, totalDurationMs)), agentEvent.status("ready"));
-				return events;
+				yield agentEvent.assistantMessage(finalText.trim() || "I got an empty response from the model.", formatAgentMessageMeta(result.modelId, totalDurationMs, tokenUsageTotals));
+				yield agentEvent.status("ready");
+				return;
 			}
 			if (toolCalls === MAX_TOOL_CALLS_PER_TURN) {
-				await emit(agentEvent.choice({
+				yield agentEvent.choice({
 					tone: "warning",
 					title: "Tool call limit reached",
 					body: `Stopped after ${MAX_TOOL_CALLS_PER_TURN} tool calls in one turn. Continue starts another turn; abort leaves the call stopped.`,
 					actions: [choiceAction("Continue", "Continue the previous task from where you stopped."), choiceAction("Abort", ABORT_CHOICE_VALUE)]
-				}), agentEvent.status("ready"));
-				return events;
+				});
+				yield agentEvent.status("ready");
+				return;
+			}
+			if (result.toolCalls.length > 1 && result.toolCalls.every((call) => call.tool === "task")) {
+				const taskCalls = result.toolCalls.map((call) => call);
+				const taskResults = [];
+				for (let index = 0; index < taskCalls.length; index += DEFAULT_TASK_CONCURRENCY) {
+					const batch = taskCalls.slice(index, index + DEFAULT_TASK_CONCURRENCY);
+					const taskEventQueue = createRuntimeEventQueue();
+					const batchResultPromise = Promise.all(batch.map((call, batchIndex) => executeToolCall(this.context.workspaceRoot, call, {
+						logger: this.context.logger,
+						taskPlan: this.taskPlan,
+						profile,
+						permissions,
+						subagents,
+						abortSignal,
+						toolCallId: result.toolCalls[index + batchIndex]?.id,
+						eventSink: (event) => taskEventQueue.push(event)
+					}))).finally(() => {
+						taskEventQueue.close();
+					});
+					for await (const event of taskEventQueue) yield event;
+					taskResults.push(...await batchResultPromise);
+				}
+				for (let index = 0; index < taskCalls.length; index += 1) yield agentEvent.toolCall(taskCalls[index], formatToolCallMessage(taskCalls[index], taskResults[index]));
+				afterTool = "task";
+				nextPrompt = `${nextPrompt}\n\n${taskResults.map((toolResult) => formatToolResultForPrompt(toolResult)).join("\n\n")}\n\n${formatContinuationInstruction(result.toolProtocol, taskResults.at(-1), isToolAllowed(permissions, "plan_todo"))}`;
+				continue;
+			}
+			if (result.toolCalls.length > 1 && result.toolCalls.every((call) => isParallelSafeToolName(call.tool))) {
+				const parallelCalls = result.toolCalls.map((call) => call);
+				const parallelResults = await Promise.all(parallelCalls.map((call, index) => executeToolCall(this.context.workspaceRoot, call, {
+					logger: this.context.logger,
+					taskPlan: this.taskPlan,
+					profile,
+					permissions,
+					subagents,
+					abortSignal,
+					toolCallId: result.toolCalls[index]?.id
+				})));
+				for (let index = 0; index < parallelCalls.length; index += 1) yield agentEvent.toolCall(parallelCalls[index], formatToolCallMessage(parallelCalls[index], parallelResults[index]));
+				afterTool = parallelCalls.at(-1)?.tool;
+				nextPrompt = `${nextPrompt}\n\n${parallelResults.map((toolResult) => formatToolResultForPrompt(toolResult)).join("\n\n")}\n\n${formatContinuationInstruction(result.toolProtocol, parallelResults.at(-1), isToolAllowed(permissions, "plan_todo"))}`;
+				continue;
 			}
 			const executableToolCall = toolCall;
-			const toolResult = await executeToolCall(this.context.workspaceRoot, executableToolCall, {
+			const suppressiblePlanTodoAnswer = getSuppressiblePlanTodoAnswer(executableToolCall, result.text, this.taskPlan.get());
+			if (suppressiblePlanTodoAnswer !== void 0) {
+				yield agentEvent.assistantMessage(suppressiblePlanTodoAnswer || "I got an empty response from the model.", formatAgentMessageMeta(result.modelId, totalDurationMs, tokenUsageTotals));
+				yield agentEvent.status("ready");
+				return;
+			}
+			const toolEventQueue = createRuntimeEventQueue();
+			const toolResultPromise = executeToolCall(this.context.workspaceRoot, executableToolCall, {
 				logger: this.context.logger,
-				taskPlan: this.taskPlan
+				taskPlan: this.taskPlan,
+				profile,
+				permissions,
+				subagents,
+				abortSignal,
+				toolCallId: toolCall.id,
+				eventSink: (event) => toolEventQueue.push(event)
+			}).finally(() => {
+				toolEventQueue.close();
 			});
-			await emit(agentEvent.toolCall(executableToolCall, formatToolCallMessage(executableToolCall, toolResult)));
-			if (!isToolErrorResult(toolResult) && toolResult.tool === "plan_todo") await emit(agentEvent.taskPlan(toolResult.plan));
+			for await (const event of toolEventQueue) yield event;
+			const toolResult = await toolResultPromise;
+			yield agentEvent.toolCall(executableToolCall, formatToolCallMessage(executableToolCall, toolResult));
+			if (!isToolErrorResult(toolResult) && toolResult.tool === "plan_todo") yield agentEvent.taskPlan(toolResult.plan);
 			afterTool = executableToolCall.tool;
-			nextPrompt = `${nextPrompt}\n\n${formatToolResultForPrompt(toolResult)}\n\n${formatContinuationInstruction(result.toolProtocol, toolResult)}`;
+			nextPrompt = `${nextPrompt}\n\n${formatToolResultForPrompt(toolResult)}\n\n${formatContinuationInstruction(result.toolProtocol, toolResult, isToolAllowed(permissions, "plan_todo"))}`;
+		}
+		yield agentEvent.assistantMessage("I stopped because the tool loop ended unexpectedly.", formatAgentMessageMeta(lastModelId, totalDurationMs, tokenUsageTotals));
+		yield agentEvent.status("ready");
+	}
+	/**
+	* Compatibility wrapper for callers that still expect a completed event
+	* array or use the older `onEvent` callback shape.
+	*/
+	async submitMessage(conversation, message, abortSignal, onEvent, options = {}) {
+		const events = [];
+		for await (const event of this.submitMessageStream(conversation, message, abortSignal, options)) {
+			events.push(event);
+			await onEvent?.(event);
 		}
-		await emit(agentEvent.assistantMessage("I stopped because the tool loop ended unexpectedly.", formatAgentMessageMeta(lastModelId, totalDurationMs)), agentEvent.status("ready"));
 		return events;
 	}
 	/**
@@ -7503,6 +8313,13 @@ var TopchesterAgentRuntime = class {
 	* user's chat turn from reaching the model.
 	*/
 	async buildPromptWithKnowledgeContext(prompt, message) {
+		if (this.options.disableL1Context ?? isL1ContextDisabledByEnv()) {
+			this.context.logger.debug({
+				event: "kb_context_pack_skipped",
+				reason: "disabled"
+			}, "kb context pack skipped");
+			return prompt;
+		}
 		const status = getKnowledgeStatus(this.context.workspaceRoot);
 		if (!status.kbExists || !status.kbIsDirectory || status.kbContentState !== "ready") return prompt;
 		try {
@@ -7533,6 +8350,35 @@ var TopchesterAgentRuntime = class {
 		}
 	}
 };
+function createRuntimeEventQueue() {
+	const events = [];
+	let closed = false;
+	let notify;
+	return {
+		push(event) {
+			events.push(event);
+			notify?.();
+			notify = void 0;
+		},
+		close() {
+			closed = true;
+			notify?.();
+			notify = void 0;
+		},
+		async *[Symbol.asyncIterator]() {
+			while (!closed || events.length > 0) {
+				const event = events.shift();
+				if (event) {
+					yield event;
+					continue;
+				}
+				await new Promise((resolve) => {
+					notify = resolve;
+				});
+			}
+		}
+	};
+}
 /**
 * Calls the configured model gateway for a single agent step and normalizes
 * the result into the newer `ModelAgentResult` shape. Gateways that implement
@@ -7541,10 +8387,7 @@ var TopchesterAgentRuntime = class {
 * so the rest of the runtime can use the same tool loop.
 */
 async function generateAgentStep(context, request) {
-	if ("generateAgentStep" in context.modelGateway && typeof context.modelGateway.generateAgentStep === "function") return context.modelGateway.generateAgentStep({
-		...request,
-		tools: Object.values(toolRegistry)
-	});
+	if ("generateAgentStep" in context.modelGateway && typeof context.modelGateway.generateAgentStep === "function") return context.modelGateway.generateAgentStep({ ...request });
 	const result = await context.modelGateway.generateText(request);
 	const parsed = parseToolCallWithSource(result.text);
 	const toolProtocol = parsed?.source === "text-xml" ? "text-xml" : "text-json";
@@ -7568,6 +8411,21 @@ async function generateAgentStep(context, request) {
 		openRouterRoutingApplied: false
 	};
 }
+function getSuppressiblePlanTodoAnswer(call, modelText, currentPlan) {
+	if (call.tool !== "plan_todo" || hasOpenTaskPlan(currentPlan)) return;
+	const items = call.args.items;
+	if (!Array.isArray(items) || items.some((item) => !isCompletedPlanTodoItem(item))) return;
+	const parsed = parseToolCallWithSource(modelText, ["text-json"]);
+	return parsed?.remainder ? parsed.remainder : void 0;
+}
+function stripSuppressiblePlanTodoPrefix(modelText, currentPlan) {
+	const parsed = parseToolCallWithSource(modelText, ["text-json"]);
+	if (!parsed) return;
+	return getSuppressiblePlanTodoAnswer(parsed.call, modelText, currentPlan);
+}
+function isCompletedPlanTodoItem(item) {
+	return Boolean(item && typeof item === "object" && "status" in item && item.status === "completed");
+}
 /**
 * Reads the optional environment override for the tool-calling protocol.
 * Invalid values are ignored instead of failing startup, which keeps local
@@ -7578,6 +8436,14 @@ function readToolProtocolEnvOverride() {
 	const value = process.env.TOPCHESTER_TOOL_PROTOCOL;
 	if (value === "auto" || value === "native" || value === "text-json" || value === "text-xml") return value;
 }
+function isL1ContextDisabledByEnv() {
+	const value = process.env.TOPCHESTER_DISABLE_L1_CONTEXT?.trim().toLowerCase();
+	return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+function shouldShowTokenUsageByEnv() {
+	const value = process.env.TOPCHESTER_SHOW_TOKEN_USAGE?.trim().toLowerCase();
+	return value !== void 0 && value !== "" && value !== "0" && value !== "false" && value !== "no" && value !== "off";
+}
 /**
 * Applies TUI styling to per-file KB sync states. The raw scanner statuses
 * are preserved as text, but success, warning, and error categories get
@@ -7651,6 +8517,7 @@ function formatToolResultForPrompt(result) {
 		"```"
 	].join("\n");
 	if (result.tool === "plan_todo") return [`Tool result from ${result.tool}:`, result.content].join("\n");
+	if (result.tool === "task") return [`Tool result from ${result.tool}:`, result.content].join("\n");
 	if (result.tool === "edit_file") return [
 		`Tool result from ${result.tool}${path}:`,
 		`before_hash: ${result.beforeHash}`,
@@ -7754,13 +8621,13 @@ function formatToolResultForPrompt(result) {
 * restates the current tool-call protocol so the next model step remains
 * parseable by the runtime.
 */
-function formatContinuationInstruction(protocol, result) {
+function formatContinuationInstruction(protocol, result, canUsePlanTodo = true) {
 	const toolInstruction = protocol === "text-xml" ? "If another tool is needed, reply with only one XML tool call." : protocol === "text-json" ? "If another tool is needed, reply with only that tool JSON." : "If another tool is needed, use the available tool calling path.";
 	return [
 		"Continue the user's request using the tool result above and the visible plan when one is active.",
 		result.tool === "find_file" ? "find_file results are paths only; if the user asked to read or answer from file contents, call read_file on the relevant path before answering. Do not ask the user to provide the read_file result or permission." : "",
-		"Update plan_todo after major progress changes.",
-		"Before a final answer, close the visible plan by calling plan_todo with all finished items marked completed, or with [] if abandoning the plan.",
+		canUsePlanTodo ? "Update plan_todo after major progress changes." : "",
+		canUsePlanTodo ? "Before a final answer, close the visible plan by calling plan_todo with all finished items marked completed, or with [] if abandoning the plan." : "",
 		toolInstruction,
 		"Otherwise answer the user. Do not guess."
 	].filter(Boolean).join(" ");
@@ -7790,6 +8657,7 @@ function formatOpenPlanClosureInstruction(draftAnswer, protocol) {
 function formatToolCallMessage(call, result) {
 	if (result && isToolErrorResult(result)) return `${call.tool} failed: ${result.error}`;
 	switch (call.tool) {
+		case "task": return result?.tool === "task" ? `task: ${result.status} ${result.childSessionId}` : `task: ${call.args.description}`;
 		case "plan_todo": return result?.tool === "plan_todo" ? `plan_todo: ${result.plan.items.length} items, ${result.inProgressCount} active` : `plan_todo: ${call.args.items.length} items`;
 		case "read_file": return `read_file: ${call.args.path}`;
 		case "list_files": return `list_files: ${call.args.path}${call.args.recursive ? " (recursive)" : ""}`;
@@ -7838,8 +8706,22 @@ function formatWriteFileChangeSummary(result) {
 * The model identifier and cumulative turn duration are kept together here
 * so callers do not need to know how agent-loop timing should be presented.
 */
-function formatAgentMessageMeta(model, durationMs) {
-	return `${model} · ${formatDuration$1(durationMs)}`;
+function formatAgentMessageMeta(model, durationMs, usage) {
+	const tokenUsage = shouldShowTokenUsageByEnv() ? formatTokenUsage(usage) : void 0;
+	return [
+		model,
+		formatDuration$1(durationMs),
+		tokenUsage
+	].filter(Boolean).join(" · ");
+}
+function addTokenUsageTotals(totals, usage) {
+	if (!usage) return;
+	if (typeof usage.inputTokens === "number") totals.inputTokens = (totals.inputTokens ?? 0) + usage.inputTokens;
+	if (typeof usage.outputTokens === "number") totals.outputTokens = (totals.outputTokens ?? 0) + usage.outputTokens;
+}
+function formatTokenUsage(usage) {
+	if (usage?.inputTokens === void 0 && usage?.outputTokens === void 0) return;
+	return `${formatInteger(usage.inputTokens ?? 0)} input / ${formatInteger(usage.outputTokens ?? 0)} output tokens`;
 }
 /**
 * Converts elapsed milliseconds into the short human-readable duration used
@@ -7868,6 +8750,9 @@ function formatNumber(value, fractionDigits) {
 		maximumFractionDigits: fractionDigits
 	});
 }
+function formatInteger(value) {
+	return value.toLocaleString("en", { maximumFractionDigits: 0 });
+}
 //#endregion
 //#region src/tui/runtime-events.ts
 function renderRuntimeEvent(event) {
@@ -7882,9 +8767,38 @@ function renderRuntimeEvent(event) {
 			actions: event.actions
 		})];
 		case "task_plan": return [];
+		case "subagent_started": return [subagentMessage({
+			status: "running",
+			sessionId: event.sessionId,
+			title: event.title
+		})];
+		case "subagent_event": return formatForwardedSubagentEvent(event.sessionId, event.event);
+		case "subagent_completed": return [subagentMessage({
+			status: "completed",
+			sessionId: event.sessionId,
+			text: event.result
+		})];
+		case "subagent_failed": return [subagentMessage({
+			status: "failed",
+			sessionId: event.sessionId,
+			text: event.error
+		})];
 		case "status": return [];
 	}
 }
+function formatForwardedSubagentEvent(sessionId, event) {
+	if (event.type === "message" && event.role === "assistant") return [subagentMessage({
+		status: "event",
+		sessionId,
+		text: event.text
+	})];
+	if (event.type === "tool_call") return [subagentMessage({
+		status: "event",
+		sessionId,
+		text: event.label
+	})];
+	return [];
+}
 function formatKbPathSource(status) {
 	return status.kbPathSource === "env" ? " (custom)" : "";
 }
@@ -7933,10 +8847,10 @@ var TopchesterTuiShell = class {
 		});
 		app.setTaskPlan(this.options.initialTaskPlan);
 		app.setSubmitMessage((message) => {
-			this.submitChatMessage(app, tui, message);
+			this.startBackgroundTask(app, tui, "Chat", () => this.submitChatMessage(app, tui, message));
 		});
 		app.setSubmitCommand((command) => {
-			this.submitSlashCommand(app, tui, command);
+			this.startBackgroundTask(app, tui, "Command", () => this.submitSlashCommand(app, tui, command));
 		});
 		tui.addChild(app);
 		tui.setFocus(app);
@@ -7953,7 +8867,15 @@ var TopchesterTuiShell = class {
 			}
 		}));
 		tui.start();
-		this.checkAgent(app, tui);
+		this.startBackgroundTask(app, tui, "Agent check", () => this.checkAgent(app, tui));
+	}
+	startBackgroundTask(app, tui, label, task) {
+		task().catch((error) => {
+			app.addMessage(systemMessage(`${label} failed: ${formatPlainError(error)}`));
+			app.setStatus("ready");
+			app.setCancelPending(void 0);
+			tui.requestRender();
+		});
 	}
 	async checkAgent(app, tui) {
 		const busy = new BusyIndicator(app, tui, {
@@ -7980,7 +8902,7 @@ var TopchesterTuiShell = class {
 				app.addMessage(systemMessage("Agent check stopped."));
 				app.setStatus("ready");
 			} else {
-				const message = error instanceof Error ? error.message : String(error);
+				const message = formatPlainError(error);
 				app.addMessage(systemMessage(`Agent check failed: ${message}`));
 				app.setStatus("agent check failed");
 			}
@@ -8002,6 +8924,7 @@ var TopchesterTuiShell = class {
 			]
 		});
 		const abortController = new AbortController();
+		const reasoningDisplay = isStreamReasoningEnabledByEnv() ? createBusyReasoningSink(busy) : void 0;
 		let cancelled = false;
 		app.setCancelPending(() => {
 			cancelled = true;
@@ -8016,17 +8939,23 @@ var TopchesterTuiShell = class {
 				role: "user",
 				text: message
 			});
-			await this.runtime.submitMessage(app.getConversationTurns(), message, abortController.signal, async (event) => {
+			for await (const event of this.runtime.submitMessageStream(app.getConversationTurns(), message, abortController.signal, {
+				onReasoning: reasoningDisplay?.sink,
+				session: this.session
+			})) {
+				if (event.type === "message" && event.role === "assistant") {
+					reasoningDisplay?.commit(app);
+					busy.clearActivity();
+				}
 				await this.applyRuntimeEvents(app, [event], tui);
 				tui.requestRender();
-			});
+			}
 		} catch (error) {
 			if (cancelled) {
 				app.addMessage(systemMessage("Response stopped."));
 				app.setStatus("ready");
 			} else {
-				const errorMessage = error instanceof Error ? error.message : String(error);
-				app.addMessage(systemMessage(`Chat failed: ${errorMessage}`));
+				app.addMessage(systemMessage(`Chat failed: ${formatPlainError(error)}`));
 				app.setStatus("chat failed");
 				await this.persistPayloadWithWarning(app, {
 					kind: "status",
@@ -8055,8 +8984,7 @@ var TopchesterTuiShell = class {
 				busy.setActivity(event.message);
 			}), tui);
 		} catch (error) {
-			const errorMessage = error instanceof Error ? error.message : String(error);
-			app.addMessage(systemMessage(`Command failed: ${errorMessage}`));
+			app.addMessage(systemMessage(`Command failed: ${formatPlainError(error)}`));
 			app.setStatus("command failed");
 			await this.persistPayloadWithWarning(app, {
 				kind: "status",
@@ -8135,6 +9063,8 @@ function chatMessageToSessionPayload(message) {
 		text: message.text,
 		...message.meta === void 0 ? {} : { meta: message.meta }
 	};
+	if (message.kind === "thinking") return;
+	if (message.kind === "subagent") return;
 	if (message.kind === "modal") return {
 		kind: "choice",
 		tone: message.tone,
@@ -8148,38 +9078,6 @@ function chatMessageToSessionPayload(message) {
 		call: message.call
 	};
 }
-function runtimeEventToSessionPayload(event) {
-	switch (event.type) {
-		case "message": return {
-			kind: "message",
-			role: event.role,
-			text: event.text,
-			...event.meta === void 0 ? {} : { meta: event.meta }
-		};
-		case "tool_call": return {
-			kind: "tool_call",
-			label: event.label,
-			call: event.call
-		};
-		case "task_plan": return {
-			kind: "task_plan",
-			items: event.plan.items,
-			updatedAt: event.plan.updatedAt
-		};
-		case "knowledge_status": return;
-		case "choice": return {
-			kind: "choice",
-			tone: event.tone,
-			title: event.title,
-			...event.body === void 0 ? {} : { body: event.body },
-			actions: event.actions
-		};
-		case "status": return {
-			kind: "status",
-			status: event.status
-		};
-	}
-}
 function slashCommandToSessionPayload(command) {
 	return {
 		kind: "message",
@@ -8191,8 +9089,34 @@ function slashCommandToSessionPayload(command) {
 		}
 	};
 }
+function isStreamReasoningEnabledByEnv() {
+	const value = process.env.TOPCHESTER_STREAM_REASONING?.trim().toLowerCase();
+	return value === "1" || value === "true" || value === "yes" || value === "on";
+}
+function createBusyReasoningSink(busy) {
+	const buffer = new ReasoningTailBuffer();
+	let committed = false;
+	return {
+		commit(app) {
+			if (committed || !buffer.hasText) return;
+			app.addMessage(thinkingMessage(buffer.value));
+			committed = true;
+		},
+		async sink(event) {
+			if (event.type === "clear") {
+				buffer.clear();
+				committed = false;
+				busy.clearActivity();
+				return;
+			}
+			const text = event.type === "summary" ? buffer.replace(event.text ?? "") : buffer.append(event.text ?? "");
+			if (!text) return;
+			busy.setActivity(ui.muted(text));
+		}
+	};
+}
 function formatPlainError(error) {
-	return error instanceof Error ? error.message : String(error);
+	return (error instanceof Error ? error.message : String(error)).split(/\r?\n/u).map((line) => line.trim()).find((line) => line.length > 0) ?? "Unknown error";
 }
 function printExitBanner(sessionId, durationMs) {
 	console.log("");
@@ -8336,8 +9260,8 @@ async function executeRunCommand(context, options) {
 				text: options.prompt,
 				inputType: "prompt"
 			});
-			await applyRuntimeEvents({
-				events: await runtime.submitMessage(conversation, options.prompt, abortController.signal),
+			for await (const event of runtime.submitMessageStream(conversation, options.prompt, abortController.signal, { session })) await applyRuntimeEvent({
+				event,
 				session,
 				jsonEvents,
 				runId,
@@ -8386,7 +9310,9 @@ async function loadConversation(workspaceRoot, resume) {
 				text: message.text
 			}];
 			case "system":
+			case "thinking":
 			case "tool_call":
+			case "subagent":
 			case "modal": return [];
 		}
 	});
@@ -8398,12 +9324,16 @@ async function persistStartupMessages(session, context) {
 	}
 }
 async function applyRuntimeEvents(options) {
-	for (const event of options.events) {
-		const payload = runtimeEventToSessionPayload(event);
-		if (payload) await options.session.append(payload);
-		pushJson(options.jsonEvents, options.runId, options.session.sessionId, event.type, { event });
-		if (options.plain) printPlainEvent(event);
-	}
+	for (const event of options.events) await applyRuntimeEvent({
+		...options,
+		event
+	});
+}
+async function applyRuntimeEvent(options) {
+	const payload = runtimeEventToSessionPayload(options.event);
+	if (payload) await options.session.append(payload);
+	pushJson(options.jsonEvents, options.runId, options.session.sessionId, options.event.type, { event: options.event });
+	if (options.plain) printPlainEvent(options.event);
 }
 function printPlainEvent(event) {
 	if (event.type === "message") {