fengming 0.3.7 → 0.3.9

package/dist/embedded-backend-BdbgfpBP.js

@@ -1,1581 +0,0 @@
-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-gQkwsWYz.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-uoi7E4Xp.js";
-import { c as getMaxChatHistoryMessagesBytes } from "./server-constants-BGwLM6XN.js";
-import { n as agentCommandFromIngress } from "./agent-command-iLD_nsVY.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-DWRXkuvU.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-DlAAvQvB.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 };