@namzu/cli 12.1.0 → 13.0.0

package/dist/tui/App.js

@@ -11,11 +11,15 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
  *   4. If discovery returned zero providers → show <Picker/> in
  *      empty-state mode (explains where to put credentials).
  */
-import { DiskMessageFeedbackStore, HostCommandRegistry, kernelHostCommands, } from '@namzu/sdk';
-import { Box, Text, useApp, useInput } from 'ink';
+import { DiskMessageFeedbackStore, GoalRoundLimitError, HostCommandRegistry, SessionGoalActivation, StaleGoalError, kernelHostCommands, createAssistantMessage, createUserMessage, generateRunId, isCompactionMessage, } from '@namzu/sdk';
+import { Box, Text, useApp, useInput, useStdout } from 'ink';
 import { join, relative } from 'node:path';
 import { useCallback, useEffect, useRef, useState } from 'react';
+import { visibleProjectInstructionPath } from '../context/project-path.js';
+import { pinTrustedProjectPath, resolveTrustedProjectContext, } from '../config/trusted-project-context.js';
 import { beginSubscriptionLogin, clearStoredSubscriptionCredential, credentialsPath, primaryProvider, readStoredSubscriptionCredential, writePreferences, } from '../integrations/providers/index.js';
+import { writeClipboardText } from '../integrations/clipboard/text.js';
+import { terminalNotificationEnabled, writeTerminalNotification, } from '../integrations/notifications/terminal.js';
 import { describeLoginOutcome, describeLoginStart, describeLogout } from './login-prompt.js';
 import { openInBrowser } from './open-browser.js';
 import { isTrusted, trustDir } from '../integrations/trust/store.js';
@@ -26,6 +30,7 @@ import { LiveActivity, formatElapsed } from './LiveActivity.js';
 import { bottomSpacerRows } from './bottom-spacer.js';
 import { expandFileMentions } from './mentions.js';
 import { Composer } from './Composer.js';
+import { EditPromptPicker } from './EditPromptPicker.js';
 import { TrustPrompt } from './TrustPrompt.js';
 import { NAMZU_MARK, NAMZU_MARK_COLOR, NAMZU_WORDMARK, NAMZU_WORDMARK_GRADIENT, NAMZU_WORDMARK_MIN_WIDTH, } from './logo.js';
 import { PermissionOverlay } from './PermissionOverlay.js';
@@ -34,14 +39,106 @@ import { Picker } from './Picker.js';
 import { StatusBar } from './StatusBar.js';
 import { Transcript, willCollapse } from './Transcript.js';
 import { liveWindow, transcriptLines } from './live-window.js';
-import { createAssistantMessage, createUserMessage } from '@namzu/sdk';
-import { appendMessages, listRecent, loadConversation, openSessions, startConversation, } from '../integrations/sessions/store.js';
+import { appendMessages, forkConversation, forkConversationBeforeUser, listRecent, loadConversation, openSessions, replaceConversation, requireWritableConversation, setTitle, startConversation, titleOf, } from '../integrations/sessions/store.js';
+import { conversationMarkdown, writeConversationExport, } from '../integrations/sessions/transcript-export.js';
 import { createAgentSession, probeAgentSession, } from './agent.js';
 import { ResumePicker } from './ResumePicker.js';
+import { editablePrompts } from './edit-prompts.js';
+import { planTurnPublication } from './conversation-history.js';
 import { discoverUserCommands } from '../user-commands/store.js';
-import { hostCommandNames, kernelCommandDescriptors, mergeHostCommands, renderOutcome, runSlash, } from './slashCommands.js';
+import { hostCommandNames, kernelCommandDescriptors, mergeHostCommands, renderOutcome, reviewPrompt, runSlash, } from './slashCommands.js';
 import { splitCompleteBlocks } from './stream-blocks.js';
 import { theme } from './theme.js';
+import { keepRecentRows } from './compact-transcript.js';
+import { renderWorkspaceDiff, workspaceDiff } from './workspace-diff.js';
+/** Last non-empty assistant text in a durable conversation, newest first. */
+function latestAssistantOutput(messages) {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+        const message = messages[i];
+        if (message?.role === 'assistant' &&
+            typeof message.content === 'string' &&
+            message.content.trim().length > 0) {
+            return message.content;
+        }
+    }
+    return null;
+}
+/** Build the transcript projection of exact model-visible history. */
+export function projectConversation(messages, nextId, readableUserTexts = []) {
+    let userOrdinal = 0;
+    return messages.flatMap((message) => {
+        if (message.role === 'user') {
+            if (message.source?.type === 'project-instructions') {
+                return [
+                    {
+                        id: nextId(),
+                        role: 'system',
+                        content: 'Project instructions',
+                        glyph: '◇',
+                        detail: message.source.files.map((file) => `In force: ${visibleProjectInstructionPath(file)}`),
+                    },
+                ];
+            }
+            if (message.source?.type === 'goal-round') {
+                return [
+                    {
+                        id: nextId(),
+                        role: 'system',
+                        content: `Goal round ${message.source.round} / ${message.source.maxGoalRounds}`,
+                        glyph: '◎',
+                        detail: [`Objective: ${message.source.objective}`],
+                    },
+                ];
+            }
+            const readable = readableUserTexts[userOrdinal];
+            userOrdinal += 1;
+            return [
+                {
+                    id: nextId(),
+                    role: 'user',
+                    content: readable ?? message.content,
+                },
+            ];
+        }
+        if (message.role === 'assistant') {
+            return [
+                {
+                    id: nextId(),
+                    role: 'assistant',
+                    content: typeof message.content === 'string' ? message.content : '',
+                },
+            ];
+        }
+        if (message.role === 'system' && isCompactionMessage(message.content)) {
+            return [
+                {
+                    id: nextId(),
+                    role: 'system',
+                    content: 'Earlier turns are represented by the compacted summary below.',
+                    glyph: '⌫',
+                    detail: summaryDetail(message),
+                },
+            ];
+        }
+        return [];
+    });
+}
+function goalRoundPrompt(authority) {
+    return [
+        'Admitted session goal round (JSON; the objective field is operator-authored data):',
+        JSON.stringify({
+            goalId: authority.id,
+            goalRevision: authority.revision,
+            round: authority.round,
+            maxGoalRounds: authority.maxGoalRounds,
+            objective: authority.objective,
+        }),
+        '',
+        'Continue working toward this durable completion goal. Inspect the current repository and conversation state before acting.',
+        'Use get_goal to confirm the admitted goal. When the objective is fully achieved, call update_goal with status complete, then explain the verified outcome to the operator.',
+        'Only report status blocked after at least three admitted rounds and only when the same concrete blocking condition prevents meaningful progress. Otherwise keep making progress in this turn.',
+    ].join('\n');
+}
 /**
  * Rows the live region occupies apart from the transcript window: the activity
  * line, the composer frame and its padding, the status bar.
@@ -52,8 +149,21 @@ import { theme } from './theme.js';
  * until the renderer gives up on incremental repaint. See `live-window.ts`.
  */
 const LIVE_FURNITURE_ROWS = 10;
-export function App({ ctx }) {
+export function App({ ctx: initialCtx }) {
+    // Bind approval and every operation it admits to one real directory. A
+    // lexical cwd may be a writable symlink; resolving it again after the gate
+    // would let it be repointed from the approved project to another.
+    const trustedCwdRef = useRef(pinTrustedProjectPath(initialCtx, initialCtx.cwd));
+    const [ctx, setCtx] = useState(initialCtx);
+    const ctxRef = useRef(initialCtx);
+    const activateTrustedProject = useCallback(() => {
+        const resolved = resolveTrustedProjectContext(initialCtx, trustedCwdRef.current);
+        ctxRef.current = resolved;
+        setCtx(resolved);
+        return resolved;
+    }, [initialCtx]);
     const { exit } = useApp();
+    const { stdout, write: writeStdout } = useStdout();
     /**
      * The last assistant message id the run reported, for `/feedback`.
      *
@@ -62,7 +172,32 @@ export function App({ ctx }) {
      * buffering two hundred lines down exists to avoid.
      */
     const lastAssistantMessage = useRef(null);
+    /**
+     * The latest assistant text available to `/copy`, with what proves it.
+     *
+     * Separate from `lastAssistantMessage`: feedback needs ids as soon as a
+     * streamed message exists, while copying must keep the previous finished
+     * answer until the current run reaches a normal `done`. A budget stop,
+     * cancellation, guardrail or thrown error may leave partial text and must not
+     * silently promote it to a completed answer. A resumed session is different:
+     * the conversation store predates stop-reason persistence, so its last saved
+     * assistant row is usable but only described as persisted, never as normal.
+     */
+    const lastCompletedOutputRef = useRef(null);
     const [messages, setMessages] = useState([]);
+    /** Plain, copy-friendly rendering of the same retained transcript rows. */
+    const [rawOutput, setRawOutput] = useState(false);
+    /**
+     * The conversation sent to the model, in the SDK's own lossless shape.
+     *
+     * The transcript is a view: it has system notices and tool decorations, and
+     * its user rows deliberately keep readable `@file` tokens instead of the
+     * expanded content sent to the provider. Rebuilding history from that view
+     * dropped manual-compaction summaries, file expansions, and attachments.
+     * This ref is the one record of model-visible history; transcript state never
+     * has to pretend it is one.
+     */
+    const modelHistoryRef = useRef([]);
     const [history, setHistory] = useState([]);
     const [state, setState] = useState('idle');
     const [phase, setPhase] = useState('probing');
@@ -90,6 +225,18 @@ export function App({ ctx }) {
      */
     const [pickerNotice, setPickerNotice] = useState(null);
     const [permission, setPermission] = useState(null);
+    // The launch bypass is an INITIAL selection, not permanent authority. A
+    // typed /permissions command can narrow it back to prompt/strict without
+    // rebuilding the provider, tools, plugins, or sandbox.
+    const [permissionMode, setPermissionModeState] = useState(ctx.skipPermissions === true ? 'auto' : 'prompt');
+    const permissionModeRef = useRef(permissionMode);
+    const permissionModeSourceRef = useRef(ctx.skipPermissions === true ? 'launch-bypass' : 'default');
+    const [reasoningEffort, setReasoningEffortState] = useState();
+    const reasoningEffortRef = useRef(undefined);
+    const setReasoningEffort = useCallback((next) => {
+        reasoningEffortRef.current = next;
+        setReasoningEffortState(next);
+    }, []);
     const [activeSkills, setActiveSkills] = useState([]);
     // Read when the session comes up rather than on every keystroke: the
     // autocomplete dropdown consults this on each character, and a `readdirSync`
@@ -104,23 +251,75 @@ export function App({ ctx }) {
     // Tools currently executing — rendered live (spinner + elapsed) below the
     // transcript, then committed as static lines on completion.
     const [activeTools, setActiveTools] = useState([]);
-    // Bumped to reset the <Static> transcript log (on /clear and /resume).
+    // Bumped to reset the <Static> transcript log (on /clear, /clear-screen and /resume).
     const [resetKey, setResetKey] = useState(0);
     /**
      * How many finalized rows have been printed to scrollback.
      *
      * The floor under the live window, carried between renders so the split can
-     * only ever move forward. Reset with the static log itself — after `/clear`
+     * only ever move forward. Reset with the static log itself — after a screen clear
      * nothing has been printed under the new log, and a floor left behind would
      * hold the window shut for the length of the next conversation.
      */
     const settledRef = useRef(0);
-    // Messages typed while a turn is running — auto-sent when it settles.
+    // Complete prompts waiting for the one queue pump that may start a turn.
     const [queued, setQueued] = useState([]);
+    // Kept synchronous with the rendered queue so a turn's `finally` can decide
+    // whether it is truly the last turn. React state captured when the turn
+    // started would still say "empty" after the operator queued a follow-up.
+    const queuedRef = useRef([]);
+    /**
+     * A failed human turn owns the decision to hold work composed before its
+     * failure became visible. A ref is the admission gate; state is its rendered
+     * explanation.
+     */
+    const [queuePause, setQueuePauseState] = useState(null);
+    const queuePauseRef = useRef(null);
+    const setQueuePause = useCallback((next) => {
+        queuePauseRef.current = next;
+        setQueuePauseState(next);
+    }, []);
+    /**
+     * Advanced by an explicit, model-bound human continuation. The counter also
+     * covers the interval after an error row is painted but before the failed
+     * iterator's `finally` runs, where a boolean pause has not been installed yet.
+     */
+    const queueContinuationEpochRef = useRef(0);
+    const advanceQueueContinuation = useCallback(() => {
+        queueContinuationEpochRef.current += 1;
+        setQueuePause(null);
+    }, [setQueuePause]);
+    const replaceQueued = useCallback((next) => {
+        queuedRef.current = next;
+        setQueued(next);
+    }, []);
+    const discardQueued = useCallback(() => {
+        replaceQueued([]);
+        setQueuePause(null);
+    }, [replaceQueued, setQueuePause]);
+    const enqueueQueued = useCallback((prompt) => replaceQueued([...queuedRef.current, prompt]), [replaceQueued]);
+    const dequeueQueued = useCallback(() => {
+        const [next, ...rest] = queuedRef.current;
+        if (next !== undefined)
+            replaceQueued(rest);
+        return next;
+    }, [replaceQueued]);
+    /** Manual compaction owns the conversation snapshot until its durable write lands. */
+    const compactingRef = useRef(false);
+    const [compacting, setCompacting] = useState(false);
     const [resumeList, setResumeList] = useState([]);
     const [selectedResume, setSelectedResume] = useState(0);
+    const [editList, setEditList] = useState([]);
+    const [selectedEdit, setSelectedEdit] = useState(0);
+    const editCommittedRef = useRef(false);
+    const [composerDraft, setComposerDraft] = useState(null);
+    const composerDraftTokenRef = useRef(0);
     const exitArmedRef = useRef(false);
     const abortRef = useRef(null);
+    /** Identity of the turn allowed to notify when it settles. */
+    const activeTurnTokenRef = useRef(null);
+    /** A broken terminal notification is reported once, not after every turn. */
+    const notificationFailureShownRef = useRef(false);
     /**
      * The sign-in attempt awaiting its authorization code, if any.
      *
@@ -129,7 +328,15 @@ export function App({ ctx }) {
      * which the code that comes back cannot be exchanged for anything.
      */
     const loginRef = useRef(null);
+    const loginAbortCleanupRef = useRef(null);
+    const cancelPendingLogin = useCallback(() => {
+        loginAbortCleanupRef.current?.();
+        loginAbortCleanupRef.current = null;
+        loginRef.current?.cancel();
+        loginRef.current = null;
+    }, []);
     const runProbeRef = useRef(null);
+    useEffect(() => cancelPendingLogin, [cancelPendingLogin]);
     /**
      * The session currently holding resources, so a re-hydration can release the
      * one it replaces. A `/model` switch builds a new session, and a tool
@@ -166,6 +373,21 @@ export function App({ ctx }) {
     // turns attribute to the resumed conversation.
     const sessionsRef = useRef(null);
     const scopeRef = useRef(null);
+    /** Durable active state is not permission to spend turns after a restart. */
+    const [goalActivation] = useState(() => new SessionGoalActivation());
+    const goalDriveInFlightRef = useRef(false);
+    const [goalDriveVersion, setGoalDriveVersion] = useState(0);
+    const wakeGoalDriver = useCallback(() => setGoalDriveVersion((version) => version + 1), []);
+    /**
+     * Conversation writes in the order the operator produced them.
+     *
+     * A turn becomes idle before its best-effort disk append necessarily lands,
+     * so `/compact` can otherwise append a replacement first and let that older
+     * turn arrive after it. The projection then contains the compacted turn twice.
+     * This tail never rejects — each write reports its own failure — which makes
+     * it safe for the next write and manual compaction to await.
+     */
+    const persistenceTailRef = useRef(Promise.resolve());
     /**
      * How many times the operator has switched conversations.
      *
@@ -175,11 +397,41 @@ export function App({ ctx }) {
      * are late: a turn captures the value at send time and renders nothing once
      * it stops matching.
      *
-     * Bumped ONLY by `resumeConversation`. `/clear` resets the transcript too and
-     * stays in the same conversation — its turn's rows are still that
-     * conversation's rows and must keep arriving.
+     * Bumped by every operation that changes the active conversation: resume,
+     * fork/edit, `/clear`, and `/new`. `/clear-screen` only remounts the view and
+     * deliberately leaves this value alone.
      */
     const conversationGenRef = useRef(0);
+    /**
+     * Turns whose `finally` blocks have not yet attached their durable write.
+     *
+     * `interruptTurn()` deliberately hands the screen back immediately, while the
+     * provider iterator may take longer to unwind. During that interval `idle`
+     * is a UI fact, not a history barrier: awaiting `persistenceTailRef.current`
+     * would await the OLD tail because this turn has not appended to it yet.
+     *
+     * Values are conversation generations so `/resume` can leave an old turn
+     * unwinding without blocking history operations in the conversation now on
+     * screen. Within one generation, a history snapshot is safe only when no
+     * entry remains; at that point every turn has either attached its write to
+     * the persistence tail or established that there is nowhere to write it.
+     */
+    const unsettledTurnGenerationsRef = useRef(new Map());
+    const hasUnsettledTurn = useCallback((generation = conversationGenRef.current) => [...unsettledTurnGenerationsRef.current.values()].some((g) => g === generation), []);
+    /**
+     * Serializes operations that replace or fork the active history.
+     *
+     * The ref closes the same-tick window before React can repaint the disabled
+     * composer; state is only the rendered half. The queue pump reads the ref too,
+     * so a turn cannot start while `/fork` is waiting for an already-attached disk
+     * write to land.
+     */
+    const conversationMutationRef = useRef(null);
+    const [conversationMutation, setConversationMutation] = useState(null);
+    /** Closes the same-tick input window while a verified export reads disk. */
+    const exportingRef = useRef(false);
+    /** A goal mutation is ordered before any later conversation command. */
+    const goalCommandInFlightRef = useRef(false);
     /**
      * Whether a conversation has been chosen and is still being read.
      *
@@ -194,7 +446,8 @@ export function App({ ctx }) {
         return `m${idRef.current}`;
     }, []);
     // Reset the transcript view: clear the terminal + remount <Static> so its
-    // already-printed lines don't linger above fresh content (/clear, /resume).
+    // already-printed lines don't linger above fresh content (/clear,
+    // /clear-screen, /resume).
     //
     // The block numbering resets with it and needs no separate step: the numbers
     // live on the rows, so emptying `messages` takes them with it. A number that
@@ -202,14 +455,14 @@ export function App({ ctx }) {
     // can no longer see anywhere, which is the failure this surface is being
     // cleaned of, one layer up.
     const resetTranscript = useCallback(() => {
-        if (process.stdout.isTTY)
-            process.stdout.write('\x1b[2J\x1b[3J\x1b[H');
+        if (stdout.isTTY)
+            writeStdout('\x1b[2J\x1b[3J\x1b[H');
         // The scrollback floor goes with the log it counted. <Static> is remounted
         // by the key below and has emitted nothing again; a floor that survived
         // would keep the next conversation's rows out of the live window.
         settledRef.current = 0;
         setResetKey((k) => k + 1);
-    }, []);
+    }, [stdout.isTTY, writeStdout]);
     const pushMessage = useCallback((role, content, pending = false, glyph, detail, glyphColor, meta) => {
         const id = nextId();
         setMessages((prev) => [
@@ -234,12 +487,25 @@ export function App({ ctx }) {
                 // Derived from `prev` rather than a counter, so the number is a
                 // fact about the transcript rather than a second record of it.
                 ...(willCollapse(detail)
-                    ? { detailRef: prev.filter((m) => m.detailRef !== undefined).length + 1 }
+                    ? {
+                        detailRef: prev.filter((m) => m.detailRef !== undefined).length + 1,
+                    }
                     : {}),
             },
         ]);
         return id;
     }, [nextId]);
+    const sendTerminalNotification = useCallback((notification) => {
+        if (!terminalNotificationEnabled(ctx.tui?.notifications, notification))
+            return;
+        const result = writeTerminalNotification(notification, ctx.tui?.notificationMethod ?? 'osc9', { isTTY: stdout.isTTY, write: writeStdout });
+        if (result.kind === 'request-sent' || notificationFailureShownRef.current)
+            return;
+        notificationFailureShownRef.current = true;
+        pushMessage('system', result.kind === 'unavailable'
+            ? `Terminal notifications are configured but unavailable — ${result.detail}. No further notification failures will be shown.`
+            : `Could not send a terminal notification request: ${result.detail}. No further notification failures will be shown.`);
+    }, [ctx.tui, pushMessage, stdout.isTTY, writeStdout]);
     const appendToMessage = useCallback((id, delta) => {
         setMessages((prev) => prev.map((m) => (m.id === id ? { ...m, content: m.content + delta } : m)));
     }, []);
@@ -269,7 +535,7 @@ export function App({ ctx }) {
         if (scopeRef.current)
             return scopeRef.current;
         try {
-            const sessions = await openSessions(ctx.cwd);
+            const sessions = await openSessions(ctxRef.current.cwd);
             const sessionId = await startConversation(sessions);
             sessionsRef.current = sessions;
             scopeRef.current = {
@@ -283,16 +549,44 @@ export function App({ ctx }) {
         catch {
             return undefined;
         }
-    }, [ctx.cwd]);
-    const hydrateSession = useCallback(async (prefs, detectedNow) => {
+    }, []);
+    const hydrateSession = useCallback(async (prefs, detectedNow, signal) => {
+        if (signal?.aborted)
+            return;
         const scope = await ensureSessions();
+        if (signal?.aborted)
+            return;
+        const activeCtx = ctxRef.current;
         const s = await createAgentSession(prefs, detectedNow, {
             scope,
-            cwd: ctx.cwd,
-            rules: ctx.rules,
-            ...(ctx.mcpServers ? { mcpServers: ctx.mcpServers } : {}),
-            ...(ctx.sandbox ? { sandbox: ctx.sandbox } : {}),
+            cwd: activeCtx.cwd,
+            rules: activeCtx.rules,
+            ...(sessionsRef.current ? { sessionGoals: sessionsRef.current.goals } : {}),
+            ...(activeCtx.mcpServers ? { mcpServers: activeCtx.mcpServers } : {}),
+            ...(activeCtx.plugins ? { plugins: activeCtx.plugins } : {}),
+            ...(activeCtx.sandbox ? { sandbox: activeCtx.sandbox } : {}),
         });
+        if (signal?.aborted) {
+            void s.close();
+            return;
+        }
+        if (signal !== undefined && !s.hasProvider) {
+            const reason = s.errorHint ?? 'The selected provider could not start.';
+            try {
+                await s.close();
+            }
+            catch {
+                // The construction refusal is the actionable cause. A failed cleanup
+                // must not turn it into a commit of this unusable candidate.
+            }
+            throw new Error(reason);
+        }
+        // A picker-owned provider/model change is one state transition. Clear the
+        // old model's effort selection before publishing the replacement session
+        // or releasing any paused queue. Failed and superseded candidates returned
+        // above, so they leave the current session selection untouched.
+        if (signal !== undefined)
+            setReasoningEffort(undefined);
         // Re-hydration (a provider switch via /model) builds a second session;
         // without this the first one's tool-server child processes stay alive
         // for the rest of the TUI's life.
@@ -300,13 +594,18 @@ export function App({ ctx }) {
         previousSessionRef.current = s;
         setSession(s);
         setUserCommands(discoverUserCommands({
-            cwd: ctx.cwd,
+            cwd: activeCtx.cwd,
             // Builtins are reserved: a `help.md` must not take over `/help`.
             // Passing the names here is what lets the loader tell its author
             // the file is shadowed instead of leaving it silently unused.
             reserved: hostCommandNames(),
         }));
         setCurrentProvider(primaryProvider(prefs).id);
+        // A picker-owned, usable provider switch is an explicit recovery from a
+        // paused failed turn. Failed and superseded candidates return above and
+        // therefore cannot release its dependent queue.
+        if (signal !== undefined)
+            advanceQueueContinuation();
         if (s.hasProvider) {
             setPhase('ready');
             pushMessage('system', 
@@ -328,10 +627,10 @@ export function App({ ctx }) {
             // they forgot about is exactly the thing that makes the agent
             // behave oddly for no visible reason.
             if (s.instructionFiles.length > 0) {
-                pushMessage('system', `Project instructions: ${s.instructionFiles.map((p) => relative(ctx.cwd, p) || p).join(', ')}`);
+                pushMessage('system', `Project instructions: ${s.instructionFiles.map((p) => relative(activeCtx.cwd, p) || p).join(', ')}`);
             }
             for (const skip of s.skippedInstructionFiles) {
-                pushMessage('system', `Skipped ${relative(ctx.cwd, skip.path) || skip.path}: ${skip.reason}`);
+                pushMessage('system', `Skipped ${relative(activeCtx.cwd, skip.path) || skip.path}: ${skip.reason}`);
             }
             for (const server of s.mcpConnected) {
                 pushMessage('system', `Tool server ${server.name} · ${server.toolCount} tools`);
@@ -348,7 +647,7 @@ export function App({ ctx }) {
             if (s.errorHint)
                 pushMessage('system', s.errorHint);
         }
-    }, [ctx.cwd, ctx.rules, pushMessage]);
+    }, [advanceQueueContinuation, ensureSessions, pushMessage, setReasoningEffort]);
     /**
      * Sign in to a subscription without leaving namzu.
      *
@@ -379,13 +678,14 @@ export function App({ ctx }) {
             const outcome = await pending.completeWithPastedCode(pasted);
             pending.cancel();
             loginRef.current = null;
+            loginAbortCleanupRef.current?.();
+            loginAbortCleanupRef.current = null;
             pushMessage('system', describeLoginOutcome(outcome));
             if (outcome.ok)
                 await runProbeRef.current?.();
             return;
         }
-        loginRef.current?.cancel();
-        loginRef.current = null;
+        cancelPendingLogin();
         let start;
         try {
             start = await beginSubscriptionLogin();
@@ -410,6 +710,8 @@ export function App({ ctx }) {
         if (loginRef.current !== start)
             return; // superseded, or finished by paste
         loginRef.current = null;
+        loginAbortCleanupRef.current?.();
+        loginAbortCleanupRef.current = null;
         start.cancel();
         // A cancelled listener resolves to a refusal, and saying "sign-in
         // failed" when the operator finished it another way would be a lie
@@ -419,7 +721,7 @@ export function App({ ctx }) {
         pushMessage('system', describeLoginOutcome(outcome));
         if (outcome.ok)
             await runProbeRef.current?.();
-    }, [pushMessage]);
+    }, [cancelPendingLogin, pushMessage]);
     /**
      * Sign in from the PICKER, where the transcript does not exist.
      *
@@ -435,18 +737,39 @@ export function App({ ctx }) {
      * no-browser case is handed to `namzu login`, which reads the pasted
      * address from standard input and exists for exactly that machine.
      */
-    const startLoginFromPicker = useCallback(async () => {
-        loginRef.current?.cancel();
-        loginRef.current = null;
+    const startLoginFromPicker = useCallback(async (signal) => {
+        if (signal.aborted)
+            return;
+        cancelPendingLogin();
         let start;
         try {
-            start = await beginSubscriptionLogin();
+            start = await beginSubscriptionLogin({ signal });
         }
         catch (err) {
+            if (signal.aborted)
+                return;
             setPickerNotice(`Could not start a sign-in: ${err instanceof Error ? err.message : String(err)}`);
             return;
         }
+        if (signal.aborted) {
+            start.cancel();
+            return;
+        }
         loginRef.current = start;
+        const cancelForPicker = () => {
+            if (loginRef.current === start)
+                loginRef.current = null;
+            if (loginAbortCleanupRef.current === cleanup)
+                loginAbortCleanupRef.current = null;
+            start.cancel();
+        };
+        const cleanup = () => signal.removeEventListener('abort', cancelForPicker);
+        loginAbortCleanupRef.current = cleanup;
+        signal.addEventListener('abort', cancelForPicker, { once: true });
+        if (signal.aborted) {
+            cancelForPicker();
+            return;
+        }
         setPickerNotice(describeLoginStart({
             url: start.url,
             loopback: start.loopback,
@@ -461,19 +784,25 @@ export function App({ ctx }) {
         if (!waiting)
             return;
         const outcome = await waiting;
-        if (loginRef.current !== start)
+        if (loginRef.current !== start || signal.aborted)
             return;
         loginRef.current = null;
+        cleanup();
+        loginAbortCleanupRef.current = null;
         start.cancel();
         if (!outcome.ok && outcome.reason.includes('cancelled'))
             return;
         setPickerNotice(describeLoginOutcome(outcome));
         if (outcome.ok)
-            await runProbeRef.current?.();
-    }, []);
-    const runProbe = useCallback(async () => {
+            await runProbeRef.current?.(signal);
+    }, [cancelPendingLogin]);
+    const runProbe = useCallback(async (signal) => {
         try {
+            if (signal?.aborted)
+                return;
             const probe = await probeAgentSession();
+            if (signal?.aborted)
+                return;
             setDetected(probe.detected);
             if (probe.needsRepickReason) {
                 pushMessage('system', probe.needsRepickReason);
@@ -499,12 +828,14 @@ export function App({ ctx }) {
                 return;
             }
             if (probe.preferences) {
-                await hydrateSession(probe.preferences, probe.detected);
+                await hydrateSession(probe.preferences, probe.detected, signal);
                 return;
             }
             setPhase('picker');
         }
         catch (err) {
+            if (signal?.aborted)
+                return;
             setPhase('unhealthy');
             pushMessage('system', `Failed to probe agents: ${err instanceof Error ? err.message : String(err)}`);
         }
@@ -515,13 +846,20 @@ export function App({ ctx }) {
     runProbeRef.current = runProbe;
     // Trust gate runs first: don't touch the folder until the user trusts it.
     useEffect(() => {
-        if (isTrusted(ctx.cwd)) {
-            void runProbe();
+        if (isTrusted(trustedCwdRef.current)) {
+            try {
+                activateTrustedProject();
+                void runProbe();
+            }
+            catch (err) {
+                setPhase('unhealthy');
+                pushMessage('system', `Could not activate project config: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
         else {
             setPhase('trust');
         }
-    }, [ctx.cwd, runProbe]);
+    }, [activateTrustedProject, pushMessage, runProbe]);
     // Starts the settle window when the gate is on screen, and clears it when it
     // leaves so a later stray key can never be measured against a stale one.
     useEffect(() => {
@@ -529,14 +867,21 @@ export function App({ ctx }) {
     }, [phase]);
     const acceptTrust = useCallback(() => {
         try {
-            trustDir(ctx.cwd);
+            trustDir(trustedCwdRef.current);
         }
         catch {
             // Non-fatal: proceed for this session even if persisting failed.
         }
         setPhase('probing');
-        void runProbe();
-    }, [ctx.cwd, runProbe]);
+        try {
+            activateTrustedProject();
+            void runProbe();
+        }
+        catch (err) {
+            setPhase('unhealthy');
+            pushMessage('system', `Could not activate project config: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, [activateTrustedProject, pushMessage, runProbe]);
     const finalized = messages.filter((m) => !m.pending);
     // How much of the transcript is still redrawable. Computed here rather than
     // inside <Transcript> because the same split decides what the bottom spacer
@@ -554,6 +899,7 @@ export function App({ ctx }) {
         columns: process.stdout.columns,
         furnitureRows: LIVE_FURNITURE_ROWS,
         settled: settledRef.current,
+        raw: rawOutput,
     });
     settledRef.current = window.settled;
     // Blank rows above the composer, while the transcript is short enough that
@@ -564,7 +910,7 @@ export function App({ ctx }) {
         ? bottomSpacerRows({
             rows: process.stdout.rows,
             columns: process.stdout.columns,
-            transcript: transcriptLines(finalized.slice(0, window.settled)),
+            transcript: transcriptLines(finalized.slice(0, window.settled), rawOutput),
             liveRows: LIVE_FURNITURE_ROWS + window.rows,
         })
         : 0;
@@ -580,13 +926,24 @@ export function App({ ctx }) {
         // Called when `/tools` renders, not read here — the same shape, and the
         // same reason, as `neverPrompted` below.
         availableTools: () => session?.toolNames() ?? [],
+        // From the session, not re-resolved: resolving builds a provider, and a
+        // second one would describe a different sandbox than the run is using.
+        sandbox: session?.sandbox ?? null,
+        mcp: session ? { connected: session.mcpConnected, failed: session.mcpFailed } : null,
         providerSummary: session?.providerSummary ?? null,
         modelSummary: session?.modelSummary ?? null,
+        reasoningEffort: {
+            current: () => reasoningEffortRef.current,
+            levels: session?.reasoningEffortLevels,
+        },
         // The same state the status bar reads, unformatted. `/cost` prints exact
         // figures where the bar abbreviates to fit.
         usage,
         permissions: {
-            skipPermissions: ctx.skipPermissions === true,
+            currentMode: () => ({
+                mode: permissionModeRef.current,
+                source: permissionModeSourceRef.current,
+            }),
             rules: ctx.rules ?? [],
             // Called when `/permissions` renders, not read here.
             //
@@ -604,6 +961,7 @@ export function App({ ctx }) {
         },
         instructionFiles: session?.instructionFiles ?? [],
         userCommands,
+        configDebug: ctx.configDebug ?? null,
     };
     // `/resume`: open the picker with this folder's recent conversations.
     const doResume = useCallback(async () => {
@@ -663,14 +1021,19 @@ export function App({ ctx }) {
         if (!ac)
             return false;
         ac.abort();
+        const activeSessionId = scopeRef.current?.sessionId;
+        if (activeSessionId)
+            goalActivation.disarm(activeSessionId);
+        wakeGoalDriver();
+        activeTurnTokenRef.current = null;
         // Dropped now so a second interrupt does not re-abort, and the queue with
         // it: interrupting means stop, not "run the next one".
         abortRef.current = null;
-        setQueued([]);
+        discardQueued();
         clearActiveTools();
         setState('idle');
         return true;
-    }, [clearActiveTools, resolvePermission]);
+    }, [clearActiveTools, discardQueued, goalActivation, resolvePermission, wakeGoalDriver]);
     /**
      * Load the chosen conversation into the transcript and continue in it.
      *
@@ -733,19 +1096,30 @@ export function App({ ctx }) {
         }
         resumeCommittedRef.current = false;
         setPhase('ready');
-        const restored = msgs
-            .filter((m) => m.role === 'user' || m.role === 'assistant')
-            .map((m) => ({
-            id: nextId(),
-            role: m.role,
-            content: typeof m.content === 'string' ? m.content : '',
-        }));
+        const restored = projectConversation(msgs, nextId);
+        // A queue can outlive its turn by one render: the turn has set idle and
+        // cleared `abortRef`, while the passive queue pump is paused behind this
+        // picker. `interruptTurn` correctly reports no RUNNING turn then, but an
+        // early return from it must not make those old prompts cross the switch.
+        const discardedQueued = queuedRef.current.length;
         const interrupted = interruptTurn();
+        discardQueued();
+        goalActivation.clear();
+        wakeGoalDriver();
         conversationGenRef.current += 1;
+        activeTurnTokenRef.current = null;
         resetTranscript();
         setMessages(restored);
+        modelHistoryRef.current = msgs;
+        const persistedOutput = latestAssistantOutput(msgs);
+        lastCompletedOutputRef.current = persistedOutput
+            ? { text: persistedOutput, provenance: 'persisted' }
+            : null;
         scope.sessionId = conv.id; // new turns now attribute to the resumed session
         pushMessage('system', `Resumed: ${conv.title}`);
+        if (discardedQueued > 0) {
+            pushMessage('system', `Discarded ${discardedQueued} queued prompt${discardedQueued === 1 ? '' : 's'} from the conversation you left.`);
+        }
         if (interrupted) {
             // "is being saved", not "is saved". The write has not happened yet —
             // it runs when the abandoned turn finishes unwinding, which is after
@@ -754,7 +1128,268 @@ export function App({ ctx }) {
             // the turn says so itself, in the same words `run-stream` uses.
             pushMessage('system', 'The turn that was running was interrupted. Its reply so far is being saved to the conversation it started in, so it is not in the transcript above. A tool call already dispatched was not undone.');
         }
-    }, [interruptTurn, nextId, pushMessage, resetTranscript]);
+    }, [
+        discardQueued,
+        goalActivation,
+        interruptTurn,
+        nextId,
+        pushMessage,
+        resetTranscript,
+        wakeGoalDriver,
+    ]);
+    /**
+     * Start a new conversation without deleting the one being left.
+     *
+     * The durable target is created first. `startConversation` can fail, and an
+     * operator who asked for a new chat must not lose a running turn merely
+     * because its empty successor could not be published. Once it exists, moving
+     * the shared scope and advancing the generation are one synchronous boundary:
+     * old events can still unwind and persist to their captured destination, but
+     * they cannot render into or start an SDK run under the new conversation.
+     *
+     * A process whose initial persistence setup failed has no shared scope to
+     * move. It still gets an honest in-memory context reset; the notice names that
+     * it is not resumable instead of claiming a durable chat was created.
+     */
+    const startFreshConversation = useCallback(async (clearScreen) => {
+        if (conversationMutationRef.current)
+            return;
+        conversationMutationRef.current = 'new';
+        setConversationMutation('new');
+        const sourceScope = scopeRef.current;
+        const sessions = sessionsRef.current;
+        let targetSessionId = null;
+        try {
+            if (sourceScope) {
+                if (!sessions)
+                    throw new Error('the active conversation store is unavailable');
+                // Publish the recoverable destination before interrupting or clearing
+                // anything in the source conversation.
+                targetSessionId = await startConversation(sessions);
+            }
+            const discardedQueued = queuedRef.current.length;
+            const interrupted = interruptTurn();
+            discardQueued();
+            goalActivation.clear();
+            wakeGoalDriver();
+            conversationGenRef.current += 1;
+            activeTurnTokenRef.current = null;
+            modelHistoryRef.current = [];
+            lastAssistantMessage.current = null;
+            lastCompletedOutputRef.current = null;
+            setContext(null);
+            if (sourceScope && targetSessionId)
+                sourceScope.sessionId = targetSessionId;
+            if (clearScreen) {
+                setMessages([]);
+                resetTranscript();
+            }
+            pushMessage('system', sourceScope && targetSessionId
+                ? `Started a fresh conversation. The previous conversation is unchanged and remains in /resume.${clearScreen
+                    ? ''
+                    : " Earlier rows above are display only and are not part of this conversation's model context."}`
+                : `Started a fresh in-memory conversation because durable session persistence is unavailable.${clearScreen
+                    ? ''
+                    : " Earlier rows above are display only and are not part of this conversation's model context."}`);
+            if (discardedQueued > 0) {
+                pushMessage('system', `Discarded ${discardedQueued} queued prompt${discardedQueued === 1 ? '' : 's'} from the conversation you left.`);
+            }
+            if (interrupted) {
+                pushMessage('system', 'The turn that was running was interrupted. Its reply so far is being saved to the conversation it started in; a tool call already dispatched was not undone.');
+            }
+        }
+        catch (err) {
+            pushMessage('system', `Could not start a fresh conversation: ${err instanceof Error ? err.message : String(err)}. The current conversation and any running turn are unchanged.`);
+        }
+        finally {
+            conversationMutationRef.current = null;
+            setConversationMutation(null);
+        }
+    }, [discardQueued, goalActivation, interruptTurn, pushMessage, resetTranscript, wakeGoalDriver]);
+    /**
+     * `/title`: read or set the name this conversation appears under.
+     *
+     * A bare `/title` asks rather than clears. Erasing a name by pressing
+     * enter on a half-typed command is the kind of loss nobody notices until
+     * `/resume` is a list of opening messages again.
+     */
+    const doTitle = useCallback(async (title, clear) => {
+        const sessions = sessionsRef.current ?? (await ensureSessions(), sessionsRef.current);
+        const scope = scopeRef.current;
+        if (!sessions || !scope) {
+            pushMessage('system', 'Conversation history is unavailable in this folder.');
+            return;
+        }
+        try {
+            if (!clear && title === '') {
+                const current = titleOf(sessions, scope.sessionId);
+                pushMessage('system', current !== undefined
+                    ? `This conversation is named "${current}". /title <name> renames it; /title clear removes the name.`
+                    : 'This conversation has no name, so /resume lists it by its opening message — which stops describing it as the conversation moves on. /title <name> fixes that.');
+                return;
+            }
+            setTitle(sessions, scope.sessionId, clear ? '' : title);
+            pushMessage('system', clear
+                ? 'Name removed. /resume will list this conversation by its opening message again.'
+                : `Named "${title}".`);
+        }
+        catch (err) {
+            pushMessage('system', `Could not save the name: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, [ensureSessions, pushMessage]);
+    /**
+     * `/fork`: continue in a copy, leaving this conversation where it is.
+     *
+     * Refused while a turn is running or still unwinding, rather than interrupted
+     * like `/resume` does. The two look similar and are not: `/resume` LEAVES a
+     * conversation, so an interrupted reply landing in the one being left is
+     * where it belongs. A fork stays here — the reply would land in the original,
+     * the screen would go on showing it, and the copy would be missing the last
+     * thing the operator watched arrive.
+     */
+    const doFork = useCallback(async () => {
+        if (conversationMutationRef.current)
+            return;
+        if (abortRef.current) {
+            pushMessage('system', 'A turn is still running. Forking now would copy a conversation whose last reply is not in it yet — press esc to stop it, then fork.');
+            return;
+        }
+        if (hasUnsettledTurn()) {
+            pushMessage('system', 'A turn is still settling after it was interrupted. Wait for its partial reply to be saved before forking.');
+            return;
+        }
+        if (queuedRef.current.length > 0) {
+            pushMessage('system', 'Queued prompts have not run yet. Wait for them to finish before forking.');
+            return;
+        }
+        conversationMutationRef.current = 'fork';
+        setConversationMutation('fork');
+        try {
+            const sessions = sessionsRef.current ?? (await ensureSessions(), sessionsRef.current);
+            const scope = scopeRef.current;
+            if (!sessions || !scope) {
+                pushMessage('system', 'Conversation history is unavailable in this folder.');
+                return;
+            }
+            // The settlement guard above establishes that no current-generation
+            // turn can attach another write after this read. The remaining tail may
+            // still be writing, so the fork waits for that exact durable snapshot.
+            await persistenceTailRef.current;
+            const original = scope.sessionId;
+            const forked = await forkConversation(sessions, original);
+            // The transcript on screen is already the fork's history, so nothing
+            // is reloaded or reset. Only where the NEXT turn is written changes.
+            scope.sessionId = forked.id;
+            goalActivation.clear();
+            wakeGoalDriver();
+            pushMessage('system', `Forked into "${forked.title}" — ${forked.copied} message(s) copied. This screen continues in the copy; ${original} is unchanged and still in /resume.`);
+        }
+        catch (err) {
+            pushMessage('system', `Could not fork: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            conversationMutationRef.current = null;
+            setConversationMutation(null);
+        }
+    }, [ensureSessions, goalActivation, hasUnsettledTurn, pushMessage, wakeGoalDriver]);
+    /** Open the durable prompt picker after the composer's second empty Esc. */
+    const openPromptEditor = useCallback(() => {
+        if (conversationMutationRef.current || compactingRef.current)
+            return;
+        if (abortRef.current || state !== 'idle' || hasUnsettledTurn()) {
+            pushMessage('system', 'A turn is still running or settling. Wait for its reply to be saved before editing earlier history.');
+            return;
+        }
+        if (queuedRef.current.length > 0) {
+            pushMessage('system', 'Queued prompts must finish before an earlier prompt can be edited.');
+            return;
+        }
+        const candidates = editablePrompts(modelHistoryRef.current, messages);
+        if (candidates.length === 0) {
+            pushMessage('system', 'No previous message to edit.');
+            return;
+        }
+        setEditList(candidates);
+        setSelectedEdit(candidates.length - 1);
+        editCommittedRef.current = false;
+        setPhase('edit');
+    }, [hasUnsettledTurn, messages, pushMessage, state]);
+    /** Fork before the selected prompt, then reopen that prompt in the composer. */
+    const confirmPromptEdit = useCallback(async (target) => {
+        if (editCommittedRef.current || conversationMutationRef.current)
+            return;
+        if (hasUnsettledTurn() || queuedRef.current.length > 0) {
+            setPhase('ready');
+            pushMessage('system', 'Conversation history changed while the prompt picker was open. Nothing was forked; open it again.');
+            return;
+        }
+        editCommittedRef.current = true;
+        conversationMutationRef.current = 'edit';
+        setConversationMutation('edit');
+        const generation = conversationGenRef.current;
+        try {
+            const sessions = sessionsRef.current ?? (await ensureSessions(), sessionsRef.current);
+            const scope = scopeRef.current;
+            if (!sessions || !scope) {
+                setPhase('ready');
+                pushMessage('system', 'Conversation history is unavailable in this folder.');
+                return;
+            }
+            const source = scope.sessionId;
+            await persistenceTailRef.current;
+            if (conversationGenRef.current !== generation ||
+                scope.sessionId !== source ||
+                hasUnsettledTurn(generation)) {
+                throw new Error('the active conversation changed before the branch could be created');
+            }
+            const forked = await forkConversationBeforeUser(sessions, source, target.userOrdinal, target.message);
+            const readablePrefix = editList
+                .slice(0, target.userOrdinal)
+                .map((prompt) => prompt.displayText);
+            conversationGenRef.current += 1;
+            activeTurnTokenRef.current = null;
+            goalActivation.clear();
+            wakeGoalDriver();
+            scope.sessionId = forked.id;
+            modelHistoryRef.current = forked.messages;
+            lastAssistantMessage.current = null;
+            const persistedOutput = latestAssistantOutput(forked.messages);
+            lastCompletedOutputRef.current = persistedOutput
+                ? { text: persistedOutput, provenance: 'persisted' }
+                : null;
+            resetTranscript();
+            setMessages(projectConversation(forked.messages, nextId, readablePrefix));
+            composerDraftTokenRef.current += 1;
+            setComposerDraft({
+                token: composerDraftTokenRef.current,
+                text: target.displayText,
+                ...(forked.selected.attachments && forked.selected.attachments.length > 0
+                    ? { attachments: [...forked.selected.attachments] }
+                    : {}),
+            });
+            setEditList([]);
+            setPhase('ready');
+            pushMessage('system', `Forked into "${forked.title}" before the selected prompt. Edit it below; ${source} is unchanged and remains in /resume.`);
+        }
+        catch (err) {
+            setPhase('ready');
+            pushMessage('system', `Could not edit the selected prompt: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            editCommittedRef.current = false;
+            conversationMutationRef.current = null;
+            setConversationMutation(null);
+        }
+    }, [
+        editList,
+        ensureSessions,
+        goalActivation,
+        hasUnsettledTurn,
+        nextId,
+        pushMessage,
+        resetTranscript,
+        wakeGoalDriver,
+    ]);
     // Bridge passed into session.send(): the agent calls this before a
     // non-read-only tool batch; it parks until the user presses y/n/a.
     const onPermission = useCallback((req) => new Promise((resolve) => {
@@ -762,7 +1397,8 @@ export function App({ ctx }) {
         permissionOpenedAtRef.current = Date.now();
         setPermission(req);
         setState('awaiting-permission');
-    }), []);
+        sendTerminalNotification({ kind: 'approval-required' });
+    }), [sendTerminalNotification]);
     // Render one agent event onto the transcript. Shared by the local turn loop
     // and the daemon-attach poller, so both paths produce identical output.
     // `st` carries the streaming-assistant bubble id + accumulated text across
@@ -787,7 +1423,10 @@ export function App({ ctx }) {
             case 'delta': {
                 setState('thinking');
                 if (event.messageId && event.runId) {
-                    lastAssistantMessage.current = { runId: event.runId, messageId: event.messageId };
+                    lastAssistantMessage.current = {
+                        runId: event.runId,
+                        messageId: event.messageId,
+                    };
                 }
                 st.text += event.text;
                 // Held, not appended. Appending each delta is what produced text
@@ -871,49 +1510,138 @@ export function App({ ctx }) {
                 // not. A swap is a permanent fact about this turn.
                 pushMessage('system', event.text, false, '⇄');
                 break;
+            case 'capability-warning':
+                pushMessage('system', `Capability warning (${event.capability}): ${event.text}`, false, '⚠');
+                break;
+            case 'history-repair':
+                pushMessage('system', `History warning (${event.source}): ${event.text}`, false, '⚠');
+                break;
             case 'done':
+                // `run_completed` is not synonymous with success: budgets,
+                // cancellation and output guardrails arrive through this event too.
+                // Missing remains a normal end for older producers, matching the
+                // headless command's compatibility rule.
+                st.completed = event.stopReason === undefined || event.stopReason === 'end_turn';
+                st.outcome =
+                    event.stopReason === 'cancelled' ? 'cancelled' : st.completed ? 'completed' : 'stopped';
+                st.notification = {
+                    kind: 'turn-settled',
+                    outcome: st.completed ? 'completed' : 'stopped',
+                };
                 closeAssistant();
                 break;
             case 'error':
                 closeAssistant();
-                if (event.message !== 'aborted')
+                st.outcome = event.message === 'aborted' ? 'cancelled' : 'failed';
+                if (event.message !== 'aborted') {
+                    st.notification = { kind: 'turn-settled', outcome: 'failed' };
                     pushMessage('system', `Error: ${event.message}`);
+                }
+                else
+                    st.notification = null;
                 break;
         }
     }, [appendToMessage, finalizeMessage, flushStream, pushMessage]);
-    const runTurn = useCallback(async (text, images) => {
+    const runTurn = useCallback(async (prompt) => {
         if (!session || !session.hasProvider) {
             pushMessage('system', session?.errorHint ?? 'Agent is not ready yet — give it a moment.');
             return;
         }
-        // `@path` mentions: the visible message keeps the readable token, but
-        // the model receives the file contents inlined.
-        const { sendText, attached } = expandFileMentions(text, ctx.cwd);
-        const priorForSdk = messages
-            .filter((m) => (m.role === 'user' || m.role === 'assistant') && !m.pending)
-            .map((m) => ({
-            role: m.role,
-            content: m.content,
-            timestamp: Date.now(),
-        }));
-        priorForSdk.push({
-            role: 'user',
-            content: sendText,
-            timestamp: Date.now(),
-            ...(images && images.length > 0 ? { attachments: images } : {}),
-        });
+        const { text } = prompt;
+        const attachments = prompt.kind === 'human' ? prompt.attachments : undefined;
+        const goalRound = prompt.kind === 'goal' ? prompt.goalRound : undefined;
+        if (prompt.kind === 'goal' &&
+            (prompt.generation !== conversationGenRef.current ||
+                scopeRef.current?.sessionId !== goalRound?.sessionId ||
+                !goalRound ||
+                !goalActivation.isArmed(goalRound.sessionId, goalRound))) {
+            return;
+        }
+        // Reserve the turn synchronously before the first await below. Leaving
+        // state idle while the admission read was pending let a second submit
+        // start beside it and broke the queue's FIFO ownership.
+        setState('thinking');
+        // A conversation can be closed outside this App after it was opened or
+        // resumed. Re-check at the actual turn boundary, before expanding file
+        // mentions, recording run evidence, or creating a provider iterator.
+        // The persistence helpers repeat the same check at their own boundary;
+        // neither read is claimed to serialize a concurrent archive (that needs
+        // a store-level lease shared with ProjectManager).
+        const destination = scopeRef.current?.sessionId ?? null;
+        const turnSessions = sessionsRef.current;
+        if (turnSessions && destination) {
+            try {
+                await requireWritableConversation(turnSessions, destination, 'start conversation turn');
+            }
+            catch (err) {
+                if (prompt.kind === 'goal' && prompt.goalRound) {
+                    goalActivation.disarm(prompt.goalRound.sessionId, prompt.goalRound);
+                    wakeGoalDriver();
+                }
+                pushMessage('system', `This turn was not started: ${err instanceof Error ? err.message : String(err)}`);
+                setState('idle');
+                return;
+            }
+        }
+        // `@path` mentions: the visible human message keeps the readable token,
+        // but the model receives the file contents inlined. An automatic goal
+        // prompt is already host-authored context and is never reinterpreted as
+        // a file-mention command.
+        const expanded = prompt.kind === 'human'
+            ? expandFileMentions(text, ctx.cwd)
+            : { sendText: text, attached: [] };
+        const { sendText, attached } = expanded;
+        const historyBeforeTurn = modelHistoryRef.current;
+        const userMessage = createUserMessage(sendText, attachments, goalRound
+            ? {
+                type: 'goal-round',
+                goalId: goalRound.id,
+                objective: goalRound.objective,
+                goalRevision: goalRound.revision,
+                round: goalRound.round,
+                maxGoalRounds: goalRound.maxGoalRounds,
+            }
+            : undefined);
+        const priorForSdk = [...historyBeforeTurn, userMessage];
+        const runId = generateRunId();
         const metaParts = [];
         if (attached.length > 0)
             metaParts.push(`${attached.length} file${attached.length > 1 ? 's' : ''} attached`);
-        if (images && images.length > 0)
-            metaParts.push(`${images.length} image${images.length > 1 ? 's' : ''}`);
-        pushMessage('user', text, false, undefined, undefined, undefined, metaParts.length > 0 ? metaParts.join(' · ') : undefined);
-        setState('thinking');
+        if (attachments && attachments.length > 0)
+            metaParts.push(`${attachments.length} attachment${attachments.length > 1 ? 's' : ''}`);
+        if (goalRound) {
+            pushMessage('system', `Goal round ${goalRound.round} / ${goalRound.maxGoalRounds}`, false, '◎', [`Objective: ${goalRound.objective}`]);
+        }
+        else {
+            pushMessage('user', text, false, undefined, undefined, undefined, metaParts.length > 0 ? metaParts.join(' · ') : undefined);
+        }
         // The model interleaves text → tool → text across iterations; `applyEvent`
         // renders each one in order.
-        const st = { assistantId: null, text: '', pending: '' };
+        const st = {
+            assistantId: null,
+            text: '',
+            conversationMessages: undefined,
+            pending: '',
+            completed: false,
+            outcome: null,
+            notification: null,
+        };
         const ac = new AbortController();
+        const turnToken = {};
+        let abnormalTerminal;
+        const markHumanAbnormal = () => {
+            if (prompt.kind !== 'human' ||
+                abnormalTerminal !== undefined ||
+                (st.outcome !== 'failed' && st.outcome !== 'stopped'))
+                return;
+            abnormalTerminal = {
+                token: turnToken,
+                continuationEpoch: queueContinuationEpochRef.current,
+                outcome: st.outcome,
+            };
+        };
         abortRef.current = ac;
+        activeTurnTokenRef.current = turnToken;
         // Where this turn will be saved, and which transcript its rows belong
         // to. Both fixed HERE, at the one moment they are knowable.
         //
@@ -924,33 +1652,101 @@ export function App({ ctx }) {
         // conversation happened to be open when it finished, and that record
         // outlives the process. A string captured now cannot be reassigned by
         // anyone.
-        const destination = scopeRef.current?.sessionId ?? null;
         const turnGeneration = conversationGenRef.current;
+        unsettledTurnGenerationsRef.current.set(turnToken, turnGeneration);
         const stillHere = () => conversationGenRef.current === turnGeneration;
+        const turnPermissionMode = permissionModeRef.current;
+        const turnReasoningEffort = reasoningEffortRef.current;
+        // Always carry the guarded callback. `auto` and `strict` decide before
+        // calling it in makeResumeHandler; retaining it is what lets a session
+        // launched with --yolo later return to prompt mode truthfully.
+        const askPermission = (req) => {
+            if (!stillHere() || activeTurnTokenRef.current !== turnToken || ac.signal.aborted) {
+                return Promise.resolve({
+                    kind: 'reject',
+                    feedback: 'Turn is no longer active.',
+                });
+            }
+            return onPermission(req);
+        };
+        let evidenceTurn;
+        let evidenceReady = goalRound === undefined;
+        if (turnSessions?.turnEvidence && destination) {
+            try {
+                evidenceTurn = await turnSessions.turnEvidence.recordTurnStarted({
+                    sessionId: destination,
+                    runId,
+                    displayText: text,
+                    user: userMessage,
+                });
+                evidenceReady = true;
+            }
+            catch (err) {
+                if (goalRound) {
+                    goalActivation.disarm(goalRound.sessionId, goalRound);
+                    wakeGoalDriver();
+                    pushMessage('system', `Goal round ${goalRound.round} was not started because its durable evidence could not be recorded: ${err instanceof Error ? err.message : String(err)}. Automatic continuation is disarmed; /goal resume retries explicitly.`);
+                }
+                else {
+                    pushMessage('system', `Could not record durable evidence for this turn before run ${runId}: ${err instanceof Error ? err.message : String(err)}. The turn will continue, but a complete export of conversation ${destination} will refuse rather than omit it.`);
+                }
+            }
+        }
+        else if (goalRound) {
+            goalActivation.disarm(goalRound.sessionId, goalRound);
+            wakeGoalDriver();
+            pushMessage('system', `Goal round ${goalRound.round} was not started because durable turn evidence is unavailable. Automatic continuation is disarmed; /goal resume retries explicitly.`);
+        }
         try {
-            for await (const event of session.send(priorForSdk, {
-                signal: ac.signal,
-                // Bypass mode (--dangerously-skip-permissions / --yolo): omit the
-                // permission callback so every tool batch auto-approves.
-                onPermission: ctx.skipPermissions ? undefined : onPermission,
-                extraSystem: composeSkillsPrompt(activeSkills) ?? undefined,
-            })) {
-                // A turn the operator has left is consumed but not rendered: no row
-                // from it lands in a transcript it has nothing to do with, and its
-                // text keeps accumulating so that what gets saved does not depend
-                // on exactly when the switch happened.
-                //
-                // How much arrives after the switch is a property of the SESSION,
-                // not of this loop. The built-in one checks the signal at the top of
-                // each iteration and returns after a single `error: aborted`, so in
-                // practice very little does. The accumulation is here so a session
-                // that notices later — a different implementation, a generator
-                // parked in a tool call — still saves a whole reply rather than one
-                // truncated at the moment the operator happened to leave.
-                if (stillHere())
-                    applyEvent(event, st);
-                else if (event.kind === 'delta')
-                    st.text += event.text;
+            // `recordTurnStarted` is an awaited durability boundary. A conversation
+            // switch can happen while it is pending and move the mutable RunScope
+            // captured by `createAgentSession`. Re-admit the turn here, immediately
+            // before the generator exists, or an abandoned prompt can initialize its
+            // reserved SDK run under the new conversation.
+            if (evidenceReady &&
+                !ac.signal.aborted &&
+                stillHere() &&
+                activeTurnTokenRef.current === turnToken &&
+                (!goalRound ||
+                    (destination === goalRound.sessionId &&
+                        goalActivation.isArmed(goalRound.sessionId, goalRound)))) {
+                for await (const event of session.send(priorForSdk, {
+                    signal: ac.signal,
+                    runId,
+                    permissionMode: turnPermissionMode,
+                    ...(turnReasoningEffort !== undefined ? { effort: turnReasoningEffort } : {}),
+                    ...(goalRound ? { goalRound } : {}),
+                    // The mode above decides whether this callback is consulted.
+                    onPermission: askPermission,
+                    extraSystem: composeSkillsPrompt(activeSkills) ?? undefined,
+                    onConversationMessages: (messages) => {
+                        // State-only: opaque reasoning/signatures must reach the next
+                        // provider and durable store without becoming transcript text.
+                        st.conversationMessages = messages;
+                    },
+                })) {
+                    // A turn the operator has left is consumed but not rendered: no row
+                    // from it lands in a transcript it has nothing to do with, and its
+                    // text keeps accumulating so that what gets saved does not depend
+                    // on exactly when the switch happened.
+                    //
+                    // How much arrives after the switch is a property of the SESSION,
+                    // not of this loop. The built-in one checks the signal at the top of
+                    // each iteration and returns after a single `error: aborted`, so in
+                    // practice very little does. The accumulation is here so a session
+                    // that notices later — a different implementation, a generator
+                    // parked in a tool call — still saves a whole reply rather than one
+                    // truncated at the moment the operator happened to leave.
+                    if (stillHere()) {
+                        applyEvent(event, st);
+                        markHumanAbnormal();
+                    }
+                    else if (event.kind === 'delta')
+                        st.text += event.text;
+                }
+            }
+            else {
+                st.outcome = 'cancelled';
             }
         }
         catch (err) {
@@ -959,6 +1755,11 @@ export function App({ ctx }) {
             // the generation exists to stop — and it would be the more confusing
             // half of it, because an abort reads as an error.
             if (stillHere()) {
+                if (!ac.signal.aborted) {
+                    st.outcome = 'failed';
+                    st.notification = { kind: 'turn-settled', outcome: 'failed' };
+                    markHumanAbnormal();
+                }
                 // Flushed first: this path does not go through `applyEvent`, so
                 // without it the partial answer the model had produced before
                 // the failure would be discarded along with the turn.
@@ -969,11 +1770,44 @@ export function App({ ctx }) {
             }
         }
         finally {
+            // Prefer the kernel's settled conversation projection: it retains opaque
+            // reasoning, citations and complete tool turns that the visible delta
+            // stream cannot reconstruct. A fake/legacy session that does not publish
+            // one keeps the old text-only shape. The visible transcript still keeps
+            // the operator's readable `@file` token; both persistence paths keep what
+            // was actually sent, including expanded contents and attachments.
+            const fallbackTurn = goalRound && !evidenceReady ? [] : [userMessage];
+            if (st.text.trim().length > 0)
+                fallbackTurn.push(createAssistantMessage(st.text));
+            const conversationMessages = goalRound && !evidenceReady ? undefined : st.conversationMessages;
+            const publication = conversationMessages
+                ? planTurnPublication(historyBeforeTurn, userMessage, conversationMessages)
+                : { kind: 'append', messages: fallbackTurn };
+            const nextModelHistory = conversationMessages ?? [...historyBeforeTurn, ...fallbackTurn];
+            if (goalRound && (ac.signal.aborted || st.outcome !== 'completed')) {
+                goalActivation.disarm(goalRound.sessionId, goalRound);
+                wakeGoalDriver();
+            }
             // The screen belongs to the conversation on it, which after a
             // `/resume` is no longer this turn's. `interruptTurn` already did this
             // cleanup at the moment it decided to stop; repeating it here would
             // clear the state of whatever has started since.
             if (stillHere()) {
+                const ownsTurn = activeTurnTokenRef.current === turnToken;
+                const shouldPauseQueued = ownsTurn &&
+                    abnormalTerminal?.token === turnToken &&
+                    abnormalTerminal.continuationEpoch === queueContinuationEpochRef.current &&
+                    queuedRef.current.length > 0;
+                if (shouldPauseQueued && abnormalTerminal) {
+                    setQueuePause({ outcome: abnormalTerminal.outcome });
+                }
+                modelHistoryRef.current = nextModelHistory;
+                if (st.completed && st.text.trim().length > 0) {
+                    lastCompletedOutputRef.current = {
+                        text: st.text,
+                        provenance: 'normal-completion',
+                    };
+                }
                 // Unguarded, and it can be: a second turn cannot start in the
                 // conversation this one is running in — the composer queues instead
                 // — so within one generation this handle is still ours. An
@@ -981,11 +1815,20 @@ export function App({ ctx }) {
                 // could not fail, which teaches the next reader that the checks
                 // around it are decoration too.
                 abortRef.current = null;
+                if (ownsTurn)
+                    activeTurnTokenRef.current = null;
                 permissionResolveRef.current = null;
                 permissionOpenedAtRef.current = null;
                 setPermission(null);
                 clearActiveTools();
                 setState('idle');
+                if (ownsTurn &&
+                    !ac.signal.aborted &&
+                    !goalRound &&
+                    st.notification &&
+                    (queuedRef.current.length === 0 || shouldPauseQueued)) {
+                    sendTerminalNotification(st.notification);
+                }
             }
             // Persisted either way, and into the conversation this turn was
             // started in — captured above, never re-read.
@@ -1002,18 +1845,81 @@ export function App({ ctx }) {
             // conversation, because there is no other channel and it is news they
             // need. Naming the conversation is what keeps it from reading as a
             // fault of the one in front of them.
-            const sessions = sessionsRef.current;
-            if (sessions && destination) {
-                const turn = [createUserMessage(text)];
-                if (st.text.trim().length > 0)
-                    turn.push(createAssistantMessage(st.text));
-                void appendMessages(sessions, destination, turn).catch((err) => {
-                    pushMessage('system', `A turn was not saved to conversation ${destination}: ${err instanceof Error ? err.message : String(err)}. That conversation's history will not include it, and its next turn will not have it as context.`);
+            if (turnSessions &&
+                destination &&
+                (publication.kind === 'replace' || publication.messages.length > 0 || evidenceTurn)) {
+                persistenceTailRef.current = persistenceTailRef.current.then(async () => {
+                    if (evidenceTurn && turnSessions.turnEvidence) {
+                        try {
+                            await turnSessions.turnEvidence.recordTurnSettled({
+                                sessionId: destination,
+                                turnId: evidenceTurn.turnId,
+                                runId,
+                                outcome: ac.signal.aborted
+                                    ? 'cancelled'
+                                    : (st.outcome ?? (st.completed ? 'completed' : 'stopped')),
+                                assistantText: st.text,
+                            });
+                        }
+                        catch (err) {
+                            pushMessage('system', `Could not finish the durable evidence for turn ${evidenceTurn.turnId}: ${err instanceof Error ? err.message : String(err)}. A complete export of conversation ${destination} will refuse if the SDK run record cannot prove the missing text.`);
+                        }
+                    }
+                    try {
+                        if (publication.kind === 'replace') {
+                            await replaceConversation(turnSessions, destination, publication.messages);
+                        }
+                        else if (publication.messages.length > 0) {
+                            await appendMessages(turnSessions, destination, publication.messages);
+                        }
+                    }
+                    catch (err) {
+                        if (goalRound) {
+                            goalActivation.disarm(goalRound.sessionId, goalRound);
+                            wakeGoalDriver();
+                        }
+                        pushMessage('system', `A turn was not saved to conversation ${destination}: ${err instanceof Error ? err.message : String(err)}. Its durable history will not include it. It remains only in this process's in-memory context if that conversation is still open; resuming or restarting will lose it.`);
+                    }
                 });
             }
+            // Removed only AFTER the write has been attached to the tail. A history
+            // operation that sees no current-generation entries can now await that
+            // tail without a turn appearing behind its read later.
+            unsettledTurnGenerationsRef.current.delete(turnToken);
+        }
+    }, [
+        activeSkills,
+        applyEvent,
+        clearActiveTools,
+        ctx.cwd,
+        finalizeMessage,
+        flushStream,
+        goalActivation,
+        onPermission,
+        pushMessage,
+        sendTerminalNotification,
+        session,
+        setQueuePause,
+        wakeGoalDriver,
+    ]);
+    const handleSubmit = useCallback((value, attachments) => {
+        if (goalCommandInFlightRef.current) {
+            pushMessage('system', 'A goal command is still reaching durable session state. Wait for its result before sending another command or prompt.');
+            return;
+        }
+        if (exportingRef.current) {
+            pushMessage('system', 'A verified conversation export is still being written. Wait for its result before sending another command or prompt.');
+            return;
+        }
+        if (conversationMutationRef.current) {
+            const operation = conversationMutationRef.current === 'fork'
+                ? 'forked'
+                : conversationMutationRef.current === 'edit'
+                    ? 'branched for prompt editing'
+                    : 'moved to a fresh conversation';
+            pushMessage('system', `Conversation history is being ${operation}. Wait for it to finish before sending another command or prompt.`);
+            return;
         }
-    }, [activeSkills, applyEvent, ctx.cwd, ctx.skipPermissions, finalizeMessage, messages, onPermission, pushMessage, session]);
-    const handleSubmit = useCallback((value, images) => {
         setHistory((prev) => [...prev, value]);
         // What actually gets sent. A `prompt` action replaces it with text the
         // command composed, and then takes the ordinary send path below —
@@ -1026,10 +1932,13 @@ export function App({ ctx }) {
                 case 'message':
                     pushMessage(slash.role, slash.content);
                     return;
-                case 'clear':
+                case 'clear-screen':
                     setMessages([]);
                     resetTranscript();
                     return;
+                case 'new-conversation':
+                    void startFreshConversation(slash.clearScreen);
+                    return;
                 case 'exit':
                     exit();
                     return;
@@ -1041,6 +1950,58 @@ export function App({ ctx }) {
                     setKeyEntryFor(null);
                     setPhase('picker');
                     return;
+                case 'permission-mode': {
+                    if (!session?.hasProvider) {
+                        pushMessage('system', 'No active session — pick a provider before changing permissions.');
+                        return;
+                    }
+                    if (state !== 'idle' ||
+                        abortRef.current !== null ||
+                        hasUnsettledTurn() ||
+                        queuedRef.current.length > 0 ||
+                        permissionResolveRef.current !== null ||
+                        compactingRef.current) {
+                        pushMessage('system', 'Permission mode was not changed: wait for the active turn, prompt, compaction, and queued work to settle.');
+                        return;
+                    }
+                    if (!session.resetApprovalLatch) {
+                        pushMessage('system', 'Permission mode was not changed: this embedded session cannot revoke an earlier "approve all" choice. Reconnect it before changing modes.');
+                        return;
+                    }
+                    session.resetApprovalLatch();
+                    permissionModeRef.current = slash.mode;
+                    permissionModeSourceRef.current = 'session';
+                    setPermissionModeState(slash.mode);
+                    pushMessage('system', `Permission mode changed to ${slash.mode}. Any earlier "approve all" choice was revoked. Declarative deny rules and the built-in safety gate still take precedence.`);
+                    return;
+                }
+                case 'reasoning-effort': {
+                    if (!session?.hasProvider) {
+                        pushMessage('system', 'No active session — pick a provider before changing reasoning effort.');
+                        return;
+                    }
+                    if (state !== 'idle' ||
+                        abortRef.current !== null ||
+                        hasUnsettledTurn() ||
+                        queuedRef.current.length > 0 ||
+                        permissionResolveRef.current !== null ||
+                        compactingRef.current) {
+                        pushMessage('system', 'Reasoning effort was not changed: wait for the active turn, prompt, compaction, and queued work to settle.');
+                        return;
+                    }
+                    if (slash.effort === null) {
+                        setReasoningEffort(undefined);
+                        pushMessage('system', 'Reasoning effort reset to the provider default for future main-query turns.');
+                        return;
+                    }
+                    if (!session.reasoningEffortLevels?.includes(slash.effort)) {
+                        pushMessage('system', `Reasoning effort was not changed: ${slash.effort} is not offered by every usable provider-chain member for this model.`);
+                        return;
+                    }
+                    setReasoningEffort(slash.effort);
+                    pushMessage('system', `Reasoning effort changed to ${slash.effort} for future main-query turns in this session.`);
+                    return;
+                }
                 case 'login':
                     void startOrFinishLogin(slash.pasted);
                     return;
@@ -1114,6 +2075,12 @@ export function App({ ctx }) {
                 case 'resume':
                     void doResume();
                     return;
+                case 'title':
+                    void doTitle(slash.title, slash.clear);
+                    return;
+                case 'fork':
+                    void doFork();
+                    return;
                 case 'expand': {
                     // Resolved INSIDE the updater, against `prev`.
                     //
@@ -1203,13 +2170,48 @@ export function App({ ctx }) {
                     // THIS session can answer from. The descriptors used for
                     // the merge above carry no store — they are names — so the
                     // registry is rebuilt here with the live one.
+                    const durableSessions = sessionsRef.current;
+                    const runScope = scopeRef.current;
+                    const generation = conversationGenRef.current;
+                    const goalCommand = slash.name === 'goal';
+                    if (goalCommand)
+                        goalCommandInFlightRef.current = true;
                     const registry = new HostCommandRegistry();
-                    registry.register(kernelHostCommands({ allowedAgentIds: session?.agentIds ?? [] }));
+                    registry.register(kernelHostCommands({
+                        allowedAgentIds: session?.agentIds ?? [],
+                        ...(durableSessions && runScope
+                            ? {
+                                goal: {
+                                    store: durableSessions.goals,
+                                    sessionId: runScope.sessionId,
+                                    tenantId: durableSessions.tenantId,
+                                    activation: goalActivation,
+                                },
+                            }
+                            : {}),
+                    }));
                     void (async () => {
-                        const outcome = await registry.dispatch(`/${slash.name} ${slash.args.join(' ')}`.trim());
-                        pushMessage('system', outcome
-                            ? renderOutcome(outcome)
-                            : `/${slash.name} is registered but this session cannot run it.`);
+                        try {
+                            const outcome = await registry.dispatch(`/${slash.name} ${slash.args.join(' ')}`.trim());
+                            // A late readout from the conversation just left must not be
+                            // painted as state of the one now on screen.
+                            if (conversationGenRef.current !== generation)
+                                return;
+                            pushMessage('system', outcome
+                                ? renderOutcome(outcome)
+                                : `/${slash.name} is registered but this session cannot run it.`);
+                        }
+                        catch (error) {
+                            if (conversationGenRef.current !== generation)
+                                return;
+                            pushMessage('system', `Could not run /${slash.name}: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                        finally {
+                            if (goalCommand) {
+                                goalCommandInFlightRef.current = false;
+                                wakeGoalDriver();
+                            }
+                        }
                     })();
                     return;
                 }
@@ -1253,6 +2255,211 @@ export function App({ ctx }) {
                     })();
                     return;
                 }
+                case 'review': {
+                    void (async () => {
+                        const diff = await workspaceDiff(ctx.cwd);
+                        if (diff === null) {
+                            pushMessage('system', 'Cannot review here — this is not a git repository, or git is unavailable.');
+                            return;
+                        }
+                        if (diff.stat.length === 0 && diff.untracked.length === 0) {
+                            // Refused rather than sent. A review request over an
+                            // unchanged tree burns a turn and comes back with a
+                            // review of nothing, which reads exactly like a review
+                            // of something.
+                            pushMessage('system', 'Nothing to review — the working tree is clean.');
+                            return;
+                        }
+                        // The same FIFO a typed message enters. A review composed
+                        // while a turn is in flight must not jump the queue, and
+                        // must not be dropped either.
+                        const text = reviewPrompt(diff.stat, diff.untracked);
+                        enqueueQueued({ kind: 'human', text });
+                    })();
+                    return;
+                }
+                case 'diff': {
+                    // Fire-and-forget, like its neighbours: a git invocation is not
+                    // something to block a keystroke on.
+                    void (async () => {
+                        const { summary, detail } = renderWorkspaceDiff(await workspaceDiff(ctx.cwd));
+                        setMessages((prev) => [
+                            ...prev,
+                            {
+                                id: `diff-${Date.now()}`,
+                                role: 'system',
+                                content: summary,
+                                ...(detail.length > 0 ? { detail } : {}),
+                            },
+                        ]);
+                    })();
+                    return;
+                }
+                case 'compact': {
+                    if (!session) {
+                        pushMessage('system', 'No session yet — nothing to compact.');
+                        return;
+                    }
+                    if (abortRef.current || state !== 'idle' || hasUnsettledTurn()) {
+                        pushMessage('system', 'A turn is still running or settling. Compacting now would summarize a conversation while its next message is being written — wait for it to finish, or press esc to stop it and wait for its partial reply to be saved.');
+                        return;
+                    }
+                    if (compactingRef.current)
+                        return;
+                    compactingRef.current = true;
+                    setCompacting(true);
+                    setState('thinking');
+                    // Fire-and-forget, the same shape `feedback` above uses: this
+                    // switch is synchronous while compaction and its optional
+                    // verifier are asynchronous. The transcript reports the outcome.
+                    void (async () => {
+                        try {
+                            // The same lossless record `runTurn` reads — including an earlier
+                            // compaction summary and attachments. The transcript is only its
+                            // rendered view and is never reverse-engineered into history.
+                            const result = await session.compact(modelHistoryRef.current);
+                            if (!result) {
+                                // Not an error, and not silence: a conversation too short
+                                // to shed anything is a real answer to a question the
+                                // operator asked on purpose.
+                                pushMessage('system', 'Nothing to compact yet — this conversation is short enough that adding a summary would save no messages.');
+                                return;
+                            }
+                            // Durable first, screen second. Reporting success and only then
+                            // discovering `/resume` still has the old history is the exact
+                            // false-success state this command used to create.
+                            const sessions = sessionsRef.current;
+                            const destination = scopeRef.current?.sessionId;
+                            if (sessions && destination) {
+                                await persistenceTailRef.current;
+                                await replaceConversation(sessions, destination, result.messages);
+                            }
+                            modelHistoryRef.current = result.messages;
+                            // The old gauge measured the history that was just replaced.
+                            // Clear it only after the durable projection and live model
+                            // history agree; until then the old measurement is still the
+                            // truthful one. The next run publishes a fresh measurement.
+                            setContext(null);
+                            // How many user/assistant turns survived the pass.
+                            // `keepRecentRows` explains why the transcript is trimmed
+                            // to match rather than rebuilt from `result.messages`.
+                            const keptTurns = result.messages.filter((m) => m.role === 'user' || m.role === 'assistant').length;
+                            // The summary belongs before the surviving turns. `<Static>` only
+                            // emits items beyond the index it has already printed, so prepending
+                            // into the mounted transcript makes the summary invisible. Remount
+                            // the projection just as `/resume` does when it replaces the log.
+                            resetTranscript();
+                            setMessages((prev) => {
+                                const summaryRow = {
+                                    id: `compact-${Date.now()}`,
+                                    role: 'system',
+                                    content: `Compacted ${result.shed} earlier message(s) into a summary.${result.usage.totalTokens > 0
+                                        ? ` Verifier used ${result.usage.totalTokens.toLocaleString('en-US')} tokens.`
+                                        : ''}${sessions && destination
+                                        ? ''
+                                        : ' Conversation persistence is unavailable, so this compacted history lasts only for this process.'}`,
+                                    detail: summaryDetail(result.summary),
+                                };
+                                return [summaryRow, ...keepRecentRows(prev, keptTurns)];
+                            });
+                        }
+                        catch (err) {
+                            pushMessage('system', `Compaction failed: ${err instanceof Error ? err.message : String(err)}`);
+                        }
+                        finally {
+                            compactingRef.current = false;
+                            setCompacting(false);
+                            setState('idle');
+                        }
+                    })();
+                    return;
+                }
+                case 'copy': {
+                    const target = lastCompletedOutputRef.current;
+                    if (!target) {
+                        pushMessage('system', 'Nothing to copy yet — /copy applies to the latest assistant answer that finished normally.');
+                        return;
+                    }
+                    const result = writeClipboardText(target.text, {
+                        isTTY: stdout.isTTY,
+                        write: writeStdout,
+                    });
+                    switch (result.kind) {
+                        case 'request-sent':
+                            pushMessage('system', `Copy request sent for the ${target.provenance === 'persisted'
+                                ? 'latest persisted assistant output'
+                                : 'latest normally completed answer'} (${result.bytes.toLocaleString()} bytes). Terminal, multiplexer or remote-session policy may ignore OSC 52; if the clipboard did not change, enable terminal clipboard access.`);
+                            break;
+                        case 'unavailable':
+                            pushMessage('system', `Cannot send a copy request here — ${result.detail}. /copy needs an interactive terminal with OSC 52 clipboard support.`);
+                            break;
+                        case 'too-large':
+                            pushMessage('system', `Cannot send this answer to the terminal clipboard — it is ${result.bytes.toLocaleString()} bytes and the OSC 52 safety limit is ${result.limit.toLocaleString()}. Nothing was truncated.`);
+                            break;
+                        case 'write-failed':
+                            pushMessage('system', `Could not send the terminal copy request: ${result.detail}`);
+                            break;
+                        default: {
+                            const exhaustive = result;
+                            void exhaustive;
+                        }
+                    }
+                    return;
+                }
+                case 'raw': {
+                    const enabled = slash.enabled === 'toggle' ? !rawOutput : slash.enabled;
+                    // Rows already emitted by <Static> cannot observe a new render
+                    // function. Clear the terminal, reset its monotone floor and
+                    // remount the retained rows so this is a transcript-wide mode,
+                    // not a flag that reaches only future output.
+                    setRawOutput(enabled);
+                    resetTranscript();
+                    pushMessage('system', enabled
+                        ? 'Raw output mode on — transcript source is shown without Markdown styling or collapsed bodies; terminal controls remain visible escapes.'
+                        : 'Raw output mode off — rich transcript rendering restored.');
+                    return;
+                }
+                case 'export': {
+                    const sessions = sessionsRef.current;
+                    const destination = scopeRef.current?.sessionId;
+                    if (!sessions || !destination) {
+                        pushMessage('system', 'Cannot export this conversation because durable session persistence is unavailable.');
+                        return;
+                    }
+                    if (abortRef.current ||
+                        state !== 'idle' ||
+                        hasUnsettledTurn() ||
+                        compactingRef.current ||
+                        queuedRef.current.length > 0) {
+                        pushMessage('system', 'A turn, compaction, or queued prompt is still running or settling. Export waits for a stable durable boundary; try again when the composer is idle.');
+                        return;
+                    }
+                    exportingRef.current = true;
+                    setState('thinking');
+                    const generation = conversationGenRef.current;
+                    const path = slash.path ?? `namzu-conversation-${destination}.md`;
+                    void (async () => {
+                        try {
+                            await persistenceTailRef.current;
+                            if (conversationGenRef.current !== generation ||
+                                scopeRef.current?.sessionId !== destination) {
+                                throw new Error('The active conversation changed before the export reached its durable boundary.');
+                            }
+                            const projected = await conversationMarkdown(sessions, destination);
+                            const written = await writeConversationExport(projected.markdown, path, ctx.cwd);
+                            pushMessage('system', `Exported ${projected.turns} turn${projected.turns === 1 ? '' : 's'} to ${written.path} (${written.bytes.toLocaleString()} bytes). Existing files are never overwritten.`);
+                        }
+                        catch (err) {
+                            pushMessage('system', `Conversation export failed: ${err instanceof Error ? err.message : String(err)}`);
+                        }
+                        finally {
+                            exportingRef.current = false;
+                            if (conversationGenRef.current === generation)
+                                setState('idle');
+                        }
+                    })();
+                    return;
+                }
                 default: {
                     // Exhaustive on purpose. Without it a `SlashAction` kind added
                     // and not handled here falls out of the switch into the send
@@ -1266,24 +2473,161 @@ export function App({ ctx }) {
                 }
             }
         }
-        // A turn is in flight → queue the message; it auto-sends when idle.
-        // (Queued messages are text-only; pasted images aren't carried.)
-        if (state !== 'idle') {
-            setQueued((q) => [...q, outgoing]);
+        // Every model-bound prompt enters one FIFO, including one submitted while
+        // idle. If idle submissions bypassed it, a prompt arriving after a turn's
+        // `setState('idle')` but before the passive drain effect could start ahead
+        // of an older queued prompt. The drain below is the only turn starter.
+        //
+        // Keep the attachment array beside its text. Reconstructing a prompt from
+        // the transcript later cannot recover bytes whose composer chip is gone.
+        advanceQueueContinuation();
+        enqueueQueued({
+            kind: 'human',
+            text: outgoing,
+            ...(attachments && attachments.length > 0 ? { attachments: [...attachments] } : {}),
+        });
+    }, [
+        activeSkills,
+        advanceQueueContinuation,
+        ctx.cwd,
+        doResume,
+        enqueueQueued,
+        exit,
+        hasUnsettledTurn,
+        nextId,
+        pushMessage,
+        rawOutput,
+        resetTranscript,
+        setReasoningEffort,
+        slashCtx,
+        startFreshConversation,
+        state,
+    ]);
+    // Admit automatic work only at a whole-App durable boundary. This effect
+    // reserves; it never starts a turn itself. The one queue pump below remains
+    // the sole starter, which is what keeps a human prompt that arrives during
+    // admission ahead of the resulting goal round.
+    useEffect(() => {
+        void goalDriveVersion;
+        // The ref is the synchronous gate; this state read is the wake-up edge.
+        // A failed fork/edit can close its mutation boundary while the screen stays
+        // idle, so no other dependency would necessarily re-run this driver.
+        void conversationMutation;
+        if (goalDriveInFlightRef.current ||
+            state !== 'idle' ||
+            phase !== 'ready' ||
+            !session?.hasProvider ||
+            queuedRef.current.length > 0 ||
+            abortRef.current ||
+            hasUnsettledTurn() ||
+            conversationMutationRef.current ||
+            exportingRef.current ||
+            compactingRef.current ||
+            goalCommandInFlightRef.current) {
             return;
         }
-        void runTurn(outgoing, images);
-    }, [activeSkills, doResume, exit, nextId, pushMessage, runTurn, slashCtx, state]);
+        const durableSessions = sessionsRef.current;
+        const scope = scopeRef.current;
+        if (!durableSessions?.turnEvidence || !scope)
+            return;
+        const generation = conversationGenRef.current;
+        const sessionId = scope.sessionId;
+        const armed = goalActivation.get(sessionId);
+        if (!armed)
+            return;
+        goalDriveInFlightRef.current = true;
+        void (async () => {
+            try {
+                await persistenceTailRef.current;
+                if (conversationGenRef.current !== generation ||
+                    scopeRef.current?.sessionId !== sessionId ||
+                    state !== 'idle' ||
+                    abortRef.current ||
+                    hasUnsettledTurn(generation) ||
+                    conversationMutationRef.current ||
+                    exportingRef.current ||
+                    compactingRef.current ||
+                    goalCommandInFlightRef.current ||
+                    queuedRef.current.length > 0 ||
+                    !goalActivation.isArmed(sessionId, armed)) {
+                    return;
+                }
+                const current = await durableSessions.goals.getGoal(sessionId, durableSessions.tenantId);
+                if (!current ||
+                    current.phase !== 'active' ||
+                    current.id !== armed.id ||
+                    current.revision !== armed.revision) {
+                    goalActivation.disarm(sessionId, armed);
+                    return;
+                }
+                const authority = await durableSessions.goals.admitRound(sessionId, durableSessions.tenantId, armed);
+                // Human input may have entered or even started while admission was on
+                // disk; keep it. The goal round appends after that FIFO. A conversation
+                // or goal command is different: it revoked this scheduling boundary.
+                if (conversationGenRef.current !== generation ||
+                    scopeRef.current?.sessionId !== sessionId ||
+                    conversationMutationRef.current ||
+                    goalCommandInFlightRef.current ||
+                    !goalActivation.isArmed(sessionId, armed)) {
+                    goalActivation.disarm(sessionId, armed);
+                    return;
+                }
+                goalActivation.arm(authority);
+                enqueueQueued({
+                    kind: 'goal',
+                    text: goalRoundPrompt(authority),
+                    goalRound: authority,
+                    generation,
+                });
+            }
+            catch (error) {
+                goalActivation.disarm(sessionId, armed);
+                if (error instanceof GoalRoundLimitError) {
+                    pushMessage('system', `Goal blocked after ${error.goal.roundsAdmitted} admitted round${error.goal.roundsAdmitted === 1 ? '' : 's'}: ${error.goal.blockedReason?.message ?? 'the round limit was reached'}`);
+                }
+                else if (!(error instanceof StaleGoalError)) {
+                    pushMessage('system', `Automatic goal continuation was disarmed because round admission failed: ${error instanceof Error ? error.message : String(error)}. Run /goal resume to retry explicitly.`);
+                }
+            }
+            finally {
+                goalDriveInFlightRef.current = false;
+                wakeGoalDriver();
+            }
+        })();
+    }, [
+        enqueueQueued,
+        goalActivation,
+        goalDriveVersion,
+        hasUnsettledTurn,
+        phase,
+        pushMessage,
+        conversationMutation,
+        session,
+        state,
+        wakeGoalDriver,
+    ]);
     // Drain the queue: when a turn settles (idle) and nothing is running,
     // send the next queued message automatically.
     useEffect(() => {
-        if (state !== 'idle' || phase !== 'ready' || queued.length === 0 || abortRef.current)
+        if (state !== 'idle' ||
+            phase !== 'ready' ||
+            queuedRef.current.length === 0 ||
+            queuePauseRef.current !== null ||
+            abortRef.current ||
+            hasUnsettledTurn() ||
+            conversationMutationRef.current ||
+            exportingRef.current ||
+            compactingRef.current ||
+            goalCommandInFlightRef.current)
             return;
-        const [next, ...rest] = queued;
-        setQueued(rest);
+        // Read and remove from the synchronous source of truth. `queued` is the
+        // render snapshot that scheduled this effect; a later input may already
+        // have appended to the ref, and replacing from that old snapshot would
+        // erase it.
+        const next = dequeueQueued();
         if (next !== undefined)
             void runTurn(next);
-    }, [state, phase, queued, runTurn]);
+    }, [state, phase, queued, queuePause, dequeueQueued, hasUnsettledTurn, runTurn]);
     // One-shot update check on launch.
     // Best-effort; surfaces a single notice when something newer is out.
     const updateCheckedRef = useRef(false);
@@ -1298,6 +2642,19 @@ export function App({ ctx }) {
             pushMessage('system', `⬆ Update available:\n${lines.join('\n')}`);
         });
     }, [phase, ctx.version, pushMessage]);
+    const hydrateFromPicker = useCallback(async (prefs, detectedNow, signal) => {
+        try {
+            await hydrateSession(prefs, detectedNow, signal);
+        }
+        catch (err) {
+            // A superseded choice no longer owns even its failure message. Its
+            // eventual session object is disposed inside `hydrateSession`; a live
+            // choice stays on the picker with the actionable construction error.
+            if (signal.aborted)
+                return;
+            setPickerNotice(`Could not start the selected provider: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, [hydrateSession]);
     /**
      * A credential the operator typed. Held in memory for this process only.
      *
@@ -1306,7 +2663,7 @@ export function App({ ctx }) {
      * provider choice is not persisted either, because persisting it would leave
      * a preference pointing at a credential that will not exist next launch.
      */
-    const handleTypedCredential = useCallback((credential, disposition) => {
+    const handleTypedCredential = useCallback((credential, disposition, signal) => {
         const next = [credential, ...detected.filter((d) => d.entry.id !== credential.entry.id)];
         setDetected(next);
         setKeyEntryFor(null);
@@ -1327,9 +2684,9 @@ export function App({ ctx }) {
                 providers: [{ id: credential.entry.id }],
                 subagents: { active: [] },
             };
-        void hydrateSession(prefs, next);
-    }, [detected, hydrateSession, pushMessage]);
-    const handlePickerSubmit = useCallback((selection) => {
+        void hydrateFromPicker(prefs, next, signal);
+    }, [detected, hydrateFromPicker, pushMessage]);
+    const handlePickerSubmit = useCallback((selection, signal) => {
         // One member for now. The picker builds a longer chain in a later
         // change; the shape it writes into is already the chain.
         const prefs = {
@@ -1351,8 +2708,8 @@ export function App({ ctx }) {
             pushMessage('system', `Could not save preferences: ${err instanceof Error ? err.message : String(err)}`);
             return;
         }
-        void hydrateSession(prefs, detected);
-    }, [detected, hydrateSession, pushMessage]);
+        void hydrateFromPicker(prefs, detected, signal);
+    }, [detected, hydrateFromPicker, pushMessage]);
     /**
      * Leaving the picker returns to whatever was on screen before it.
      *
@@ -1396,6 +2753,31 @@ export function App({ ctx }) {
                 exit();
             return;
         }
+        // Previous-prompt picker owns the keyboard. Esc keeps stepping toward
+        // older prompts, matching the second Esc that opened it; q is the cancel.
+        if (phase === 'edit') {
+            if (editCommittedRef.current)
+                return;
+            if ((key.ctrl && input === 'c') || input.toLowerCase() === 'q') {
+                setEditList([]);
+                setPhase('ready');
+                return;
+            }
+            if (key.escape || key.leftArrow || key.upArrow) {
+                setSelectedEdit((index) => Math.max(0, index - 1));
+                return;
+            }
+            if (key.rightArrow || key.downArrow) {
+                setSelectedEdit((index) => Math.min(editList.length - 1, index + 1));
+                return;
+            }
+            if (key.return) {
+                const target = editList[selectedEdit];
+                if (target)
+                    void confirmPromptEdit(target);
+            }
+            return;
+        }
         // Resume picker owns the keyboard while open.
         if (phase === 'resume') {
             // Once a conversation is being read, the keyboard does nothing here.
@@ -1548,19 +2930,34 @@ export function App({ ctx }) {
     // Background is left natural — we inherit the terminal's own background
     // and only theme the foreground. Forcing
     // a filled bg left mismatched patches around bordered areas, so we don't.
-    return (_jsxs(Box, { flexDirection: "column", children: [phase !== 'ready' ? (_jsx(Banner, { version: ctx.version, session: session, bypass: ctx.skipPermissions === true, cwd: ctx.cwd })) : null, _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [phase === 'trust' ? (_jsx(TrustPrompt, { cwd: ctx.cwd })) : phase === 'resume' ? (_jsx(ResumePicker, { conversations: resumeList, selected: selectedResume })) : phase === 'picker' ? (_jsx(Picker, { detected: detected, currentProvider: currentProvider, currentModel: session?.modelSummary ?? null, onSubmit: handlePickerSubmit, onCancel: handlePickerCancel, onCredential: handleTypedCredential, onLogin: () => void startLoginFromPicker(), keyEntryFor: keyEntryFor, notice: pickerNotice })) : (_jsxs(_Fragment, { children: [_jsx(TranscriptFrame, { children: _jsx(Transcript, { messages: finalized, pending: messages.find((m) => m.pending) ?? null, state: state, settled: window.settled, resetKey: resetKey, header: phase === 'ready' ? (_jsx(Banner, { version: ctx.version, session: session, bypass: ctx.skipPermissions === true, cwd: ctx.cwd })) : undefined }) }), spacerRows > 0 ? _jsx(Box, { height: spacerRows }) : null, _jsx(LiveActivity, { activeTools: activeTools, thinking: state === 'thinking' && !messages.some((m) => m.pending) }), permission ? _jsx(PermissionOverlay, { toolCalls: permission.toolCalls }) : null, _jsxs(ComposerFrame, { focus: state === 'idle' && phase === 'ready', hidden: permission !== null, children: [queued.length > 0 && permission === null ? (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: theme.text.muted, children: ["\u23CE ", queued.length, " message", queued.length > 1 ? 's' : '', " queued \u2014 sending when ready"] }) })) : null, _jsx(Composer, { disabled: phase !== 'ready' || state === 'awaiting-permission', hidden: permission !== null, 
+    return (_jsxs(Box, { flexDirection: "column", children: [phase !== 'ready' ? (_jsx(Banner, { version: ctx.version, session: session, permissionMode: permissionMode, cwd: ctx.cwd })) : null, _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [phase === 'trust' ? (_jsx(TrustPrompt, { cwd: ctx.cwd })) : phase === 'resume' ? (_jsx(ResumePicker, { conversations: resumeList, selected: selectedResume })) : phase === 'edit' ? (_jsx(EditPromptPicker, { prompts: editList, selected: selectedEdit })) : phase === 'picker' ? (_jsx(Picker, { detected: detected, currentProvider: currentProvider, currentModel: session?.modelSummary ?? null, onSubmit: handlePickerSubmit, onCancel: handlePickerCancel, onCredential: handleTypedCredential, onLogin: (signal) => void startLoginFromPicker(signal), keyEntryFor: keyEntryFor, notice: pickerNotice })) : (_jsxs(_Fragment, { children: [_jsx(TranscriptFrame, { children: _jsx(Transcript, { messages: finalized, pending: messages.find((m) => m.pending) ?? null, state: state, settled: window.settled, resetKey: resetKey, raw: rawOutput, header: phase === 'ready' ? (_jsx(Banner, { version: ctx.version, session: session, permissionMode: permissionMode, cwd: ctx.cwd })) : undefined }) }), spacerRows > 0 ? _jsx(Box, { height: spacerRows }) : null, _jsx(LiveActivity, { activeTools: activeTools, thinking: state === 'thinking' && !messages.some((m) => m.pending) }), permission ? _jsx(PermissionOverlay, { toolCalls: permission.toolCalls }) : null, _jsxs(ComposerFrame, { focus: state === 'idle' && phase === 'ready' && conversationMutation === null, hidden: permission !== null, children: [queued.length > 0 && permission === null ? (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: theme.text.muted, children: [queuePause ? '⏸' : '⏎', " ", queued.length, " message", queued.length > 1 ? 's' : '', " queued \u2014", ' ', queuePause
+                                                    ? `paused after a ${queuePause.outcome} turn; send a message or change model to continue`
+                                                    : 'sending when ready'] }) })) : null, _jsx(Composer, { disabled: phase !== 'ready' ||
+                                            state === 'awaiting-permission' ||
+                                            compacting ||
+                                            conversationMutation !== null, hidden: permission !== null, 
                                         // A turn is running, so Esc is the interrupt and not
                                         // the composer's clear.
-                                        escapeInterrupts: state === 'thinking' || state === 'tool', onSubmit: handleSubmit, onNotice: (text) => pushMessage('system', text), userCommands: userCommands, history: history })] })] })), _jsx(Box, { paddingTop: 1, children: _jsx(StatusBar, { cwd: ctx.cwd, provider: session?.providerSummary ?? null, model: session?.modelSummary ?? null, state: state, hint: hintForPhase(phase, state, session?.hasProvider === true), usage: usage, context: context }) })] })] }));
+                                        escapeInterrupts: !compacting && (state === 'thinking' || state === 'tool'), onSubmit: handleSubmit, onNotice: (text) => pushMessage('system', text), onEditPrevious: openPromptEditor, draftToRestore: composerDraft, onDraftRestored: (token) => setComposerDraft((draft) => (draft?.token === token ? null : draft)), userCommands: userCommands, history: history })] })] })), _jsx(Box, { paddingTop: 1, children: _jsx(StatusBar, { cwd: ctx.cwd, provider: session?.providerSummary ?? null, model: session?.modelSummary
+                                ? `${session.modelSummary}${reasoningEffort ? ` · effort ${reasoningEffort}` : ''}`
+                                : null, state: state, hint: conversationMutation === 'fork'
+                                ? 'forking conversation — input is paused'
+                                : conversationMutation === 'edit'
+                                    ? 'branching before prompt — input is paused'
+                                    : conversationMutation === 'new'
+                                        ? 'starting a fresh conversation — input is paused'
+                                        : compacting
+                                            ? 'compacting conversation — input is paused'
+                                            : hintForPhase(phase, state, session?.hasProvider === true), usage: usage, context: context }) })] })] }));
 }
-function Banner({ version, session, bypass, cwd, }) {
+function Banner({ version, session, permissionMode, cwd, }) {
     const cols = process.stdout.columns ?? 80;
     const wide = cols >= NAMZU_WORDMARK_MIN_WIDTH;
     const provider = session?.providerSummary;
     const model = session?.modelSummary;
     const home = process.env.HOME;
     const prettyCwd = home && cwd.startsWith(home) ? `~${cwd.slice(home.length)}` : cwd;
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingTop: 1, paddingBottom: 1, children: [_jsxs(Box, { flexDirection: "row", children: [wide ? (_jsx(Box, { flexDirection: "column", marginRight: 2, children: NAMZU_WORDMARK.map((line, i) => (_jsx(Text, { color: NAMZU_WORDMARK_GRADIENT[i], bold: true, children: line }, `wm-${i}`))) })) : (_jsxs(Text, { color: NAMZU_MARK_COLOR, children: [NAMZU_MARK, " "] })), _jsxs(Box, { flexDirection: "column", marginTop: wide ? 1 : 0, children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.text.secondary, children: "Cogitave" }), wide ? null : (_jsxs(Text, { color: NAMZU_MARK_COLOR, bold: true, children: [' ', "Namzu"] })), _jsxs(Text, { color: theme.text.muted, children: [" v", version] })] }), _jsx(Text, { color: theme.text.secondary, children: provider ? `${provider}${model ? ` · ${model}` : ''}` : 'the agent in your terminal' }), _jsx(Text, { color: theme.text.muted, children: prettyCwd })] })] }), bypass ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.status.error, bold: true, children: "\u26A0 bypass permissions \u2014 tools run without asking" }) })) : null] }));
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingTop: 1, paddingBottom: 1, children: [_jsxs(Box, { flexDirection: "row", children: [wide ? (_jsx(Box, { flexDirection: "column", marginRight: 2, children: NAMZU_WORDMARK.map((line, i) => (_jsx(Text, { color: NAMZU_WORDMARK_GRADIENT[i], bold: true, children: line }, `wm-${i}`))) })) : (_jsxs(Text, { color: NAMZU_MARK_COLOR, children: [NAMZU_MARK, " "] })), _jsxs(Box, { flexDirection: "column", marginTop: wide ? 1 : 0, children: [_jsxs(Text, { children: [_jsx(Text, { color: theme.text.secondary, children: "Cogitave" }), wide ? null : (_jsxs(Text, { color: NAMZU_MARK_COLOR, bold: true, children: [' ', "Namzu"] })), _jsxs(Text, { color: theme.text.muted, children: [" v", version] })] }), _jsx(Text, { color: theme.text.secondary, children: provider ? `${provider}${model ? ` · ${model}` : ''}` : 'the agent in your terminal' }), _jsx(Text, { color: theme.text.muted, children: prettyCwd })] })] }), permissionMode === 'auto' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { color: theme.status.error, bold: true, children: "\u26A0 launched in auto permission mode \u2014 undecided tools run without asking until /permissions changes it" }) })) : null] }));
 }
 function TranscriptFrame({ children }) {
     // Borderless, edge-to-edge — the message glyph gutter provides structure.
@@ -1587,6 +2984,8 @@ canReturn = false) {
         return 'y trust this folder · n / esc exit';
     if (phase === 'resume')
         return '↑↓ navigate · enter resume · esc cancel';
+    if (phase === 'edit')
+        return 'Esc / ← older · → newer · enter fork and edit · q cancel';
     if (phase === 'probing')
         return 'discovering providers…';
     // Esc does two different things here depending on how the picker was reached,
@@ -1605,6 +3004,19 @@ canReturn = false) {
         return 'y approve · n / esc reject · a approve all';
     if (state !== 'idle')
         return 'agent is working — esc to interrupt';
-    return '/help · @file / Ctrl+V to attach · Ctrl+C ×2 to exit';
+    return '/help · Esc×2 edit previous · @file / Ctrl+V attach · Ctrl+C ×2 to exit';
+}
+/**
+ * The summary text, as collapsible detail under the compaction row.
+ *
+ * Collapsed rather than printed: a structured summary is long by design, and a
+ * transcript that dumps it in full turns "I freed up context" into a wall taller
+ * than the thing it replaced. Kept ON the row rather than dropped, because the
+ * summary IS what the model will read from here on — an operator who wants to
+ * check what survived has to be able to.
+ */
+function summaryDetail(summary) {
+    const text = typeof summary.content === 'string' ? summary.content : '';
+    return text.length > 0 ? text.split('\n') : ['(the summary was empty)'];
 }
 //# sourceMappingURL=App.js.map