@namzu/cli 26.3.0 → 28.0.0

package/dist/tui/App.js

@@ -1,7 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { resolveRunGuards } from '../config/run-limits.js';
-import { RUN_LIMIT_FIELDS, runLimitCommands } from './run-limits-settings.js';
-import { CliPathBuilder } from '../integrations/sessions/paths.js';
+import { resolveTurnGuards } from '../config/turn-guards.js';
+import { TURN_LIMIT_FIELDS, turnLimitCommands } from './turn-limits-settings.js';
 /**
  * TUI root. Composes the banner, transcript, composer, status bar, and
  * the first-run provider picker overlay.
@@ -17,8 +16,8 @@ import { CliPathBuilder } from '../integrations/sessions/paths.js';
 import { discoverProviders } from '../integrations/providers/discover.js';
 import { ProviderSetup } from './ProviderSetup.js';
 import { ToolOutputViewer } from './ToolOutputViewer.js';
-import { join, relative } from 'node:path';
-import { DEFAULT_MAX_GOAL_ROUNDS, DiskMessageFeedbackStore, GoalRoundLimitError, HostCommandRegistry, RunCancelled, SessionGoalActivation, StaleGoalError, asSessionId, createAssistantMessage, createUserMessage, generateRunId, generateSessionId, isCompactionMessage, kernelHostCommands, } from '@namzu/sdk';
+import { relative } from 'node:path';
+import { DEFAULT_MAX_GOAL_ROUNDS, DiskMessageFeedbackStore, GoalRoundLimitError, HostCommandRegistry, SessionGoalActivation, StaleGoalError, TurnCancelled, asSessionId, createAssistantMessage, createUserMessage, generateSessionId, generateTurnId, isCompactionMessage, kernelHostCommands, } from '@namzu/sdk';
 import { Box, Text, useApp, useInput, useStdout, useWindowSize } from 'ink';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { pinTrustedProjectPath, resolveTrustedProjectContext, } from '../config/trusted-project-context.js';
@@ -27,13 +26,13 @@ import { runtimeContextLabel } from '../context/runtime-message.js';
 import { writeClipboardText } from '../integrations/clipboard/text.js';
 import { terminalNotificationEnabled, writeTerminalNotification, } from '../integrations/notifications/terminal.js';
 import { beginCodexDeviceLogin, beginSubscriptionLogin, clearAllStoredCredentials, clearStoredCodexCredential, clearStoredSubscriptionCredential, credentialsPath, parsePastedInput, primaryProvider, readStoredCodexCredential, readStoredSubscriptionCredential, signedInSubscriptionProviders, writePreferences, } from '../integrations/providers/index.js';
-import { appendMessages, archiveConversation, forkConversation, forkConversationBeforeUser, listRecent, loadConversation, loadResumableConversation, openSessions, replaceConversation, requireWritableConversation, setTitle, startConversation, titleOf, } from '../integrations/sessions/store.js';
+import { activeConversationTurn, archiveConversation, forkConversation, forkConversationBeforeUser, listRecent, loadConversation, loadResumableConversation, openSessions, requireWritableConversation, setTitle, startConversation, titleOf, } from '../integrations/sessions/store.js';
 import { conversationMarkdown, writeConversationExport, } from '../integrations/sessions/transcript-export.js';
-import { liveOrchestrationRuns } from '../integrations/subagents/runs.js';
 import { NARRATION_TOOL_NAME } from '../integrations/subagents/runtime.js';
+import { agentsSlashCommand } from '../integrations/subagents/slash.js';
 import { isTrusted, trustDir } from '../integrations/trust/store.js';
 import { checkUpdates } from '../integrations/updates.js';
-import { renderMemoryReport, renderMemorySaveResult } from '../memory/presentation.js';
+import { renderMemoryReport, renderMemorySaveResult, renderStoredMemorySection, renderTypedNoteResult, } from '../memory/presentation.js';
 import { appendMemoryWithStatus, readMemory } from '../memory/store.js';
 import { effectivePermissionMode, permissionModeDescription, permissionModeLabel, } from '../permissions/mode.js';
 import { composeSkillsPrompt, discoverSkills, loadSkillBody } from '../skills/store.js';
@@ -61,7 +60,7 @@ import { createAgentSession, describeProviderModels, probeAgentSession, } from '
 import { choicePickerWindowSize, filterChoiceOptions, moveChoiceSelection, } from './choice-selection.js';
 import { keepRecentRows } from './compact-transcript.js';
 import { approvalIsDeliberate } from './consent-timing.js';
-import { assistantTranscriptTexts, planTurnPublication } from './conversation-history.js';
+import { assistantTranscriptTexts } from './conversation-history.js';
 import { copyTargetsForResponse } from './copy-targets.js';
 import { editablePrompts } from './edit-prompts.js';
 import { editDraftInExternalEditor } from './external-editor.js';
@@ -74,11 +73,11 @@ import { eraseLastChoiceGrapheme } from './terminal-choice-text.js';
 import { renderCheckpoints, renderRestore } from '../checkpoints/store.js';
 import { expandFileMentions, listMentionableFiles } from './mentions.js';
 import { openInBrowser } from './open-browser.js';
-import { buildPermissionReview, buildPermissionSummary, permissionReviewPageRows, permissionReviewRefusal, permissionReviewRows, } from './permission-review.js';
-import { describeRunInterruption, describeRunStop } from './run-interruption.js';
+import { buildPermissionReview, buildPermissionSummary, permissionReviewPageRows, permissionReviewRefusal, permissionReviewRows, releasedByApproveAll, } from './permission-review.js';
+import { describeTurnInterruption, describeTurnStop } from './turn-interruption.js';
 import { moveSelection } from './selection-window.js';
 import { describeShellEscape, describeShellEscapeForModel, runShellEscape, shellEscapeCommand, } from './shell-escape.js';
-import { baseBranchReviewPrompt, combineOrchestrationRuns, commitReviewPrompt, hostCommandNames, kernelCommandDescriptors, mergeHostCommands, renderAgentRuns, renderOutcome, reviewPrompt, runSlash, } from './slashCommands.js';
+import { baseBranchReviewPrompt, commitReviewPrompt, hostCommandNames, kernelCommandDescriptors, mergeHostCommands, renderAgents, renderOutcome, reviewPrompt, runSlash, } from './slashCommands.js';
 import { splitCompleteBlocks, splitSafeCut } from './stream-blocks.js';
 import { terminalSupportsHyperlinks } from './terminal-hyperlinks.js';
 import { theme } from './theme.js';
@@ -246,7 +245,7 @@ function goalRoundPrompt(authority) {
  */
 const LIVE_FURNITURE_ROWS = 10;
 const defaultExternalEditor = ({ seed, cwd, signal }) => editDraftInExternalEditor(seed, { cwd, signal });
-export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultExternalEditor, }) {
+export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultExternalEditor, terminationExit, }) {
     // 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.
@@ -264,7 +263,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const terminal = useWindowSize();
     const hyperlinks = terminalSupportsHyperlinks(process.env, stdout.isTTY === true);
     /**
-     * The last assistant message id the run reported, for `/feedback`.
+     * The last assistant message id the turn reported, for `/feedback`.
      *
      * A ref rather than state: nothing renders it, and making it state would
      * re-render the transcript on every delta — the exact cost the `pending`
@@ -276,7 +275,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
      *
      * 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,
+     * answer until the current turn 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
@@ -384,7 +383,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const permissionModeSourceRef = useRef(ctx.skipPermissions === true ? 'launch-bypass' : 'default');
     const [reasoningEffort, setReasoningEffortState] = useState();
     const reasoningEffortRef = useRef(undefined);
-    const runLimitsOverrideRef = useRef({});
+    const turnLimitsOverrideRef = useRef({});
     const setReasoningEffort = useCallback((next) => {
         reasoningEffortRef.current = next;
         setReasoningEffortState(next);
@@ -594,7 +593,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const [composerDraft, setComposerDraft] = useState(null);
     const [composerHasDraft, setComposerHasDraft] = useState(false);
     const composerDraftTokenRef = useRef(0);
-    /** Bounded child-run projection published by the current AgentSession. */
+    /** Bounded child session projection published by the current AgentSession. */
     const [subagents, setSubagentsState] = useState([]);
     const subagentsRef = useRef([]);
     /**
@@ -623,8 +622,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         agentSurfaceCommittedRef.current = agentSurface;
     }, [agentSurface]);
     /**
-     * Children of this conversation's earlier runs, rebuilt from saved
-     * evidence, kept apart from the live monitor's own snapshot.
+     * Children of this conversation's earlier turns, rebuilt from their own
+     * session logs, kept apart from the live monitor's own snapshot.
      *
      * A ref and not state because it is an input to `replaceSubagents`, which
      * runs from the monitor's subscription: holding it as state would make
@@ -638,11 +637,14 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         if (saved.length === 0)
             return live;
         // A child the live monitor still holds wins over its own saved copy:
-        // both describe one run, and only one of the two is attached to
-        // anything. Saved rows land after the live ones, so a cohort that is
+        // both describe one child session, and only one of the two is attached
+        // to anything. Saved rows land after the live ones, so a cohort that is
         // still running keeps the top of the list.
-        const liveRunIds = new Set(live.map((agent) => agent.runId).filter((id) => id !== undefined));
-        return [...live, ...saved.filter((agent) => !agent.runId || !liveRunIds.has(agent.runId))];
+        const liveSessionIds = new Set(live.map((agent) => agent.sessionId).filter((id) => id !== undefined));
+        return [
+            ...live,
+            ...saved.filter((agent) => !agent.sessionId || !liveSessionIds.has(agent.sessionId)),
+        ];
     }, []);
     const replaceSubagents = useCallback((incoming) => {
         const next = withSavedSubagents(incoming);
@@ -753,6 +755,12 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const reviewChoiceInFlightRef = useRef(null);
     const exitArmedRef = useRef(false);
     const abortRef = useRef(null);
+    /**
+     * A prompt that holds the turn slot while it waits at the turn boundary,
+     * before it has an abort controller. An interrupt or a conversation switch
+     * takes the slot back by clearing this; the prompt then drops itself.
+     */
+    const admissionRef = useRef(null);
     /** Identity of the turn allowed to notify when it settles. */
     const activeTurnTokenRef = useRef(null);
     /** A tool can reserve a switch; only the owning turn's finalizer may publish it. */
@@ -1118,81 +1126,87 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         return id;
     }, [nextId]);
     /**
-     * `/agents runs`: opens a picker immediately with a disabled loading row,
-     * then replaces it once the live snapshot and the disk walk both resolve.
-     *
-     * The composer stays reachable the whole time — nothing here awaits before
-     * the first `setChoicePicker`. A stale read is dropped by comparing
-     * `choicePickerRef.current` against the exact loading-picker object this
-     * call put there (the idiom the `/review` pickers already use below),
-     * rather than a counter: Escape and every other picker-replacing path
-     * already route through `setChoicePicker`, so they retire this object as a
-     * side effect and need no separate token bump of their own. That covers
-     * both "the operator left this picker" (any other object is current now,
-     * `null` included) and "opened it again" (a second call's own object is
-     * current instead).
+     * `/agents [running|available|batches]`, answered by the delegation UI's
+     * `agentsSlashCommand` over this session's live monitor and the batches the
+     * session index holds. A `batches` answer opens a picker immediately with a
+     * disabled loading row, then replaces it once the listing resolves; the
+     * composer stays reachable the whole time. A stale read is dropped by
+     * comparing `choicePickerRef.current` against the exact loading-picker
+     * object this call put there.
      */
-    const openAgentRunsPicker = useCallback(() => {
-        setSelectedChoice(0);
-        const pending = {
-            kind: 'agent-runs',
-            title: 'Orchestration runs',
-            values: ['loading'],
-            options: [
-                { label: 'Loading…', description: 'Reading saved evidence…', disabledReason: 'Loading…' },
-            ],
-        };
-        setChoicePicker(pending);
-        void (async () => {
-            const live = liveOrchestrationRuns(subagentsRef.current, Date.now());
-            let finished = [];
-            try {
-                finished = (await session?.listOrchestrationRuns?.()) ?? [];
-            }
-            catch {
-                // Disk evidence is optional here: a live-only listing is still an
-                // honest answer, and the empty-history message below still applies
-                // if that live half turns out empty too.
+    const runAgentsCommand = useCallback((args, openCockpit, listAvailable) => {
+        const wantsBatches = args.length === 1 && args[0] === 'batches';
+        const pending = wantsBatches
+            ? {
+                kind: 'agent-batches',
+                title: 'Batches',
+                values: ['loading'],
+                options: [
+                    {
+                        label: 'Loading…',
+                        description: 'Reading saved batches…',
+                        // A disabled row shows its reason in place of its description.
+                        disabledReason: 'Reading saved batches…',
+                    },
+                ],
             }
-            if (appLifetime.signal.aborted || choicePickerRef.current !== pending)
+            : undefined;
+        if (pending) {
+            setSelectedChoice(0);
+            setChoicePicker(pending);
+        }
+        void (async () => {
+            const result = await agentsSlashCommand(args, {
+                liveAgents: () => subagentsRef.current,
+                ...(session?.listSavedBatches ? { savedBatches: session.listSavedBatches } : {}),
+            });
+            if (appLifetime.signal.aborted)
                 return;
-            const listing = combineOrchestrationRuns(live, finished);
-            const empty = renderAgentRuns(listing);
-            if (empty) {
-                setChoicePicker(null);
-                pushMessage('system', empty);
+            if (pending && choicePickerRef.current !== pending)
                 return;
+            switch (result.kind) {
+                case 'agent-cockpit':
+                    openCockpit();
+                    return;
+                case 'available-agents':
+                    listAvailable();
+                    return;
+                case 'message':
+                    if (pending)
+                        setChoicePicker(null);
+                    pushMessage('system', result.content);
+                    return;
+                case 'batches':
+                    setChoicePicker({
+                        kind: 'agent-batches',
+                        title: 'Batches',
+                        notice: result.listing.omitted > 0
+                            ? `${result.listing.omitted} older batch${result.listing.omitted === 1 ? '' : 'es'} not shown.`
+                            : undefined,
+                        values: result.listing.batches,
+                        options: result.listing.batches.map(batchOption),
+                    });
+                    return;
             }
-            setChoicePicker({
-                kind: 'agent-runs',
-                title: 'Orchestration runs',
-                notice: listing.omitted > 0
-                    ? `${listing.omitted} older run${listing.omitted === 1 ? '' : 's'} not shown.`
-                    : undefined,
-                values: listing.runs,
-                options: listing.runs.map(agentRunOption),
-            });
         })();
     }, [appLifetime, pushMessage, session, setChoicePicker, setSelectedChoice]);
     /**
-     * Opens an `/agents runs` selection straight into its first agent's
+     * Opens an `/agents batches` selection straight into its first agent's
      * transcript — where the replayed banner actually lives, for a finished
-     * run — rather than the phase/agent list Ctrl+T lands on.
+     * batch — rather than the phase/agent list Ctrl+T lands on.
      *
-     * A finished run's evidence is hydrated first, since a run this operator
-     * has not opened the cockpit for yet may not be in `subagents` at all.
-     * A live run skips that: it is already there, and re-reading disk for a
-     * run this process is still writing would risk the very half-written
-     * evidence `listSavedOrchestrationRuns` exists to stay off of.
+     * A finished batch's children are hydrated from their logs first, since a
+     * batch this operator has not opened the cockpit for yet may not be in
+     * `subagents` at all. A live batch skips that: it is already there.
      */
-    const openOrchestrationRun = useCallback(async (run) => {
-        if (!run.live)
+    const openBatch = useCallback(async (batch) => {
+        if (!batch.live)
             await hydrateSavedChildren();
-        const workflow = agentWorkflows(subagentsRef.current).find((candidate) => candidate.agents.some((agent) => agent.workflowId === run.id));
+        const workflow = agentWorkflows(subagentsRef.current).find((candidate) => candidate.agents.some((agent) => agent.workflowId === batch.id));
         const firstPhase = workflow?.phases[0];
         const firstAgent = firstPhase?.agents[0];
         if (!firstPhase || !firstAgent) {
-            pushMessage('system', `Could not open "${run.name}" — its saved evidence is no longer available.`);
+            pushMessage('system', `Could not open "${batch.name}" — its saved children are no longer available.`);
             return;
         }
         setAgentSurface({
@@ -1379,31 +1393,25 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         }
         applyReasoningEffort(next);
     }, [applyReasoningEffort, pushMessage, session]);
-    const recordFeedback = useCallback((sessionId, runIdValue, messageIdValue, rating, note) => {
+    const recordFeedback = useCallback((sessionId, messageIdValue, rating, note) => {
         const sessions = sessionsRef.current;
         if (!sessions) {
             pushMessage('system', 'Could not record feedback: conversation persistence is unavailable.');
             return;
         }
-        // Run evidence is session-scoped in the canonical store. The old flat
-        // `<cwd>/.namzu/runs` lookup never existed after the hierarchy migration,
-        // so the feedback store correctly refused every TUI rating as unverifiable.
-        // Bind both trees to the exact conversation captured with the streamed
-        // message; `/resume` may change the active scope before a delayed click.
-        const sessionDir = new CliPathBuilder(sessions.root).sessionDir(sessions.projectId, sessionId);
-        const store = new DiskMessageFeedbackStore({
-            rootDir: join(sessionDir, 'feedback'),
-            runsDir: join(sessionDir, 'runs'),
-        });
-        const runId = runIdValue;
+        // Feedback lives beside the conversation's log (`<session-id>/feedback/`)
+        // and is checked against it: a rating names a message that log holds.
+        // Bound to the exact conversation captured with the streamed message;
+        // `/resume` may change the active scope before a delayed click.
+        const store = new DiskMessageFeedbackStore({ paths: sessions.paths });
         const messageId = messageIdValue;
         void (async () => {
             try {
                 // A later rating replaces the first. Read-then-write preserves the
                 // store's owner-version collision check instead of blind overwrite.
-                const current = (await store.listMessageFeedback({ runId })).find((record) => record.messageId === messageId);
+                const current = (await store.listMessageFeedback({ sessionId })).find((record) => record.messageId === messageId);
                 const record = await store.putMessageFeedback({
-                    runId,
+                    sessionId,
                     messageId,
                     rating,
                     ...(note ? { note } : {}),
@@ -1857,10 +1865,10 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 setChoicePicker({ ...child, back: picker });
             return;
         }
-        if (picker.kind === 'agent-runs') {
+        if (picker.kind === 'agent-batches') {
             if (value === 'loading')
                 return;
-            void openOrchestrationRun(value);
+            void openBatch(value);
             return;
         }
         if (picker.kind === 'archive-conversation') {
@@ -1905,7 +1913,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             return;
         }
         if (picker.kind === 'feedback-rating') {
-            recordFeedback(picker.sessionId, picker.runId, picker.messageId, value);
+            recordFeedback(picker.sessionId, picker.messageId, value);
             return;
         }
         if (picker.kind === 'skill') {
@@ -1931,7 +1939,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         archiveCurrentConversation,
         ctx.cwd,
         enqueueQueued,
-        openOrchestrationRun,
+        openBatch,
         pushMessage,
         recordFeedback,
         removeStoredCredential,
@@ -2655,7 +2663,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         // 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.
+        // second one would describe a different sandbox than the turn is using.
         sandbox: session?.sandbox ?? null,
         mcp: () => session
             ? (session.mcpStatus?.() ?? {
@@ -2700,12 +2708,104 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         sessionId: scopeRef.current?.sessionId,
     };
     // `/resume`: open the picker with this folder's recent conversations.
+    /**
+     * `/abandon`: close this conversation's paused or interrupted turn without
+     * resuming it (`turn_failed{ abandoned }`), so the next prompt can begin a
+     * turn. A turn running in this process is stopped with esc, not abandoned.
+     */
+    const abandonActiveTurn = useCallback(async (reason) => {
+        const sessions = sessionsRef.current;
+        const scope = scopeRef.current;
+        if (!sessions || !scope || !conversationMaterializedRef.current) {
+            pushMessage('system', 'Nothing to abandon: this conversation has no recorded turn yet.');
+            return;
+        }
+        if (abortRef.current || state !== 'idle') {
+            pushMessage('system', 'A turn is running here. Press esc to stop it; /abandon closes a paused or interrupted one.');
+            return;
+        }
+        try {
+            const active = await activeConversationTurn(sessions, scope.sessionId);
+            if (!active) {
+                pushMessage('system', 'This conversation has no paused or interrupted turn to abandon.');
+                return;
+            }
+            if (!session?.abandonTurn) {
+                pushMessage('system', 'This session cannot abandon turns.');
+                return;
+            }
+            await session.abandonTurn(active.turnId, reason);
+            pushMessage('system', `Abandoned turn ${active.turnId}. The next prompt starts a new turn in this conversation.`);
+        }
+        catch (err) {
+            pushMessage('system', `Could not abandon the turn: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, [pushMessage, session, state]);
+    /**
+     * `/resume` in a conversation whose turn is parked: continue that turn —
+     * the same turn id, from its checkpoint — rendering it like any turn.
+     * Returns false when there is no parked turn to continue.
+     */
+    // `applyEvent` is declared further down; the resume path reads it at call time.
+    const applyEventRef = useRef(null);
+    const resumeActiveTurn = useCallback(async () => {
+        const sessions = sessionsRef.current;
+        const scope = scopeRef.current;
+        if (!sessions || !scope || !conversationMaterializedRef.current || !session?.hasProvider)
+            return false;
+        const active = await activeConversationTurn(sessions, scope.sessionId).catch(() => undefined);
+        if (!active)
+            return false;
+        if (abortRef.current || state !== 'idle') {
+            pushMessage('system', 'Wait for the running turn to finish before resuming the parked one.');
+            return true;
+        }
+        const ac = new AbortController();
+        abortRef.current = ac;
+        setState('thinking');
+        const st = {
+            assistantId: null,
+            text: '',
+            conversationMessages: undefined,
+            pending: '',
+            completed: false,
+            outcome: null,
+            sessionId: scope.sessionId,
+            notification: null,
+        };
+        pushMessage('system', `Resuming turn ${active.turnId} from its checkpoint.`, false, '▶');
+        try {
+            for await (const event of session.resumePaused({
+                turnId: active.turnId,
+                signal: ac.signal,
+            })) {
+                applyEventRef.current?.(event, st);
+            }
+            flushStream(st);
+            if (st.assistantId)
+                finalizeMessage(st.assistantId);
+            // The resumed segment was appended to the log; the fold is the context
+            // the next prompt continues from.
+            modelHistoryRef.current = await loadConversation(sessions, scope.sessionId);
+        }
+        catch (err) {
+            pushMessage('system', `Could not resume the turn: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            if (abortRef.current === ac)
+                abortRef.current = null;
+            setState('idle');
+        }
+        return true;
+    }, [finalizeMessage, flushStream, pushMessage, session, state]);
     const doResume = useCallback(async () => {
         const sessions = sessionsRef.current ?? (await ensureSessions(), sessionsRef.current);
         if (!sessions) {
             pushMessage('system', 'Conversation history is unavailable in this folder.');
             return;
         }
+        if (await resumeActiveTurn())
+            return;
         try {
             const recent = await listRecent(sessions);
             // Don't offer the active (empty/just-started) conversation.
@@ -2721,7 +2821,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         catch (err) {
             pushMessage('system', `Could not list conversations: ${err instanceof Error ? err.message : String(err)}`);
         }
-    }, [ensureSessions, pushMessage]);
+    }, [ensureSessions, pushMessage, resumeActiveTurn]);
     // Resolve a pending permission prompt with the user's decision and tear
     // down the overlay. No-op if nothing is pending.
     const resolvePermission = useCallback((decision) => {
@@ -2743,8 +2843,17 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             resolve(decision);
         }
         if (decision.kind === 'approve-all') {
-            for (const pending of permissionQueueRef.current.splice(0))
-                pending.resolve(decision);
+            // A queued sandbox escape or outside path stays queued: "allow
+            // all" was answered on another prompt, and a crossing is approved
+            // only on its own.
+            const kept = [];
+            for (const pending of permissionQueueRef.current.splice(0)) {
+                if (releasedByApproveAll(pending.permission.toolCalls))
+                    pending.resolve(decision);
+                else
+                    kept.push(pending);
+            }
+            permissionQueueRef.current.push(...kept);
         }
         const next = permissionQueueRef.current.shift();
         setQueuedPermissionCount(permissionQueueRef.current.length);
@@ -2784,11 +2893,24 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             resolvePermission({ kind: 'reject', feedback: 'User interrupted.' });
         const ac = abortRef.current;
         if (!ac) {
+            // A prompt still at the turn boundary: nothing has begun, so taking
+            // the slot back is the whole interrupt. It drops itself when its
+            // await returns.
+            if (admissionRef.current) {
+                admissionRef.current = null;
+                const activeSessionId = scopeRef.current?.sessionId;
+                if (activeSessionId)
+                    goalActivation.disarm(activeSessionId);
+                wakeGoalDriver();
+                discardQueued();
+                setState('idle');
+                return true;
+            }
             if (cancelledSwitch)
                 discardQueued();
             return cancelledSwitch;
         }
-        ac.abort(new RunCancelled('user'));
+        ac.abort(new TurnCancelled('user'));
         const activeSessionId = scopeRef.current?.sessionId;
         if (activeSessionId)
             goalActivation.disarm(activeSessionId);
@@ -2811,6 +2933,20 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         resolvePermission,
         wakeGoalDriver,
     ]);
+    // A termination signal leaves like `/exit`, after stopping the turn: the
+    // session still owns tool servers, jobs and the `session_end` hook, and
+    // Ink's unmount is what gives the terminal back.
+    useEffect(() => {
+        if (!terminationExit)
+            return;
+        terminationExit.current = () => {
+            interruptTurn();
+            exitWithSummary();
+        };
+        return () => {
+            terminationExit.current = null;
+        };
+    }, [terminationExit, interruptTurn, exitWithSummary]);
     /**
      * Load the chosen conversation into the transcript and continue in it.
      *
@@ -2821,12 +2957,12 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
      * would have run against a conversation nobody asked them of. And, the one
      * that outlived the process, its `appendMessages` wrote into the RESUMED
      * conversation's durable record, because `sessionId` was mutated on a
-     * `RunScope` the running loop held the very same object of.
+     * `SessionScope` the running loop held the very same object of.
      *
      * The mutation below stays, and it is the sharing that makes it necessary:
      * `createAgentSession` closed over this exact object and spreads it into
      * every `query()`, so replacing it here would leave the agent attributing
-     * every future turn to the conversation the operator has left. `RunScope`
+     * every future turn to the conversation the operator has left. `SessionScope`
      * says as much — `sessionId` is its one non-`readonly` field. What changed is
      * on the other side: a turn now fixes its own destination when it starts
      * (see `runTurn`), so a shared cursor moving under it can no longer decide
@@ -2916,7 +3052,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             // it runs when the abandoned turn finishes unwinding, which is after
             // this line — and a surface that reports a result it has not read is
             // the defect class this whole change is about. If that write fails,
-            // the turn says so itself, in the same words `run-stream` uses.
+            // the turn says so itself, in the same words `exec --json` 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.');
         }
     }, [
@@ -2940,7 +3076,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
      * 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.
+     * they cannot render into or start an SDK turn 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
@@ -2978,7 +3114,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             if (sourceScope && targetSessionId) {
                 sourceScope.sessionId = targetSessionId;
                 conversationMaterializedRef.current = true;
-                // A fresh conversation owns no runs yet, so this normally reads
+                // A fresh conversation owns no turns yet, so this normally reads
                 // nothing. It runs anyway because the rule is "the scope changed,
                 // re-read", and an exception here is how the resume path lost
                 // its own re-read.
@@ -3038,7 +3174,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         }
         try {
             if (!clear && title === '') {
-                const current = titleOf(sessions, scope.sessionId);
+                const current = await titleOf(sessions, scope.sessionId);
                 textPromptTokenRef.current += 1;
                 setTextPrompt({
                     token: textPromptTokenRef.current,
@@ -3051,7 +3187,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 });
                 return;
             }
-            setTitle(sessions, scope.sessionId, clear ? '' : title);
+            await setTitle(sessions, scope.sessionId, clear ? '' : title);
             pushMessage('system', clear
                 ? 'Name removed. /resume will list this conversation by its opening message again.'
                 : `Named "${title}".`);
@@ -3083,8 +3219,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             pushMessage('system', 'The conversation changed while this editor was open. Reopen the command in the current conversation.');
             return;
         }
-        if (prompt.kind === 'run-limit') {
-            const field = RUN_LIMIT_FIELDS.find((field) => field.key === prompt.limitKey);
+        if (prompt.kind === 'turn-limit') {
+            const field = TURN_LIMIT_FIELDS.find((field) => field.key === prompt.limitKey);
             if (field)
                 commandPickerSubmitRef.current(`/config limits ${field.name} ${value.trim()}`);
             return;
@@ -3103,13 +3239,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             pushMessage('system', 'Conversation history is unavailable in this folder.');
             return;
         }
-        try {
-            setTitle(sessions, prompt.sessionId, value);
-            pushMessage('system', `Named "${value.trim()}".`);
-        }
-        catch (error) {
-            pushMessage('system', `Could not save the name: ${error instanceof Error ? error.message : String(error)}`);
-        }
+        void setTitle(sessions, prompt.sessionId, value).then(() => pushMessage('system', `Named "${value.trim()}".`), (error) => pushMessage('system', `Could not save the name: ${error instanceof Error ? error.message : String(error)}`));
     }, [pushMessage, runConversationExport, setTextPrompt]);
     const cancelTextPrompt = useCallback(() => {
         const prompt = textPromptRef.current;
@@ -3431,9 +3561,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     st.sourceTextPartId = event.textPart?.id;
                 }
                 setState('thinking');
-                if (event.messageId && event.runId && st.sessionId) {
+                if (event.messageId && event.turnId && st.sessionId) {
                     lastAssistantMessage.current = {
-                        runId: event.runId,
                         messageId: event.messageId,
                         sessionId: st.sessionId,
                     };
@@ -3476,12 +3605,12 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 setState('tool');
                 const waitingAgent = event.toolName === 'wait_for_task' && event.taskId
                     ? subagentsRef.current.find((agent) => agent.taskId === event.taskId &&
-                        (event.runId === undefined || agent.workflowId === event.runId))
+                        (event.turnId === undefined || agent.workflowId === event.turnId))
                     : undefined;
                 const tool = {
                     ...(waitingAgent ? { taskId: waitingAgent.taskId } : {}),
                     id: event.toolUseId,
-                    ...(event.runId ? { runId: event.runId } : {}),
+                    ...(event.turnId ? { turnId: event.turnId } : {}),
                     toolName: event.toolName,
                     activity: event.activity,
                     label: waitingAgent
@@ -3497,7 +3626,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             case 'tool-progress': {
                 const running = activeToolsRef.current;
                 const index = running.findIndex((tool) => tool.id === event.toolUseId &&
-                    (event.runId === undefined || tool.runId === event.runId));
+                    (event.turnId === undefined || tool.turnId === event.turnId));
                 // A terminal event may already have removed this call. Never recreate
                 // a live row from late diagnostic state.
                 if (index < 0)
@@ -3524,7 +3653,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 // result to the wrong call. If no id matches, render the
                 // completion on its own (label from the end event itself).
                 const i = running.findIndex((tool) => tool.id === event.toolUseId &&
-                    (event.runId === undefined || tool.runId === event.runId));
+                    (event.turnId === undefined || tool.turnId === event.turnId));
                 const done = i >= 0 ? running[i] : undefined;
                 if (i >= 0) {
                     activeToolsRef.current = [...running.slice(0, i), ...running.slice(i + 1)];
@@ -3533,7 +3662,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 // Lifecycle updates own completion rows, even when the model never waits.
                 // Keep unknown waits and errors visible; never hide an unrepresented task.
                 const inspectableWait = done?.taskId && subagentsRef.current.some((agent) => agent.taskId === done.taskId &&
-                    (event.runId === undefined || agent.workflowId === event.runId) &&
+                    (event.turnId === undefined || agent.workflowId === event.turnId) &&
                     agent.transcript.some((row) => row.kind === 'assistant' && row.text.trim().length > 0));
                 if (!event.isError && inspectableWait && event.toolName === 'wait_for_task') {
                     setState(activeToolsRef.current.length > 0 ? 'tool' : 'thinking');
@@ -3542,7 +3671,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 const representedSuccessfulAgent = !event.isError &&
                     event.toolName.toLowerCase() === 'agent' &&
                     subagentsRef.current.some((agent) => agent.toolUseId === event.toolUseId &&
-                        (event.runId === undefined || agent.workflowId === event.runId));
+                        (event.turnId === undefined || agent.workflowId === event.turnId));
                 // The band above the rail already carries a narrated line, in the
                 // parent's own words, from the moment it is written. Printing the
                 // call that wrote it would show the same sentence twice, the
@@ -3697,7 +3826,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 // commentary deltas. The transcript keeps each visible part above.
                 if (event.text !== undefined)
                     st.text = event.text;
-                // `run_completed` is not synonymous with success: budgets,
+                // `turn_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.
@@ -3709,7 +3838,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     outcome: st.completed ? 'completed' : 'stopped',
                 };
                 closeAssistant();
-                const stopNotice = describeRunStop(event.stopReason, event.budget);
+                const stopNotice = describeTurnStop(event.stopReason, event.budget);
                 if (stopNotice)
                     pushMessage('system', stopNotice, false, '■');
                 break;
@@ -3723,20 +3852,21 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 st.outcome = 'stopped';
                 st.queuePauseOutcome = 'paused';
                 st.notification = { kind: 'turn-settled', outcome: 'stopped' };
-                pushMessage('system', describeRunInterruption(event), false, '⏸');
+                pushMessage('system', describeTurnInterruption(event), false, '⏸');
                 break;
             case 'error':
                 closeAssistant();
                 st.outcome = event.message === 'aborted' ? 'cancelled' : 'failed';
                 if (event.message !== 'aborted') {
                     st.notification = { kind: 'turn-settled', outcome: 'failed' };
-                    pushMessage('system', describeRunInterruption(event), false, '!');
+                    pushMessage('system', describeTurnInterruption(event), false, '!');
                 }
                 else
                     st.notification = null;
                 break;
         }
     }, [appendToMessage, finalizeMessage, flushStream, pushMessage]);
+    applyEventRef.current = applyEvent;
     const runTurn = useCallback(async (prompt) => {
         // A passive queue effect can still hold the previous render's session
         // while a replacement is being committed. Keep FIFO ownership until
@@ -3764,6 +3894,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         // state idle while the admission read was pending let a second submit
         // start beside it and broke the queue's FIFO ownership.
         setState('thinking');
+        // Both awaits below can span an interrupt, a `/clear` or a `/resume`,
+        // and neither has an abort controller yet for them to cancel. The
+        // token is what they take back instead.
+        const admission = {};
+        admissionRef.current = admission;
         let durableScope;
         try {
             durableScope = await materializeConversation();
@@ -3786,6 +3921,10 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 await requireWritableConversation(turnSessions, destination, 'start conversation turn');
             }
             catch (err) {
+                // Taken back meanwhile: the slot is no longer this prompt's.
+                if (admissionRef.current !== admission)
+                    return;
+                admissionRef.current = null;
                 if (prompt.kind === 'goal' && prompt.goalRound) {
                     goalActivation.disarm(prompt.goalRound.sessionId, prompt.goalRound);
                     wakeGoalDriver();
@@ -3795,6 +3934,13 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 return;
             }
         }
+        // Interrupted, or the conversation changed, while this prompt waited at
+        // the boundary. Whoever took the slot back already freed it and said
+        // so, and a turn of the new conversation may hold it now; this prompt
+        // is dropped rather than begun under that conversation.
+        if (admissionRef.current !== admission)
+            return;
+        admissionRef.current = null;
         // `@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
@@ -3815,7 +3961,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             }
             : undefined);
         const priorForSdk = [...historyBeforeTurn, userMessage];
-        const runId = generateRunId();
+        // Reserved before the turn begins, so everything that refers to this
+        // turn — its goal-round authority above all — names it from the start.
+        const turnId = generateTurnId();
         if (goalRound) {
             pushMessage('system', `Goal round ${goalRound.round} / ${goalRound.maxGoalRounds}`, false, '◎', [`Objective: ${goalRound.objective}`]);
         }
@@ -4010,7 +4158,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         const turnPermissionMode = permissionModeRef.current;
         const turnReasoningEffort = reasoningEffortRef.current;
         const turnOrchestrateMode = orchestrateModeRef.current;
-        const turnRunLimits = resolveRunGuards(ctxRef.current.limits, runLimitsOverrideRef.current);
+        const turnLimits = resolveTurnGuards(ctxRef.current.limits, turnLimitsOverrideRef.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.
@@ -4023,41 +4171,22 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             }
             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) {
+        // A goal round is a turn of a durable conversation: its round is recorded
+        // on the turn (`origin.kind: 'goal-round'`), and a conversation that is
+        // not in a log has nowhere to record it.
+        const admitted = goalRound === undefined || Boolean(turnSessions && destination);
+        if (!admitted && 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.`);
+            pushMessage('system', `Goal round ${goalRound.round} was not started because this conversation is not durable. Automatic continuation is disarmed; /goal resume retries explicitly.`);
         }
         try {
-            // `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 &&
+            // Setup above awaited. A conversation switch can happen meanwhile and
+            // move the mutable SessionScope captured by `createAgentSession`. Re-admit
+            // the turn here, immediately before the generator exists, or an
+            // abandoned prompt can begin its reserved turn under the new
+            // conversation.
+            if (admitted &&
                 !ac.signal.aborted &&
                 stillHere() &&
                 activeTurnTokenRef.current === turnToken &&
@@ -4066,9 +4195,13 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         goalActivation.isArmed(goalRound.sessionId, goalRound)))) {
                 for await (const event of session.send(priorForSdk, {
                     signal: ac.signal,
-                    runId,
+                    turnId,
+                    origin: { protocol: 'cli', kind: goalRound ? 'goal-round' : 'prompt' },
+                    // The TUI never resumes a turn whose process is gone; the next
+                    // prompt closes it. A paused turn is never closed this way.
+                    abandonInterrupted: true,
                     permissionMode: turnPermissionMode,
-                    limits: turnRunLimits,
+                    limits: turnLimits,
                     ...(turnReasoningEffort !== undefined ? { effort: turnReasoningEffort } : {}),
                     ...(turnOrchestrateMode ? { orchestrate: true } : {}),
                     ...(goalRound ? { goalRound } : {}),
@@ -4143,16 +4276,13 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             // 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];
+            // one keeps the old text-only shape. The durable record is the session
+            // log, which the kernel appended to as the turn ran; this is only the
+            // in-memory context the next send starts from.
+            const fallbackTurn = admitted ? [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 conversationMessages = admitted ? st.conversationMessages : undefined;
             const nextModelHistory = conversationMessages ?? [...historyBeforeTurn, ...fallbackTurn];
             if (goalRound && (ac.signal.aborted || st.outcome !== 'completed')) {
                 goalActivation.disarm(goalRound.sessionId, goalRound);
@@ -4207,61 +4337,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     sendTerminalNotification(st.notification);
                 }
             }
-            // Persisted either way, and into the conversation this turn was
-            // started in — captured above, never re-read.
-            //
-            // Best-effort is about not FAILING, not about staying quiet. The
-            // rejection used to be swallowed whole, and it is the one failure here
-            // that makes a LATER surface wrong: `/resume` comes back missing a
-            // turn that was on screen, and the next turn in that conversation
-            // silently lacks it as context, with nothing connecting either to a
-            // write that failed minutes ago. `run-stream` already says this, in
-            // these words and for this reason.
-            //
-            // Said wherever the operator is now, even when that is a different
-            // 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.
-            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.
+            // The kernel recorded the turn in the session log as it ran; nothing is
+            // left to publish once the loop has unwound.
             unsettledTurnGenerationsRef.current.delete(turnToken);
             const pending = pendingModelSwitchRef.current;
             if (pending?.turnToken === turnToken && pending.selection) {
@@ -4445,6 +4522,22 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         hydrateSession,
         wakeGoalDriver,
     ]);
+    // `#note` and `/memory add`: a typed memory file in the session's stored
+    // memory, default type `project`. A session without a store — no provider
+    // yet — appends to the curated project file the way every note used to.
+    const rememberProjectNote = useCallback(async (note, type) => {
+        try {
+            if (session?.rememberNote) {
+                pushMessage('system', renderTypedNoteResult(await session.rememberNote(note, type), note));
+                return;
+            }
+            const saved = appendMemoryWithStatus(note, { scope: 'project', cwd: ctx.cwd });
+            pushMessage('system', renderMemorySaveResult(saved, note));
+        }
+        catch (err) {
+            pushMessage('system', `Could not save memory: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, [ctx.cwd, pushMessage, session]);
     const handleSubmit = useCallback((value, attachments, mode = 'submit') => {
         if (goalCommandInFlightRef.current) {
             pushMessage('system', 'A goal command is still reaching durable session state. Wait for its result before sending another command or prompt.');
@@ -4478,13 +4571,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         // and both leave a row the model reads on its next turn.
         if (value.startsWith('#') && value.slice(1).trim().length > 0) {
             const note = value.slice(1).trim();
-            try {
-                const saved = appendMemoryWithStatus(note, { scope: 'project', cwd: ctx.cwd });
-                pushMessage('system', renderMemorySaveResult(saved, note));
-            }
-            catch (err) {
-                pushMessage('system', `Could not save memory: ${err instanceof Error ? err.message : String(err)}`);
-            }
+            void rememberProjectNote(note);
             return;
         }
         const escaped = shellEscapeCommand(value);
@@ -4550,21 +4637,23 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     });
                     return;
                 }
-                case 'agent-cockpit': {
-                    // Reported after the read, not before it: the answer to "are
-                    // there any" may be on disk, and a conversation whose evidence
-                    // is sitting in its own directory must never be told it
-                    // delegated nothing.
+                case 'agents': {
                     const agentIds = session?.agentIds ?? [];
-                    void openAgentCockpit().then((opened) => {
-                        if (opened)
-                            return;
-                        pushMessage('system', `No delegated agents in this conversation.${agentIds.length ? `\nAvailable: ${agentIds.join(', ')}` : '\nNo agents are configured.'}`);
-                    });
+                    runAgentsCommand(slash.args, () => {
+                        // Reported after the read, not before it: the answer to "are
+                        // there any" may be in the session's logs, and a conversation
+                        // whose children are recorded there must never be told it
+                        // delegated nothing.
+                        void openAgentCockpit().then((opened) => {
+                            if (opened)
+                                return;
+                            pushMessage('system', `No delegated agents in this conversation.${agentIds.length ? `\nAvailable: ${agentIds.join(', ')}` : '\nNo agents are configured.'}`);
+                        });
+                    }, () => pushMessage('system', renderAgents(agentIds)));
                     return;
                 }
-                case 'agent-runs': {
-                    openAgentRunsPicker();
+                case 'abandon': {
+                    void abandonActiveTurn(slash.reason);
                     return;
                 }
                 case 'provider-setup':
@@ -4574,21 +4663,21 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     }
                     setProviderSetup(true);
                     return;
-                case 'run-limits-set':
-                case 'run-limit-editor':
-                case 'run-limits-picker': {
-                    const currentLimits = resolveRunGuards(ctxRef.current.limits, runLimitsOverrideRef.current);
-                    if (slash.kind === 'run-limit-editor') {
+                case 'turn-limits-set':
+                case 'turn-limit-editor':
+                case 'turn-limits-picker': {
+                    const currentLimits = resolveTurnGuards(ctxRef.current.limits, turnLimitsOverrideRef.current);
+                    if (slash.kind === 'turn-limit-editor') {
                         const scope = scopeRef.current;
                         if (!scope) {
-                            pushMessage('system', 'Run limits are available after the session starts.');
+                            pushMessage('system', 'Turn limits are available after the session starts.');
                             return;
                         }
-                        const field = RUN_LIMIT_FIELDS.find((field) => field.key === slash.key);
+                        const field = TURN_LIMIT_FIELDS.find((field) => field.key === slash.key);
                         textPromptTokenRef.current += 1;
                         setTextPrompt({
                             token: textPromptTokenRef.current,
-                            kind: 'run-limit',
+                            kind: 'turn-limit',
                             limitKey: slash.key,
                             title: `${field.label} (${slash.key === 'timeoutMs' ? 'ms; ' : ''}0 = unlimited)`,
                             placeholder: field.hint,
@@ -4598,15 +4687,15 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         });
                         return;
                     }
-                    if (slash.kind === 'run-limits-set') {
-                        runLimitsOverrideRef.current = { ...runLimitsOverrideRef.current, ...slash.limits };
+                    if (slash.kind === 'turn-limits-set') {
+                        turnLimitsOverrideRef.current = { ...turnLimitsOverrideRef.current, ...slash.limits };
                     }
-                    const commands = runLimitCommands(resolveRunGuards(currentLimits, runLimitsOverrideRef.current));
+                    const commands = turnLimitCommands(resolveTurnGuards(currentLimits, turnLimitsOverrideRef.current));
                     setSelectedChoice(0);
                     setChoicePicker({
                         kind: 'command',
-                        title: 'Run limits',
-                        notice: `${slash.kind === 'run-limits-set' ? 'Updated. ' : ''}This session · new turns and their agents. Existing runs keep their limits.`,
+                        title: 'Turn limits',
+                        notice: `${slash.kind === 'turn-limits-set' ? 'Updated. ' : ''}This session · new turns and their agents. Existing turns keep their limits.`,
                         values: commands,
                         options: commands.map((command) => ({
                             label: command.label,
@@ -4638,8 +4727,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         },
                         {
                             name: 'config limits',
-                            label: 'Run limits',
-                            description: runLimitCommands(resolveRunGuards(ctxRef.current.limits, runLimitsOverrideRef.current))
+                            label: 'Turn limits',
+                            description: turnLimitCommands(resolveTurnGuards(ctxRef.current.limits, turnLimitsOverrideRef.current))
                                 .slice(0, 3)
                                 .map((field) => `${field.label}: ${field.description}`)
                                 .join(' · '),
@@ -4660,7 +4749,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     setChoicePicker({
                         kind: 'command',
                         title: 'Configuration',
-                        notice: 'Model, reasoning, permission and run-limit changes apply to this session.',
+                        notice: 'Model, reasoning, permission and turn-limit changes apply to this session.',
                         values: commands,
                         options: commands.map((command) => ({
                             label: command.label,
@@ -4940,6 +5029,10 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     return;
                 }
                 case 'remember':
+                    if (slash.scope === 'project') {
+                        void rememberProjectNote(slash.text, slash.memoryType);
+                        return;
+                    }
                     try {
                         const saved = appendMemoryWithStatus(slash.text, { scope: slash.scope, cwd: ctx.cwd });
                         pushMessage('system', renderMemorySaveResult(saved, slash.text));
@@ -4948,14 +5041,35 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         pushMessage('system', `Could not save memory: ${err instanceof Error ? err.message : String(err)}`);
                     }
                     return;
+                case 'import-notes': {
+                    if (!session?.importCuratedNotes) {
+                        pushMessage('system', 'Stored memory is not open yet; /memory import-notes works once a session has started.');
+                        return;
+                    }
+                    void session.importCuratedNotes().then((report) => pushMessage('system', report), (err) => pushMessage('system', `Notes were not copied: ${err instanceof Error ? err.message : String(err)}`));
+                    return;
+                }
                 case 'show-memory': {
-                    pushMessage('system', renderMemoryReport(readMemory(undefined, ctx.cwd), { cwd: ctx.cwd }));
+                    const curated = renderMemoryReport(readMemory(undefined, ctx.cwd), { cwd: ctx.cwd });
+                    const stored = session?.storedMemoryIndex;
+                    if (!stored) {
+                        pushMessage('system', curated);
+                        return;
+                    }
+                    void stored().then(({ directory, index, derived }) => {
+                        const section = renderStoredMemorySection(directory, index, derived);
+                        pushMessage('system', section
+                            ? curated.startsWith('No saved memory.')
+                                ? section
+                                : `${section}\n\n${curated}`
+                            : curated);
+                    }, (err) => pushMessage('system', `${curated}\n\nStored memories not loaded: ${err instanceof Error ? err.message : String(err)}`));
                     return;
                 }
                 case 'list-skills': {
                     // The session's directory, not the process's — the same
                     // distinction the headless commands get from `--cwd`. They are
-                    // the same value today, and were the same value in `run-stream`
+                    // the same value today, and were the same value in `exec --json`
                     // too until they were not.
                     const skills = discoverSkills({ cwd: ctx.cwd });
                     if (skills.length === 0) {
@@ -5042,9 +5156,35 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         pushMessage('system', 'No session yet; /add-dir works once one has started.');
                         return;
                     }
-                    void dirs.add(slash.path).then((result) => {
+                    void dirs
+                        .add(slash.path, {
+                        // Outside the working directory, adding it lets every file
+                        // tool reach it unasked, so it is asked about once here.
+                        approve: (absolute) => {
+                            if (questionRef.current) {
+                                pushMessage('system', 'Answer the open question first; /add-dir asks one of its own.');
+                                return Promise.resolve(false);
+                            }
+                            return askQuestion({
+                                questionId: `add-dir:${absolute}`,
+                                question: `Let the file tools read and write ${absolute} for this session?`,
+                                header: 'Outside the working directory',
+                                options: [
+                                    {
+                                        id: 'yes',
+                                        label: 'Yes, add it',
+                                        description: 'File tools reach it without asking again; a sandboxed turn binds it read-write.',
+                                    },
+                                    { id: 'no', label: 'No', description: 'Leave it out' },
+                                ],
+                                multiSelect: false,
+                                allowFreeText: false,
+                            }).then((answer) => answer.kind === 'answer' && answer.selectedOptionIds.includes('yes'));
+                        },
+                    })
+                        .then((result) => {
                         pushMessage('system', result.added
-                            ? `Added ${result.path}. The file tools reach it by absolute path from the next turn; a sandboxed run binds it read-write.`
+                            ? `Added ${result.path}. The file tools reach it by absolute path from the next turn; a sandboxed turn binds it read-write.`
                             : `Not added: ${result.path} — ${result.reason ?? 'refused'}`);
                     });
                     return;
@@ -5079,7 +5219,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                             if (goalCommand)
                                 await materializeConversation();
                             const durableSessions = sessionsRef.current;
-                            const runScope = scopeRef.current;
+                            const sessionScope = scopeRef.current;
                             const taskStore = slash.name === 'tasks' ? session?.currentTaskStore?.() : undefined;
                             if (slash.name === 'tasks' && !taskStore) {
                                 pushMessage('system', session?.currentTaskStore
@@ -5091,11 +5231,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                             registry.register(kernelHostCommands({
                                 allowedAgentIds: session?.agentIds ?? [],
                                 ...(taskStore ? { taskStore } : {}),
-                                ...(durableSessions && runScope && conversationMaterializedRef.current
+                                ...(durableSessions && sessionScope && conversationMaterializedRef.current
                                     ? {
                                         goal: {
                                             store: durableSessions.goals,
-                                            sessionId: runScope.sessionId,
+                                            sessionId: sessionScope.sessionId,
                                             tenantId: durableSessions.tenantId,
                                             activation: goalActivation,
                                         },
@@ -5140,7 +5280,6 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     setChoicePicker({
                         kind: 'feedback-rating',
                         title: 'Rate the latest answer',
-                        runId: target.runId,
                         messageId: target.messageId,
                         sessionId: target.sessionId,
                         values,
@@ -5160,7 +5299,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         pushMessage('system', 'Nothing to rate yet.');
                         return;
                     }
-                    recordFeedback(target.sessionId, target.runId, slash.messageId, slash.rating, slash.note);
+                    recordFeedback(target.sessionId, slash.messageId, slash.rating, slash.note);
                     return;
                 }
                 case 'review': {
@@ -5249,16 +5388,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                 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;
+                            // Durable first, screen second: for a conversation in a log,
+                            // `session.compact` has already appended the compaction record
+                            // the next `/resume` folds, before it returned.
+                            const durable = Boolean(sessionsRef.current && scopeRef.current && conversationMaterializedRef.current);
+                            modelHistoryRef.current = [...result.messages];
                             // How many user/assistant turns survived the pass.
                             // `keepRecentRows` explains why the transcript is trimmed
                             // to match rather than rebuilt from `result.messages`.
@@ -5274,7 +5408,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                     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
+                                        : ''}${durable
                                         ? ''
                                         : ' Conversation persistence is unavailable, so this compacted history lasts only for this process.'}`,
                                     detail: summaryDetail(result.summary),
@@ -5406,9 +5540,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         hostCommands,
         nextId,
         openAgentCockpit,
-        openAgentRunsPicker,
+        runAgentsCommand,
+        abandonActiveTurn,
         pushMessage,
         rawOutput,
+        rememberProjectNote,
         removeStoredCredential,
         resetTranscript,
         runConversationExport,
@@ -5502,7 +5638,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         }
         const durableSessions = sessionsRef.current;
         const scope = scopeRef.current;
-        if (!durableSessions?.turnEvidence || !scope)
+        if (!durableSessions || !scope || !conversationMaterializedRef.current)
             return;
         const generation = conversationGenRef.current;
         const sessionId = scope.sessionId;
@@ -5858,7 +5994,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     ? permission.review
                     : (permission.summary.compactText ?? permission.summary.text);
                 const count = permissionReviewRows(source, terminal.columns).length;
-                const pageRows = Math.max(1, permissionReviewPageRows(terminal.rows) - (permission.runId ? 1 : 0));
+                const pageRows = Math.max(1, permissionReviewPageRows(terminal.rows) - (reviewSource(permission, scopeRef.current?.sessionId) ? 1 : 0));
                 const maxOffset = Math.max(0, count - pageRows);
                 const current = Math.min(permissionReviewOffsetRef.current, maxOffset);
                 const next = key.home
@@ -6263,8 +6399,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     // while the provider event that removes the generic tool row arrives on the
     // next tick; filtering only live children made that raw row flash back.
     const visibleActiveTools = activeTools.filter((tool) => tool.toolName.toLowerCase() !== 'agent' ||
-        !(tool.runId
-            ? representedSubagentTools.has(JSON.stringify([tool.runId, tool.id]))
+        !(tool.turnId
+            ? representedSubagentTools.has(JSON.stringify([tool.turnId, tool.id]))
             : representedUnscopedSubagentToolUseIds.has(tool.id)));
     const outputBlocks = outputViewer
         ? messages.filter((m) => m.detailRef !== undefined && (m.detail?.length ?? 0) > 0)
@@ -6321,11 +6457,14 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                                 : goalStatus && phase === 'ready' && state === 'idle'
                                                     ? undefined
                                                     : hintForPhase(phase, state, session?.hasProvider === true, composerHasDraft);
-    const permissionOwner = permission?.runId
-        ? subagents.find((agent) => agent.runId === permission.runId)
+    const permissionSource = reviewSource(permission, scopeRef.current?.sessionId);
+    const permissionOwner = permissionSource
+        ? subagents.find((agent) => agent.sessionId === permissionSource)
         : undefined;
-    const permissionSourceLabel = permission?.runId
-        ? permissionOwner ? `Agent: ${permissionOwner.description}` : `Run: ${permission.runId}`
+    const permissionSourceLabel = permissionSource
+        ? permissionOwner
+            ? `Agent: ${permissionOwner.description}`
+            : `Session: ${permissionSource}`
         : undefined;
     const displayedPermissionMode = effectivePermissionMode(permissionMode, session?.approvalLatched() ?? false);
     // True exactly when the phase ternary below renders its final branch — the
@@ -6375,7 +6514,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                     copyPicker === null &&
                                     agentSurface === null && outputViewer === null ? (_jsx(Box, { paddingX: 1, children: _jsxs(Text, { color: theme.text.muted, children: [queuePause ? '⏸' : '⏎', " ", queued.length, " message", queued.length > 1 ? 's' : '', " queued \u2014", ' ', queuePause
                                                 ? queuePause.outcome === 'paused'
-                                                    ? 'held after a resumable run paused; wait for recovery, change model, or send a message to release it'
+                                                    ? 'held after a resumable turn paused; wait for recovery, change model, or send a message to release it'
                                                     : `paused after a ${queuePause.outcome} turn; send a message or change model to continue`
                                                 : 'sending when ready'] }) })) : null, _jsx(Composer, { reasoningEffortLevels: session?.reasoningEffortLevels, onCycleMode: cyclePermissionMode, disabled: outputViewer !== null ||
                                         phase !== 'ready' ||
@@ -6483,27 +6622,37 @@ function goalStatusLabel(goal, armed) {
             return 'Goal achieved';
     }
 }
+/**
+ * The child session a tool review came from, when it is not this
+ * conversation's own turn: what names the agent asking in the prompt. Read by
+ * field, because the review request names its session only when the kernel
+ * attributes it.
+ */
+function reviewSource(request, currentSessionId) {
+    const sessionId = request?.sessionId;
+    return typeof sessionId === 'string' && sessionId !== currentSessionId ? sessionId : undefined;
+}
 /** The label the operator saw for the option id they chose. */
 function labelOfOption(question, optionId) {
     return question.options.find((option) => option.id === optionId)?.label ?? optionId;
 }
-/** `/agents runs`' one-line-per-run text, mirroring `/jobs`' own column shape. */
-function agentRunOption(run) {
-    const agents = `${run.agentsDone}/${run.agentsTotal} agent${run.agentsTotal === 1 ? '' : 's'}`;
-    const tokens = `${run.tokensTotal.toLocaleString('en-US')} tokens`;
+/** `/agents batches`' one-line-per-batch text, mirroring `/jobs`' own column shape. */
+function batchOption(batch) {
+    const agents = `${batch.agentsDone}/${batch.agentsTotal} agent${batch.agentsTotal === 1 ? '' : 's'}`;
+    const tokens = `${batch.tokensTotal.toLocaleString('en-US')} tokens`;
     const columns = [
-        relativeRunStart(run.startedAt),
-        run.phases.join(', '),
+        relativeStart(batch.startedAt),
+        batch.phases.join(', '),
         agents,
         tokens,
-        formatElapsed(run.elapsedMs),
+        formatElapsed(batch.elapsedMs),
     ];
-    if (run.live)
+    if (batch.live)
         columns.push('live');
-    return { label: run.name, description: columns.join(' · ') };
+    return { label: batch.name, description: columns.join(' · ') };
 }
 /** `just now` / `12m ago` / `3h ago` / `2d ago` — the same buckets a conversation's own resume picker shows. */
-function relativeRunStart(startedAt) {
+function relativeStart(startedAt) {
     const minutes = Math.round((Date.now() - startedAt) / 60_000);
     if (minutes < 1)
         return 'just now';