fengming 0.3.8 → 0.3.10

package/dist/embedded-backend-ChaKCepC.js

@@ -0,0 +1,1581 @@
+import { i as __require } from "./chunk-CNf5ZN-e.js";
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DKw2K5wM.js";
+import { n as defaultRuntime } from "./runtime-BkTkFkXs.js";
+import { _ as resolveSessionAgentId } from "./agent-scope-EEbMCF2I.js";
+import { l as normalizeAgentId } from "./session-key-CJf5_zWs.js";
+import { c as resolveDefaultAgentId } from "./agent-scope-config-BHdZonI2.js";
+import { i as getRuntimeConfig } from "./io-T1CV3Z1L.js";
+import { r as DEFAULT_PROVIDER } from "./defaults-DNFU4TYx.js";
+import "./config-4B-JCqw_.js";
+import { i as INTERNAL_MESSAGE_CHANNEL } from "./message-channel-core-rOsWksPZ.js";
+import "./message-channel-DcN_7tYD.js";
+import { a as resetGlobalHookRunner, i as initializeGlobalHookRunner, t as getGlobalHookRunner } from "./hook-runner-global-De3loPgD.js";
+import { l as onAgentEvent } from "./agent-events-Dl8p_DjC.js";
+import { d as updateSessionStore } from "./store-DH20opqS.js";
+import { t as loadCombinedSessionStoreForGateway } from "./combined-store-gateway-n-bwAWEx.js";
+import { d as formatSessionGoalStatus, f as getSessionGoal, l as clearSessionGoal, m as updateSessionGoalStatus, u as createSessionGoal } from "./sessions-CtMqsEs2.js";
+import { r as buildConfiguredModelCatalog } from "./model-selection-shared-vfQyPxy6.js";
+import { t as resolveThinkingDefault } from "./model-thinking-default-BmexX9ZQ.js";
+import { t as buildAllowedModelSet } from "./model-selection-C4gJ7iHA.js";
+import { l as readSessionMessagesAsync, n as capArrayByJsonBytes } from "./session-utils.fs-D-Ly08WB.js";
+import { i as ensureContextWindowCacheLoaded } from "./context-CTAhrepa.js";
+import { c as loadSessionEntry, i as listAgentsForGateway, l as migrateAndPruneGatewaySessionStoreKey, m as resolveGatewaySessionStoreTarget, o as listSessionsFromStoreAsync, v as resolveSessionModelRef } from "./session-utils-pgndLXV7.js";
+import { E as setEmbeddedMode } from "./fengming-tools-DBLsJfsf.js";
+import { s as augmentChatHistoryWithCliSessionImports } from "./attempt-execution.helpers-ZwDOhq8d.js";
+import { r as isChatStopCommandText } from "./chat-abort-wipQF0Ih.js";
+import { c as performGatewaySessionReset } from "./session-reset-service-BYbADY57.js";
+import { c as getMaxChatHistoryMessagesBytes } from "./server-constants-BGwLM6XN.js";
+import { n as agentCommandFromIngress } from "./agent-command-ppfDBwET.js";
+import { t as createDefaultDeps } from "./deps-BExyLYPP.js";
+import { t as loadGatewayModelCatalog } from "./server-model-catalog-EiBfhgFV.js";
+import { a as projectRecentChatDisplayMessages, o as resolveEffectiveChatHistoryMaxChars } from "./chat-display-projection-DCLQ90zy.js";
+import { n as augmentChatHistoryWithCanvasBlocks, o as enforceChatHistoryFinalBudget, s as replaceOversizedChatHistoryMessages, t as CHAT_HISTORY_MAX_SINGLE_MESSAGE_BYTES } from "./chat-Czh_tXM0.js";
+import { n as timestampOptsFromConfig, t as injectTimestamp } from "./agent-timestamp-ClgiA1GA.js";
+import { n as parseGoalCommand } from "./commands-goal-DCf4JWIB.js";
+import { a as writePermissionRequest, i as pollForPermissionResponse, n as getRuntimePermissionMode, s as resolveLocalRunShutdownGraceMs, t as cleanupPermissionRequest } from "./permission-bridge-BGwi3VvH.js";
+import { i as shouldSuppressAssistantEventForLiveChat, n as projectLiveAssistantBufferedText, r as resolveMergedAssistantText, t as normalizeLiveAssistantEventText } from "./live-chat-projector-DPXem8rU.js";
+import { t as applySessionsPatchToStore } from "./sessions-patch-BYC5gvY1.js";
+import path, { isAbsolute, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+//#region src/agents/permission-classifier.ts
+/**
+* Permission tool classifier — maps tool names to permission classes.
+*
+* This determines how the permission pipeline handles each tool:
+*   readonly → auto-allowed in all modes
+*   readonly_scoped → auto-allowed when path is within CWD
+*   mutating → ask in default, auto in acceptEdits
+*   exec_capable → always ask (except in bypassPermissions)
+*   control_plane → always ask
+*   messaging → always ask
+*   unknown → fail-closed (ask)
+*/
+/** Pure read tools — always safe, no side effects. */
+const READONLY_TOOLS = new Set([
+	"read",
+	"search",
+	"memory_search",
+	"memory_get",
+	"sessions_history",
+	"sessions_list",
+	"lcm_grep",
+	"lcm_describe",
+	"lcm_expand",
+	"lcm_expand_query"
+]);
+/** File-mutating tools — modify filesystem. */
+const MUTATING_TOOLS = new Set([
+	"write",
+	"edit",
+	"apply_patch"
+]);
+/** Shell/process execution tools — arbitrary code execution. */
+const EXEC_TOOLS = new Set([
+	"exec",
+	"bash",
+	"shell",
+	"process",
+	"spawn",
+	"code_execution"
+]);
+/** System control tools — change system state. */
+const CONTROL_TOOLS = new Set([
+	"cron",
+	"gateway",
+	"sessions_spawn",
+	"sessions_send",
+	"session_status",
+	"subagents",
+	"canvas",
+	"nodes",
+	"browser"
+]);
+/** Messaging tools — send messages to external channels. */
+const MESSAGING_TOOLS = new Set(["message", "tts"]);
+/** Read-only actions for tools that can be either mutating or readonly. */
+const READONLY_ACTIONS = new Set([
+	"get",
+	"list",
+	"read",
+	"status",
+	"show",
+	"fetch",
+	"search",
+	"query",
+	"view",
+	"poll",
+	"log",
+	"inspect",
+	"check",
+	"probe"
+]);
+function normalizeActionName(args) {
+	if (args == null || typeof args !== "object") return void 0;
+	const action = args.action;
+	if (typeof action !== "string" || !action.trim()) return void 0;
+	return normalizeLowercaseStringOrEmpty(action.trim().replace(/[\s-]+/g, "_"));
+}
+/**
+* Classify a tool call into a permission class.
+* This determines the default handling for the tool in each permission mode.
+*/
+function classifyPermissionTool(toolName, args) {
+	const normalized = normalizeLowercaseStringOrEmpty(toolName);
+	if (READONLY_TOOLS.has(normalized)) return "readonly";
+	if (MUTATING_TOOLS.has(normalized)) return "mutating";
+	if (EXEC_TOOLS.has(normalized)) return "exec_capable";
+	if (CONTROL_TOOLS.has(normalized)) {
+		const action = normalizeActionName(args);
+		if (action && READONLY_ACTIONS.has(action)) return "readonly";
+		return "control_plane";
+	}
+	if (MESSAGING_TOOLS.has(normalized)) {
+		const action = normalizeActionName(args);
+		if (action && READONLY_ACTIONS.has(action)) return "readonly";
+		return "messaging";
+	}
+	if (normalized.endsWith("_search") || normalized.endsWith("_read") || normalized.endsWith("_list")) return "readonly";
+	if (normalized.includes("send") || normalized.startsWith("message_")) return "messaging";
+	return "unknown";
+}
+/**
+* Mode-based decision: given tool class and mode, should we auto-allow or ask?
+* Returns the default decision before rule matching.
+*/
+function modeDefaultDecision(toolClass, mode) {
+	switch (mode) {
+		case "default": return toolClass === "readonly" || toolClass === "readonly_scoped" ? "allow" : "ask";
+		case "acceptEdits":
+			if (toolClass === "readonly" || toolClass === "readonly_scoped" || toolClass === "mutating") return "allow";
+			return "ask";
+		case "plan": return "ask";
+		default: return "ask";
+	}
+}
+//#endregion
+//#region src/agents/permission-rules.ts
+/**
+* Permission rules engine — matches tool calls against deny/ask/allow rules.
+*
+* Rules are checked in priority order:
+*   1. Exact tool name match
+*   2. Wildcard tool name match ("*")
+*   3. Path pattern match (optional, appended)
+*
+* Allow-always decisions are built into rules and tracked per session.
+*/
+function matchToolPattern(pattern, toolName) {
+	if (pattern === "*") return true;
+	return pattern.toLowerCase() === toolName.toLowerCase();
+}
+function matchPathPattern(pattern, targetPath) {
+	if (pattern.includes("|")) return pattern.split("|").some((alt) => matchPathPattern(alt.trim(), targetPath));
+	if (pattern === "*") return true;
+	if (pattern === "**") return true;
+	const normalized = pattern.replace(/\\/g, "/");
+	const target = targetPath.replace(/\\/g, "/");
+	if (target.includes(normalized)) return true;
+	if (normalized === target) return true;
+	if (normalized.startsWith("**/")) {
+		const suffix = normalized.slice(3);
+		if (target.endsWith(suffix)) return true;
+		if (target.includes("/" + suffix)) return true;
+	}
+	const norm = path.posix.normalize(normalized);
+	if (norm.endsWith("/**")) {
+		const dir = norm.slice(0, -3);
+		return target.startsWith(dir + "/") || target === dir;
+	}
+	return false;
+}
+function extractPathFromArgs(args) {
+	if (args == null || typeof args !== "object") return void 0;
+	const record = args;
+	for (const key of [
+		"path",
+		"file_path",
+		"filePath",
+		"filepath",
+		"file"
+	]) {
+		const val = record[key];
+		if (typeof val === "string" && val.trim()) return val;
+	}
+}
+/** Extract the command text from exec tool args (for dangerous-command matching). */
+function extractCommandFromArgs(args) {
+	if (args == null || typeof args !== "object") return void 0;
+	const val = args["command"];
+	return typeof val === "string" && val.trim() ? val : void 0;
+}
+function ruleMatches(rule, toolName, targetPath) {
+	if (!matchToolPattern(rule.toolPattern, toolName)) return false;
+	if (rule.pathPattern && targetPath) return matchPathPattern(rule.pathPattern, targetPath);
+	if (rule.pathPattern && !targetPath) return false;
+	return true;
+}
+/**
+* Find the first matching rule in a priority-ordered list.
+* Returns the decision and the matched rule, or { matched: false }.
+*/
+function findMatchingRule(rules, toolName, targetPath) {
+	for (const rule of rules) if (ruleMatches(rule, toolName, targetPath)) return {
+		matched: true,
+		decision: rule.action,
+		rule
+	};
+	return { matched: false };
+}
+/**
+* Build a tracking key for allow-always decisions.
+* Key = `tool:[toolName]:path:[resolvedPath]` or `tool:[toolName]` for non-file tools.
+*/
+function buildAllowAlwaysKey(toolName, targetPath) {
+	const normalized = toolName.toLowerCase();
+	if (targetPath) return `tool:${normalized}:path:${targetPath}`;
+	return `tool:${normalized}`;
+}
+function checkAllowAlways(tracker, toolName, targetPath) {
+	if (targetPath) {
+		const key = buildAllowAlwaysKey(toolName, targetPath);
+		if (tracker.has(key)) return tracker.get(key);
+	}
+	return tracker.get(buildAllowAlwaysKey(toolName));
+}
+/**
+* Check if a path falls inside any safety zone.
+* Safety zones are absolute directories; tools operating inside them always require ask.
+*/
+function isInSafetyZone(targetPath, safetyZones) {
+	if (!targetPath || safetyZones.length === 0) return false;
+	const normalized = path.resolve(targetPath).replace(/\\/g, "/");
+	for (const zone of safetyZones) {
+		const normZone = path.resolve(zone).replace(/\\/g, "/");
+		if (normalized === normZone || normalized.startsWith(normZone + "/")) return true;
+	}
+	return false;
+}
+const DEFAULT_DENY_RULES = [
+	{
+		toolPattern: "write",
+		pathPattern: "/etc/**",
+		action: "deny",
+		description: "Writing to /etc"
+	},
+	{
+		toolPattern: "write",
+		pathPattern: "/boot/**",
+		action: "deny",
+		description: "Writing to /boot"
+	},
+	{
+		toolPattern: "write",
+		pathPattern: "/sys/**",
+		action: "deny",
+		description: "Writing to /sys"
+	},
+	{
+		toolPattern: "write",
+		pathPattern: "/proc/**",
+		action: "deny",
+		description: "Writing to /proc"
+	},
+	{
+		toolPattern: "write",
+		pathPattern: "**/.git/config",
+		action: "deny",
+		description: "Modifying git config"
+	},
+	{
+		toolPattern: "write",
+		pathPattern: "**/.git/hooks/**",
+		action: "deny",
+		description: "Modifying git hooks"
+	},
+	{
+		toolPattern: "edit",
+		pathPattern: "/etc/**",
+		action: "deny",
+		description: "Editing system config"
+	},
+	{
+		toolPattern: "edit",
+		pathPattern: "/boot/**",
+		action: "deny",
+		description: "Editing boot files"
+	},
+	{
+		toolPattern: "edit",
+		pathPattern: "**/.git/config",
+		action: "deny",
+		description: "Editing git config"
+	},
+	{
+		toolPattern: "edit",
+		pathPattern: "**/.git/hooks/**",
+		action: "deny",
+		description: "Editing git hooks"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: [
+			"rm -rf /",
+			"rm -rf ~",
+			"rm -rf .",
+			"dd if=",
+			"mkfs.",
+			":(){ :|:& };:",
+			"fork bomb",
+			"chmod 777 /",
+			"chmod -R 777 /",
+			"chown -R",
+			"curl.*|.*sh",
+			"wget.*|.*sh",
+			"curl.*|.*bash",
+			"/dev/sda",
+			"/dev/nvme",
+			"/dev/mmcblk",
+			"rm -rf /*",
+			"rm -rf /mnt/*",
+			"rm -rf /home/*",
+			"kill -9 -1",
+			"killall -9"
+		].join("|"),
+		action: "deny",
+		description: "Dangerous shell command"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: [
+			"format c:",
+			"del /f /s c:\\",
+			"rd /s /q c:\\",
+			"diskpart",
+			"bcdedit /delete",
+			"Remove-Item -Path C:\\ -Recurse -Force"
+		].join("|"),
+		action: "deny",
+		description: "Dangerous Windows command"
+	}
+];
+const DEFAULT_ASK_RULES = [
+	{
+		toolPattern: "exec",
+		pathPattern: "npm publish",
+		action: "ask",
+		description: "npm publish"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "npm unpublish",
+		action: "ask",
+		description: "npm unpublish"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "docker push",
+		action: "ask",
+		description: "Docker push"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "git push",
+		action: "ask",
+		description: "Git push"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "git push.*--force",
+		action: "ask",
+		description: "Git force push"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "git push.*--delete",
+		action: "ask",
+		description: "Git delete remote branch"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "gh release",
+		action: "ask",
+		description: "GitHub release"
+	},
+	{
+		toolPattern: "write",
+		pathPattern: "**/.env",
+		action: "ask",
+		description: "Writing .env"
+	},
+	{
+		toolPattern: "write",
+		pathPattern: "**/.env.*",
+		action: "ask",
+		description: "Writing env file"
+	},
+	{
+		toolPattern: "write",
+		pathPattern: "**/credentials.*",
+		action: "ask",
+		description: "Writing credentials file"
+	},
+	{
+		toolPattern: "write",
+		pathPattern: "**/*.pem",
+		action: "ask",
+		description: "Writing PEM key"
+	},
+	{
+		toolPattern: "write",
+		pathPattern: "**/*-key.pem",
+		action: "ask",
+		description: "Writing private key"
+	},
+	{
+		toolPattern: "write",
+		pathPattern: "**/id_rsa",
+		action: "ask",
+		description: "Writing SSH private key"
+	},
+	{
+		toolPattern: "edit",
+		pathPattern: "**/.env",
+		action: "ask",
+		description: "Editing .env"
+	},
+	{
+		toolPattern: "edit",
+		pathPattern: "**/.env.*",
+		action: "ask",
+		description: "Editing env file"
+	},
+	{
+		toolPattern: "edit",
+		pathPattern: "**/credentials.*",
+		action: "ask",
+		description: "Editing credentials"
+	},
+	{
+		toolPattern: "edit",
+		pathPattern: "**/*.pem",
+		action: "ask",
+		description: "Editing PEM key"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "rm -rf",
+		action: "ask",
+		description: "Recursive delete"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "rm -r",
+		action: "ask",
+		description: "Recursive delete"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "shutdown",
+		action: "ask",
+		description: "System shutdown"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "reboot",
+		action: "ask",
+		description: "System reboot"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "sudo",
+		action: "ask",
+		description: "sudo command"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "su -",
+		action: "ask",
+		description: "Switch user"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "ssh ",
+		action: "ask",
+		description: "SSH connection"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "scp ",
+		action: "ask",
+		description: "SCP file transfer"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "rsync ",
+		action: "ask",
+		description: "rsync file sync"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "wget ",
+		action: "ask",
+		description: "File download"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "curl ",
+		action: "ask",
+		description: "HTTP request"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "pip install",
+		action: "ask",
+		description: "Install Python package"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "npm install -g",
+		action: "ask",
+		description: "Global npm install"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "gem install",
+		action: "ask",
+		description: "Install Ruby gem"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "cargo install",
+		action: "ask",
+		description: "Install Rust crate"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "go install",
+		action: "ask",
+		description: "Install Go binary"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "DROP ",
+		action: "ask",
+		description: "SQL DROP operation"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "TRUNCATE ",
+		action: "ask",
+		description: "SQL TRUNCATE"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "DELETE FROM",
+		action: "ask",
+		description: "SQL bulk delete"
+	},
+	{
+		toolPattern: "exec",
+		pathPattern: "ALTER TABLE",
+		action: "ask",
+		description: "SQL schema change"
+	},
+	{
+		toolPattern: "message",
+		pathPattern: "*",
+		action: "ask",
+		description: "Sending message to external channel"
+	}
+];
+const DEFAULT_SAFETY_ZONES = [
+	".git",
+	".github/workflows",
+	".gitlab-ci.yml",
+	"Jenkinsfile",
+	"Dockerfile",
+	"docker-compose.yml",
+	"docker-compose.yaml",
+	".env",
+	".env.local",
+	".env.production",
+	".env.staging",
+	"credentials.json",
+	"service-account.json",
+	"*.pem",
+	"*.key",
+	"id_rsa",
+	"id_ed25519",
+	"package-lock.json",
+	"yarn.lock",
+	"pnpm-lock.yaml",
+	"Cargo.lock",
+	"Gemfile.lock",
+	"pyproject.toml",
+	"Cargo.toml",
+	"Makefile",
+	"~/.ssh",
+	"~/.aws",
+	"~/.kube",
+	"~/.config/gcloud",
+	"/etc/ssh",
+	"/etc/ssl",
+	"C:\\Windows\\System32",
+	"C:\\Program Files",
+	"C:\\Program Files (x86)",
+	"/System",
+	"/Library/LaunchDaemons",
+	"/Library/LaunchAgents"
+];
+//#endregion
+//#region src/agents/permission-pipeline.ts
+/**
+* Permission pipeline — main entry point for tool permission checking.
+*
+* Pipeline order (fail-closed at each step):
+*   1. Hard-deny rules     → deny  (always block, no override)
+*   2. Ask rules           → ask   (always prompt, no override)
+*   3. Safety zones        → ask   (path inside protected dir)
+*   4. Allow-always tracker→ allow (session-scoped remembered decisions)
+*   5. Tool classification → mode-based default (allow/ask)
+*
+* Integration:
+*   - Called from runBeforeToolCallHook() in agent-tools.before-tool-call.ts
+*   - Returns PermissionResult { decision, reason, matchedRule? }
+*   - When decision === "ask", caller handles user prompting via askHandler
+*/
+/**
+* Run the full permission pipeline.
+* Returns the decision and the reason.
+*
+* Note: when decision is "ask", the CALLER must handle the actual user prompt.
+* This function only decides WHAT should happen, not HOW to ask.
+*/
+function checkToolPermission(params) {
+	const { toolName, args, cwd, config, sessionTracker } = params;
+	const configMode = config?.mode ?? "default";
+	const mode = getRuntimePermissionMode() ?? configMode;
+	const targetPath = extractPathFromArgs(args);
+	const resolvedPath = targetPath && cwd ? isAbsolute(targetPath) ? targetPath : resolve(cwd, targetPath) : targetPath;
+	const commandText = extractCommandFromArgs(args);
+	const matchTarget = resolvedPath ?? commandText;
+	const denyMatch = findMatchingRule([...DEFAULT_DENY_RULES, ...config?.deny ?? []], toolName, matchTarget);
+	if (denyMatch.matched) return {
+		decision: "deny",
+		reason: denyMatch.rule.description ?? `Deny rule matched: ${denyMatch.rule.toolPattern}`,
+		matchedRule: denyMatch.rule
+	};
+	const askMatch = findMatchingRule([...DEFAULT_ASK_RULES, ...config?.ask ?? []], toolName, matchTarget);
+	if (askMatch.matched) return {
+		decision: "ask",
+		reason: askMatch.rule.description ?? `Ask rule matched: ${askMatch.rule.toolPattern}`,
+		matchedRule: askMatch.rule
+	};
+	const safetyZones = [...DEFAULT_SAFETY_ZONES, ...config?.safetyZones ?? []];
+	if (resolvedPath && isInSafetyZone(resolvedPath, safetyZones)) return {
+		decision: "ask",
+		reason: `Path "${targetPath}" is inside a safety zone`
+	};
+	if (sessionTracker) {
+		const allowAlways = checkAllowAlways(sessionTracker, toolName, resolvedPath);
+		if (allowAlways) return {
+			decision: "allow",
+			reason: allowAlways.description ?? `Allow-always: ${toolName}`,
+			matchedRule: allowAlways
+		};
+	}
+	const toolClass = classifyPermissionTool(toolName, args);
+	if (modeDefaultDecision(toolClass, mode) === "allow") return {
+		decision: "allow",
+		reason: `Auto-allowed in ${mode} mode (${toolClass})`
+	};
+	if (mode === "plan") return {
+		decision: "ask",
+		reason: PLAN_MODE_REASON
+	};
+	return {
+		decision: "ask",
+		reason: `Requires confirmation in ${mode} mode (${toolClass})`
+	};
+}
+const PLAN_MODE_REASON = [
+	"Plan mode is active. No file edits or command execution are allowed.",
+	"Read the codebase, analyze the problem, and propose a detailed plan.",
+	"Once your plan is approved, the user will switch to acceptEdits mode."
+].join(" ");
+//#endregion
+//#region src/agents/permission-ask-default.ts
+/**
+* Default permission ask handler using file-based IPC.
+*
+* When no explicit askHandler is set on the HookContext, this fallback
+* uses cross-process file IPC to communicate with the TUI.
+*
+* The TUI watches the IPC directory for new .req files and handles them.
+*/
+/**
+* Create the default permission ask handler that uses file-based IPC.
+*
+* Flow:
+*   1. Write a .req file to %TEMP%/fengming-permissions/
+*   2. Poll for the .resp file (up to 60s)
+*   3. Clean up and return the choice
+*
+* If the TUI doesn't respond within 60s, auto-denies.
+*/
+function createFileIpcPermissionAskHandler() {
+	return async (description, toolName, args) => {
+		const requestId = randomUUID();
+		writePermissionRequest(requestId, toolName, description, args);
+		const resp = await pollForPermissionResponse(requestId, 6e4);
+		cleanupPermissionRequest(requestId);
+		if (!resp) return "deny";
+		const choice = resp.choice;
+		if (choice === "allow" || choice === "allow_always" || choice === "deny") return choice;
+		return "deny";
+	};
+}
+//#endregion
+//#region src/tui/tui-permission-hook.ts
+/**
+* TUI Permission Hook — bridges agent tool execution to the Ink TUI PermissionPrompt.
+*
+* Installed as a plugin `before_tool_call` hook via the global hook runner,
+* so that `runBeforeToolCallHook()` (agent-tools.before-tool-call.ts) calls it
+* for every tool execution in local/embedded mode.
+*
+* Uses file-based IPC (permission-bridge.ts) to communicate with the TUI's
+* polling loop in tui-ink-run.ts, which renders PermissionPrompt overlays.
+*/
+let _askHandler = null;
+function getAskHandler() {
+	if (!_askHandler) _askHandler = createFileIpcPermissionAskHandler();
+	return _askHandler;
+}
+/** Simple rule store for "don't ask again" decisions. */
+let _cachedRules = null;
+function loadPermissionRules() {
+	if (_cachedRules) return _cachedRules;
+	try {
+		const fs = __require("node:fs");
+		const path = __require("node:path");
+		const os = __require("node:os");
+		const rulesPath = path.join(os.homedir(), ".fengming", "permissions.json");
+		if (fs.existsSync(rulesPath)) _cachedRules = JSON.parse(fs.readFileSync(rulesPath, "utf8"));
+		else _cachedRules = [];
+	} catch {
+		_cachedRules = [];
+	}
+	return _cachedRules;
+}
+function savePermissionRule(rule) {
+	const rules = loadPermissionRules();
+	rules.push(rule);
+	_cachedRules = rules;
+	try {
+		const fs = __require("node:fs");
+		const path = __require("node:path");
+		const os = __require("node:os");
+		const dir = path.join(os.homedir(), ".fengming");
+		if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+		fs.writeFileSync(path.join(dir, "permissions.json"), JSON.stringify(rules, null, 2));
+	} catch {}
+}
+function checkRules(toolName, cwd) {
+	const rules = loadPermissionRules();
+	for (const rule of rules) {
+		if (rule.tool !== toolName && rule.tool !== "*") continue;
+		if (rule.scope === "cwd" && rule.pattern && !cwd.includes(rule.pattern)) continue;
+		return rule.decision;
+	}
+	return null;
+}
+/**
+* Plugin `before_tool_call` hook handler.
+*
+* Flow:
+*   1. Run the permission pipeline (deny rules → ask rules → safety zones → mode default)
+*   2. If decision is "ask", use file IPC to show PermissionPrompt in the TUI
+*   3. If user denies or timeout, return { block: true }
+*   4. Otherwise, allow the tool to proceed (return void)
+*/
+async function tuiBeforeToolCall(event, _ctx) {
+	const toolName = event.toolName ?? "";
+	if (!toolName) return;
+	const ruleDecision = checkRules(toolName, process.cwd());
+	if (ruleDecision === "allow") return;
+	if (ruleDecision === "deny") return {
+		block: true,
+		blockReason: `Denied by saved rule for ${toolName}`,
+		params: event.params
+	};
+	const result = checkToolPermission({
+		toolName,
+		args: event.params,
+		cwd: process.cwd()
+	});
+	if (result.decision !== "ask") {
+		if (result.decision === "deny") return {
+			block: true,
+			blockReason: result.reason,
+			params: event.params
+		};
+		return;
+	}
+	const description = `Tool: ${toolName}`;
+	const askHandler = getAskHandler();
+	try {
+		const userDecision = await askHandler(description, toolName, event.params);
+		if (userDecision === "deny") return {
+			block: true,
+			blockReason: `User denied: ${description}`,
+			params: event.params
+		};
+		if (userDecision === "allow_always") savePermissionRule({
+			tool: toolName,
+			scope: "global",
+			decision: "allow"
+		});
+		return;
+	} catch {
+		return {
+			block: true,
+			blockReason: `Approval failed (timeout): ${description}`,
+			params: event.params
+		};
+	}
+}
+/**
+* Create a PluginHookRegistration for the TUI before_tool_call hook.
+*
+* Use this to register the hook via initializeGlobalHookRunner().
+*/
+function createTuiBeforeToolCallHookRegistration() {
+	return {
+		pluginId: "fengming-tui",
+		hookName: "before_tool_call",
+		handler: tuiBeforeToolCall,
+		source: "tui:permission-hook"
+	};
+}
+//#endregion
+//#region src/tui/embedded-backend.ts
+const LIFECYCLE_ERROR_RETRY_GRACE_MS = 15e3;
+const silentRuntime = {
+	log: (..._args) => void 0,
+	error: (..._args) => void 0,
+	exit: (code) => {
+		throw new Error(`embedded tui runtime exit ${String(code)}`);
+	}
+};
+function hasProviderWildcardModelAllowlist(cfg) {
+	return [cfg.agents?.defaults?.models, ...cfg.agents?.list?.map((agent) => agent?.models) ?? []].some((models) => Object.keys(models ?? {}).some((key) => key.trim().endsWith("/*")));
+}
+function resolveConfiguredReplaceModeCatalog(cfg) {
+	if (cfg.models?.mode !== "replace") return;
+	if (hasProviderWildcardModelAllowlist(cfg)) return;
+	return buildConfiguredModelCatalog({ cfg });
+}
+function shouldLoadFullGatewayCatalogForReplaceMode(cfg) {
+	return cfg.models?.mode === "replace" && hasProviderWildcardModelAllowlist(cfg);
+}
+async function loadEmbeddedTuiModelCatalog(cfg) {
+	const configuredCatalog = resolveConfiguredReplaceModeCatalog(cfg);
+	if (configuredCatalog !== void 0) return configuredCatalog;
+	return await loadGatewayModelCatalog(shouldLoadFullGatewayCatalogForReplaceMode(cfg) ? { readOnly: false } : void 0);
+}
+function resolveBtwQuestion(message) {
+	const question = /^\/(?:btw|side)(?::|\s)+(.*)$/i.exec(message.trim())?.[1]?.trim();
+	return question ? question : void 0;
+}
+function payloadText(...args) {
+	return null;
+}
+function timeoutSecondsFromMs(timeoutMs) {
+	if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs < 0) return;
+	return String(Math.max(0, Math.ceil(timeoutMs / 1e3)));
+}
+function resolveDeltaPayload(text, previousText) {
+	if (previousText === void 0) return { deltaText: text };
+	if (!text.startsWith(previousText)) return {
+		deltaText: text,
+		replace: true
+	};
+	return { deltaText: text.slice(previousText.length) };
+}
+function createQueuedRunReadiness() {
+	let resolve;
+	const promise = new Promise((ready) => {
+		resolve = ready;
+	});
+	if (!resolve) throw new Error("Expected queue readiness resolver to be initialized");
+	const resolveReady = resolve;
+	let settled = false;
+	return {
+		promise,
+		markReady: () => {
+			if (settled) return;
+			settled = true;
+			resolveReady();
+		}
+	};
+}
+async function waitForLocalRunShutdown(promises) {
+	if (promises.length === 0) return true;
+	const timeoutMs = resolveLocalRunShutdownGraceMs();
+	if (timeoutMs <= 0) return false;
+	let timeout;
+	let completed = false;
+	await Promise.race([Promise.allSettled(promises).then(() => {
+		completed = true;
+	}), new Promise((resolve) => {
+		timeout = setTimeout(resolve, timeoutMs);
+		timeout.unref?.();
+	})]);
+	if (timeout) clearTimeout(timeout);
+	return completed;
+}
+async function waitForQueuedLocalRun(previousRun, runId) {
+	await previousRun.run.queuedRunReady;
+	if (!previousRun.run.finishing && !previousRun.run.lifecycleEnded) {
+		await previousRun.promise;
+		return;
+	}
+	const timeoutMs = resolveLocalRunShutdownGraceMs();
+	if (timeoutMs <= 0) throw new Error(`timed out waiting for previous local run to finish post-turn maintenance for ${runId}`);
+	let timeout;
+	try {
+		await Promise.race([previousRun.promise, new Promise((_, reject) => {
+			timeout = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error(`timed out waiting for previous local run to finish post-turn maintenance for ${runId}`));
+			}, timeoutMs);
+			timeout.unref?.();
+		})]);
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+var EmbeddedTuiBackend = class {
+	constructor() {
+		this.connection = { url: "local embedded" };
+		this.deps = createDefaultDeps();
+		this.runs = /* @__PURE__ */ new Map();
+		this.runPromises = /* @__PURE__ */ new Map();
+		this.seq = 0;
+		this.tuiOwnsHookRunner = false;
+		this.pendingLifecycleErrors = /* @__PURE__ */ new Map();
+	}
+	start() {
+		if (this.unsubscribe) return;
+		setEmbeddedMode(true);
+		if (!getGlobalHookRunner()) {
+			initializeGlobalHookRunner({
+				hooks: [],
+				typedHooks: [createTuiBeforeToolCallHookRegistration()],
+				plugins: [{
+					id: "fengming-tui",
+					status: "loaded"
+				}]
+			});
+			this.tuiOwnsHookRunner = true;
+		}
+		ensureContextWindowCacheLoaded();
+		this.previousRuntimeLog = defaultRuntime.log;
+		this.previousRuntimeError = defaultRuntime.error;
+		defaultRuntime.log = silentRuntime.log;
+		defaultRuntime.error = silentRuntime.error;
+		this.unsubscribe = onAgentEvent((evt) => {
+			this.handleAgentEvent(evt);
+		});
+		queueMicrotask(() => {
+			this.onConnected?.();
+		});
+	}
+	async stop() {
+		const maintenancePromises = [];
+		for (const [runId, run] of this.runs) {
+			if (run.finishing || run.lifecycleEnded) {
+				const promise = this.runPromises.get(runId);
+				if (promise) maintenancePromises.push(promise);
+				continue;
+			}
+			run.controller.abort();
+		}
+		if (!await waitForLocalRunShutdown(maintenancePromises)) {
+			for (const run of this.runs.values()) if (run.finishing || run.lifecycleEnded) run.controller.abort();
+		}
+		this.unsubscribe?.();
+		this.unsubscribe = void 0;
+		this.clearPendingLifecycleErrors();
+		for (const run of this.runs.values()) run.controller.abort();
+		this.runs.clear();
+		this.runPromises.clear();
+		defaultRuntime.log = this.previousRuntimeLog ?? defaultRuntime.log;
+		defaultRuntime.error = this.previousRuntimeError ?? defaultRuntime.error;
+		this.previousRuntimeLog = void 0;
+		this.previousRuntimeError = void 0;
+		if (this.tuiOwnsHookRunner) {
+			resetGlobalHookRunner();
+			this.tuiOwnsHookRunner = false;
+		}
+		setEmbeddedMode(false);
+	}
+	async sendChat(opts) {
+		const runId = opts.runId ?? randomUUID();
+		const question = resolveBtwQuestion(opts.message);
+		const runScope = {
+			sessionKey: opts.sessionKey,
+			agentId: opts.agentId
+		};
+		const stopCommand = this.hasAbortableSessionRun(runScope) && isChatStopCommandText(opts.message);
+		const queuedAfter = question || stopCommand ? void 0 : this.findQueuedSessionRunPromise(runScope);
+		if (stopCommand) {
+			this.abortSessionRuns(runScope);
+			return { runId };
+		}
+		const controller = new AbortController();
+		const queuedRunReadiness = createQueuedRunReadiness();
+		this.runs.set(runId, {
+			sessionKey: opts.sessionKey,
+			agentId: opts.agentId,
+			controller,
+			buffer: "",
+			isBtw: Boolean(question),
+			question,
+			finishing: false,
+			lifecycleEnded: false,
+			finalSent: false,
+			registered: false,
+			queuedRunReady: queuedRunReadiness.promise,
+			markQueuedRunReady: queuedRunReadiness.markReady
+		});
+		const runPromise = this.runTurn({
+			runId,
+			sessionKey: opts.sessionKey,
+			agentId: opts.agentId,
+			message: opts.message,
+			thinking: opts.thinking,
+			deliver: opts.deliver,
+			timeoutMs: opts.timeoutMs,
+			controller,
+			queuedAfter
+		});
+		this.runPromises.set(runId, runPromise);
+		runPromise.finally(() => {
+			this.runPromises.delete(runId);
+		});
+		return { runId };
+	}
+	async abortChat(opts) {
+		const run = this.runs.get(opts.runId);
+		if (!run || run.sessionKey !== opts.sessionKey) return {
+			ok: true,
+			aborted: false
+		};
+		if (opts.sessionKey === "global") {
+			const defaultAgentId = resolveDefaultAgentId(getRuntimeConfig());
+			const requestedAgentId = opts.agentId ? normalizeAgentId(opts.agentId) : defaultAgentId;
+			if ((run.agentId ? normalizeAgentId(run.agentId) : defaultAgentId) !== requestedAgentId) return {
+				ok: true,
+				aborted: false
+			};
+		}
+		if (!this.isAbortableRun(opts.runId, run)) return {
+			ok: true,
+			aborted: false
+		};
+		run.controller.abort();
+		return {
+			ok: true,
+			aborted: true
+		};
+	}
+	async loadHistory(opts) {
+		const loadOptions = opts.agentId ? { agentId: opts.agentId } : void 0;
+		const { cfg, storePath, entry } = loadSessionEntry(opts.sessionKey, loadOptions);
+		const sessionId = entry?.sessionId;
+		const resolvedSessionModel = resolveSessionModelRef(cfg, entry, resolveSessionAgentId({
+			sessionKey: opts.sessionKey,
+			config: cfg,
+			agentId: opts.agentId
+		}));
+		const max = Math.min(1e3, typeof opts.limit === "number" ? opts.limit : 200);
+		const maxHistoryBytes = getMaxChatHistoryMessagesBytes();
+		const localMessages = sessionId && storePath ? await readSessionMessagesAsync(sessionId, storePath, entry?.sessionFile, {
+			mode: "recent",
+			maxMessages: max,
+			maxBytes: Math.max(maxHistoryBytes * 2, 1024 * 1024)
+		}) : [];
+		const capped = capArrayByJsonBytes(replaceOversizedChatHistoryMessages({
+			messages: augmentChatHistoryWithCanvasBlocks(projectRecentChatDisplayMessages(augmentChatHistoryWithCliSessionImports({
+				entry,
+				provider: resolvedSessionModel.provider,
+				localMessages
+			}), {
+				maxChars: resolveEffectiveChatHistoryMaxChars(cfg),
+				maxMessages: max
+			})),
+			maxSingleMessageBytes: Math.min(CHAT_HISTORY_MAX_SINGLE_MESSAGE_BYTES, maxHistoryBytes)
+		}).messages, maxHistoryBytes).items;
+		const messages = enforceChatHistoryFinalBudget({
+			messages: capped,
+			maxBytes: maxHistoryBytes
+		}).messages;
+		let thinkingLevel = entry?.thinkingLevel;
+		if (!thinkingLevel) {
+			const catalog = await loadEmbeddedTuiModelCatalog(cfg);
+			thinkingLevel = resolveThinkingDefault({
+				cfg,
+				provider: resolvedSessionModel.provider,
+				model: resolvedSessionModel.model,
+				catalog
+			});
+		}
+		return {
+			sessionKey: opts.sessionKey,
+			sessionId,
+			messages,
+			thinkingLevel,
+			fastMode: entry?.fastMode,
+			verboseLevel: entry?.verboseLevel ?? cfg.agents?.defaults?.verboseDefault
+		};
+	}
+	async listSessions(opts) {
+		const cfg = getRuntimeConfig();
+		const { storePath, store } = loadCombinedSessionStoreForGateway(cfg, { agentId: opts?.agentId });
+		return await listSessionsFromStoreAsync({
+			cfg,
+			storePath,
+			store,
+			opts: opts ?? {}
+		});
+	}
+	async listAgents() {
+		return listAgentsForGateway(getRuntimeConfig());
+	}
+	async patchSession(opts) {
+		const cfg = getRuntimeConfig();
+		const target = resolveGatewaySessionStoreTarget({
+			cfg,
+			key: opts.key,
+			agentId: opts.agentId
+		});
+		const applied = await updateSessionStore(target.storePath, async (store) => {
+			const { primaryKey } = migrateAndPruneGatewaySessionStoreKey({
+				cfg,
+				key: opts.key,
+				store,
+				agentId: opts.agentId
+			});
+			return await applySessionsPatchToStore({
+				cfg,
+				store,
+				storeKey: primaryKey,
+				agentId: opts.agentId,
+				patch: opts,
+				loadGatewayModelCatalog: () => loadEmbeddedTuiModelCatalog(cfg)
+			});
+		});
+		if (!applied.ok) throw new Error(applied.error.message);
+		const agentId = resolveSessionAgentId({
+			sessionKey: target.canonicalKey ?? opts.key,
+			config: cfg,
+			agentId: opts.agentId
+		});
+		const resolved = resolveSessionModelRef(cfg, applied.entry, agentId);
+		return {
+			ok: true,
+			path: target.storePath,
+			key: target.canonicalKey ?? opts.key,
+			entry: applied.entry,
+			resolved: {
+				modelProvider: resolved.provider,
+				model: resolved.model
+			}
+		};
+	}
+	async resetSession(key, reason, opts) {
+		const result = await performGatewaySessionReset({
+			key,
+			...opts?.agentId ? { agentId: opts.agentId } : {},
+			reason: reason === "new" ? "new" : "reset",
+			commandSource: "tui:embedded"
+		});
+		if (!result.ok) throw new Error(result.error.message);
+		return {
+			ok: true,
+			key: result.key,
+			entry: result.entry
+		};
+	}
+	async getGatewayStatus() {
+		return `local embedded mode${this.runs.size > 0 ? ` (${String(this.runs.size)} active run${this.runs.size === 1 ? "" : "s"})` : ""}`;
+	}
+	async listModels() {
+		const cfg = getRuntimeConfig();
+		const catalog = await loadEmbeddedTuiModelCatalog(cfg);
+		const { allowedCatalog } = buildAllowedModelSet({
+			cfg,
+			catalog,
+			defaultProvider: DEFAULT_PROVIDER
+		});
+		return (allowedCatalog.length > 0 ? allowedCatalog : catalog).map((entry) => ({
+			id: entry.id,
+			name: entry.name ?? entry.id,
+			provider: entry.provider,
+			contextWindow: entry.contextWindow,
+			reasoning: entry.reasoning
+		}));
+	}
+	async runGoalCommand(opts) {
+		const loadOptions = opts.agentId ? { agentId: opts.agentId } : void 0;
+		const { canonicalKey, storePath, entry } = loadSessionEntry(opts.sessionKey, loadOptions);
+		const sessionKey = canonicalKey ?? opts.sessionKey;
+		const parsed = parseGoalCommand(opts.command.trim());
+		if (!parsed) throw new Error("invalid goal command");
+		switch (parsed.action) {
+			case "status": return { text: formatSessionGoalStatus((await getSessionGoal({
+				sessionKey,
+				storePath
+			})).goal) };
+			case "start":
+			case "set":
+			case "create": {
+				const objective = parsed.text.trim();
+				if (!objective) return { text: "Usage: /goal start <objective>" };
+				return { text: `Goal started: ${(await createSessionGoal({
+					sessionKey,
+					storePath,
+					objective,
+					fallbackEntry: entry ?? {
+						sessionId: randomUUID(),
+						updatedAt: Date.now()
+					}
+				})).objective}` };
+			}
+			case "pause": return { text: `Goal paused: ${(await updateSessionGoalStatus({
+				sessionKey,
+				storePath,
+				status: "paused",
+				...parsed.text ? { note: parsed.text } : {}
+			})).objective}` };
+			case "resume": return { text: `Goal resumed: ${(await updateSessionGoalStatus({
+				sessionKey,
+				storePath,
+				status: "active",
+				...parsed.text ? { note: parsed.text } : {}
+			})).objective}` };
+			case "complete":
+			case "done": {
+				const goal = await updateSessionGoalStatus({
+					sessionKey,
+					storePath,
+					status: "complete",
+					...parsed.text ? { note: parsed.text } : {}
+				});
+				return { text: `Goal complete: ${goal.objective}\nTokens used: ${goal.tokensUsed}` };
+			}
+			case "block":
+			case "blocked": return { text: `Goal blocked: ${(await updateSessionGoalStatus({
+				sessionKey,
+				storePath,
+				status: "blocked",
+				...parsed.text ? { note: parsed.text } : {}
+			})).objective}` };
+			case "clear": return { text: await clearSessionGoal({
+				sessionKey,
+				storePath
+			}) ? "Goal cleared." : "No goal to clear." };
+			default: return { text: "Usage: /goal [status] | /goal start <objective> | /goal pause|resume|complete|block|clear" };
+		}
+	}
+	findQueuedSessionRunPromise(params) {
+		let queuedAfter;
+		for (const [runId, run] of this.runs) if (this.isSameRunScope(run, params) && !run.isBtw) {
+			const promise = this.runPromises.get(runId);
+			if (promise) queuedAfter = {
+				run,
+				promise
+			};
+		}
+		return queuedAfter;
+	}
+	abortSessionRuns(params) {
+		for (const [runId, run] of this.runs) if (this.isSameRunScope(run, params) && !run.isBtw && this.isAbortableRun(runId, run)) run.controller.abort();
+	}
+	hasAbortableSessionRun(params) {
+		for (const [runId, run] of this.runs) if (this.isSameRunScope(run, params) && !run.isBtw && this.isAbortableRun(runId, run)) return true;
+		return false;
+	}
+	isSameRunScope(run, params) {
+		if (run.sessionKey !== params.sessionKey) return false;
+		if (params.sessionKey !== "global") return true;
+		return run.agentId === params.agentId;
+	}
+	isAbortableRun(runId, run) {
+		return !run.lifecycleEnded || this.runPromises.has(runId);
+	}
+	nextSeq() {
+		this.seq += 1;
+		return this.seq;
+	}
+	emit(event, payload) {
+		this.onEvent?.({
+			event,
+			payload,
+			seq: this.nextSeq()
+		});
+	}
+	clearPendingLifecycleError(runId) {
+		const pending = this.pendingLifecycleErrors.get(runId);
+		if (!pending) return;
+		clearTimeout(pending);
+		this.pendingLifecycleErrors.delete(runId);
+	}
+	clearPendingLifecycleErrors() {
+		for (const pending of this.pendingLifecycleErrors.values()) clearTimeout(pending);
+		this.pendingLifecycleErrors.clear();
+	}
+	scheduleChatError(runId, run, errorMessage) {
+		this.clearPendingLifecycleError(runId);
+		const timer = setTimeout(() => {
+			this.pendingLifecycleErrors.delete(runId);
+			this.emitChatError(runId, run, errorMessage);
+		}, LIFECYCLE_ERROR_RETRY_GRACE_MS);
+		timer.unref?.();
+		this.pendingLifecycleErrors.set(runId, timer);
+	}
+	emitChatDelta(runId, run) {
+		const projected = projectLiveAssistantBufferedText(run.buffer.trim(), { suppressLeadFragments: true });
+		const text = projected.text.trim();
+		if (!text || projected.suppress) return;
+		const deltaPayload = resolveDeltaPayload(text, run.lastBroadcastText);
+		if (!deltaPayload.deltaText && !deltaPayload.replace) return;
+		run.registered = true;
+		run.lastBroadcastText = text;
+		this.emit("chat", {
+			runId,
+			sessionKey: run.sessionKey,
+			state: "delta",
+			...deltaPayload,
+			message: {
+				role: "assistant",
+				content: [{
+					type: "text",
+					text
+				}],
+				timestamp: Date.now()
+			}
+		});
+	}
+	emitChatFinal(runId, run, stopReason) {
+		this.clearPendingLifecycleError(runId);
+		run.markQueuedRunReady();
+		const alreadyFinal = run.finalSent;
+		run.finishing = false;
+		run.lifecycleEnded = true;
+		run.finalSent = true;
+		if (alreadyFinal) return;
+		run.registered = true;
+		run.lastBroadcastText = void 0;
+		const projected = projectLiveAssistantBufferedText(run.buffer.trim(), { suppressLeadFragments: false });
+		const text = projected.text.trim();
+		const shouldIncludeMessage = Boolean(text) && !projected.suppress;
+		this.emit("chat", {
+			runId,
+			sessionKey: run.sessionKey,
+			state: "final",
+			...stopReason ? { stopReason } : {},
+			...shouldIncludeMessage ? { message: {
+				role: "assistant",
+				content: [{
+					type: "text",
+					text
+				}],
+				timestamp: Date.now()
+			} } : {}
+		});
+	}
+	emitChatAborted(runId, run) {
+		this.clearPendingLifecycleError(runId);
+		run.markQueuedRunReady();
+		const alreadyFinal = run.finalSent;
+		run.finishing = false;
+		run.lifecycleEnded = true;
+		run.finalSent = true;
+		if (alreadyFinal) return;
+		run.registered = true;
+		run.lastBroadcastText = void 0;
+		this.emit("chat", {
+			runId,
+			sessionKey: run.sessionKey,
+			state: "aborted"
+		});
+	}
+	emitChatError(runId, run, errorMessage) {
+		this.clearPendingLifecycleError(runId);
+		run.markQueuedRunReady();
+		const alreadyFinal = run.finalSent;
+		run.finishing = false;
+		run.lifecycleEnded = true;
+		run.finalSent = true;
+		if (alreadyFinal) return;
+		run.registered = true;
+		run.lastBroadcastText = void 0;
+		this.emit("chat", {
+			runId,
+			sessionKey: run.sessionKey,
+			state: "error",
+			...errorMessage ? { errorMessage } : {}
+		});
+	}
+	ensureRunRegistered(runId, run) {
+		if (run.registered || run.isBtw) return;
+		run.registered = true;
+		run.lastBroadcastText = "";
+		this.emit("chat", {
+			runId,
+			sessionKey: run.sessionKey,
+			state: "delta",
+			deltaText: "",
+			message: {
+				role: "assistant",
+				content: [{
+					type: "text",
+					text: ""
+				}],
+				timestamp: Date.now()
+			}
+		});
+	}
+	async handleAgentEvent(evt) {
+		const run = this.runs.get(evt.runId);
+		if (!run) return;
+		const lifecyclePhase = evt.stream === "lifecycle" && typeof evt.data?.phase === "string" ? evt.data.phase : "";
+		if (evt.stream !== "lifecycle" || lifecyclePhase !== "error") this.clearPendingLifecycleError(evt.runId);
+		if (evt.stream !== "assistant") this.ensureRunRegistered(evt.runId, run);
+		this.emit("agent", {
+			runId: evt.runId,
+			stream: evt.stream,
+			data: evt.data
+		});
+		if (evt.stream === "assistant" && !run.isBtw && typeof evt.data?.text === "string" && !shouldSuppressAssistantEventForLiveChat(evt.data)) {
+			const cleaned = normalizeLiveAssistantEventText({
+				text: evt.data.text,
+				delta: evt.data.delta
+			});
+			run.buffer = resolveMergedAssistantText({
+				previousText: run.buffer,
+				nextText: cleaned.text,
+				nextDelta: cleaned.delta
+			});
+			this.emitChatDelta(evt.runId, run);
+			return;
+		}
+		if (evt.stream !== "lifecycle") return;
+		const phase = lifecyclePhase;
+		const aborted = evt.data?.aborted === true || run.controller.signal.aborted;
+		if (phase === "finishing") {
+			run.finishing = true;
+			run.markQueuedRunReady();
+			run.lifecycleStopReason = typeof evt.data?.stopReason === "string" ? evt.data.stopReason : void 0;
+			return;
+		}
+		if (phase === "end") {
+			run.finishing = false;
+			if (aborted) {
+				this.emitChatAborted(evt.runId, run);
+				return;
+			}
+			run.lifecycleEnded = true;
+			run.markQueuedRunReady();
+			run.lifecycleStopReason = typeof evt.data?.stopReason === "string" ? evt.data.stopReason : void 0;
+			return;
+		}
+		if (phase === "error") {
+			run.finishing = false;
+			if (aborted) {
+				this.emitChatAborted(evt.runId, run);
+				return;
+			}
+			const errorMessage = typeof evt.data?.error === "string" ? evt.data.error : void 0;
+			run.buffer = "";
+			this.scheduleChatError(evt.runId, run, errorMessage);
+		}
+	}
+	async runTurn(params) {
+		try {
+			if (params.queuedAfter) {
+				try {
+					await waitForQueuedLocalRun(params.queuedAfter, params.runId);
+				} catch (error) {
+					const run = this.runs.get(params.runId);
+					if (run) {
+						const errorMessage = error instanceof Error ? error.message : String(error);
+						this.emitChatError(params.runId, run, `previous run did not finish cleanly: ${errorMessage}`);
+					}
+					return;
+				}
+				if (params.controller.signal.aborted) {
+					const run = this.runs.get(params.runId);
+					if (run) this.emitChatAborted(params.runId, run);
+					return;
+				}
+			}
+			const loadOptions = params.agentId ? { agentId: params.agentId } : void 0;
+			const { cfg, canonicalKey, entry } = loadSessionEntry(params.sessionKey, loadOptions);
+			const result = await agentCommandFromIngress({
+				message: injectTimestamp(params.message, timestampOptsFromConfig(cfg)),
+				sessionKey: canonicalKey,
+				...params.agentId ? { agentId: params.agentId } : {},
+				...entry?.sessionId ? { sessionId: entry.sessionId } : {},
+				thinking: params.thinking,
+				deliver: params.deliver,
+				channel: INTERNAL_MESSAGE_CHANNEL,
+				runContext: { messageChannel: INTERNAL_MESSAGE_CHANNEL },
+				timeout: timeoutSecondsFromMs(params.timeoutMs),
+				runId: params.runId,
+				abortSignal: params.controller.signal,
+				allowModelOverride: false
+			}, silentRuntime, this.deps);
+			const run = this.runs.get(params.runId);
+			if (!run) return;
+			if (params.controller.signal.aborted || result?.meta?.aborted === true) {
+				this.emitChatAborted(params.runId, run);
+				return;
+			}
+			if (run.isBtw) {
+				const text = payloadText(result?.payloads);
+				if (run.question && text) this.emit("chat.side_result", {
+					kind: "btw",
+					runId: params.runId,
+					sessionKey: run.sessionKey,
+					question: run.question,
+					text
+				});
+				this.emitChatFinal(params.runId, run);
+				return;
+			}
+			if (!run.finalSent) {
+				const normalizedText = payloadText(result?.payloads);
+				if (normalizedText && !run.buffer) run.buffer = normalizedText;
+				const stopReason = run.lifecycleStopReason ?? (typeof result?.meta?.stopReason === "string" ? result.meta.stopReason : void 0);
+				this.emitChatFinal(params.runId, run, stopReason);
+			}
+		} catch (error) {
+			const run = this.runs.get(params.runId);
+			if (!run) return;
+			if (params.controller.signal.aborted) {
+				this.emitChatAborted(params.runId, run);
+				return;
+			}
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			this.emitChatError(params.runId, run, errorMessage);
+		} finally {
+			this.runs.get(params.runId)?.markQueuedRunReady();
+			this.runs.delete(params.runId);
+		}
+	}
+};
+//#endregion
+export { EmbeddedTuiBackend };