march-cli 0.1.36 → 0.1.38

package/src/cli/repl-loop.mjs

@@ -14,12 +14,13 @@ export async function runSingleShotPrompt({
   refreshStatusBar,
   modeState = null,
 }) {
-  const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
-  ui.writeln(turnInput.displayMessage);
-  ui.recall?.({ source: "user", hints: turnInput.userRecallHints });
-  if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ source: "assistant", hints: turnInput.carryoverRecallHints });
-  refreshStatusBar.startWorking?.();
+  memoryStore.beginTurn();
   try {
+    const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
+    ui.writeln(turnInput.displayMessage);
+    ui.recall?.({ source: "user", hints: turnInput.userRecallHints });
+    if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ source: "assistant", hints: turnInput.carryoverRecallHints });
+    refreshStatusBar.startWorking?.();
     const result = await runner.runTurn(turnInput.fullPrompt, turnInput.userMessage, turnInput.runOptions);
     renderPendingAssistantRecallPreview({ runner, ui });
     await handleTurnLifecycleAction(result?.lifecycleAction, { runner, ui });
@@ -36,6 +37,10 @@ export async function runInteractiveRepl({
   runner,
   memoryStore,
   currentProject,
+  currentProjectInfo = null,
+  workspaceSupervisor = null,
+  workspaceOutputRouter = null,
+  stateRoot = null,
   sessionState,
   sessionsRoot,
   projectMarchDir,
@@ -57,7 +62,8 @@ export async function runInteractiveRepl({
     let trimmed = line.trim();
     if (!trimmed) continue;
 
-    const handledInline = handleInlineCommand(trimmed, { cwd, ui, lastInlineShellCommand });
+    const active = getActiveRuntime({ workspaceSupervisor, cwd, runner, memoryStore, currentProject, currentProjectInfo, sessionState, sessionsRoot, projectMarchDir, extensionPaths, keybindingConfig, promptTemplateConfig });
+    const handledInline = handleInlineCommand(trimmed, { cwd: active.cwd, ui, lastInlineShellCommand });
     if (handledInline.type === "handled") {
       lastInlineShellCommand = handledInline.lastInlineShellCommand;
       continue;
@@ -66,45 +72,70 @@ export async function runInteractiveRepl({
 
     const slashResult = await handleSlashCommand(trimmed, {
       ui,
-      runner,
-      sessionState,
-      sessionsRoot,
-      projectMarchDir,
+      runner: active.runner,
+      workspaceSupervisor,
+      workspaceOutputRouter,
+      sessionState: active.sessionState,
+      sessionsRoot: active.sessionsRoot,
+      projectMarchDir: active.projectMarchDir,
       sessionSource,
-      extensionPaths,
-      keybindings: keybindingConfig.keybindings,
-      keybindingDiagnostics: keybindingConfig.diagnostics,
-      promptTemplates: promptTemplateConfig.templates,
-      promptTemplateDiagnostics: promptTemplateConfig.diagnostics,
+      extensionPaths: active.extensionPaths,
+      keybindings: active.keybindingConfig.keybindings,
+      keybindingDiagnostics: active.keybindingConfig.diagnostics,
+      promptTemplates: active.promptTemplateConfig.templates,
+      promptTemplateDiagnostics: active.promptTemplateConfig.diagnostics,
       modeState,
       renderStartupBanner,
       configHomeDir,
+      stateRoot,
+      currentProjectId: active.project?.projectId ?? null,
     });
     if (slashResult.exit) break;
     if (slashResult.handled) {
-      refreshStatusBar(contextTokenRefreshOptions(slashResult, runner));
+      const refreshedActive = getActiveRuntime({ workspaceSupervisor, cwd, runner, memoryStore, currentProject, currentProjectInfo, sessionState, sessionsRoot, projectMarchDir, extensionPaths, keybindingConfig, promptTemplateConfig });
+      refreshStatusBar(contextTokenRefreshOptions(slashResult, refreshedActive.runner));
       continue;
     }
 
-    const templateResult = expandPromptTemplate(trimmed, promptTemplateConfig.templates);
+    const turnActive = getActiveRuntime({ workspaceSupervisor, cwd, runner, memoryStore, currentProject, currentProjectInfo, sessionState, sessionsRoot, projectMarchDir, extensionPaths, keybindingConfig, promptTemplateConfig });
+    const templateResult = expandPromptTemplate(trimmed, turnActive.promptTemplateConfig.templates);
     if (templateResult.type === "template") {
       ui.writeln(brightBlack(`● template: ${templateResult.name}`));
       trimmed = templateResult.prompt;
     }
 
-    await runReplTurn({
+    if (turnActive.turnTask) {
+      ui.writeln("This session is still running. Use /switch to start or inspect another session.");
+      continue;
+    }
+
+    startReplTurn({
+      runtime: turnActive,
       prompt: trimmed,
-      runner,
-      memoryStore,
-      currentProject,
       ui,
       refreshStatusBar,
       setTurnRunning,
+      workspaceSupervisor,
       modeState,
     });
   }
 }
 
+export function getActiveRuntime({ workspaceSupervisor, cwd, runner, memoryStore, currentProject, currentProjectInfo, sessionState, sessionsRoot, projectMarchDir, extensionPaths, keybindingConfig, promptTemplateConfig }) {
+  return workspaceSupervisor?.getActive?.() ?? {
+    project: currentProjectInfo,
+    cwd,
+    runner,
+    memoryStore,
+    currentProject,
+    sessionState,
+    sessionsRoot,
+    projectMarchDir,
+    extensionPaths,
+    keybindingConfig,
+    promptTemplateConfig,
+  };
+}
 export function contextTokenRefreshOptions(slashResult, runner) {
   if (!slashResult?.refreshContextTokens) return undefined;
   if (typeof runner.estimateContextTokens !== "function") return undefined;
@@ -126,9 +157,31 @@ function handleInlineCommand(trimmed, { cwd, ui, lastInlineShellCommand }) {
   return { type: "none" };
 }
 
+function startReplTurn({ runtime, prompt, ui, refreshStatusBar, setTurnRunning, workspaceSupervisor = null, modeState = null }) {
+  const turnUi = runtime.ui ?? ui;
+  const task = runReplTurn({
+    prompt,
+    runner: runtime.runner,
+    memoryStore: runtime.memoryStore,
+    currentProject: runtime.currentProject,
+    ui: turnUi,
+    refreshStatusBar,
+    setTurnRunning,
+    modeState,
+  }).finally(() => {
+    if (runtime.turnTask === task) runtime.turnTask = null;
+    const hasRunningTurn = Boolean(workspaceSupervisor?.hasRunningTurn?.());
+    setTurnRunning(hasRunningTurn);
+    if (!hasRunningTurn) refreshStatusBar.stopWorking?.();
+    refreshStatusBar();
+  });
+  runtime.turnTask = task;
+}
+
 async function runReplTurn({ prompt, runner, memoryStore, currentProject, ui, refreshStatusBar, setTurnRunning, modeState = null }) {
-  const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
+  memoryStore.beginTurn();
   try {
+    const turnInput = prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState });
     ui.writeln(turnInput.displayMessage);
     ui.recall?.({ source: "user", hints: turnInput.userRecallHints });
     if (turnInput.shouldRenderCarryoverRecall) ui.recall?.({ source: "assistant", hints: turnInput.carryoverRecallHints });
@@ -141,10 +194,7 @@ async function runReplTurn({ prompt, runner, memoryStore, currentProject, ui, re
   } catch (err) {
     ui.writeln(`Error: ${err.message}`);
   } finally {
-    setTurnRunning(false);
-    refreshStatusBar.stopWorking?.();
     memoryStore.endTurn();
-    refreshStatusBar();
   }
 }
 

package/src/cli/startup/app-runtime.mjs

@@ -1,7 +1,6 @@
 import { basename, join, resolve } from "node:path";
 import { existsSync, mkdirSync } from "node:fs";
 import { createUI } from "../ui.mjs";
-import { createPermissionController, MODE } from "../permissions.mjs";
 import { loadKeybindings } from "../input/keybindings.mjs";
 import { createInputHistoryStore } from "../input/history-store.mjs";
 import { createModeState } from "../input/mode-state.mjs";
@@ -12,21 +11,21 @@ import { createMarchAuthStorage } from "../../auth/storage.mjs";
 import { createRuntimeRunner } from "./create-runtime-runner.mjs";
 import { createCliShellRuntime } from "../../shell/cli-runtime.mjs";
 import { MarkdownMemoryStore } from "../../memory/markdown-store.mjs";
-import { createMarkdownMemoryTools } from "../../memory/markdown-tools.mjs";
 import { discoverProjectExtensionPaths } from "../../extensions/discovery.mjs";
 import { loadProjectLifecycleHookManifests } from "../../extensions/lifecycle-manifest.mjs";
 import { loadOrCreateProjectId, resumeStartupSession } from "./startup-session.mjs";
-import { initializeMcp } from "../../mcp/index.mjs";
-import { createWebToolsFromConfig } from "../../web/tools.mjs";
-import { createModelContextDumper } from "../../debug/model-context-dumper.mjs";
 import { createLogger, installProcessLogHandlers } from "../../debug/logger.mjs";
 import { defaultProfilePaths, ensureProfileFiles } from "../../context/profiles.mjs";
-import { createDesktopTurnNotifier } from "../../notification/desktop-notifier.mjs";
 import { normalizeRemoteMemorySources } from "../../memory/remote/config.mjs";
 import { resolveMemoryRoot } from "../../memory/root.mjs";
 import { ensureBrowserDaemon } from "../../browser/client/lifecycle.mjs";
+import { registerProject } from "../../workspace/project-registry.mjs";
+import { listWorkspaceSessions } from "../../workspace/session-index.mjs";
+import { createWorkspaceSessionSupervisor } from "../../workspace/supervisor.mjs";
+import { createWorkspaceProjectRuntime } from "../workspace/project-runtime.mjs";
+import { createWorkspaceOutputRouter } from "../workspace/output-router.mjs";
 
-export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot, useRuntimeProcess } = {}) {
+export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot } = {}) {
   if (!existsSync(stateRoot)) mkdirSync(stateRoot, { recursive: true });
   await ensureBrowserDaemon({ stateRoot }).catch(() => {});
 
@@ -62,28 +61,15 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot,
   const inputHistoryStore = createInputHistoryStore({ path: join(projectMarchDir, "input-history.json") });
   const modeState = createModeState();
   const namespace = loadOrCreateProjectId(projectMarchDir);
+  const currentProjectInfo = registerProject({ stateRoot, rootPath: cwd });
   const memoryRoot = resolveMemoryRoot(config.memoryRoot, stateRoot);
   const profilePaths = defaultProfilePaths();
   ensureProfileFiles(profilePaths);
   const memoryStore = new MarkdownMemoryStore({ root: memoryRoot });
   const remoteMemorySources = normalizeRemoteMemorySources(config);
-  const memoryTools = createMarkdownMemoryTools(memoryStore, { remoteSources: remoteMemorySources });
   const currentProject = basename(cwd);
   const shellRuntime = args.shellRuntime ? createCliShellRuntime({ cwd }) : null;
 
-  const mcpInit = useRuntimeProcess
-    ? { clientManager: null, mcpTools: [], mcpInjections: [], errors: [] }
-    : await initializeMcp({ projectDir: cwd });
-  for (const { server, error } of mcpInit.errors) {
-    if (!args.json) process.stderr.write(`[mcp] ${server}: ${error}\n`);
-  }
-
-  const webTools = createWebToolsFromConfig(config);
-  const turnNotifier = createDesktopTurnNotifier({ enabled: Boolean(config.notifications?.turnEnd), config: config.notifications });
-  const permissionMode = args.permissionMode ?? MODE.BYPASS;
-  const permissionController = createPermissionController({ mode: permissionMode });
-  const usePiSessions = true;
-  const usePiRuntimeHost = true;
   const sessionSource = "pi";
   const sessionsRoot = join(projectMarchDir, "sessions");
   const sessionState = {
@@ -92,10 +78,6 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot,
   };
   sessionState.sessionDir = join(sessionsRoot, sessionState.sessionId);
   const contextDumpRoot = resolve(projectMarchDir, "context-dumps", sessionState.sessionId);
-  const modelContextDumper = createModelContextDumper({
-    enabled: args.dumpContext,
-    rootDir: contextDumpRoot,
-  });
 
   const ui = createUI({
     json: args.json,
@@ -105,7 +87,8 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot,
     shellRuntime,
     historyStore: inputHistoryStore,
   });
-
+  const outputRouter = createWorkspaceOutputRouter({ ui, activeProjectId: currentProjectInfo.projectId, activeSessionId: sessionState.sessionId });
+  const runtimeUi = outputRouter.createProjectUi(currentProjectInfo.projectId, () => sessionState.sessionId);
   let turnRunning = false;
   let refreshStatusBar = null;
   const runnerOptions = {
@@ -121,22 +104,26 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot,
     namespace,
     projectMarchDir,
     extensionPaths,
-    permissionMode,
     shellRuntime: Boolean(shellRuntime),
     lifecycleHooks: lifecycleManifests.hooks,
     lifecycleDiagnostics: lifecycleManifests.diagnostics,
     modelContextDumper: { enabled: args.dumpContext, rootDir: contextDumpRoot },
     remoteMemorySources,
+    notificationContext: { projectId: currentProjectInfo.projectId },
   };
 
   let runner;
+  let workspaceSupervisor = null;
+  const onNotificationActivation = (activation) => {
+    handleNotificationActivation({ activation, stateRoot, workspaceSupervisor, outputRouter, ui }).catch((err) => ui.writeln(`Notification activation failed: ${err.message}`));
+  };
   try {
     runner = await createRuntimeRunner({
-      useRuntimeProcess, runnerOptions, ui, memoryStore, memoryTools, shellRuntime,
-      mcpTools: mcpInit.mcpTools, mcpInjections: mcpInit.mcpInjections, mcpClientManager: mcpInit.clientManager, webTools,
-      usePiSessions, usePiRuntimeHost, authStorage: authConfig.authStorage,
-      permissionController, modelContextDumper, turnNotifier, logger,
+      runnerOptions,
+      ui: runtimeUi,
+      shellRuntime,
       refreshStatusBar: (...args) => refreshStatusBar?.(...args),
+      onNotificationActivation,
     });
   } catch (err) {
     process.stderr.write(`Error: ${err.message}\n`);
@@ -145,6 +132,42 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot,
     return { ok: false, code: 1, logger };
   }
 
+  const initialRuntime = {
+    project: currentProjectInfo,
+    cwd,
+    currentProject,
+    runner,
+    ui: runtimeUi,
+    memoryStore,
+    sessionState,
+    sessionsRoot,
+    projectMarchDir,
+    extensionPaths,
+    keybindingConfig,
+    promptTemplateConfig,
+  };
+  workspaceSupervisor = createWorkspaceSessionSupervisor({
+    initialRuntime,
+    createProjectRuntime: (project) => createWorkspaceProjectRuntime({
+      project,
+      args,
+      config,
+      stateRoot,
+      memoryRoot,
+      profilePaths,
+      createMemoryStore: () => new MarkdownMemoryStore({ root: memoryRoot }),
+      provider,
+      serviceTier,
+      model,
+      remoteMemorySources,
+      createUi: (runtimeSessionState) => outputRouter.createProjectUi(project.projectId, () => runtimeSessionState.sessionId),
+      refreshStatusBar: (...args) => refreshStatusBar?.(...args),
+      onNotificationActivation,
+    }),
+    onActivate: ({ projectId, sessionId }) => outputRouter.setActiveSession(projectId, sessionId),
+  });
+  runner = workspaceSupervisor.runner;
+
   refreshStatusBar = createStatusLineUpdater({
     ui,
     runner,
@@ -174,6 +197,8 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot,
     projectMarchDir,
     ui,
   });
+  workspaceSupervisor.refreshActiveRuntime();
+  outputRouter.setActiveSession(currentProjectInfo.projectId, sessionState.sessionId);
   refreshStatusBar();
 
   return {
@@ -182,8 +207,11 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot,
     cwd,
     ui,
     runner,
+    workspaceSupervisor,
+    workspaceOutputRouter: outputRouter,
     memoryStore,
     currentProject,
+    currentProjectInfo,
     sessionState,
     sessionsRoot,
     projectMarchDir,
@@ -199,3 +227,16 @@ export async function createCliAppRuntime({ args, config, cwd, argv, stateRoot,
     setTurnRunning(value) { turnRunning = value; },
   };
 }
+
+async function handleNotificationActivation({ activation, stateRoot, workspaceSupervisor, outputRouter, ui }) {
+  if (activation?.type !== "workspace-session" || !activation.projectId) return;
+  if (!workspaceSupervisor) throw new Error("workspace supervisor is not ready");
+  const projects = await listWorkspaceSessions({ stateRoot, currentProjectId: workspaceSupervisor.getActive?.()?.project?.projectId ?? null });
+  const runtime = await workspaceSupervisor.activateWorkspaceSessionById({
+    projects,
+    projectId: activation.projectId,
+    sessionId: activation.sessionId,
+  });
+  outputRouter?.replayBufferedCalls?.(activation.projectId, activation.sessionId);
+  ui.writeln(`Activated session from notification: ${runtime.project.displayName}`);
+}

package/src/cli/startup/create-runtime-runner.mjs

@@ -1,61 +1,20 @@
-import { createRunner } from "../../agent/runner.mjs";
 import { createRunnerProcessClient } from "../../agent/runtime/runner-process-client.mjs";
-import { resolvePiSessionManager } from "../../session/pi-manager.mjs";
 
 export async function createRuntimeRunner({
-  useRuntimeProcess = false,
   runnerOptions,
   ui,
-  memoryStore,
-  memoryTools,
   shellRuntime,
-  mcpTools,
-  mcpInjections,
-  mcpClientManager,
-  webTools,
-  usePiSessions,
-  usePiRuntimeHost,
-  authStorage,
-  permissionController,
-  modelContextDumper,
-  turnNotifier,
-  logger,
   refreshStatusBar,
+  onNotificationActivation = null,
 } = {}) {
   const onModelPayload = ({ estimatedTokens }) => {
     refreshStatusBar?.({ contextTokens: estimatedTokens });
   };
+  const onLspStatusChange = () => {
+    refreshStatusBar?.();
+  };
 
-  const runner = useRuntimeProcess
-    ? (await createRunnerProcessClient({ runnerOptions, ui, onModelPayload })).runner
-    : await createRunner({
-      ...runnerOptions,
-      ui,
-      memoryStore,
-      memoryTools,
-      shellRuntime,
-      mcpTools,
-      mcpInjections,
-      mcpClientManager,
-      webTools,
-      sessionManager: resolvePiSessionManager({
-        cwd: runnerOptions.cwd,
-        projectMarchDir: runnerOptions.projectMarchDir,
-        enabled: usePiSessions,
-      }),
-      useRuntimeHost: usePiRuntimeHost,
-      syncPiSidecar: usePiSessions || usePiRuntimeHost,
-      authStorage,
-      maxTurns: runnerOptions.config?.maxTurns ?? undefined,
-      trimBatch: runnerOptions.config?.trimBatch ?? undefined,
-      hostedTools: runnerOptions.config?.hostedTools,
-      permissionController,
-      modelContextDumper,
-      turnNotifier,
-      logger,
-      onModelPayload,
-    });
-
+  const { runner } = await createRunnerProcessClient({ runnerOptions, ui, onModelPayload, onLspStatusChange, onNotificationActivation });
   runner.shellRuntime ??= shellRuntime;
   return runner;
 }

package/src/cli/startup/startup-session.mjs

@@ -1,20 +1,10 @@
-import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { loadOrCreateProjectId } from "../../workspace/project-id.mjs";
 import { listPiSessionInfos } from "../../session/pi-manager.mjs";
+
 import { loadPiSessionTranscriptTurns } from "../../session/transcript.mjs";
 import { resumePiSessionById } from "../session/pi-session-switch-command.mjs";
 
-export function loadOrCreateProjectId(projectMarchDir) {
-  if (!existsSync(projectMarchDir)) mkdirSync(projectMarchDir, { recursive: true });
-  const idFile = resolve(projectMarchDir, "project-id");
-  if (existsSync(idFile)) {
-    return readFileSync(idFile, "utf8").trim();
-  }
-  const id = randomUUID();
-  writeFileSync(idFile, id, "utf8");
-  return id;
-}
+export { loadOrCreateProjectId };
 
 export async function resumeStartupSession({
   resumeId,

package/src/cli/tui/input/history-navigation-controller.mjs

@@ -0,0 +1,56 @@
+import { matchesKey } from "@earendil-works/pi-tui";
+
+export function createHistoryNavigationController({ editor, requestRender, isAutocompleteOpen = () => false, hasOverlay = () => false } = {}) {
+  let draftText = null;
+
+  return {
+    handleInput(data) {
+      if (isAutocompleteOpen() || hasOverlay()) return undefined;
+
+      if (matchesKey(data, "alt+up")) return moveWithinInput(-1);
+      if (matchesKey(data, "alt+down")) return moveWithinInput(1);
+      if (matchesKey(data, "up")) return navigateHistory(-1);
+      if (matchesKey(data, "down")) return navigateHistory(1);
+
+      return undefined;
+    },
+  };
+
+  function navigateHistory(direction) {
+    const history = Array.isArray(editor?.history) ? editor.history : [];
+    const currentIndex = Number.isInteger(editor?.historyIndex) ? editor.historyIndex : -1;
+    const nextIndex = currentIndex - direction;
+    if (nextIndex < -1 || nextIndex >= history.length) return undefined;
+
+    if (currentIndex === -1) draftText = editor.getText?.() ?? "";
+    editor.lastAction = null;
+    editor.historyIndex = nextIndex;
+    setEditorTextPreservingHistory(nextIndex === -1 ? draftText ?? "" : history[nextIndex] ?? "");
+    if (nextIndex === -1) draftText = null;
+    requestRender?.();
+    return { consume: true };
+  }
+
+  function moveWithinInput(direction) {
+    editor.lastAction = null;
+    if (direction < 0) {
+      if (editor.isOnFirstVisualLine?.()) editor.moveToLineStart?.();
+      else editor.moveCursor?.(-1, 0);
+    } else {
+      if (editor.isOnLastVisualLine?.()) editor.moveToLineEnd?.();
+      else editor.moveCursor?.(1, 0);
+    }
+    requestRender?.();
+    return { consume: true };
+  }
+
+  function setEditorTextPreservingHistory(text) {
+    if (typeof editor.setTextInternal === "function") {
+      editor.setTextInternal(text);
+      return;
+    }
+    const historyIndex = editor.historyIndex;
+    editor.setText?.(text);
+    editor.historyIndex = historyIndex;
+  }
+}

package/src/cli/turn/turn-input-preparer.mjs

@@ -5,7 +5,6 @@ import { formatMessageAttachmentsForDisplay } from "../../session/attachment-dis
 import { formatShellHints } from "../../shell/hints.mjs";
 
 export function prepareTurnInput({ prompt, runner, memoryStore, currentProject, modeState = null }) {
-  memoryStore.beginTurn();
   const engine = runner.engine ?? {};
   const carryoverAlreadyRendered = engine.hasRenderedPendingAssistantRecallHints?.() ?? false;
   const carryoverRecallHints = engine.takePendingAssistantRecallHints?.() ?? [];

package/src/cli/ui.mjs

@@ -5,7 +5,6 @@ import { buildMarchCommands, MarchAutocompleteProvider } from "./input/autocompl
 import { createJsonUI, createPlainUI } from "./fallback-ui.mjs";
 import { createKeybindingDispatcher } from "./input/keybinding-dispatch.mjs";
 import { OutputBuffer } from "./tui/output-buffer.mjs";
-import { requestToolPermission } from "./tui/permission-request-ui.mjs";
 import { runTuiExternalEditor } from "./tui/editor/external-editor-runner.mjs";
 import { createRetryStatusController } from "./tui/status/retry-status.mjs";
 import { createShellDrawerControls } from "./shell/shell-drawer-controls.mjs";
@@ -16,6 +15,7 @@ import { showEditorSelectList } from "./tui/select/editor-select-list.mjs";
 import { StatusBar } from "./tui/status/status-bar.mjs";
 import { MainPaneLayout } from "./tui/layout/main-pane-layout.mjs";
 import { SafeRenderBoundary } from "./tui/layout/safe-render-boundary.mjs";
+import { createHistoryNavigationController } from "./tui/input/history-navigation-controller.mjs";
 import { createMouseSelectionController } from "./tui/input/mouse-selection-controller.mjs";
 import { ScreenSelection } from "./tui/selection-screen.mjs";
 import { writeEditDiff } from "./tui/tui-diff-rendering.mjs";
@@ -68,6 +68,12 @@ export function createTuiUI({
   const retryStatus = createRetryStatusController({ output, requestRender, stopSpinner: spinnerStatus.stop });
   const shellDrawerControls = createShellDrawerControls({ shellDrawer, output, requestRender });
   const mouseSelectionController = createMouseSelectionController({ terminal, output, shellDrawer, shellDrawerControls, selection, writeClipboard, requestRender });
+  const historyNavigationController = createHistoryNavigationController({
+    editor,
+    requestRender,
+    isAutocompleteOpen: () => editor.isShowingAutocomplete(),
+    hasOverlay: () => tui.hasOverlay(),
+  });
 
   let onEscapeHandler = null, onCtrlCHandler = null, onShiftTabHandler = null;
   let onCtrlTHandler = null, onCtrlLHandler = null, onPasteImageHandler = null, onToggleModeHandler = null;
@@ -108,6 +114,8 @@ export function createTuiUI({
           requestRender();
           return { consume: true };
         }
+        const historyNavigationResult = historyNavigationController.handleInput(data);
+        if (historyNavigationResult) return historyNavigationResult;
       });
       terminal.write("\x1b[?1049h");
       terminal.write("\x1b[?1002h\x1b[?1006h");
@@ -239,11 +247,6 @@ export function createTuiUI({
       requestRender();
     },
 
-    requestPermission: async ({ toolName, params, category }) => {
-      ensureStarted();
-      spinnerStatus.stop();
-      return requestToolPermission({ toolName, params, category, output, selectList, requestRender });
-    },
 
     setEscapeHandler: (fn) => { onEscapeHandler = fn; },
     setCtrlCHandler: (fn) => { onCtrlCHandler = fn; },