@linghun/tui 0.1.0

package/dist/index.js

@@ -0,0 +1,2346 @@
+import {
+  reduceTranscriptScroll
+} from "./chunk-JPXSFZFC.js";
+import {
+  writeTextToClipboard
+} from "./chunk-HWD22O6F.js";
+import {
+  buildPromptCommandUserText,
+  findPromptCommand
+} from "./chunk-YTQFOZRZ.js";
+import {
+  runMemoryEviction
+} from "./chunk-O7EFPSMC.js";
+import {
+  handleAppsCommand
+} from "./chunk-JDWXC2OQ.js";
+import {
+  handleCapabilitiesCommand
+} from "./chunk-QB4VWH7W.js";
+import {
+  __testFormatStartAgentDidNotStartMessage,
+  __testParseRunWorkflowToolInput,
+  __testRenderInteractiveChoiceLines,
+  __testSendMessage,
+  __testStopCommandPanelSelection,
+  __testStopSingleBackgroundTask,
+  __testToggleCommandPanelSelection,
+  __testUpdateCommandPanelSelection,
+  addAllowRuleForTest,
+  cancelPendingInteraction,
+  configureSlashCommandRuntime,
+  confirmPendingInteraction,
+  cycleMode,
+  executePermissionApprove,
+  executePermissionDeny,
+  getWorkspaceTrustCommandGuard,
+  gitSlashDeps,
+  handleAutopilotCommand,
+  handleBranchCommand,
+  handleBreakCacheCommand,
+  handleBtwCommand,
+  handleCacheCommand,
+  handleCacheLogCommand,
+  handleClaimCheckCommand,
+  handleCompactCommand,
+  handleDoctorCommand,
+  handleImageCommand,
+  handleInterruptCommand,
+  handleLanguageCommand,
+  handleModeCommand,
+  handleNaturalInput,
+  handlePermissionsCommand,
+  handlePlanCommand,
+  handleRemoteInboundMessage,
+  handleResumeCommand,
+  handleReviewCommand,
+  handleRewindCommand,
+  handleToolCommand,
+  handleTrustCommand,
+  handleTuiKeypress,
+  handleVerifyCommand,
+  handleVisionCommand,
+  hasPendingEnterConfirmation,
+  interruptAllActiveWork,
+  promptInitialLanguage,
+  promptInitialWorkspaceTrust,
+  recordModelUsage,
+  reevaluatePendingLocalApprovalAfterModeChange,
+  refreshBackgroundLifecycle,
+  requestIndexInitFastApproval,
+  requestIndexRefreshApproval,
+  runCommandCaptureForTest,
+  runIndexSafetyRepair,
+  runVerificationCommandForTest,
+  sendMessage,
+  shouldPromptForInitialLanguage,
+  shouldPromptForInitialWorkspaceTrust,
+  stopCommandPanelSelection,
+  toggleCommandPanelSelection,
+  updateCommandPanelSelection,
+  writeWorkspaceTrustStartupNotice
+} from "./chunk-4WHZ6JKD.js";
+import {
+  createCommandBlock,
+  createUserTextBlock
+} from "./chunk-SJOS5PM6.js";
+import {
+  computeHomePromptPrefix,
+  writePlainShell
+} from "./chunk-IN42UISW.js";
+import "./chunk-GC55DMZV.js";
+import "./chunk-DICVLZHH.js";
+import {
+  createInitialContinuityState
+} from "./chunk-3XNUDLOM.js";
+import {
+  formatTerminalProblemsPanel,
+  formatTerminalReadinessStatus
+} from "./chunk-ZYSN7AWW.js";
+import "./chunk-RM5QMOFY.js";
+import "./chunk-WKMBK5UP.js";
+import {
+  consumeRemoteInboundMessage,
+  createRemoteEvent,
+  handleRemoteCommand,
+  processRemoteApprovalForTest,
+  processRemoteInbound,
+  sendRemoteEventReal,
+  validateRemoteInboundEnvelope,
+  validateRemotePairingEnvelope
+} from "./chunk-66BNE332.js";
+import "./chunk-UT5BOJKU.js";
+import "./chunk-RM5JDRCW.js";
+import {
+  formatPendingApprovalDetails
+} from "./chunk-QTDGRZMZ.js";
+import {
+  handleMemoryCommand,
+  resumeSessionWithHandoff,
+  runAutoLearningOnTurnEnd
+} from "./chunk-GMUCSNUD.js";
+import "./chunk-VTQL23UM.js";
+import "./chunk-DNQN74CC.js";
+import "./chunk-KQJHVJZB.js";
+import {
+  handleModelCommand,
+  handleModelSetupInput,
+  startModelSetup
+} from "./chunk-D7TCSOAZ.js";
+import "./chunk-NMNOAFFT.js";
+import {
+  executeExtraTool,
+  executeSearchExtraTools,
+  findBundledCodebaseMemoryBinary,
+  getBundledCodebaseMemoryRoots,
+  getCodebaseMemoryPlatformArch,
+  handleIndexCommand,
+  handleMcpCommand,
+  refreshIndexStatus
+} from "./chunk-JQCRCDOC.js";
+import "./chunk-W6NU7ZAV.js";
+import "./chunk-OF3K3CU5.js";
+import "./chunk-SRZIA6B4.js";
+import {
+  isPotentiallyMutatingMcpTool
+} from "./chunk-OEYW3JE3.js";
+import {
+  formatProviderGuardSummary,
+  formatRunnerGuardSummary,
+  formatRuntimePathDoctor,
+  formatStartupPathDoctor,
+  formatVerificationLevelDoctor,
+  validateChangeDeclarationHuman,
+  validateCompletionClaim
+} from "./chunk-CRW3636S.js";
+import "./chunk-W3KHJNSH.js";
+import "./chunk-P277M7Z5.js";
+import {
+  handleCheckpointCommand,
+  handleGitCommand,
+  handleWorktreeCommand
+} from "./chunk-GKZYTPN2.js";
+import "./chunk-GTP2KPLY.js";
+import "./chunk-7ZE5JFAZ.js";
+import {
+  handlePluginsCommand,
+  handleSkillsCommand
+} from "./chunk-FTAEPAVY.js";
+import {
+  handleFailuresCommand
+} from "./chunk-2FVEKTKN.js";
+import "./chunk-X7A22JHP.js";
+import {
+  startFeishuLongConnection
+} from "./chunk-WJWYRBWH.js";
+import {
+  createRemotePairing,
+  createSignedRemoteInboundFixture,
+  decideRemoteInbox,
+  dingtalkBridgeAdapter,
+  dingtalkStreamFrameToBridgeEvent,
+  feishuBridgeAdapter,
+  feishuReceiveMessageToBridgeEvent,
+  formatRemoteBridgeDoctor,
+  getRemoteBridgeDoctor,
+  processRemoteBindCommand,
+  wecomBridgeAdapter
+} from "./chunk-CFXB5SE5.js";
+import "./chunk-WHFDDZHY.js";
+import {
+  breakCacheTestHooks
+} from "./chunk-WVAQYKGL.js";
+import "./chunk-QIU3FJPC.js";
+import {
+  writeLightHintsForTest
+} from "./chunk-LDABZV5V.js";
+import {
+  __testBuildExplicitDetailsCommandPanel,
+  __testCreateShellBlockOutput,
+  __testCreateVerificationLevelForReadiness,
+  __testGetCurrentWorkflowStepRequest,
+  __testRunWorkflowStepsWithPlan,
+  __testWorkflowStepStatusFromNestedJob,
+  buildStatusPanel,
+  createSessionEndEvent,
+  ensureSession,
+  formatHomeScreen,
+  formatShellBackgroundSummaries,
+  handleAgentsCommand,
+  handleBackgroundCommand,
+  handleBatchCommand,
+  handleDetailsCommand,
+  handleForkCommand,
+  handleJobCommand,
+  handleWorkflowsCommand,
+  hydrateDurableJobBackgroundTasks,
+  hydratePersistentAgents,
+  hydrateWorkflowRuns,
+  showCommandPanel,
+  t,
+  writeStatus
+} from "./chunk-JO5ANTMR.js";
+import "./chunk-WQMSRO4D.js";
+import "./chunk-V7GDHHBL.js";
+import "./chunk-GCMH5P4W.js";
+import "./chunk-THZBFYAH.js";
+import {
+  ShellBlockOutput
+} from "./chunk-ECFLCY5V.js";
+import {
+  addAllowRule,
+  decidePermission,
+  loadPermissionState
+} from "./chunk-DDXS2RDZ.js";
+import {
+  formatCatalogHelp,
+  formatSlashDiscovery,
+  formatUnknownSlashCommand,
+  getSlashPrefixCandidates,
+  slashCommandToTool
+} from "./chunk-4K6UB524.js";
+import {
+  createTerminalReadinessView
+} from "./chunk-PBIPV4LD.js";
+import {
+  cleanupCompletedBackgroundTasks,
+  getDurableJobPaths
+} from "./chunk-ZZ2CNCXJ.js";
+import {
+  getDurableJobsRoot
+} from "./chunk-TYF4GJR3.js";
+import "./chunk-B4GQTZMT.js";
+import "./chunk-L4XXW6Y5.js";
+import {
+  classifyProviderVerificationLevel,
+  classifyRunnerVerificationLevel,
+  classifyVerificationLevel,
+  compareVerificationLevels,
+  detectVerificationInflation,
+  formatVerificationLevel,
+  isNonUpgradeableStatus
+} from "./chunk-CRSLDQOA.js";
+import {
+  canClaimCurrentVerification,
+  canClaimTuiMaturity,
+  classifyRuntimePath,
+  classifyStartupPath,
+  detectRuntimePathInflation,
+  formatRuntimePathMarker,
+  formatStartupPathMarker
+} from "./chunk-VIBENDE3.js";
+import {
+  formatConfigOverview,
+  formatFeaturePolicy,
+  validateExtensionContributionExecution
+} from "./chunk-LVIM2PA7.js";
+import "./chunk-RVY34HK4.js";
+import {
+  installProcessGuardExitHandlers,
+  requestTrackedProcessStop
+} from "./chunk-JHGWGH2C.js";
+import "./chunk-E72U7WW7.js";
+import {
+  buildConfigPanelActions,
+  createOutputBlock,
+  createShellViewModel,
+  mapPendingApprovalToPermission,
+  mapRequestActivityToView
+} from "./chunk-AKPXMCVF.js";
+import {
+  buildTranscriptScreenBuffer,
+  isSelectionStale,
+  reduceTranscriptSelection
+} from "./chunk-NKFKOEYX.js";
+import "./chunk-3AKXDMVS.js";
+import "./chunk-H3T4EF5F.js";
+import "./chunk-NSIKYD3X.js";
+import {
+  getBackgroundOverlaySelectedTask,
+  updateBackgroundOverlayCursor
+} from "./chunk-FRIMDSRU.js";
+import {
+  messages
+} from "./chunk-RBOQJFIZ.js";
+import "./chunk-KI7C6ZOD.js";
+import {
+  createModelSystemPrompt,
+  sanitizeMainScreenLeakage
+} from "./chunk-3GCIXKCI.js";
+import "./chunk-J7ZE2JKP.js";
+import "./chunk-BOV4K7FP.js";
+import "./chunk-KTWV5JC5.js";
+import "./chunk-PGNALDEH.js";
+import "./chunk-UDQT5CWK.js";
+import {
+  loadProjectKeybindings
+} from "./chunk-6SMM5CMP.js";
+import {
+  deferredToolListHashInput,
+  findDeferredTool,
+  formatDeferredToolsSystemReminder,
+  getCodebaseMemoryToolRisk,
+  isLocalStdioMcpServer,
+  listDeferredTools,
+  parseMcpDeferredToolName,
+  sanitizeDiscoveredDeferredToolName,
+  searchDeferredTools,
+  snapshotDeferredTools,
+  snapshotDeferredToolsSummary,
+  snapshotDiscoveredDeferredToolsSummary,
+  validateCodebaseMemoryToolExecution
+} from "./chunk-I3NTAIMF.js";
+import {
+  appendSystemEvent
+} from "./chunk-64MJP6FK.js";
+import "./chunk-O7S3HYE6.js";
+import {
+  BACKGROUND_KIND_CAPS,
+  BACKGROUND_RUNNING_GLOBAL_CAP,
+  CODEBASE_MEMORY_COMMAND,
+  CODEBASE_MEMORY_ENV,
+  DEFAULT_LIGHT_HINT_COOLDOWN_MS,
+  MAX_BACKGROUND_TASKS,
+  MAX_CACHE_HISTORY_SIZE,
+  MAX_CHECKPOINTS,
+  MAX_CONTEXT_MESSAGES,
+  MAX_EVIDENCE_RECORDS,
+  MAX_LIGHT_HINTS_PER_TURN,
+  MAX_MODEL_TOTAL_TOOL_ROUNDS,
+  MAX_RAW_TOOL_PROTOCOL_TEXT_RETRIES,
+  MAX_TODO_ONLY_CONSECUTIVE_ROUNDS,
+  MEMORY_PROMPT_ITEM_WIDTH,
+  MEMORY_PROMPT_TOP_K,
+  MEMORY_PROMPT_TOTAL_WIDTH,
+  MIN_CACHE_HISTORY_SIZE,
+  PROJECT_RULES_STATUS_WIDTH,
+  REQUEST_SLOW_HINT_MS,
+  USER_VISIBLE_DISPATCH_SLASH_COMMANDS,
+  VERIFICATION_COMMAND_TIMEOUT_MS,
+  WORKFLOW_ARCHITECTURE_REVIEW_FILE_LIMIT,
+  createSingleToolCallContinuation,
+  runtimeFromContinuation
+} from "./chunk-RDGM4RUE.js";
+import {
+  LINGHUN_BASH_MAX_OUTPUT_DEFAULT,
+  LINGHUN_BASH_MAX_OUTPUT_UPPER_LIMIT,
+  LINGHUN_BYTES_PER_TOKEN,
+  LINGHUN_DEFAULT_TOOL_RESULT_CHARS,
+  LINGHUN_MAX_AGENTIC_TURNS,
+  LINGHUN_MAX_AGENT_CHILD_TOOL_ROUNDS,
+  LINGHUN_MAX_AGENT_CHILD_TURNS,
+  LINGHUN_MAX_EVIDENCE_TOOL_ROUNDS,
+  LINGHUN_MAX_RAW_TOOL_PROTOCOL_TEXT_RETRIES,
+  LINGHUN_MAX_TODO_ONLY_CONSECUTIVE_ROUNDS,
+  LINGHUN_MAX_TOOL_RESULTS_PER_MESSAGE_CHARS,
+  LINGHUN_MAX_TOOL_RESULT_BYTES,
+  LINGHUN_MAX_TOOL_RESULT_TOKENS,
+  LINGHUN_TASK_MAX_OUTPUT_DEFAULT,
+  LINGHUN_TASK_MAX_OUTPUT_UPPER_LIMIT
+} from "./chunk-IWUIOLMF.js";
+import "./chunk-MLUIOBKL.js";
+import {
+  containsSecret
+} from "./chunk-LQTVYUT3.js";
+import {
+  createSolutionCompletenessStatus
+} from "./chunk-K56D3X7S.js";
+import "./chunk-BFVPLGAC.js";
+import "./chunk-6USL33ZO.js";
+import "./chunk-4EIC5BCT.js";
+import "./chunk-AO4CXI37.js";
+import {
+  createFailureLearningState,
+  loadFailureRecords
+} from "./chunk-GDQQNPBP.js";
+import "./chunk-RMLTVKOY.js";
+import {
+  createIndexState
+} from "./chunk-UT2TYK2A.js";
+import {
+  applyRemoteSessionDisables,
+  codebaseMemoryRequiredArgs,
+  createCacheState,
+  createHookState,
+  createMcpState,
+  createMcpToolPlaceholders,
+  createMemoryState,
+  createPluginState,
+  createRemoteState,
+  createSkillState,
+  createWorkflowState,
+  getRemoteInstallHint,
+  isRecord,
+  normalizeMemoryStatus,
+  pathExists,
+  stableId,
+  summarizeProjectRules
+} from "./chunk-QLRTQHTR.js";
+import "./chunk-ZJK25VFP.js";
+import "./chunk-5H7RRF7C.js";
+import "./chunk-4EP3TUFF.js";
+import "./chunk-EORRZP3F.js";
+import {
+  formatStats,
+  formatUsage
+} from "./chunk-QBCGAIU7.js";
+import "./chunk-K4FSYBSY.js";
+import {
+  createModelGateway,
+  getSelectedModelRuntime,
+  getStartupProjectRouteProblem,
+  hasSelectedProviderConfigProblem,
+  resolveInitialModel,
+  shouldOfferUserScopedModelSetup
+} from "./chunk-3LT6OWQ2.js";
+import "./chunk-2YL5VKJ5.js";
+import {
+  createProviderCircuitBreakerState
+} from "./chunk-EBACIBJP.js";
+import "./chunk-OZMX3E35.js";
+import "./chunk-URNQUECO.js";
+import "./chunk-WV6YJGZR.js";
+import "./chunk-4T5DJW54.js";
+import {
+  createAgentCompletionState
+} from "./chunk-SYBNJZEL.js";
+import {
+  createShellLimitations,
+  formatError,
+  formatProjectRouteProblem,
+  formatProviderEnvWarning,
+  formatUserScopedSetupNeeded,
+  readInputLines,
+  readOutputColumns,
+  readOutputRows,
+  shouldEnterProductShellCandidate,
+  truncateDisplay,
+  writeLine
+} from "./chunk-OMZYPQVA.js";
+import "./chunk-APJIC2O5.js";
+import {
+  loadAgentRegistry,
+  loadWorkflowRegistry,
+  registryAgentToWorkflowTemplate,
+  registryWorkflowToTemplate
+} from "./chunk-HQIJGQYU.js";
+import {
+  DEFAULT_THRESHOLDS,
+  checkBoundaries,
+  checkFileBoundaries,
+  detectCircularDependencyRisk,
+  detectCrossLayerImports,
+  estimateFileMetrics,
+  formatBoundaryViolations,
+  validateChangeDeclaration
+} from "./chunk-HAEU6OTS.js";
+import "./chunk-MVONSJEN.js";
+import "./chunk-LHHKPGLX.js";
+
+// src/index.ts
+import "child_process";
+import "crypto";
+import "fs";
+import { readFile, readdir, rm } from "fs/promises";
+import "os";
+import { join, resolve } from "path";
+import {
+  stderr as defaultStderr,
+  stdin as defaultStdin,
+  stdout as defaultStdout
+} from "process";
+import "readline";
+import "readline/promises";
+import {
+  ensureProviderEnvTemplate,
+  getProviderEnvPath,
+  lastProviderEnvWarning,
+  loadConfig,
+  providerEnvExists,
+  resolveStoragePaths
+} from "@linghun/config";
+import {
+  SessionStore
+} from "@linghun/core";
+import {
+  registerHooks as registerProviderHooks
+} from "@linghun/providers";
+import { LINGHUN_NAME } from "@linghun/shared";
+import {
+  createToolContext
+} from "@linghun/tools";
+var tuiStatus = "ready";
+async function createAgentRegistryState(projectPath) {
+  const result = await loadAgentRegistry(projectPath);
+  return { agents: result.items, errors: result.errors };
+}
+async function createWorkflowRegistryState(projectPath) {
+  const result = await loadWorkflowRegistry(projectPath);
+  return { workflows: result.items, errors: result.errors };
+}
+function mergeWorkflowTemplates(...groups) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const group of groups) {
+    for (const template of group) {
+      byId.set(template.id, template);
+    }
+  }
+  return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+function isCtrlOExpandableBlock(block) {
+  const fullText = (block.fullText ?? "").trim();
+  const summary = (block.summary ?? "").trim();
+  if (!fullText) return false;
+  if (!summary) return fullText.length > 0;
+  const nonEmptyLines = fullText.split(/\r?\n/u).filter((line) => line.trim().length > 0).length;
+  return nonEmptyLines >= 2 || fullText.length > summary.length + 16;
+}
+function findLatestCtrlOExpandableBlock(blocks) {
+  return [...blocks].reverse().find(isCtrlOExpandableBlock);
+}
+function toggleCurrentCommandPanelDetails(context) {
+  const panel = context.commandPanelState;
+  if (!panel) return false;
+  const selectableRows = (panel.sections ?? []).flatMap((section) => section.rows).filter((row) => typeof row !== "string");
+  const cursor = Math.max(0, Math.min(panel.cursor ?? 0, selectableRows.length - 1));
+  const selectedDetails = selectableRows[cursor]?.detailsText?.trim();
+  const panelDetails = panel.detailsText?.trim();
+  if (!selectedDetails && !panelDetails) return false;
+  context.commandPanelState = { ...panel, expanded: !panel.expanded };
+  context.ctrlOExpandState = { active: false };
+  return true;
+}
+async function runTui(options = {}) {
+  const input = options.stdin ?? defaultStdin;
+  const output = options.stdout ?? defaultStdout;
+  const errorOutput = options.stderr ?? defaultStderr;
+  const projectPath = options.projectPath ?? process.cwd();
+  const config = await loadConfig(projectPath);
+  const storagePaths = resolveStoragePaths(config, projectPath);
+  const store = new SessionStore({ sessionRootDir: storagePaths.sessions, projectPath });
+  const initialModel = resolveInitialModel(config);
+  const context = {
+    store,
+    model: initialModel,
+    permissionMode: config.permission.defaultMode,
+    projectPath,
+    tools: createToolContext(projectPath),
+    permissions: await loadPermissionState(projectPath),
+    language: config.language,
+    config,
+    backgroundTasks: [],
+    checkpoints: [],
+    evidence: [],
+    cache: createCacheState(projectPath, initialModel, [], config),
+    mcp: createMcpState(config),
+    index: createIndexState(config),
+    memory: await createMemoryState(config, projectPath),
+    keybindings: await loadProjectKeybindings(projectPath),
+    failureLearning: createFailureLearningState(projectPath, config),
+    skills: await createSkillState(config, projectPath),
+    workflows: createWorkflowState(config),
+    agentRegistry: await createAgentRegistryState(projectPath),
+    workflowRegistry: await createWorkflowRegistryState(projectPath),
+    hooks: await createHookState(config, projectPath),
+    plugins: await createPluginState(config, projectPath),
+    remote: createRemoteState(config),
+    agents: [],
+    agentCompletions: createAgentCompletionState(),
+    roleUsage: [],
+    routeDecisions: [],
+    roleHandoffs: [],
+    visionObservations: [],
+    imageResults: [],
+    interrupt: { type: "idle" },
+    recentlyMentionedFiles: [],
+    lastProviderFailure: void 0,
+    lastProviderFallbackAttempt: void 0,
+    providerBreaker: createProviderCircuitBreakerState(),
+    solutionCompleteness: createSolutionCompletenessStatus(),
+    backgroundAbortControllers: /* @__PURE__ */ new Map(),
+    discoveredDeferredToolNames: /* @__PURE__ */ new Set()
+  };
+  context.turnContinuity = createInitialContinuityState();
+  context.recentTaskKinds = [];
+  context.workflows.templates = mergeWorkflowTemplates(
+    context.workflows.templates,
+    context.agentRegistry.agents.map(registryAgentToWorkflowTemplate),
+    context.workflowRegistry.workflows.map(registryWorkflowToTemplate)
+  );
+  installProcessGuardExitHandlers();
+  const startup = await prepareTuiStartup(input, output, context);
+  await refreshIndexStatus(context);
+  await hydrateDurableJobBackgroundTasks(context);
+  await hydratePersistentAgents(context);
+  await cleanStaleToolLogs(context);
+  await cleanStaleDurableJobDirs(context);
+  context.store.prune(50).catch(() => {
+  });
+  context.failureLearning.records = await loadFailureRecords(context.failureLearning);
+  const gateway = createModelGateway(context.config);
+  context.modelGateway = gateway;
+  registerProviderHooks({
+    onRetry: (info) => {
+      if (info.requestContext === "agent") return;
+      context.requestActivityPhase = "provider_retrying";
+      context.requestActivityToolName = void 0;
+      context.retryInfo = {
+        attempt: info.attempt,
+        max: info.maxAttempts,
+        delaySec: Math.ceil(info.delayMs / 1e3)
+      };
+    }
+  });
+  context.pushNotification = (text, tone) => pushTransientNotification(context, text, tone);
+  const sigintHandler = () => {
+    requestTrackedProcessStop(false);
+    void handleInterruptCommand([], context, output).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      writeLine(output, `Interrupt failed: ${message}`);
+    });
+  };
+  process.once("SIGINT", sigintHandler);
+  try {
+    const useInkShell = await shouldEnterInkShell(input, output);
+    if (useInkShell) {
+      return await runInkShell(
+        input,
+        output,
+        errorOutput,
+        context,
+        gateway,
+        store,
+        startup,
+        sigintHandler
+      );
+    }
+    return await runPlainTui(input, output, context, gateway, store, startup, sigintHandler);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "TUI \u8FD0\u884C\u5931\u8D25\u3002";
+    writeLine(errorOutput, `\u9519\u8BEF\uFF1A${message}`);
+    return 1;
+  } finally {
+    process.removeListener("SIGINT", sigintHandler);
+  }
+}
+var MAX_TOOL_LOG_FILES = 200;
+async function cleanStaleToolLogs(context) {
+  const logsRoot = resolveStoragePaths(context.config, context.projectPath).logs;
+  const subdirs = ["tools", "verification"];
+  for (const sub of subdirs) {
+    const dir = resolve(logsRoot, sub);
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    const files = entries.filter((e) => e.isFile()).sort((a, b) => b.name.localeCompare(a.name));
+    if (files.length <= MAX_TOOL_LOG_FILES) continue;
+    for (const file of files.slice(MAX_TOOL_LOG_FILES)) {
+      try {
+        await rm(resolve(dir, file.name));
+      } catch {
+      }
+    }
+  }
+}
+async function cleanStaleDurableJobDirs(context) {
+  const root = getDurableJobsRoot(context);
+  let entries;
+  try {
+    entries = await readdir(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const statePath = join(root, entry.name, "state.json");
+    let state = null;
+    try {
+      state = JSON.parse(await readFile(statePath, "utf8"));
+    } catch {
+      continue;
+    }
+    if (state?.status) continue;
+  }
+}
+async function prepareTuiStartup(input, output, context) {
+  if (await shouldPromptForInitialLanguage(input, context)) {
+    await promptInitialLanguage(input, output, context);
+  }
+  if (shouldPromptForInitialWorkspaceTrust(input, context)) {
+    await promptInitialWorkspaceTrust(input, output, context);
+  }
+  const projectRouteProblem = await getStartupProjectRouteProblem(context);
+  const startup = {
+    setupNeeded: !projectRouteProblem && hasSelectedProviderConfigProblem(context),
+    providerEnvWarning: lastProviderEnvWarning?.reason,
+    projectRouteProblem
+  };
+  if (startup.setupNeeded && !shouldEnterProductShellCandidate(input, output)) {
+    startup.providerEnvPath = input.isTTY === true ? await providerEnvExists() ? getProviderEnvPath() : await ensureProviderEnvTemplate() : getProviderEnvPath();
+  }
+  return startup;
+}
+function writeLegacyStartup(output, context, startup) {
+  writeLine(output, t(context, "appTitle", { name: LINGHUN_NAME }));
+  writeWorkspaceTrustStartupNotice(output, context);
+  writeStatus(output, context);
+  writeLine(output, formatHomeScreen(context));
+  writeLine(output, `${t(context, "intro")}
+`);
+  if (!context.memory.projectRulesExists) {
+    writeLine(output, t(context, "projectRulesMissingHint"));
+  }
+  if (startup.providerEnvWarning) {
+    writeLine(output, formatProviderEnvWarning(startup.providerEnvWarning, context.language));
+  }
+  if (startup.projectRouteProblem) {
+    writeLine(output, formatProjectRouteProblem(startup.projectRouteProblem, context.language));
+  }
+  if (startup.setupNeeded) {
+    writeLine(
+      output,
+      formatUserScopedSetupNeeded(
+        startup.providerEnvPath ?? getProviderEnvPath(),
+        context.language
+      )
+    );
+  }
+}
+function pushTransientNotification(context, text, tone = "default") {
+  if (!context.notifications) context.notifications = [];
+  context.notifications.push({
+    key: `transient:${Date.now()}:${context.notifications.length}`,
+    text: truncateDisplay(text, 160),
+    priority: tone === "error" || tone === "warning" ? "immediate" : "medium",
+    timeoutMs: 5e3,
+    createdAt: Date.now(),
+    tone
+  });
+}
+async function runPlainTui(input, output, context, gateway, store, startup, sigintHandler) {
+  const { isNoColorTerminal } = await import("./shell/ink-renderer.js");
+  const isTty = input.isTTY === true;
+  const blocks = [];
+  context.pushTranscriptBlock = (block) => blocks.push(block);
+  if (!isTty) {
+    writeLegacyStartup(output, context, startup);
+  } else {
+    const view = createShellViewModel(context, {
+      width: readOutputColumns(output),
+      height: readOutputRows(output),
+      noColor: isNoColorTerminal(),
+      setupNeeded: startup.setupNeeded,
+      projectRouteProblem: startup.projectRouteProblem,
+      outputBlocks: blocks,
+      reasoningLevel: getSelectedModelRuntime(context).reasoningLevel,
+      reasoningSent: getSelectedModelRuntime(context).reasoningSent,
+      limitations: createShellLimitations({
+        language: context.language,
+        providerEnvWarning: startup.providerEnvWarning
+      })
+    });
+    writePlainShell(output, view);
+  }
+  for await (const line of readInputLines(input, output, {
+    prompt: isTty ? `${computeHomePromptPrefix(readOutputColumns(output))}> ` : t(context, "inputPrompt"),
+    onEsc: () => handleTuiKeypress("escape", context, output),
+    onEnter: () => handleTuiKeypress("return", context, output),
+    onShiftTab: () => handleTuiKeypress("shift-tab", context, output),
+    shouldMaskInput: () => context.pendingModelSetup?.step === "apiKey"
+  })) {
+    process.removeListener("SIGINT", sigintHandler);
+    process.once("SIGINT", sigintHandler);
+    const result = await processTuiLine(line, context, gateway, output, store);
+    if (result === "exit") return 0;
+    if (isTty) {
+      const runtime = getSelectedModelRuntime(context);
+      const refreshView = createShellViewModel(context, {
+        width: readOutputColumns(output),
+        height: readOutputRows(output),
+        noColor: isNoColorTerminal(),
+        setupNeeded: startup.setupNeeded,
+        projectRouteProblem: startup.projectRouteProblem,
+        activity: mapRequestActivityToView(context),
+        permission: mapPendingApprovalToPermission(context),
+        outputBlocks: blocks,
+        reasoningLevel: runtime.reasoningLevel,
+        reasoningSent: runtime.reasoningSent,
+        backgroundSummaries: formatShellBackgroundSummaries(context),
+        limitations: createShellLimitations({
+          language: context.language,
+          providerEnvWarning: startup.providerEnvWarning
+        })
+      });
+      writePlainShell(output, refreshView);
+    }
+  }
+  return 0;
+}
+function isSameTranscriptScrollState(previous, next) {
+  return previous?.scrollOffset === next?.scrollOffset && previous?.stickToBottom === next?.stickToBottom && previous?.hasOverflow === next?.hasOverflow && previous?.viewportHeight === next?.viewportHeight && previous?.contentHeight === next?.contentHeight && previous?.wheelStep === next?.wheelStep;
+}
+function isSameTranscriptViewportGeometry(previous, next) {
+  return previous?.x === next?.x && previous?.y === next?.y && previous?.width === next?.width && previous?.height === next?.height && previous?.contentHeight === next?.contentHeight && previous?.topOffset === next?.topOffset;
+}
+async function runInkShell(input, output, errorOutput, context, gateway, store, startup, sigintHandler) {
+  const { renderInkShell, isNoColorTerminal, shouldUseInkShell } = await import("./shell/ink-renderer.js");
+  if (!shouldUseInkShell(input, output)) {
+    return await runPlainTui(input, output, context, gateway, store, startup, sigintHandler);
+  }
+  context.isInkSession = true;
+  const blocks = [];
+  let shell;
+  let submittedPending = false;
+  let submittedPendingStartedAt;
+  let activityTicker;
+  let commandSequence = 0;
+  let resolveExit = () => void 0;
+  const exitPromise = new Promise((resolve2) => {
+    resolveExit = resolve2;
+  });
+  const shellOutput = new ShellBlockOutput(context, blocks, () => shell?.rerender());
+  context.compactOutputMemory = () => shellOutput.compactOutputMemory();
+  context.pushTranscriptBlock = (block) => blocks.push(block);
+  const controller = {
+    getViewModel: () => {
+      const runtime = getSelectedModelRuntime(context);
+      return createShellViewModel(context, {
+        width: readOutputColumns(output),
+        height: readOutputRows(output),
+        noColor: isNoColorTerminal(),
+        setupNeeded: startup.setupNeeded,
+        projectRouteProblem: startup.projectRouteProblem,
+        outputBlocks: blocks,
+        activity: mapRequestActivityToView(context),
+        permission: mapPendingApprovalToPermission(context),
+        submitted: submittedPending,
+        submittedStartedAt: submittedPendingStartedAt,
+        reasoningLevel: runtime.reasoningLevel,
+        reasoningSent: runtime.reasoningSent,
+        // D.13Q-UX Task Surface — controller 持有的 configPanelState 必须显式
+        // 喂给 view-model；旧实现遗漏这一行，导致 /config submit 后 ConfigPanel
+        // 永远不会出现在 ShellViewModel.configPanel 上。
+        configPanelState: context.configPanelState,
+        backgroundSummaries: formatShellBackgroundSummaries(context),
+        limitations: createShellLimitations({
+          language: context.language,
+          providerEnvWarning: startup.providerEnvWarning
+        })
+      });
+    },
+    onInput: async (event) => {
+      process.removeListener("SIGINT", sigintHandler);
+      process.once("SIGINT", sigintHandler);
+      if (event.type === "escape") {
+        submittedPending = false;
+        if (context.transcriptSelectionState) {
+          context.transcriptSelectionState = void 0;
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+          return;
+        }
+        if (context.ctrlOExpandState?.active) {
+          context.ctrlOExpandState = { active: false };
+          context.agentTreeState = void 0;
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+          return;
+        }
+        if (context.commandPanelState || context.helpPanelState || context.configPanelState || context.btwPanelState || context.sessionsPanelState || context.backgroundOverlayState?.open) {
+          if (context.btwPanelState?.phase === "loading" && context.activeBtwAbortController) {
+            context.activeBtwAbortController.abort();
+            context.activeBtwAbortController = void 0;
+          }
+          context.commandPanelState = void 0;
+          context.helpPanelState = void 0;
+          context.configPanelState = void 0;
+          context.btwPanelState = void 0;
+          context.sessionsPanelState = void 0;
+          context.backgroundOverlayState = void 0;
+          context.agentTreeState = void 0;
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+          return;
+        }
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "interrupt") {
+        submittedPending = false;
+        await handleInterruptCommand([], context, shellOutput);
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "cycle-permission-mode") {
+        const modes = ["default", "auto-review", "plan", "full-access"];
+        const idx = modes.indexOf(context.permissionMode);
+        const nextMode = modes[(idx + 1) % modes.length] ?? "default";
+        const previousMode = context.permissionMode;
+        context.permissionMode = nextMode;
+        context.planAccepted = false;
+        try {
+          const sessionId = await ensureSession(context);
+          await appendSystemEvent(
+            context,
+            sessionId,
+            `permission mode change: ${previousMode} -> ${nextMode}; reason ink shift-tab quiet cycle; boundary Start Gate and permission pipeline remain active`,
+            "info"
+          );
+        } catch (error) {
+          process.stderr.write(
+            `[linghun] permission_mode_system_event_failed reason=${formatError(error, context.language).replace(/\s+/g, " ")}
+`
+          );
+        }
+        const continued = await reevaluatePendingLocalApprovalAfterModeChange(
+          context,
+          gateway,
+          shellOutput
+        );
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        if (continued) {
+          writeStatus(shellOutput, context);
+        }
+        return;
+      }
+      if (event.type === "shift-enter") {
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "toggle-details") {
+        submittedPending = false;
+        if (toggleCurrentCommandPanelDetails(context)) {
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+          return;
+        }
+        const expandableBlock = findLatestCtrlOExpandableBlock(blocks);
+        if (expandableBlock) {
+          const isSameBlockExpanded = context.ctrlOExpandState?.active && (!context.ctrlOExpandState.blockId || context.ctrlOExpandState.blockId === expandableBlock.id);
+          context.ctrlOExpandState = isSameBlockExpanded ? { active: false } : { active: true, blockId: expandableBlock.id };
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+          return;
+        }
+        context.ctrlOExpandState = { active: false };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "command-panel-close") {
+        context.commandPanelState = void 0;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "command-panel-move") {
+        updateCommandPanelSelection(context, event.delta);
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "command-panel-toggle") {
+        toggleCommandPanelSelection(context);
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "command-panel-stop") {
+        await stopCommandPanelSelection(context, output);
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "background-overlay-open") {
+        context.backgroundOverlayState = {
+          open: true,
+          cursor: context.backgroundOverlayState?.cursor ?? 0
+        };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "background-overlay-close") {
+        context.backgroundOverlayState = void 0;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "background-overlay-move") {
+        updateBackgroundOverlayCursor(context, event.delta);
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "background-overlay-toggle") {
+        const selected = getBackgroundOverlaySelectedTask(context);
+        context.commandPanelState = selected ? {
+          title: "/background",
+          summary: [selected.userVisibleSummary],
+          detailsText: selected.nextAction ?? selected.userVisibleSummary
+        } : void 0;
+        context.backgroundOverlayState = void 0;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "background-overlay-stop") {
+        const selected = getBackgroundOverlaySelectedTask(context);
+        if (selected) {
+          context.commandPanelState = {
+            title: "/background",
+            sections: [
+              {
+                rows: [
+                  {
+                    text: selected.title,
+                    taskRef: {
+                      id: selected.id,
+                      kind: selected.kind === "agent" ? "agent" : selected.kind === "job" ? "job" : "background"
+                    },
+                    detailsText: selected.nextAction ?? selected.userVisibleSummary
+                  }
+                ]
+              }
+            ],
+            cursor: 0
+          };
+          await stopCommandPanelSelection(context, output);
+          context.commandPanelState = void 0;
+        }
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "agent-tree-move") {
+        const agents = context.agents ?? [];
+        const running = agents.filter((a) => a.status === "running");
+        const cursor = context.agentTreeState?.cursor ?? -1;
+        const next = cursor < 0 ? 0 : Math.max(0, Math.min(cursor + event.delta, running.length - 1));
+        context.agentTreeState = { cursor: next, expandedId: context.agentTreeState?.expandedId };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "agent-tree-enter") {
+        const agents = context.agents ?? [];
+        const running = agents.filter((a) => a.status === "running");
+        const cursor = context.agentTreeState?.cursor ?? -1;
+        if (cursor >= 0 && cursor < running.length) {
+          const agent = running[cursor];
+          const expandedId = context.agentTreeState?.expandedId === agent?.id ? void 0 : agent?.id;
+          context.agentTreeState = { cursor, expandedId };
+        }
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "agent-tree-close") {
+        const agents = context.agents ?? [];
+        const running = agents.filter((a) => a.status === "running");
+        const cursor = context.agentTreeState?.cursor ?? -1;
+        if (cursor >= 0 && cursor < running.length) {
+          const agent = running[cursor];
+          if (agent) {
+            agent.status = "cancelled";
+          }
+          context.agentTreeState = { cursor: -1 };
+        }
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "agent-tree-escape") {
+        context.agentTreeState = { cursor: -1 };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "copy-selection") {
+        const sel = context.transcriptSelectionState;
+        const text = sel?.selectedText ?? sel?.copiedText;
+        if (text) {
+          const copy = await writeTextToClipboard(text, { stdout: output });
+          if (!copy.ok && copy.error) {
+            pushTransientNotification(context, `Copy failed: ${copy.error}`, "warning");
+          } else if (copy.ok) {
+            const lineCount = Math.max(1, text.split("\n").length);
+            const message = context.language === "en-US" ? `Copied ${lineCount} line${lineCount === 1 ? "" : "s"}` : `\u5DF2\u590D\u5236 ${lineCount} \u884C`;
+            pushTransientNotification(context, message, "success");
+          }
+        }
+        shell?.rerender();
+        return;
+      }
+      if (event.type === "transcript-scroll") {
+        const previous = context.transcriptScrollState;
+        const next = "action" in event ? reduceTranscriptScroll(context.transcriptScrollState, {
+          type: "scroll",
+          action: event.action
+        }) : reduceTranscriptScroll(context.transcriptScrollState, {
+          type: "scroll",
+          delta: event.delta
+        });
+        context.transcriptScrollState = next;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "transcript-scroll-measure") {
+        const previous = context.transcriptScrollState;
+        const next = reduceTranscriptScroll(context.transcriptScrollState, {
+          type: "measure",
+          viewportHeight: event.viewportHeight,
+          contentHeight: event.contentHeight
+        });
+        if (!isSameTranscriptScrollState(previous, next)) {
+          context.transcriptScrollState = next;
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+        }
+        return;
+      }
+      if (event.type === "transcript-block-measure") {
+        context.transcriptBlockHeightCache ??= {};
+        const existing = context.transcriptBlockHeightCache[event.id];
+        const next = {
+          height: event.height,
+          width: event.width,
+          textHash: existing?.textHash ?? "measured"
+        };
+        if (!existing || existing.height !== next.height || existing.width !== next.width || existing.textHash !== next.textHash) {
+          context.transcriptBlockHeightCache[event.id] = next;
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+        }
+        return;
+      }
+      if (event.type === "transcript-viewport-geometry") {
+        if (!isSameTranscriptViewportGeometry(context.transcriptViewportGeometry, event.geometry)) {
+          context.transcriptViewportGeometry = event.geometry;
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+        }
+        return;
+      }
+      if (event.type === "transcript-mouse") {
+        if (isSelectionStale(context.transcriptSelectionState, Date.now())) {
+          context.transcriptSelectionState = void 0;
+        }
+        const currentView = controller.getViewModel();
+        const rows = buildTranscriptScreenBuffer(
+          currentView.blocks,
+          Math.max(8, currentView.width - 4)
+        ).rows;
+        const result2 = reduceTranscriptSelection({
+          state: context.transcriptSelectionState,
+          event: event.event,
+          rows,
+          geometry: context.transcriptViewportGeometry,
+          scroll: context.transcriptScrollState,
+          copyOnSelect: false
+        });
+        if (!result2.consumed) return;
+        context.transcriptSelectionState = result2.state;
+        if (result2.scrollDelta) {
+          context.transcriptScrollState = reduceTranscriptScroll(context.transcriptScrollState, {
+            type: "scroll",
+            delta: result2.scrollDelta
+          });
+        }
+        if (result2.copyText) {
+          const copy = await writeTextToClipboard(result2.copyText, {
+            stdout: output
+          });
+          if (!copy.ok && copy.error) {
+            pushTransientNotification(context, `Copy failed: ${copy.error}`, "warning");
+          } else if (copy.ok) {
+            const lineCount = Math.max(1, result2.copyText.split("\n").length);
+            const message = context.language === "en-US" ? `Copied ${lineCount} line${lineCount === 1 ? "" : "s"}` : `\u5DF2\u590D\u5236 ${lineCount} \u884C`;
+            pushTransientNotification(context, message, "success");
+          }
+        }
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "transcript-scroll-end") {
+        context.transcriptScrollState = reduceTranscriptScroll(context.transcriptScrollState, {
+          type: "end"
+        });
+        context.unseenMessageCount = 0;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "transcript-scroll-top") {
+        context.transcriptScrollState = reduceTranscriptScroll(context.transcriptScrollState, {
+          type: "top"
+        });
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "submit" && event.text.trim() === "/config") {
+        const trimmed = event.text;
+        blocks.push(createCommandBlock(commandSequence++, trimmed));
+        context.configPanelState = { phase: "panel_list", cursor: 0, scrollOffset: 0 };
+        submittedPending = false;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "submit") {
+        const trimmed = event.text.trim();
+        if (trimmed === "/help" || trimmed === "/help advanced" || trimmed === "/help details") {
+          const group = trimmed === "/help advanced" ? "advanced" : trimmed === "/help details" ? "details" : "core";
+          blocks.push(createCommandBlock(commandSequence++, trimmed));
+          context.helpPanelState = { group, cursor: 0, scrollOffset: 0 };
+          submittedPending = false;
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+          return;
+        }
+      }
+      if (event.type === "help-open") {
+        context.helpPanelState = { group: event.group ?? "core", cursor: 0, scrollOffset: 0 };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "help-close") {
+        context.helpPanelState = void 0;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "help-move") {
+        if (!context.helpPanelState) return;
+        const { buildHelpPanelData: build } = await import("./shell/models/help-panel.js");
+        const entries = build(context.helpPanelState.group, 0, 0, context.language).entries;
+        const total = entries.length;
+        if (total === 0) return;
+        const MAX_VISIBLE = 10;
+        const nextCursor = (context.helpPanelState.cursor + event.delta + total) % total;
+        const oldOffset = context.helpPanelState.scrollOffset ?? 0;
+        let nextOffset = oldOffset;
+        if (nextCursor < oldOffset) nextOffset = nextCursor;
+        else if (nextCursor >= oldOffset + MAX_VISIBLE) nextOffset = nextCursor - MAX_VISIBLE + 1;
+        context.helpPanelState = {
+          ...context.helpPanelState,
+          cursor: nextCursor,
+          scrollOffset: nextOffset
+        };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "help-switch-group") {
+        if (!context.helpPanelState) return;
+        const groups = ["core", "advanced", "details"];
+        const idx = groups.indexOf(context.helpPanelState.group);
+        const next = groups[(idx + event.delta + groups.length) % groups.length] ?? "core";
+        context.helpPanelState = { group: next, cursor: 0, scrollOffset: 0 };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "help-enter") {
+        if (!context.helpPanelState) return;
+        const { buildHelpPanelData: build } = await import("./shell/models/help-panel.js");
+        const entries = build(context.helpPanelState.group, 0, 0, context.language).entries;
+        const target = entries[context.helpPanelState.cursor];
+        if (!target) return;
+        context.helpPanelState = void 0;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        blocks.push(createCommandBlock(commandSequence++, target.slash));
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        await processTuiLine(target.slash, context, gateway, shellOutput, store);
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "help-select") {
+        if (!context.helpPanelState) return;
+        const { buildHelpPanelData: build } = await import("./shell/models/help-panel.js");
+        const entries = build(context.helpPanelState.group, 0, 0, context.language).entries;
+        const target = entries[event.index];
+        if (!target) return;
+        context.helpPanelState = void 0;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        blocks.push(createCommandBlock(commandSequence++, target.slash));
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        await processTuiLine(target.slash, context, gateway, shellOutput, store);
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "btw-close") {
+        if (context.btwPanelState?.phase === "loading" && context.activeBtwAbortController) {
+          context.activeBtwAbortController.abort();
+          context.activeBtwAbortController = void 0;
+        }
+        context.btwPanelState = void 0;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "btw-open") {
+        context.btwPanelState = { question: event.question, phase: "loading" };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "sessions-close") {
+        context.sessionsPanelState = void 0;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "sessions-open") {
+        blocks.push(createCommandBlock(commandSequence++, "/sessions"));
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        await processTuiLine("/sessions", context, gateway, shellOutput, store);
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "sessions-move") {
+        if (!context.sessionsPanelState) return;
+        const total = context.sessionsPanelState.entries.length;
+        if (total === 0) return;
+        const next = (context.sessionsPanelState.cursor + event.delta + total) % total;
+        context.sessionsPanelState = { ...context.sessionsPanelState, cursor: next };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "sessions-resume") {
+        if (!context.sessionsPanelState) return;
+        const target = context.sessionsPanelState.entries[context.sessionsPanelState.cursor];
+        if (!target) return;
+        if (target.isCurrent) {
+          const tip = context.language === "en-US" ? "Already on this session; nothing to resume." : "\u5DF2\u5728\u5F53\u524D\u4F1A\u8BDD\uFF0C\u65E0\u9700\u6062\u590D\u3002";
+          if (!context.notifications) context.notifications = [];
+          context.notifications.push({
+            key: "sessions:resume-current",
+            text: tip,
+            priority: "medium",
+            timeoutMs: 4e3,
+            createdAt: Date.now(),
+            tone: "warning"
+          });
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+          return;
+        }
+        context.sessionsPanelState = void 0;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        const cmd = `/resume ${target.id}`;
+        blocks.push(createCommandBlock(commandSequence++, cmd));
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        await processTuiLine(cmd, context, gateway, shellOutput, store);
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "sessions-search") {
+        if (!context.sessionsPanelState) return;
+        context.sessionsPanelState = {
+          ...context.sessionsPanelState,
+          mode: "search",
+          searchQuery: ""
+        };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "sessions-search-input") {
+        if (!context.sessionsPanelState || context.sessionsPanelState.mode !== "search") return;
+        context.sessionsPanelState = {
+          ...context.sessionsPanelState,
+          searchQuery: (context.sessionsPanelState.searchQuery ?? "") + event.input
+        };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "sessions-search-delete") {
+        if (!context.sessionsPanelState || context.sessionsPanelState.mode !== "search") return;
+        const q = context.sessionsPanelState.searchQuery ?? "";
+        context.sessionsPanelState = {
+          ...context.sessionsPanelState,
+          searchQuery: q.slice(0, -1)
+        };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "sessions-search-close") {
+        if (!context.sessionsPanelState) return;
+        context.sessionsPanelState = {
+          ...context.sessionsPanelState,
+          mode: void 0,
+          searchQuery: void 0
+        };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "sessions-preview") {
+        if (!context.sessionsPanelState) return;
+        const target = context.sessionsPanelState.entries[context.sessionsPanelState.cursor];
+        if (!target || target.isCurrent) return;
+        context.sessionsPanelState = {
+          ...context.sessionsPanelState,
+          mode: "preview",
+          previewEntryId: target.id
+        };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "sessions-preview-close") {
+        if (!context.sessionsPanelState) return;
+        context.sessionsPanelState = {
+          ...context.sessionsPanelState,
+          mode: void 0,
+          previewEntryId: void 0
+        };
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "config-move") {
+        if (!context.configPanelState) return;
+        const MAX_VISIBLE = 10;
+        if (context.configPanelState.phase === "panel_detail") {
+          const actions = buildConfigPanelActions(
+            context.configPanelState.panelId,
+            context.language
+          );
+          const nextActionCursor = Math.max(
+            0,
+            Math.min(actions.length - 1, context.configPanelState.actionCursor + event.delta)
+          );
+          const oldOffset = context.configPanelState.scrollOffset ?? 0;
+          let nextOffset = oldOffset;
+          if (nextActionCursor < oldOffset) nextOffset = nextActionCursor;
+          else if (nextActionCursor >= oldOffset + MAX_VISIBLE)
+            nextOffset = nextActionCursor - MAX_VISIBLE + 1;
+          context.configPanelState = {
+            ...context.configPanelState,
+            actionCursor: nextActionCursor,
+            scrollOffset: nextOffset
+          };
+        } else {
+          const current = context.configPanelState.cursor;
+          const nextCursor = Math.max(0, Math.min(13, current + event.delta));
+          const oldOffset = context.configPanelState.scrollOffset ?? 0;
+          let nextOffset = oldOffset;
+          if (nextCursor < oldOffset) nextOffset = nextCursor;
+          else if (nextCursor >= oldOffset + MAX_VISIBLE) nextOffset = nextCursor - MAX_VISIBLE + 1;
+          context.configPanelState = {
+            phase: "panel_list",
+            cursor: nextCursor,
+            scrollOffset: nextOffset
+          };
+        }
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "config-submit") {
+        context.configPanelState = void 0;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        let command = event.command;
+        if (command === "lang-zh" || command === "lang-en") {
+          const targetLang = command === "lang-zh" ? "zh-CN" : "en-US";
+          context.language = targetLang;
+          command = `/language ${targetLang}`;
+        } else if (command === "/language") {
+          command = context.language === "zh-CN" ? "/language en-US" : "/language zh-CN";
+        }
+        blocks.push(createCommandBlock(commandSequence++, command));
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        await processTuiLine(command, context, gateway, shellOutput, store);
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "config-enter") {
+        if (!context.configPanelState || context.configPanelState.phase !== "panel_list") return;
+        const CONFIG_PANEL_IDS = [
+          "model",
+          "language",
+          "permissions",
+          "memory",
+          "index",
+          "mcp",
+          "cache",
+          "background",
+          "status",
+          "shortcuts",
+          "context",
+          "compact",
+          "verification",
+          "doctor"
+        ];
+        const panelId = CONFIG_PANEL_IDS[context.configPanelState.cursor];
+        if (panelId && buildConfigPanelActions(panelId, context.language).length > 0) {
+          context.configPanelState = {
+            phase: "panel_detail",
+            panelId,
+            actionCursor: 0,
+            scrollOffset: 0
+          };
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+        }
+        return;
+      }
+      if (event.type === "config-back") {
+        if (!context.configPanelState) return;
+        if (context.configPanelState.phase === "panel_detail") {
+          context.configPanelState = { phase: "panel_list", cursor: 0, scrollOffset: 0 };
+        } else {
+          context.configPanelState = void 0;
+        }
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "permission-action") {
+        const approval = context.pendingLocalApproval;
+        if (!approval) return;
+        switch (event.actionId) {
+          case "details":
+            writeLine(shellOutput, formatPendingApprovalDetails(approval, context));
+            shell?.rerender();
+            await shell?.waitUntilRenderFlush();
+            return;
+          case "cancel": {
+            context.pendingLocalApproval = void 0;
+            await executePermissionDeny(approval, context, gateway, shellOutput, true);
+            shell?.rerender();
+            await shell?.waitUntilRenderFlush();
+            return;
+          }
+          case "deny":
+          case "no": {
+            context.pendingLocalApproval = void 0;
+            await executePermissionDeny(approval, context, gateway, shellOutput, false);
+            shell?.rerender();
+            await shell?.waitUntilRenderFlush();
+            return;
+          }
+          case "allow_once":
+          case "yes": {
+            context.pendingLocalApproval = void 0;
+            await executePermissionApprove(approval, context, gateway, shellOutput);
+            shell?.rerender();
+            await shell?.waitUntilRenderFlush();
+            return;
+          }
+          case "allow_always_tool": {
+            if (approval.kind !== "model_tool_use") {
+              writeLine(
+                shellOutput,
+                context.language === "en-US" ? "Project-level allow is not available for this action yet. Choose allow once, deny, or details." : "\u6B64\u52A8\u4F5C\u6682\u4E0D\u652F\u6301\u9879\u76EE\u7EA7\u540C\u7C7B\u5141\u8BB8\u3002\u8BF7\u9009\u62E9\u672C\u6B21\u5141\u8BB8\u3001\u62D2\u7EDD\u6216\u67E5\u770B\u8BE6\u60C5\u3002"
+              );
+              shell?.rerender();
+              await shell?.waitUntilRenderFlush();
+              return;
+            }
+            const tool = approval.toolName;
+            const risk = tool === "Bash" ? "high" : "medium";
+            const result2 = await addAllowRule(context, tool, risk);
+            const isEn = context.language === "en-US";
+            if (result2.kind === "added" || result2.kind === "duplicate") {
+              if (!context.notifications) context.notifications = [];
+              context.notifications.push({
+                key: `permission:remembered:${tool}:${Date.now()}`,
+                text: isEn ? `Remembered: future ${tool} actions like this will be allowed.` : `\u5DF2\u8BB0\u4F4F\uFF1A\u4EE5\u540E\u8FD9\u7C7B ${tool} \u64CD\u4F5C\u5C06\u81EA\u52A8\u5141\u8BB8\u3002`,
+                priority: "medium",
+                timeoutMs: 4e3,
+                createdAt: Date.now(),
+                tone: "success"
+              });
+            }
+            if (result2.kind === "save_failed") {
+              writeLine(
+                shellOutput,
+                isEn ? `Could not save the permission rule: ${result2.error.message}` : `\u4FDD\u5B58\u6743\u9650\u89C4\u5219\u5931\u8D25\uFF1A${result2.error.message}`
+              );
+              writeLine(
+                shellOutput,
+                isEn ? "Permission rule was not persisted; pending approval kept." : "\u6743\u9650\u89C4\u5219\u672A\u4FDD\u5B58\uFF1B\u5F53\u524D pending \u4ECD\u4FDD\u7559\uFF0C\u53EF\u91CD\u8BD5\u6216\u9009\u62E9\u5176\u5B83\u52A8\u4F5C\u3002"
+              );
+              shell?.rerender();
+              await shell?.waitUntilRenderFlush();
+              return;
+            }
+            if (result2.kind === "invalid") {
+              writeLine(shellOutput, isEn ? `Unknown tool: ${tool}` : `\u672A\u77E5\u5DE5\u5177\uFF1A${tool}`);
+              shell?.rerender();
+              await shell?.waitUntilRenderFlush();
+              return;
+            }
+            context.pendingLocalApproval = void 0;
+            await executePermissionApprove(approval, context, gateway, shellOutput);
+            shell?.rerender();
+            await shell?.waitUntilRenderFlush();
+            return;
+          }
+        }
+        return;
+      }
+      if (event.type === "task-suggestion-move") {
+        const total = controller.getViewModel().taskSuggestions?.length ?? 0;
+        if (total <= 0) {
+          context.taskSuggestionCursor = 0;
+          return;
+        }
+        const current = context.taskSuggestionCursor ?? 0;
+        context.taskSuggestionCursor = (current + event.delta + total) % total;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type === "task-suggestion-action") {
+        const view = controller.getViewModel();
+        const suggestion = view.taskSuggestions?.find((item) => item.id === event.suggestionId);
+        if (!suggestion) return;
+        if (!context.handledTaskSuggestionIds) context.handledTaskSuggestionIds = /* @__PURE__ */ new Set();
+        context.handledTaskSuggestionIds.add(suggestion.id);
+        context.taskSuggestionCursor = 0;
+        if (suggestion.action.kind === "slash") {
+          context.commandPanelState = void 0;
+          blocks.push(createCommandBlock(commandSequence++, suggestion.action.command));
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+          await processTuiLine(suggestion.action.command, context, gateway, shellOutput, store);
+          shell?.rerender();
+          await shell?.waitUntilRenderFlush();
+          return;
+        }
+        if (suggestion.action.kind === "inline") {
+          await controller.onInput({
+            type: "permission-action",
+            actionId: suggestion.action.id
+          });
+          return;
+        }
+        return;
+      }
+      if (event.type === "empty-submit") {
+        submittedPending = false;
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      if (event.type !== "submit") {
+        submittedPending = false;
+        const sessionId = context.sessionId ?? await ensureSession(context);
+        await appendSystemEvent(
+          context,
+          sessionId,
+          `ink shell ignored unrecognized input event: ${event.type ?? "unknown"}`,
+          "warning"
+        );
+        shell?.rerender();
+        await shell?.waitUntilRenderFlush();
+        return;
+      }
+      submittedPending = true;
+      submittedPendingStartedAt = Date.now();
+      if (event.text.trim().length > 0) {
+        dismissCurrentFailureSuggestion(context, blocks);
+      }
+      if (event.type === "submit" && !event.text.startsWith("/")) {
+        context.commandPanelState = void 0;
+        context.helpPanelState = void 0;
+        context.configPanelState = void 0;
+        context.btwPanelState = void 0;
+        context.sessionsPanelState = void 0;
+      }
+      if (event.type === "submit" && event.text.startsWith("/")) {
+        blocks.push(createCommandBlock(commandSequence++, event.text));
+      } else if (event.type === "submit" && event.text.length > 0) {
+        const isModelSetup = Boolean(context.pendingModelSetup);
+        const isPendingConfirm = hasPendingEnterConfirmation(context);
+        if (!isModelSetup && !isPendingConfirm) {
+          blocks.push(createUserTextBlock(commandSequence++, event.text, Date.now()));
+        }
+      }
+      shell?.rerender();
+      await shell?.waitUntilRenderFlush();
+      let result;
+      try {
+        result = await processTuiLine(
+          event.type === "submit" ? event.text : "",
+          context,
+          gateway,
+          shellOutput,
+          store
+        );
+      } finally {
+        submittedPending = false;
+        submittedPendingStartedAt = void 0;
+        shell?.rerender();
+      }
+      if (result === "exit") {
+        shell?.unmount();
+        resolveExit(0);
+        return;
+      }
+      await shell?.waitUntilRenderFlush();
+      runMemoryEviction(context, blocks);
+    }
+  };
+  try {
+    shell = renderInkShell(controller, {
+      stdin: input,
+      stdout: output,
+      stderr: errorOutput
+    });
+    activityTicker = setInterval(() => {
+      cleanupCompletedBackgroundTasks(context);
+      const hasAgents = (context.agents ?? []).length > 0;
+      const hasWorkflows = (context.workflows?.activeRuns ?? []).length > 0 || Boolean(context.workflows?.activeRun);
+      const hasBgTasks = (context.backgroundTasks ?? []).length > 0;
+      if (!submittedPending && !context.requestActivityPhase && !context.activeAbortController && !hasAgents && !hasWorkflows && !hasBgTasks) {
+        return;
+      }
+      shell?.rerender();
+    }, 1e3);
+    context.shellRerender = () => shell?.rerender();
+  } catch (error) {
+    blocks.push(
+      createOutputBlock(
+        context.language === "en-US" ? `Ink shell failed to start; falling back to plain TUI. ${error instanceof Error ? error.message : String(error)}` : `Ink shell \u542F\u52A8\u5931\u8D25\uFF0C\u5DF2\u964D\u7EA7\u5230 plain TUI\u3002${error instanceof Error ? error.message : String(error)}`,
+        context.language,
+        "ink-fallback"
+      )
+    );
+    writePlainShell(output, controller.getViewModel());
+    if (activityTicker) clearInterval(activityTicker);
+    return await runPlainTui(input, output, context, gateway, store, startup, sigintHandler);
+  }
+  try {
+    return await exitPromise;
+  } finally {
+    if (activityTicker) clearInterval(activityTicker);
+  }
+}
+function dismissCurrentFailureSuggestion(context, blocks) {
+  const latestFailure = [...blocks].reverse().find((block) => block.status === "fail" || block.status === "blocked");
+  if (!latestFailure) return;
+  if (!context.handledTaskSuggestionIds) context.handledTaskSuggestionIds = /* @__PURE__ */ new Set();
+  context.handledTaskSuggestionIds.add(`tool_error:details:${latestFailure.id}`);
+}
+async function processTuiLine(line, context, gateway, output, store) {
+  const text = line.trim();
+  if (!text) {
+    if (context.pendingModelSetup) {
+      await handleModelSetupInput("", context, output);
+      return "continue";
+    }
+    if (hasPendingEnterConfirmation(context)) {
+      await confirmPendingInteraction(context, output);
+      return "continue";
+    }
+    if (shouldOfferUserScopedModelSetup(context)) {
+      await startModelSetup(context, output);
+    }
+    return "continue";
+  }
+  const commandResult = await handleSlashCommand(text, context, output);
+  if (commandResult === "exit") {
+    if (context.sessionId && !context.sessionEnded) {
+      await store.appendEvent(context.sessionId, createSessionEndEvent(context.sessionId));
+      context.sessionEnded = true;
+    }
+    writeLine(output, t(context, "exit"));
+    return "exit";
+  }
+  if (commandResult === "message") {
+    const promptCommand = context.pendingPromptCommand;
+    context.pendingPromptCommand = void 0;
+    const messageText = promptCommand?.prompt ?? text;
+    context.commandPanelState = void 0;
+    context.helpPanelState = void 0;
+    context.configPanelState = void 0;
+    context.btwPanelState = void 0;
+    context.sessionsPanelState = void 0;
+    const naturalResult = promptCommand ? "message" : await handleNaturalInput(text, context, gateway, output);
+    if (naturalResult === "message") {
+      await sendMessage(messageText, context, gateway, output);
+    }
+  }
+  return "continue";
+}
+async function shouldEnterInkShell(input, output) {
+  if (!shouldEnterProductShellCandidate(input, output)) return false;
+  const { shouldUseInkShell } = await import("./shell/ink-renderer.js");
+  return shouldUseInkShell(input, output);
+}
+async function handleSlashCommand(text, context, output) {
+  if (context.pendingModelSetup) {
+    await handleModelSetupInput(text, context, output);
+    return "handled";
+  }
+  if (!text.startsWith("/")) {
+    return "message";
+  }
+  if (context.pendingNaturalCommand?.exactCommand === text.trim()) {
+    context.pendingNaturalCommand = void 0;
+  }
+  const [command, ...rest] = text.split(/\s+/);
+  if (command === "/" || command === "/?") {
+    writeLine(output, formatSlashDiscovery(context.language));
+    return "handled";
+  }
+  const workspaceGuard = getWorkspaceTrustCommandGuard(command, rest, context);
+  if (workspaceGuard) {
+    writeLine(output, workspaceGuard);
+    writeStatus(output, context);
+    return "handled";
+  }
+  if (findPromptCommand(command)) {
+    const promptText = buildPromptCommandUserText(command, rest, context.language);
+    if (promptText) {
+      context.pendingPromptCommand = { command, prompt: promptText };
+      return "message";
+    }
+  }
+  if (command === "/help") {
+    const variantArg = (rest[0] ?? "").toLowerCase();
+    const variant = variantArg === "all" ? "all" : variantArg === "advanced" ? "advanced" : variantArg === "details" ? "details" : "short";
+    writeLine(output, formatCatalogHelp(context.language, context.permissionMode, false, variant));
+    return "handled";
+  }
+  if (command === "/features") {
+    writeLine(output, formatFeaturePolicy(context));
+    return "handled";
+  }
+  if (command === "/capabilities") {
+    await handleCapabilitiesCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/apps") {
+    await handleAppsCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/model") {
+    await handleModelCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/language") {
+    await handleLanguageCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/mode") {
+    await handleModeCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/plan") {
+    await handlePlanCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/permissions") {
+    await handlePermissionsCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/background") {
+    await hydrateWorkflowRuns(context);
+    await handleBackgroundCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/job") {
+    await handleJobCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/batch") {
+    await handleBatchCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/remote") {
+    await handleRemoteCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/details") {
+    await handleDetailsCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/agents") {
+    await handleAgentsCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/fork") {
+    await handleForkCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/rewind") {
+    await handleRewindCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/btw") {
+    await handleBtwCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/interrupt") {
+    await handleInterruptCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/claim-check") {
+    await handleClaimCheckCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/verify") {
+    await handleVerifyCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/review") {
+    await handleReviewCommand(context, output);
+    return "handled";
+  }
+  if (command === "/vision") {
+    await handleVisionCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/image") {
+    await handleImageCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/cache-log") {
+    await handleCacheLogCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/cache") {
+    await handleCacheCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/compact" || command === "/context") {
+    await handleCompactCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/break-cache") {
+    await handleBreakCacheCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/mcp") {
+    await handleMcpCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/index") {
+    if ((rest[0] ?? "") === "repair") {
+      await runIndexSafetyRepair(context, output);
+      return "handled";
+    }
+    if ((rest[0] ?? "") === "refresh") {
+      await requestIndexRefreshApproval(rest, context, output);
+      return "handled";
+    }
+    if ((rest[0] ?? "") === "init" && (rest[1] ?? "") === "fast") {
+      await requestIndexInitFastApproval(rest, context, output);
+      return "handled";
+    }
+    await handleIndexCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/resume") {
+    await handleResumeCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/branch") {
+    await handleBranchCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/git") {
+    await handleGitCommand(rest, context, output, gitSlashDeps);
+    return "handled";
+  }
+  if (command === "/worktree") {
+    await handleWorktreeCommand(rest, context, output, gitSlashDeps);
+    return "handled";
+  }
+  if (command === "/checkpoint") {
+    await handleCheckpointCommand(rest, context, output, gitSlashDeps);
+    return "handled";
+  }
+  if (command === "/memory") {
+    await handleMemoryCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/failures") {
+    await handleFailuresCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/skills") {
+    await handleSkillsCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/workflows") {
+    await handleWorkflowsCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/plugins") {
+    await handlePluginsCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/doctor") {
+    await handleDoctorCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/problems") {
+    refreshBackgroundLifecycle(context);
+    writeLine(output, formatTerminalProblemsPanel(createTerminalReadinessView(context)));
+    return "handled";
+  }
+  if (command === "/usage") {
+    writeLine(output, formatUsage(context));
+    return "handled";
+  }
+  if (command === "/stats") {
+    writeLine(output, formatStats(rest, context));
+    return "handled";
+  }
+  if (command === "/status") {
+    refreshBackgroundLifecycle(context);
+    if (context.isInkSession) {
+      showCommandPanel(context, output, buildStatusPanel(context));
+    } else {
+      writeStatus(output, context);
+      writeLine(output, formatTerminalReadinessStatus(createTerminalReadinessView(context)));
+    }
+    return "handled";
+  }
+  if (command === "/tab") {
+    await cycleMode(context, output);
+    return "handled";
+  }
+  if (command === "/esc") {
+    await cancelPendingInteraction(context, output, "Esc");
+    return "handled";
+  }
+  if (command === "/enter") {
+    await confirmPendingInteraction(context, output);
+    return "handled";
+  }
+  if (command === "/trust") {
+    await handleTrustCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/autopilot") {
+    await handleAutopilotCommand(rest, context, output);
+    return "handled";
+  }
+  if (command === "/brief") {
+    context.briefMode = !context.briefMode;
+    const msg = context.briefMode ? messages[context.language].r7BriefEnabled : messages[context.language].r7BriefDisabled;
+    writeLine(output, msg);
+    return "handled";
+  }
+  if (command === "/sessions") {
+    if (rest[0] === "resume") {
+      const sessionId = rest[1];
+      if (!sessionId) {
+        writeLine(output, "\u7528\u6CD5\uFF1A/sessions resume <id>");
+        return "handled";
+      }
+      await resumeSessionWithHandoff(sessionId, context, output, "sessions resume");
+      return "handled";
+    }
+    const sessions = await context.store.list();
+    if (context.isInkSession) {
+      const { buildSessionPanelEntries } = await import("./shell/models/session-panel.js");
+      const entries = buildSessionPanelEntries(
+        sessions.map((s) => ({
+          id: s.id,
+          updatedAt: s.updatedAt,
+          summary: s.summary ?? void 0,
+          messageCount: typeof s.messageCount === "number" ? s.messageCount : 0
+        })),
+        context.sessionId
+      );
+      context.sessionsPanelState = { cursor: 0, entries };
+      return "handled";
+    }
+    if (sessions.length === 0) {
+      writeLine(output, t(context, "noSessions"));
+      return "handled";
+    }
+    const recentSessions = sessions.slice(0, 5);
+    const summaryLines = [
+      t(context, "sessionHeader"),
+      ...recentSessions.map((s) => {
+        const marker = s.id === context.sessionId ? "*" : " ";
+        return `${marker} ${s.id}  ${s.updatedAt}  ${s.summary ?? t(context, "noSummary")}`;
+      })
+    ];
+    if (sessions.length > 5) {
+      summaryLines.push(`... \u53E6\u6709 ${sessions.length - 5} \u4E2A session\uFF08\u5B8C\u6574\u5217\u8868\u89C1 details\uFF09`);
+    }
+    const detailsText = [
+      t(context, "sessionHeader"),
+      ...sessions.map((s) => {
+        const marker = s.id === context.sessionId ? "*" : " ";
+        return `${marker} ${s.id}  ${s.updatedAt}  ${s.summary ?? t(context, "noSummary")}`;
+      })
+    ].join("\n");
+    showCommandPanel(context, output, {
+      title: "/sessions",
+      tone: "neutral",
+      summary: summaryLines,
+      actions: ["/sessions resume <id>"],
+      detailsText
+    });
+    return "handled";
+  }
+  const toolName = slashCommandToTool(command);
+  if (toolName) {
+    await handleToolCommand(toolName, rest, context, output);
+    return "handled";
+  }
+  if (command === "/config") {
+    writeLine(output, formatConfigOverview(context));
+    return "handled";
+  }
+  if (command === "/exit") {
+    return "exit";
+  }
+  const prefixCandidates = getSlashPrefixCandidates(command);
+  if (prefixCandidates.length > 0) {
+    writeLine(output, formatSlashDiscovery(context.language, command));
+    return "handled";
+  }
+  writeLine(output, formatUnknownSlashCommand(command, context.language));
+  return "handled";
+}
+configureSlashCommandRuntime({ handleSlashCommand });
+export {
+  DEFAULT_THRESHOLDS as ARCHITECTURE_BOUNDARY_THRESHOLDS,
+  BACKGROUND_KIND_CAPS,
+  BACKGROUND_RUNNING_GLOBAL_CAP,
+  CODEBASE_MEMORY_COMMAND,
+  CODEBASE_MEMORY_ENV,
+  DEFAULT_LIGHT_HINT_COOLDOWN_MS,
+  LINGHUN_BASH_MAX_OUTPUT_DEFAULT,
+  LINGHUN_BASH_MAX_OUTPUT_UPPER_LIMIT,
+  LINGHUN_BYTES_PER_TOKEN,
+  LINGHUN_DEFAULT_TOOL_RESULT_CHARS,
+  LINGHUN_MAX_AGENTIC_TURNS,
+  LINGHUN_MAX_AGENT_CHILD_TOOL_ROUNDS,
+  LINGHUN_MAX_AGENT_CHILD_TURNS,
+  LINGHUN_MAX_EVIDENCE_TOOL_ROUNDS,
+  LINGHUN_MAX_RAW_TOOL_PROTOCOL_TEXT_RETRIES,
+  LINGHUN_MAX_TODO_ONLY_CONSECUTIVE_ROUNDS,
+  LINGHUN_MAX_TOOL_RESULTS_PER_MESSAGE_CHARS,
+  LINGHUN_MAX_TOOL_RESULT_BYTES,
+  LINGHUN_MAX_TOOL_RESULT_TOKENS,
+  LINGHUN_TASK_MAX_OUTPUT_DEFAULT,
+  LINGHUN_TASK_MAX_OUTPUT_UPPER_LIMIT,
+  MAX_BACKGROUND_TASKS,
+  MAX_CACHE_HISTORY_SIZE,
+  MAX_CHECKPOINTS,
+  MAX_CONTEXT_MESSAGES,
+  MAX_EVIDENCE_RECORDS,
+  MAX_LIGHT_HINTS_PER_TURN,
+  MAX_MODEL_TOTAL_TOOL_ROUNDS,
+  MAX_RAW_TOOL_PROTOCOL_TEXT_RETRIES,
+  MAX_TODO_ONLY_CONSECUTIVE_ROUNDS,
+  MEMORY_PROMPT_ITEM_WIDTH,
+  MEMORY_PROMPT_TOP_K,
+  MEMORY_PROMPT_TOTAL_WIDTH,
+  MIN_CACHE_HISTORY_SIZE,
+  PROJECT_RULES_STATUS_WIDTH,
+  REQUEST_SLOW_HINT_MS,
+  USER_VISIBLE_DISPATCH_SLASH_COMMANDS,
+  VERIFICATION_COMMAND_TIMEOUT_MS,
+  WORKFLOW_ARCHITECTURE_REVIEW_FILE_LIMIT,
+  __testBuildExplicitDetailsCommandPanel,
+  __testCreateShellBlockOutput,
+  __testCreateVerificationLevelForReadiness,
+  __testFormatStartAgentDidNotStartMessage,
+  __testGetCurrentWorkflowStepRequest,
+  __testParseRunWorkflowToolInput,
+  __testRenderInteractiveChoiceLines,
+  __testRunWorkflowStepsWithPlan,
+  __testSendMessage,
+  __testStopCommandPanelSelection,
+  __testStopSingleBackgroundTask,
+  __testToggleCommandPanelSelection,
+  __testUpdateCommandPanelSelection,
+  __testWorkflowStepStatusFromNestedJob,
+  addAllowRuleForTest,
+  applyRemoteSessionDisables,
+  breakCacheTestHooks,
+  canClaimCurrentVerification,
+  canClaimTuiMaturity,
+  checkBoundaries,
+  checkFileBoundaries,
+  classifyProviderVerificationLevel,
+  classifyRunnerVerificationLevel,
+  classifyRuntimePath,
+  classifyStartupPath,
+  classifyVerificationLevel,
+  codebaseMemoryRequiredArgs,
+  compareVerificationLevels,
+  consumeRemoteInboundMessage,
+  containsSecret,
+  createCacheState,
+  createFailureLearningState,
+  createHookState,
+  createIndexState,
+  createMcpState,
+  createMcpToolPlaceholders,
+  createMemoryState,
+  createModelGateway,
+  createModelSystemPrompt,
+  createPluginState,
+  createRemoteEvent,
+  createRemotePairing,
+  createRemoteState,
+  createSignedRemoteInboundFixture,
+  createSingleToolCallContinuation,
+  createSkillState,
+  createSolutionCompletenessStatus,
+  createWorkflowState,
+  decidePermission,
+  decideRemoteInbox,
+  deferredToolListHashInput,
+  detectCircularDependencyRisk,
+  detectCrossLayerImports,
+  detectRuntimePathInflation,
+  detectVerificationInflation,
+  dingtalkBridgeAdapter,
+  dingtalkStreamFrameToBridgeEvent,
+  estimateFileMetrics,
+  executeExtraTool,
+  executeSearchExtraTools,
+  feishuBridgeAdapter,
+  feishuReceiveMessageToBridgeEvent,
+  findBundledCodebaseMemoryBinary,
+  findDeferredTool,
+  formatBoundaryViolations,
+  formatDeferredToolsSystemReminder,
+  formatProviderGuardSummary,
+  formatRemoteBridgeDoctor,
+  formatRunnerGuardSummary,
+  formatRuntimePathDoctor,
+  formatRuntimePathMarker,
+  formatStartupPathDoctor,
+  formatStartupPathMarker,
+  formatVerificationLevel,
+  formatVerificationLevelDoctor,
+  getBundledCodebaseMemoryRoots,
+  getCodebaseMemoryPlatformArch,
+  getCodebaseMemoryToolRisk,
+  getDurableJobPaths,
+  getRemoteBridgeDoctor,
+  getRemoteInstallHint,
+  handleBreakCacheCommand,
+  handleCacheCommand,
+  handleCacheLogCommand,
+  handleClaimCheckCommand,
+  handleCompactCommand,
+  handleNaturalInput,
+  handleRemoteInboundMessage,
+  handleSlashCommand,
+  handleTuiKeypress,
+  interruptAllActiveWork,
+  isLocalStdioMcpServer,
+  isNonUpgradeableStatus,
+  isPotentiallyMutatingMcpTool,
+  isRecord,
+  listDeferredTools,
+  normalizeMemoryStatus,
+  parseMcpDeferredToolName,
+  pathExists,
+  processRemoteApprovalForTest,
+  processRemoteBindCommand,
+  processRemoteInbound,
+  recordModelUsage,
+  runAutoLearningOnTurnEnd,
+  runCommandCaptureForTest,
+  runTui,
+  runVerificationCommandForTest,
+  runtimeFromContinuation,
+  sanitizeDiscoveredDeferredToolName,
+  sanitizeMainScreenLeakage,
+  searchDeferredTools,
+  sendRemoteEventReal,
+  snapshotDeferredTools,
+  snapshotDeferredToolsSummary,
+  snapshotDiscoveredDeferredToolsSummary,
+  stableId,
+  startFeishuLongConnection,
+  summarizeProjectRules,
+  tuiStatus,
+  validateChangeDeclaration,
+  validateChangeDeclarationHuman,
+  validateCodebaseMemoryToolExecution,
+  validateCompletionClaim,
+  validateExtensionContributionExecution,
+  validateRemoteInboundEnvelope,
+  validateRemotePairingEnvelope,
+  wecomBridgeAdapter,
+  writeLightHintsForTest
+};