pum-agent 0.2.34-beta.2 → 0.2.36-beta.1

package/src/app.tsx

@@ -7,6 +7,11 @@ import {
   type TextareaRenderable,
 } from "@opentui/core";
 import { randomUUID } from "node:crypto";
+import { diagnosticsCommandText } from "./request-diagnostics-access";
+import { checkpointControllerForSession, checkpointRecoveryFailureText } from "./file-checkpoints";
+import { VALIDATION_CUSTOM_TYPE, validationForSession } from "./project-validation";
+import type { McpController } from "./mcp";
+import type { LspController } from "./lsp";
 import { useKeyboard, usePaste, useRenderer, useTerminalDimensions } from "@opentui/react";
 import { getSupportedThinkingLevels, type Model } from "@earendil-works/pi-ai";
 import type { AgentSession, BashOperations, ModelRuntime } from "@earendil-works/pi-coding-agent";
@@ -161,6 +166,25 @@ import {
 } from "./settings-command";
 import { isRejectedToolResult, rejectedToolReason } from "./check-mode";
 import { SessionHistoryPopup } from "./session-history-popup";
+import {
+  ConversationBranchPopup,
+  CONVERSATION_BRANCH_PAGE_SIZE,
+} from "./conversation-branch-popup";
+import {
+  hasConversationBranchPendingInput,
+  listConversationBranchPoints,
+  type ConversationBranchPage,
+  type ConversationBranchSelection,
+} from "./conversation-branch";
+import type { ConversationBranchResult, PlanModeTransitionResult } from "./session-lock-runtime";
+import {
+  describePlanRecord,
+  loadPlanRecord,
+  planModeForSession,
+  savePlanRecord,
+  validatePlanText,
+  type PlanMode,
+} from "./plan-mode";
 import type { SessionHistoryItem } from "./session-history-metadata";
 import { setWritingStyle, WRITING_STYLES } from "./writing-style";
 import {
@@ -168,6 +192,7 @@ import {
   setExplanationStrength,
 } from "./explanation-strength";
 import { setCheckModeConfig } from "./check-mode";
+import { isRuntimeIdle, runtimeSettings, runtimeSettingsPendingNotice } from "./runtime-settings";
 import { applyCheckPathCommand, parseCheckPathCommand } from "./check-paths";
 import { pruneEditedMarkers, reindexMarkers } from "./attachment-markers";
 import {
@@ -801,6 +826,8 @@ const DEFAULT_PROMPT_STASH_STORE: PromptStashStore = {
   remove: removePromptStash,
 };
 
+const EMPTY_BRANCH_PAGE: ConversationBranchPage = { points: [], total: 0, nextOffset: null };
+
 /** Move any buffered stream into the transcript so later lines land in order. */
 function flushed(t: Transcript): Transcript {
   return flushStream(t);
@@ -813,6 +840,8 @@ export function App({
   loadSessions,
   onSwitchSession,
   onRelocate,
+  onBranchConversation,
+  onTransitionPlanMode,
   settings: initial,
   searchProviders,
   subagentManager,
@@ -841,6 +870,8 @@ export function App({
   initialRelocation,
   initialCwd,
   userBashOperations,
+  mcpForSession,
+  lspForSession,
 }: {
   session: AgentSession;
   modelRuntime: ModelRuntime;
@@ -849,6 +880,24 @@ export function App({
   onSwitchSession: (path: string) => Promise<AgentSession | null>;
   /** Move this same session to another directory. Null when it could not move. */
   onRelocate?: (targetCwd: string) => Promise<AgentSession | null>;
+  /**
+   * Same-session conversation navigation. The host keeps the canonical file,
+   * id and ownership; it never restores files or companion state. Null means
+   * the host declined without changing the conversation.
+   */
+  onBranchConversation?: (
+    selection: ConversationBranchSelection,
+    options: { validate: () => void; validateRetired: () => void },
+  ) => Promise<ConversationBranchResult | null>;
+  /**
+   * Enter or leave the enforced plan-only role (#51). Same canonical session and
+   * ownership; the host rebuilds the runtime with the new role. A failed
+   * transition reports `plan`, never a half-upgraded runtime.
+   */
+  onTransitionPlanMode?: (
+    mode: PlanMode,
+    options: { validate: () => void; validateRetired: () => void },
+  ) => Promise<PlanModeTransitionResult | null>;
   settings: PumSettings;
   /** Provider ids that carry the hosted web-search tool; empty means none. */
   searchProviders: string[];
@@ -886,6 +935,9 @@ export function App({
   initialCwd?: string;
   /** User commands bypass Check mode but use this native sandbox execution path. */
   userBashOperations?: BashOperations;
+  /** Exact main-runtime lookup; never inherited by workers or restored as trust. */
+  mcpForSession?: (session: AgentSession) => McpController | undefined;
+  lspForSession?: (session: AgentSession) => LspController | undefined;
 }) {
   // The one authoritative active directory. Everything directory-dependent
   // reads this rather than process.cwd(), so a live move rebinds by re-render
@@ -980,6 +1032,10 @@ export function App({
   const [settings, setSettings] = useState(
     () => mergeSessionSettings(globalSettingsRef.current, sessionOverridesRef.current),
   );
+  const [pendingSettingsNotice, setPendingSettingsNotice] = useState(() => runtimeSettingsPendingNotice(runtimeSettings.snapshot()));
+  useEffect(() => runtimeSettings.subscribe(() => {
+    setPendingSettingsNotice(runtimeSettingsPendingNotice(runtimeSettings.snapshot()));
+  }), []);
   const [transcriptFocused, setTranscriptFocused] = useState(false);
   const transcriptFocusedRef = useRef(false);
   const [transcriptCursor, setTranscriptCursor] = useState(0);
@@ -1065,11 +1121,30 @@ export function App({
   const newsCursorRef = useRef(0);
   const statsOpenRef = useRef(false);
 
+  const [branchOpen, setBranchOpen] = useState(false);
+  const branchOpenRef = useRef(false);
+  const [branchPage, setBranchPage] = useState<ConversationBranchPage>(EMPTY_BRANCH_PAGE);
+  const branchPageRef = useRef<ConversationBranchPage>(EMPTY_BRANCH_PAGE);
+  const [branchOffset, setBranchOffset] = useState(0);
+  const branchOffsetRef = useRef(0);
+  const [branchCursor, setBranchCursor] = useState(0);
+  const branchCursorRef = useRef(0);
+  const [branchConfirming, setBranchConfirming] = useState(false);
+  const branchConfirmingRef = useRef(false);
+  /** Set only for the window in which a branch transaction owns the session. */
+  const branchRunningRef = useRef(false);
+  const branchNoticeRef = useRef<string | null>(null);
+  const [branchNotice, setBranchNotice] = useState(0);
+  const [planMode, setPlanMode] = useState(() => planModeForSession(initialSession));
+  const planModeRef = useRef(planMode);
+  /** Armed by a direct `/implement`; only `/implement confirm` may upgrade. */
+  const implementArmedRef = useRef(false);
+
   // Preview only the visible autocomplete selection. The committed setting and
   // its session/global persistence never participate in this temporary state.
   const themeSuggestions = shellMode || stashOpen || commandSuggestionsDismissed || activeAgentId
     || transcriptFocused || settingsOpen || helpOpen || historyOpen || statsOpen || agentSelectorOpen
-    || triggersOpen || loginOpen || providersOpen || newsOpen || todoOpen
+    || triggersOpen || loginOpen || providersOpen || newsOpen || todoOpen || branchOpen
     || questionnaireManager?.current() || spawnPreviewManager?.current()
     ? [] : settingsCompletions(commandInput, inputCursorOffset, cwd);
   const previewTheme = themeSuggestions[Math.min(commandCursor, Math.max(0, themeSuggestions.length - 1))]?.previewTheme;
@@ -1126,7 +1201,8 @@ export function App({
   // it from each opener means a popup added later cannot forget a line here.
   const todoVisible = todoOpen
     && !settingsOpen && !helpOpen && !historyOpen && !statsOpen && !agentSelectorOpen
-    && !triggersOpen && !loginOpen && !providersOpen && !newsOpen && !visibleQuestionnaire && !spawnPreview;
+    && !triggersOpen && !loginOpen && !providersOpen && !newsOpen && !branchOpen
+    && !visibleQuestionnaire && !spawnPreview;
   // Memoized because the filtered result is a new object every call whenever
   // the transcript holds reasoning. That new identity would re-run the dwell
   // and projection passes below on every render, keystrokes included.
@@ -1386,6 +1462,11 @@ export function App({
   });
   /** Cache row currently checked out into the selected transcript input. */
   const editingStashIndex = useRef<number | null>(null);
+  // Authority belongs to the draft, never to a mutable cache row index. Edits
+  // retain this origin; only clearing the editor starts a new direct draft.
+  type DraftOrigin = "direct" | "restored";
+  const draftOrigin = useRef<DraftOrigin>("direct");
+  const viewDraftOrigins = useRef(new Map<string, DraftOrigin>());
   /**
    * Text to install after the cache view closes.
    *
@@ -1416,6 +1497,8 @@ export function App({
   const streamingRef = useRef(false);
   /** True while a session switch or /clear is replacing the session object. */
   const sessionSwitchRef = useRef(false);
+  /** User recovery copies must finish before UI actions can replace their runtime. */
+  const checkpointRecoveryRef = useRef(false);
   /** True while the running main-agent turn started from a direct user prompt. */
   const userTurnActiveRef = useRef(false);
   /** Text of the final assistant message; reset at each assistant message start. */
@@ -1622,7 +1705,9 @@ export function App({
     value: string,
     cursorOffset = value.length,
     preserveImages = false,
+    origin: DraftOrigin = "restored",
   ) => {
+    draftOrigin.current = value ? origin : "direct";
     if (!preserveImages && pendingImages.current.length > 0) clearPendingImages();
     if (!preserveImages && pendingPastedTexts.current.length > 0) clearPendingPastedTexts();
     const input = inputRef.current;
@@ -1801,7 +1886,7 @@ export function App({
         const markerStart = value.indexOf(pending.marker);
         return { ...pending, start: markerStart, end: markerStart + pending.marker.length };
       });
-      setEditorText(value, start + marker.length, true);
+      setEditorText(value, start + marker.length, true, draftOrigin.current);
     } catch (error) {
       append({ kind: "text", role: "error", text: `image paste failed: ${String(error)}` });
     } finally {
@@ -1835,6 +1920,7 @@ export function App({
       helpOpen ||
       historyOpen ||
       newsOpenRef.current ||
+      branchOpenRef.current ||
       todoOpenRef.current ||
       statsOpenRef.current ||
       settingsOpenRef.current
@@ -1880,7 +1966,7 @@ export function App({
       start,
       end: start + marker.length,
     });
-    setEditorText(value, start + marker.length, true);
+    setEditorText(value, start + marker.length, true, draftOrigin.current);
   };
 
   const append = (line: Line) =>
@@ -2019,6 +2105,10 @@ export function App({
         setLoginOpen(false);
         setNewsOpen(false);
         newsOpenRef.current = false;
+        setBranchOpen(false);
+        branchOpenRef.current = false;
+        setBranchConfirming(false);
+        branchConfirmingRef.current = false;
         setStatsOpen(false);
         statsOpenRef.current = false;
       }
@@ -2047,6 +2137,12 @@ export function App({
   useEffect(() => {
     // A replaced session cannot still be running the previous session's turn.
     streamingRef.current = false;
+    // The role is read from the session's own durable records, never carried
+    // across from the previous runtime.
+    const activePlanMode = planModeForSession(session);
+    planModeRef.current = activePlanMode;
+    setPlanMode(activePlanMode);
+    implementArmedRef.current = false;
     void subagentManager
       .bindMainSession(session.sessionManager, cwd)
       .catch((error) => append({ kind: "text", role: "error", text: String(error) }));
@@ -2086,6 +2182,7 @@ export function App({
     const mergedSettings = mergeSessionSettings(globalSettingsRef.current, loadedOverrides);
     settingsRef.current = mergedSettings;
     setSettings(mergedSettings);
+    applyRuntimeSettings(mergedSettings, cwd);
     const loadedGoal = loadGoal(session.sessionFile);
     goalRef.current = loadedGoal;
     setGoalState(loadedGoal);
@@ -2126,6 +2223,12 @@ export function App({
         case "message_end":
           if (event.message.role === "assistant") {
             setTx((value) => settleTranscriptMessage(value));
+          } else if (event.message.role === "custom" && event.message.customType === VALIDATION_CUSTOM_TYPE) {
+            append({
+              kind: "text",
+              role: (event.message.details as { outcome?: string } | undefined)?.outcome === "passed" ? "system" : "error",
+              text: String(event.message.content),
+            });
           }
           break;
         case "message_update": {
@@ -2249,6 +2352,16 @@ export function App({
     });
   }, [session]);
 
+  // Ordered after the session replay effect above, so a branch disclosure lands
+  // under the newly selected path instead of being wiped by that replay. It
+  // also runs when a host rebuilds runtime state behind the same object.
+  useEffect(() => {
+    const notice = branchNoticeRef.current;
+    if (!notice) return;
+    branchNoticeRef.current = null;
+    append({ kind: "text", role: "system", text: notice });
+  }, [branchNotice, session]);
+
   useEffect(
     () => () => {
       clearTimeout(quitTimer.current);
@@ -2500,11 +2613,7 @@ export function App({
     setCwd(target);
     // The check-mode roots follow the move immediately: the next tool call must
     // not be judged against the directory the session just left.
-    setCheckModeConfig({
-      profile: settingsRef.current.checkMode,
-      model: settingsRef.current.checkModel,
-      additionalPaths: liveCheckPaths(settingsRef.current, target),
-    });
+    applyRuntimeSettings(settingsRef.current, target);
     void subagentManager.bindMainSession(session.sessionManager, target).catch(() => {});
     // Both are keyed by project, so the old directory's recall would otherwise
     // follow the session into the new one.
@@ -2707,31 +2816,29 @@ export function App({
       : { kind: "return" });
   };
 
+  const applyRuntimeSettings = (next: PumSettings, directory: string) => {
+    setWritingStyle(next.writingStyle);
+    setExplanationStrength(next.explanationStrength);
+    setBashOutputSettingsIfPresent(next.bashOutput);
+    subagentManager.setMaxActiveSubagents?.(next.maxActiveSubagents);
+    runtimeSettings.request({
+      checkMode: next.checkMode,
+      checkModel: next.checkModel,
+      sandboxMode: forcedSandboxMode ?? next.sandboxMode ?? "auto",
+      checkPaths: liveCheckPaths(next, directory),
+      webSearch: next.webSearch,
+    }, (effective) => {
+      setCheckModeConfig({ profile: effective.checkMode, model: effective.checkModel, additionalPaths: effective.checkPaths });
+      onSandboxModeChange?.(effective.sandboxMode);
+      webSearch.enabled = effective.webSearch;
+    });
+  };
+
   const update = (patch: Partial<PumSettings>) => {
     const next = { ...settingsRef.current, ...patch };
     settingsRef.current = next;
     setSettings(next);
-    if (patch.webSearch !== undefined) webSearch.enabled = patch.webSearch;
-    if (patch.writingStyle !== undefined) setWritingStyle(patch.writingStyle);
-    if (patch.explanationStrength !== undefined) {
-      setExplanationStrength(patch.explanationStrength);
-    }
-    if (patch.sandboxMode !== undefined) {
-      onSandboxModeChange?.(forcedSandboxMode ?? patch.sandboxMode);
-    }
-    if (patch.checkMode !== undefined || patch.checkModel !== undefined || patch.checkPaths !== undefined) {
-      setCheckModeConfig({
-        profile: next.checkMode,
-        model: next.checkModel,
-        additionalPaths: liveCheckPaths(next, cwd),
-      });
-    }
-    if (patch.maxActiveSubagents !== undefined) {
-      subagentManager.setMaxActiveSubagents(patch.maxActiveSubagents);
-    }
-    // main.tsx applies this at startup. /settings can change it mid-session, so
-    // the running bash tool has to see the new policy on the next call.
-    if (patch.bashOutput !== undefined) setBashOutputSettingsIfPresent(patch.bashOutput);
+    applyRuntimeSettings(next, cwd);
     // Session-scoped: the popup never writes the global config, which the
     // sandboxes keep read-only. Popup `s` and /store explicitly promote.
     const overrides = sessionSettingsDiff(globalSettingsRef.current, next);
@@ -2979,6 +3086,266 @@ export function App({
     queueMicrotask(() => inputRef.current?.focus());
   };
 
+  // Guards that must still hold when the retired runtime's cleanup has settled
+  // and the selection is about to be published. Refusing here is not a
+  // cancellation: no queued input is dropped and no companion state changes.
+  const sessionTransitionStateBlocker = (noun: string): string | null => {
+    if (activeAgentIdRef.current !== null) {
+      return `${noun} belongs to the main transcript. Select the main transcript first.`;
+    }
+    if (checkpointRecoveryRef.current || relocatingRef.current || pendingRelocationRef.current) {
+      return `Wait for the running session operation to finish before ${noun.toLowerCase()}.`;
+    }
+    if (pendingImages.current.length > 0 || pendingPastedTexts.current.length > 0) {
+      return `Clear attached images and pasted text before ${noun.toLowerCase()}.`;
+    }
+    if (!subagentManager.canBranchMainSession(session.sessionManager)) {
+      return `Worker setup, a retained worker or a pending delivery must finish before ${noun.toLowerCase()}.`;
+    }
+    const goal = goalRef.current;
+    if (goal && (goal.state === "active" || goal.state === "blocked")) {
+      return `Stop the goal with /goal stop before ${noun.toLowerCase()}.`;
+    }
+    if (goal?.pendingContinuation) {
+      return `A goal continuation is still owed. Resolve it before ${noun.toLowerCase()}.`;
+    }
+    return null;
+  };
+
+  /** Full guard for a same-file runtime transition: state plus exact idleness. */
+  const sessionTransitionBlocker = (noun: string): string | null => {
+    if (branchRunningRef.current) return "A session transition is already being applied.";
+    if (sessionSwitchRef.current) {
+      return `Wait for the running session operation to finish before ${noun.toLowerCase()}.`;
+    }
+    const state = sessionTransitionStateBlocker(noun);
+    if (state) return state;
+    if (busyRef.current || !isRuntimeIdle(session) || session.pendingMessageCount !== 0
+      || session.isBashRunning !== false || session.hasPendingBashMessages !== false
+      || txRef.current.pending.length > 0 || hasConversationBranchPendingInput(session)) {
+      return "Wait for the main session to become idle with no pending input, delivery or Bash work first.";
+    }
+    return null;
+  };
+
+  const conversationBranchStateBlocker = () =>
+    sessionTransitionStateBlocker("Conversation branching");
+  const conversationBranchBlocker = (): string | null => {
+    if (!onBranchConversation) return "Conversation branching is unavailable for this session runtime.";
+    return sessionTransitionBlocker("Conversation branching");
+  };
+
+  const closeConversationBranch = () => {
+    branchOpenRef.current = false;
+    setBranchOpen(false);
+    branchConfirmingRef.current = false;
+    setBranchConfirming(false);
+    queueMicrotask(() => inputRef.current?.focus());
+  };
+
+  /** Bounded, read-only projection. A throw means the transcript is unsafe. */
+  const readConversationBranchPage = (offset: number): ConversationBranchPage | null => {
+    try {
+      return listConversationBranchPoints(session, { offset, limit: CONVERSATION_BRANCH_PAGE_SIZE });
+    } catch {
+      append({
+        kind: "text",
+        role: "error",
+        text: "This conversation cannot be projected safely, so branching is refused. Nothing was changed.",
+      });
+      return null;
+    }
+  };
+
+  const openConversationBranch = () => {
+    const blocked = conversationBranchBlocker();
+    if (blocked) {
+      append({ kind: "text", role: "error", text: blocked });
+      return;
+    }
+    const page = readConversationBranchPage(0);
+    if (!page) return;
+    if (page.total === 0) {
+      append({
+        kind: "text",
+        role: "system",
+        text: "No safe conversation points are available to branch from.",
+      });
+      return;
+    }
+    settingsOpenRef.current = false;
+    setSettingsOpen(false);
+    setHelpOpen(false);
+    setHistoryOpen(false);
+    setAgentSelectorOpen(false);
+    setTriggerPopup(false, false);
+    setLoginOpen(false);
+    setStatsOpen(false);
+    statsOpenRef.current = false;
+    todoOpenRef.current = false;
+    setTodoOpen(false);
+    newsOpenRef.current = false;
+    setNewsOpen(false);
+    branchOffsetRef.current = 0;
+    setBranchOffset(0);
+    branchCursorRef.current = 0;
+    setBranchCursor(0);
+    branchConfirmingRef.current = false;
+    setBranchConfirming(false);
+    branchPageRef.current = page;
+    setBranchPage(page);
+    branchOpenRef.current = true;
+    setBranchOpen(true);
+  };
+
+  const moveBranchCursor = (direction: number) => {
+    if (branchConfirmingRef.current) return;
+    const count = branchPageRef.current.points.length;
+    if (count === 0) return;
+    const next = Math.max(0, Math.min(count - 1, branchCursorRef.current + direction));
+    branchCursorRef.current = next;
+    setBranchCursor(next);
+  };
+
+  const pageConversationBranch = (direction: number) => {
+    if (branchConfirmingRef.current) return;
+    const current = branchPageRef.current;
+    const offset = direction > 0
+      ? current.nextOffset
+      : (branchOffsetRef.current > 0
+        ? Math.max(0, branchOffsetRef.current - CONVERSATION_BRANCH_PAGE_SIZE)
+        : null);
+    if (offset === null) return;
+    // Re-project instead of caching pages: a selection must always carry the
+    // transcript state it was actually read from.
+    const page = readConversationBranchPage(offset);
+    if (!page) {
+      closeConversationBranch();
+      return;
+    }
+    branchOffsetRef.current = offset;
+    setBranchOffset(offset);
+    branchPageRef.current = page;
+    setBranchPage(page);
+    branchCursorRef.current = 0;
+    setBranchCursor(0);
+  };
+
+  const confirmConversationBranch = () => {
+    if (!branchPageRef.current.points[branchCursorRef.current]) return;
+    if (!branchConfirmingRef.current) {
+      branchConfirmingRef.current = true;
+      setBranchConfirming(true);
+      return;
+    }
+    applyConversationBranch();
+  };
+
+  const applyConversationBranch = () => {
+    const point = branchPageRef.current.points[branchCursorRef.current];
+    const blocked = conversationBranchBlocker();
+    closeConversationBranch();
+    if (!point || !onBranchConversation) return;
+    if (blocked) {
+      append({ kind: "text", role: "error", text: blocked });
+      return;
+    }
+    // The App owns view/delivery admission; the host owns runtime, ownership and
+    // transcript proof. Both are rechecked while the transaction still holds the
+    // canonical lock, before and after the retired runtime's cleanup.
+    const guard = () => {
+      const reason = conversationBranchStateBlocker();
+      if (reason) throw new Error(reason);
+    };
+    branchRunningRef.current = true;
+    sessionSwitchRef.current = true;
+    setWorking(true);
+    onBranchConversation(point.selection, { validate: guard, validateRetired: guard })
+      .then((result) => {
+        if (!result) {
+          append({
+            kind: "text",
+            role: "system",
+            text: "Conversation branch was not applied; the current path is unchanged.",
+          });
+          queueMicrotask(() => inputRef.current?.focus());
+          return;
+        }
+        branchNoticeRef.current = result.recovered
+          ? "Conversation branch failed and the original conversation path was restored. Nothing else was changed."
+          : "Conversation branch selected in the same session. Files, git state and current goals, todos, settings, News and tool groups were not rewound.";
+        if (activeAgentIdRef.current !== null) selectAgentView(null);
+        focusInputAfterSwitch.current = true;
+        setSession(result.session);
+        setBranchNotice((revision) => revision + 1);
+        const restored = result.recovered ? undefined : result.editorText;
+        queueMicrotask(() => {
+          // A restored earlier prompt is never fresh command authority and is
+          // never submitted for the user.
+          if (restored !== undefined && !inputRef.current?.plainText) {
+            setEditorText(restored, restored.length, false, "restored");
+          }
+          inputRef.current?.focus();
+        });
+      })
+      .catch((error) => {
+        append({ kind: "text", role: "error", text: String(error) });
+        queueMicrotask(() => inputRef.current?.focus());
+      })
+      .finally(() => {
+        branchRunningRef.current = false;
+        sessionSwitchRef.current = false;
+        setWorking(false);
+      });
+  };
+
+  const applyPlanModeTransition = (mode: PlanMode) => {
+    if (!onTransitionPlanMode) {
+      append({ kind: "text", role: "error", text: "Plan mode is unavailable for this session runtime." });
+      return;
+    }
+    const noun = "Changing plan mode";
+    const blocked = sessionTransitionBlocker(noun);
+    if (blocked) {
+      append({ kind: "text", role: "error", text: blocked });
+      return;
+    }
+    const guard = () => {
+      const reason = sessionTransitionStateBlocker(noun);
+      if (reason) throw new Error(reason);
+    };
+    implementArmedRef.current = false;
+    branchRunningRef.current = true;
+    sessionSwitchRef.current = true;
+    setWorking(true);
+    onTransitionPlanMode(mode, { validate: guard, validateRetired: guard })
+      .then((result) => {
+        if (!result) {
+          append({ kind: "text", role: "system", text: "Plan mode was not changed." });
+          queueMicrotask(() => inputRef.current?.focus());
+          return;
+        }
+        branchNoticeRef.current = result.recovered
+          ? "Plan mode transition failed. The session stays in plan mode; no capability was restored."
+          : result.mode === "plan"
+            ? "Plan mode is ON. File mutation, mutable delegation, managed shells, MCP servers and project validation are blocked; Bash needs native sandbox enforcement. Your own ! commands are unchanged."
+            : "Plan mode is off. Full capability is restored for this session.";
+        focusInputAfterSwitch.current = true;
+        setSession(result.session);
+        setBranchNotice((revision) => revision + 1);
+        queueMicrotask(() => inputRef.current?.focus());
+      })
+      .catch((error) => {
+        append({ kind: "text", role: "error", text: String(error) });
+        queueMicrotask(() => inputRef.current?.focus());
+      })
+      .finally(() => {
+        branchRunningRef.current = false;
+        sessionSwitchRef.current = false;
+        setWorking(false);
+      });
+  };
+
   // Re-read on every transcript change while the popup is open: a todo tool call
   // always adds a line, so the list follows the agent without an event bus.
   const todoSessionFile = activeAgent?.sessionFile ?? session.sessionFile;
@@ -3348,6 +3715,7 @@ export function App({
       ? requesterAgentId
       : null;
     viewDrafts.current.set(targetAgentId ?? "main", quote);
+    viewDraftOrigins.current.set(targetAgentId ?? "main", "restored");
     if (activeAgentIdRef.current !== targetAgentId) selectAgentView(targetAgentId);
     else setEditorText(quote);
     queueMicrotask(() => {
@@ -3368,6 +3736,7 @@ export function App({
   };
 
   const selectHistorySession = (path: string) => {
+    if (checkpointRecoveryRef.current) return;
     setHistoryOpen(false);
     if (path === session.sessionFile) {
       queueMicrotask(() => inputRef.current?.focus());
@@ -3462,6 +3831,8 @@ export function App({
     histCursor.current = null;
     // clearQueue may have dropped a subagent completion notice queued to the
     // streaming main agent; re-arm undelivered notices so a merge is not stuck.
+    mcpForSession?.(session)?.cancel();
+    lspForSession?.(session)?.cancel();
     session.abort().finally(() => {
       setWorking(false);
       void subagentManager.resendUndeliveredMainSettlements();
@@ -3481,6 +3852,7 @@ export function App({
     }
     const key = target ?? "main";
     viewDrafts.current.set(key, recalled.text);
+    viewDraftOrigins.current.set(key, "restored");
     if (activeAgentIdRef.current === target) {
       setEditorText(recalled.text);
       histCursor.current = null;
@@ -3604,6 +3976,7 @@ export function App({
   };
 
   const runCommand = (text: string): boolean => {
+    if (checkpointRecoveryRef.current) return true;
     const trimmed = text.trim();
     if (runGoalCommand(trimmed)) return true;
     if (trimmed === "/s" || trimmed === "/store") {
@@ -4213,11 +4586,13 @@ export function App({
       if (activeAgentIdRef.current !== requesterAgentId) {
         if (!(viewDrafts.current.get(requesterKey) ?? "")) {
           viewDrafts.current.set(requesterKey, draftText);
+          viewDraftOrigins.current.set(requesterKey, "restored");
         }
         return;
       }
       if (!(inputRef.current?.plainText ?? "")) {
         viewDrafts.current.set(requesterKey, draftText);
+        viewDraftOrigins.current.set(requesterKey, "restored");
         setEditorText(draftText, draftText.length, true);
       }
     };
@@ -4288,7 +4663,7 @@ export function App({
     return true;
   };
 
-  const submitPrompt = (value?: string, stashIndex?: number) => {
+  const submitPrompt = (value?: string, stashIndex?: number, directCompletion = false) => {
     // Read the selected agent from the ref, not the state. A view switch updates
     // the ref synchronously, but a switch-then-send in one input chunk runs
     // before React commits the new state, so the state would still name the
@@ -4300,6 +4675,10 @@ export function App({
     const attachments = value === undefined ? [...pendingImages.current] : [];
     const pastedTexts = value === undefined ? [...pendingPastedTexts.current] : [];
     const submittedEditingIndex = editingStashIndex.current;
+    // Completion transforms a draft; it cannot turn restored/cache content into
+    // user consent. Snapshot before editor cleanup starts the next direct draft.
+    const directSubmission = draftOrigin.current === "direct"
+      && (value === undefined || directCompletion) && stashIndex === undefined;
     const expandedText = expandPastedTexts(rawDisplayText, pastedTexts);
     const displayText = pastedTexts.length ? expandedText : expandedText.trim();
     const expandedPrompt = expandPastedTexts(rawDisplayText, [
@@ -4311,6 +4690,7 @@ export function App({
     const persistedPrompt = displayText;
 
     if (!promptText && attachments.length === 0 && pastedTexts.length === 0) return;
+    if (checkpointRecoveryRef.current) return;
 
     const backgroundCandidate = commandEligible ? parseBackgroundCommand(promptText) : null;
     if (backgroundCandidate?.kind === "error") {
@@ -4385,6 +4765,7 @@ export function App({
       nextPastedTextId.current = Math.max(1, ...pastedTexts.map((pasted) => pasted.id + 1));
       setEditingStash(submittedEditingIndex);
       viewDrafts.current.set(targetKey, rawDisplayText);
+      viewDraftOrigins.current.set(targetKey, "restored");
       viewEditingStashIndices.current.set(targetKey, submittedEditingIndex);
       setEditorText(rawDisplayText, rawDisplayText.length, true);
     };
@@ -4402,6 +4783,324 @@ export function App({
       return;
     }
 
+    // Diagnostics belong to the selected session, but never enter its durable
+    // transcript or model context. Intercept before ordinary child delivery.
+    if (attachments.length === 0 && commandEligible && /^\/diagnostics(?:\s|$)/.test(promptText.trim())) {
+      const diagnosticSessionId = selectedAgentId
+        ? subagentManager.getDiagnosticsSessionId(selectedAgentId)
+        : session.sessionId;
+      const line: Line = { kind: "text", role: "system", text: diagnosticsCommandText(promptText, diagnosticSessionId)! };
+      if (selectedAgentId) subagentManager.appendAgentLine(selectedAgentId, line, { persist: false });
+      else appendMainLine(line);
+      setEditorText("");
+      setEditingStash(null);
+      histCursor.current = null;
+      draft.current = "";
+      return;
+    }
+
+    // Every LSP operation requires the same ref-backed draft origin as MCP.
+    // Even cached reads/status/stop cannot become programmatic consent commands.
+    if (attachments.length === 0 && commandEligible && /^\/lsp(?:\s|$)/.test(promptText)) {
+      setEditingStash(null);
+      histCursor.current = null;
+      draft.current = "";
+      const report = (text: string, error = false) => {
+        const line: Line = { kind: "text", role: error ? "error" : "system", text };
+        if (selectedAgentId) subagentManager.appendAgentLine(selectedAgentId, line, { persist: false });
+        else appendMainLine(line);
+      };
+      if (!directSubmission) {
+        report("LSP commands require direct user input. Clear the draft and type the command anew.", true);
+        return;
+      }
+      if (selectedAgentId) {
+        report("LSP is available only in the main TUI session; workers cannot access servers.", true);
+        return;
+      }
+      const controller = lspForSession?.(session);
+      if (!controller) {
+        report("LSP is unavailable for this session runtime.", true);
+        return;
+      }
+      const action = promptText.trim().split(/\s+/)[1];
+      if ((action === "connect" || action === "check") && (busyRef.current || !isRuntimeIdle(session)
+        || sessionSwitchRef.current || relocatingRef.current || pendingRelocationRef.current)) {
+        report("Wait for the main session to become idle and session operations to finish before connecting or checking LSP.", true);
+        return;
+      }
+      void controller.command(promptText).then((text) => {
+        if (sessionRef.current === session && lspForSession?.(session) === controller) report(text);
+      }).catch(() => {
+        if (sessionRef.current === session && lspForSession?.(session) === controller) {
+          report("LSP request failed or was revoked. Native Linux Bubblewrap, a supported server and unchanged proposal/file are required. Preview /lsp before approving again.", true);
+        }
+      });
+      return;
+    }
+
+    // MCP consent exists only at this direct input boundary. It is not an SDK
+    // command, saved prompt, model capability, or selected-worker operation.
+    if (attachments.length === 0 && commandEligible && /^\/mcp(?:\s|$)/.test(promptText)) {
+      setEditingStash(null);
+      histCursor.current = null;
+      draft.current = "";
+      const report = (text: string, error = false) => {
+        const line: Line = { kind: "text", role: error ? "error" : "system", text };
+        if (selectedAgentId) subagentManager.appendAgentLine(selectedAgentId, line, { persist: false });
+        else appendMainLine(line);
+      };
+      if (!directSubmission) {
+        report("MCP commands require direct user input. Clear the draft and type the command anew.", true);
+        return;
+      }
+      if (selectedAgentId) {
+        report("MCP is available only in the main TUI session; workers cannot access servers.", true);
+        return;
+      }
+      const controller = mcpForSession?.(session);
+      if (!controller) {
+        report("MCP is unavailable for this session runtime.", true);
+        return;
+      }
+      const action = promptText.trim().split(/\s+/)[1];
+      if (planModeRef.current && action !== "status" && action !== undefined) {
+        // PUM cannot certify a server as non-mutating, so plan mode refuses the
+        // whole lifecycle rather than reasoning about one server's intent.
+        report("Plan mode cannot connect, approve or use MCP servers. Leave plan mode with /implement confirm first.", true);
+        return;
+      }
+      if ((action === "connect" || action === "approve") && (busyRef.current || !isRuntimeIdle(session)
+        || sessionSwitchRef.current || relocatingRef.current || pendingRelocationRef.current)) {
+        report("Wait for the main session to become idle and session operations to finish before connecting or approving MCP.", true);
+        return;
+      }
+      void controller.command(promptText).then((text) => {
+        if (sessionRef.current === session && mcpForSession?.(session) === controller) report(text);
+      }).catch(() => {
+        if (sessionRef.current === session && mcpForSession?.(session) === controller) {
+          report("MCP request failed. Preview /mcp and check the current proposal and digests.", true);
+        }
+      });
+      return;
+    }
+
+    // Approval is a direct-user capability, never an SDK command or model
+    // message. Reports are transient and belong only to the selected runtime.
+    if (attachments.length === 0 && commandEligible && /^\/validation(?:\s|$)/.test(promptText)) {
+      const report = (text: string, error = false) => {
+        const line: Line = { kind: "text", role: error ? "error" : "system", text };
+        if (selectedAgentId) subagentManager.appendAgentLine(selectedAgentId, line, { persist: false });
+        else appendMainLine(line);
+      };
+      setEditingStash(null);
+      histCursor.current = null;
+      draft.current = "";
+      if (!directSubmission) {
+        report("Validation commands require direct user input. Clear the draft and type the command anew.", true);
+        return;
+      }
+      const parts = promptText.trim().split(/\s+/);
+      const action = parts[1];
+      if (!(parts.length === 1 || (parts.length === 2 && (action === "status" || action === "disable"))
+        || (parts.length === 3 && action === "enable" && /^[0-9a-f]{64}$/i.test(parts[2]!)))) {
+        report("Usage: /validation [status|enable <64-hex digest>|disable]", true);
+        return;
+      }
+      // A role refusal does not depend on a runtime controller, so it is
+      // reported before an "unavailable" message can hide the real reason.
+      if (action === "enable" && !selectedAgentId && planModeRef.current) {
+        // Validation runs configured project commands: a mutation path.
+        report("Plan mode cannot enable project validation. Leave plan mode with /implement confirm first.", true);
+        return;
+      }
+      const selected = selectedAgentId ? subagentManager.getAgent(selectedAgentId) : undefined;
+      const controller = validationForSession(selectedAgentId ? subagentManager.getDiagnosticsSessionId(selectedAgentId) ?? "" : session);
+      if (!controller) {
+        report("Project validation is unavailable for this session runtime.", true);
+        return;
+      }
+      try {
+        if (action === "enable") {
+          if (selected?.readonly) {
+            report("Readonly sessions cannot enable project validation.", true);
+            return;
+          }
+          if (!controller.isIdle || sessionSwitchRef.current || relocatingRef.current || pendingRelocationRef.current
+            || (selectedAgentId ? !selected || selected.status === "starting" || selected.status === "running" : busyRef.current)) {
+            report("Wait for the selected session to become idle and session operations to finish before enabling validation.", true);
+            return;
+          }
+          controller.enable(parts[2]!);
+          report(controller.status());
+        } else if (action === "disable") {
+          // Deliberately allowed while busy: revoke and cancel in-flight work.
+          controller.disable();
+          report(controller.status());
+        } else report(action === "status" ? controller.status() : controller.preview());
+      } catch {
+        report("Project validation request failed. Preview /validation and check the current proposal and digest before enabling.", true);
+      }
+      return;
+    }
+
+    // Explicit user-only capability gate. Entering plan mode only removes
+    // capability, so it needs no confirmation; leaving it is the upgrade, so it
+    // needs a second directly typed command, never a keypress on a restored draft.
+    if (attachments.length === 0 && commandEligible && /^\/(?:plan|implement)(?:\s|$)/.test(promptText)) {
+      setEditingStash(null);
+      histCursor.current = null;
+      draft.current = "";
+      const report = (text: string, error = false) => {
+        const line: Line = { kind: "text", role: error ? "error" : "system", text };
+        if (selectedAgentId) subagentManager.appendAgentLine(selectedAgentId, line, { persist: false });
+        else appendMainLine(line);
+      };
+      const parts = promptText.trim().split(/\s+/);
+      const implement = parts[0] === "/implement";
+      if (!directSubmission) {
+        implementArmedRef.current = false;
+        report("Plan mode commands require direct user input. Clear the draft and type the command anew.", true);
+        return;
+      }
+      if (selectedAgentId) {
+        report("Plan mode is a main-session role. Select the main transcript first.", true);
+        return;
+      }
+      const active = planModeRef.current;
+      if (implement) {
+        if (parts.length > 2 || (parts.length === 2 && parts[1] !== "confirm")) {
+          report("Usage: /implement, then /implement confirm to leave plan mode.", true);
+          return;
+        }
+        if (!active) {
+          implementArmedRef.current = false;
+          report("Plan mode is already off; this session has full capability.", true);
+          return;
+        }
+        if (parts.length === 1) {
+          implementArmedRef.current = true;
+          report("Leaving plan mode restores file mutation, mutable delegation, managed shells, MCP and project validation for this session. Files are not changed by the transition itself.\nType /implement confirm to leave plan mode, or keep planning.");
+          return;
+        }
+        if (!implementArmedRef.current) {
+          report("Type /implement first, read what it restores, then /implement confirm.", true);
+          return;
+        }
+        applyPlanModeTransition("implement");
+        return;
+      }
+      implementArmedRef.current = false;
+      const text = promptText.trim().slice("/plan".length).trim();
+      if (text) {
+        try {
+          const file = session.sessionFile;
+          if (!file) throw new Error("Recording a plan requires a saved session.");
+          const existing = loadPlanRecord(file);
+          savePlanRecord(file, {
+            version: 1,
+            mode: existing?.mode ?? (active ? "plan" : "implement"),
+            text: validatePlanText(text),
+            at: Date.now(),
+          });
+        } catch (error) {
+          report(error instanceof Error ? error.message : "The plan could not be recorded.", true);
+          return;
+        }
+        report("Plan recorded.");
+      }
+      if (active) {
+        report(describePlanRecord(loadPlanRecord(session.sessionFile), true));
+        return;
+      }
+      applyPlanModeTransition("plan");
+      return;
+    }
+
+    // Explicit user-only conversation navigation. Never an extension command,
+    // model tool, attachment or pasted marker, and never a filesystem restore.
+    if (attachments.length === 0 && commandEligible && /^\/(?:branch|rewind)(?:\s|$)/.test(promptText)) {
+      setEditingStash(null);
+      histCursor.current = null;
+      draft.current = "";
+      const report = (text: string, error = false) => {
+        const line: Line = { kind: "text", role: error ? "error" : "system", text };
+        if (selectedAgentId) subagentManager.appendAgentLine(selectedAgentId, line, { persist: false });
+        else appendMainLine(line);
+      };
+      if (!directSubmission) {
+        report("Conversation branch commands require direct user input. Clear the draft and type the command anew.", true);
+        return;
+      }
+      if (selectedAgentId) {
+        report("Conversation branching is available only in the main transcript. Select the main transcript first.", true);
+        return;
+      }
+      if (promptText.trim().split(/\s+/).length !== 1) {
+        report("Usage: /branch (alias /rewind). Choose and confirm a point in the selector.", true);
+        return;
+      }
+      openConversationBranch();
+      return;
+    }
+
+    // Explicit user-only recovery: never registered as an extension command or
+    // model tool, and never interpreted from an attached image or pasted marker.
+    if (attachments.length === 0 && commandEligible && /^\/checkpoint(?:\s|$)/.test(promptText)) {
+      const report = (text: string, error = false) => {
+        const line: Line = { kind: "text", role: error ? "error" : "system", text };
+        if (selectedAgentId) subagentManager.appendAgentLine(selectedAgentId, line, { persist: false });
+        else appendMainLine(line);
+      };
+      setEditingStash(null);
+      histCursor.current = null;
+      draft.current = "";
+      const selected = selectedAgentId ? subagentManager.getAgent(selectedAgentId) : undefined;
+      if (!directSubmission) {
+        report("Checkpoint commands require direct user input. Clear the draft and type the command anew.", true);
+        return;
+      }
+      const controller = checkpointControllerForSession(selectedAgentId ? subagentManager.getDiagnosticsSessionId(selectedAgentId) ?? "" : session.sessionId);
+      const parts = promptText.trim().split(/\s+/);
+      const action = parts[1] ?? "list";
+      if (!((action === "list" || action === "clear") && parts.length <= 2)
+        && !(action === "recover" && parts.length === 3)) {
+        report("Usage: /checkpoint [list|recover <id>|clear]", true);
+        return;
+      }
+      if (!controller) {
+        report("File checkpoints are unavailable for this session runtime.", true);
+        return;
+      }
+      if (action === "list") {
+        const records = controller.list();
+        report(`${controller.summary()}\n${records.length ? records.map((record) =>
+          `${record.id} | ${record.toolName} | ${record.priorAbsent ? "previously absent" : `${record.bytes} bytes before change`} | ${JSON.stringify(record.path)}`
+        ).join("\n") : "No file checkpoints retained."}\nRecovery creates a new copy only; original files are never restored in place.`);
+      } else if (action === "clear") {
+        controller.clear();
+        report("File checkpoints cleared for this session runtime; original files unchanged.");
+      } else {
+        if (sessionSwitchRef.current || relocatingRef.current || pendingRelocationRef.current
+          || (selectedAgentId ? !selected || selected.status === "starting" || selected.status === "running" : busyRef.current)) {
+          report("Wait for the selected session to become idle and session operations to finish before recovering a checkpoint.", true);
+          return;
+        }
+        checkpointRecoveryRef.current = true;
+        report("Creating a checkpoint recovery copy; wait for it to finish before changing sessions.");
+        void Promise.resolve().then(() => {
+          const liveId = selectedAgentId ? subagentManager.getDiagnosticsSessionId(selectedAgentId) : session.sessionId;
+          if (!liveId || checkpointControllerForSession(liveId) !== controller) throw new Error("Checkpoint runtime changed");
+          return controller.recover(parts[2]!);
+        }).then((path) => {
+          report(`Recovery copy created: ${JSON.stringify(path)}\nOriginal unchanged. Inspect the copy and apply it manually if wanted.`);
+        }).catch((error) => {
+          report(checkpointRecoveryFailureText(error), true);
+        }).finally(() => { checkpointRecoveryRef.current = false; });
+      }
+      return;
+    }
+
     // Model controls follow Settings: only main owns model mutations.
     if (selectedAgentId && attachments.length === 0 && commandEligible
       && /^\/(?:model|effort|s|store)(?:\s|$)/.test(promptText)) {
@@ -4474,6 +5173,7 @@ export function App({
   };
 
   const submitShellCommand = () => {
+    if (checkpointRecoveryRef.current) return;
     const command = expandPastedTexts(inputRef.current?.plainText ?? "", pendingPastedTexts.current);
     if (!command.trim()) return;
     const selectedAgentId = activeAgentIdRef.current;
@@ -4736,6 +5436,7 @@ export function App({
   };
 
   const selectAgentView = (target: string | null): boolean => {
+    if (checkpointRecoveryRef.current) return false;
     const current = activeAgentIdRef.current;
     // Nothing moves between views, so a pending attachment cannot be stranded.
     if (target === current) return true;
@@ -4750,11 +5451,13 @@ export function App({
     const currentKey = current ?? "main";
     const targetKey = target ?? "main";
     viewDrafts.current.set(currentKey, inputRef.current?.plainText ?? "");
+    viewDraftOrigins.current.set(currentKey, draftOrigin.current);
     viewEditingStashIndices.current.set(currentKey, editingStashIndex.current);
     activeAgentIdRef.current = target;
     setActiveAgentId(target);
     setEditingStash(viewEditingStashIndices.current.get(targetKey) ?? null);
-    setEditorText(viewDrafts.current.get(targetKey) ?? "");
+    setEditorText(viewDrafts.current.get(targetKey) ?? "", undefined, false,
+      viewDraftOrigins.current.get(targetKey) ?? "restored");
     setStashMode(false);
     histCursor.current = null;
     resetCancelArm();
@@ -4951,6 +5654,13 @@ export function App({
   });
 
   useKeyboard((key) => {
+    // A recovery is an explicit filesystem copy owned by the selected runtime.
+    // Hold user transitions (including quit, settings, and agent/session switches)
+    // until it settles rather than disposing that runtime underneath the copy.
+    if (checkpointRecoveryRef.current) {
+      key.stopPropagation();
+      return;
+    }
     // Match Textarea's printable sequence handling, but leave all modified
     // commands (including Option) with their existing owner.
     const typedText = !key.ctrl && !key.meta && !key.option && !key.super && !key.hyper
@@ -5003,7 +5713,8 @@ export function App({
       helpOpen ||
       historyOpen ||
       statsOpenRef.current ||
-      newsOpenRef.current
+      newsOpenRef.current ||
+      branchOpenRef.current
     )) {
       key.stopPropagation();
       resetCancelArm();
@@ -5025,6 +5736,7 @@ export function App({
         queueMicrotask(() => inputRef.current?.focus());
       } else if (statsOpenRef.current) closeStats();
       else if (newsOpenRef.current) closeNews();
+      else if (branchOpenRef.current) closeConversationBranch();
       return;
     }
 
@@ -5265,6 +5977,26 @@ export function App({
       return; // navigation and Enter belong to the focused select
     }
 
+    if (branchOpenRef.current || branchOpen) {
+      key.stopPropagation();
+      if (key.name === "escape") {
+        // Escape backs out of the confirmation first, so a stray key cannot
+        // apply a branch the user only wanted to look at.
+        if (branchConfirmingRef.current) {
+          branchConfirmingRef.current = false;
+          setBranchConfirming(false);
+        } else closeConversationBranch();
+      }
+      else if (key.name === "up") moveBranchCursor(-1);
+      else if (key.name === "down") moveBranchCursor(1);
+      else if (key.name === "left") pageConversationBranch(-1);
+      else if (key.name === "right") pageConversationBranch(1);
+      else if (key.name === "return" || key.name === "enter" || key.name === "kpenter") {
+        confirmConversationBranch();
+      }
+      return;
+    }
+
     if (key.ctrl && key.name === "h") {
       key.stopPropagation();
       openHistory();
@@ -5620,7 +6352,7 @@ export function App({
       if (commandMatches.length > 0 && !/\s/.test(inputValue)) {
         key.stopPropagation();
         const selected = commandMatches[Math.min(commandCursorRef.current, commandMatches.length - 1)]!;
-        setEditorText(selected.name);
+        setEditorText(selected.name, undefined, false, draftOrigin.current);
         return;
       }
 
@@ -5638,7 +6370,7 @@ export function App({
           : Math.min(commandCursorRef.current, completions.length - 1);
         const sourceValue = continuing ? previousCycle!.sourceValue : inputValue;
         const completed = applyPathCompletion(sourceValue, completions[index]!);
-        setEditorText(completed.value, completed.cursorOffset, true);
+        setEditorText(completed.value, completed.cursorOffset, true, draftOrigin.current);
         pathCompletionCycle.current = {
           sourceValue,
           completions,
@@ -5678,7 +6410,7 @@ export function App({
     if (isPlainReturn && commandMatches.length > 0 && !/\s/.test(inputValue)) {
       key.stopPropagation();
       const selected = commandMatches[Math.min(commandCursorRef.current, commandMatches.length - 1)]!;
-      submitPrompt(selected.name);
+      submitPrompt(selected.name, undefined, true);
       return;
     }
 
@@ -5687,10 +6419,10 @@ export function App({
       const index = Math.min(commandCursorRef.current, visibleArgumentMatches.length - 1);
       const completed = applyPathCompletion(inputValue, visibleArgumentMatches[index]!);
       if (closedSetMatches.length > 0) {
-        submitPrompt(completed.value);
+        submitPrompt(completed.value, undefined, true);
         return;
       }
-      setEditorText(completed.value, completed.cursorOffset, true);
+      setEditorText(completed.value, completed.cursorOffset, true, draftOrigin.current);
       pathCompletionCycle.current = {
         sourceValue: inputValue,
         completions: visibleArgumentMatches,
@@ -5863,14 +6595,14 @@ export function App({
 
   const popupResetKey = [
     loginOpen, spawnPreview?.id ?? "", Boolean(questionnaire), helpOpen, triggersOpen,
-    agentSelectorOpen, historyOpen, newsOpen, todoVisible, statsOpen, settingsOpen, page,
+    agentSelectorOpen, historyOpen, newsOpen, branchOpen, todoVisible, statsOpen, settingsOpen, page,
   ].join(":");
   const streamGap = visibleTx.stream
     ? needsTranscriptGap(lastLine, { kind: "text", role: visibleTx.stream.kind, text: visibleTx.stream.text })
     : false;
   const promptFocused = !transcriptFocused && !settingsOpen && !helpOpen && !historyOpen
     && !statsOpen && !agentSelectorOpen && !triggersOpen && !loginOpen && !providersOpen
-    && !visibleQuestionnaire && !spawnPreview && !newsOpen && !todoVisible;
+    && !visibleQuestionnaire && !spawnPreview && !newsOpen && !branchOpen && !todoVisible;
 
   // One element for the whole transcript, rebuilt only when what it shows
   // changes. React walks a child list of this size on every render of the app,
@@ -5941,6 +6673,7 @@ export function App({
         />
         <StatusBar
           theme={theme}
+          planMode={planMode}
           modelId={visibleModelId}
           thinkingLevel={visibleThinkingLevel}
           cwd={cwd}
@@ -6006,6 +6739,7 @@ export function App({
             ) : null}
           </RenderErrorBoundary>
         </scrollbox>
+        {pendingSettingsNotice ? <text content={pendingSettingsNotice} fg={theme.dim} flexShrink={0} /> : null}
         {ruleLabels.length > 0 ? <Gap /> : null}
         <WorkingRule
           theme={theme}
@@ -6218,6 +6952,18 @@ export function App({
               onSelect={selectHistorySession}
             />
           ) : null}
+          {branchOpen ? (
+            <ConversationBranchPopup
+              theme={theme}
+              points={branchPage.points}
+              cursor={branchCursor}
+              offset={branchOffset}
+              total={branchPage.total}
+              confirming={branchConfirming}
+              terminalWidth={width}
+              terminalHeight={height}
+            />
+          ) : null}
           {newsOpen ? (
             <NewsPopup
               theme={theme}