@namzu/cli 30.0.0 → 33.0.0

package/dist/tui/App.js

@@ -19,15 +19,16 @@ import { ToolOutputViewer } from './ToolOutputViewer.js';
 import { join, relative } from 'node:path';
 import { DEFAULT_MAX_GOAL_ROUNDS, DiskMessageFeedbackStore, GoalRoundLimitError, HostCommandRegistry, SessionGoalActivation, StaleGoalError, TurnCancelled, asSessionId, createAssistantMessage, createUserMessage, generateSessionId, generateTurnId, isCompactionMessage, kernelHostCommands, SKILL_TOOL_NAME, } from '@namzu/sdk';
 import { Box, Text, useApp, useInput, useStdout, useWindowSize } from 'ink';
-import { useCallback, useEffect, useRef, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { pinTrustedProjectPath, resolveTrustedProjectContext, } from '../config/trusted-project-context.js';
 import { visibleProjectInstructionPath } from '../context/project-path.js';
 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 { activeConversationTurn, archiveConversation, forkConversation, forkConversationBeforeUser, listRecent, loadConversation, loadResumableConversation, openSessions, requireWritableConversation, setTitle, startConversation, titleOf, } from '../integrations/sessions/store.js';
+import { beginCodexDeviceLogin, beginSubscriptionLogin, clearAllStoredCredentials, clearStoredCodexCredential, clearStoredGeminiApiKey as clearStoredGoogleApiKey, clearStoredSubscriptionCredential, credentialsPath, googleApiKeyPath, parsePastedInput, primaryProvider, readStoredCodexCredential, readStoredGeminiApiKey as readStoredGoogleApiKey, readStoredSubscriptionCredential, signedInSubscriptionProviders, writePreferences, writeStoredGeminiApiKey as writeStoredGoogleApiKey, } from '../integrations/providers/index.js';
+import { ConversationIndexRefreshError, activeConversationTurn, archiveConversation, forkConversation, forkConversationBeforeUser, listArchived, listRecent, loadConversation, loadResumableConversation, openSessions, requireWritableConversation, setTitle, startConversation, titleOf, unarchiveConversation, } from '../integrations/sessions/store.js';
 import { conversationMarkdown, writeConversationExport, } from '../integrations/sessions/transcript-export.js';
+import { openManagedWorktrees, worktreeOpenHint } from '../integrations/worktrees/managed.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';
@@ -43,8 +44,15 @@ import { BrandHeader } from './BrandHeader.js';
 import { ChoicePicker } from './ChoicePicker.js';
 import { emptyPluginReport, pluginDetails, pluginOption, pluginStartupState } from './plugin-view.js';
 import { Composer, suggestionWindowSize, } from './Composer.js';
+import { resolveComposerTriggers } from '../config/composer-triggers.js';
+import { triggerContextTexts, triggerEffort } from './triggers/context-text.js';
+import { transcriptTagLine } from './triggers/copy.js';
+import { unavailable as triggerUnavailable } from './triggers/detect.js';
+import { BUILTIN_TRIGGERS, compileRegistry, triggerDefinition, } from './triggers/registry.js';
+import { describeComposerTriggers, setComposerTriggers } from './triggers/setting.js';
 import { ComposerFrame } from './ComposerFrame.js';
 import { EffortSlider, effortSliderLayout } from './EffortSlider.js';
+import { HYPERMODE, HYPERMODE_SUMMARY, ORCHESTRATE_ALIAS_NOTICE, hypermodeEffort, hypermodeStopLabel, } from './hypermode.js';
 import { CopyPicker } from './CopyPicker.js';
 import { EditPromptPicker } from './EditPromptPicker.js';
 import { LiveActivity, formatElapsed } from './LiveActivity.js';
@@ -81,7 +89,7 @@ import { checklistInView, liveWindow, settledBeforeStreaming } from './live-wind
 import { ViewportBound } from './ViewportBound.js';
 import { resolveModelSwitch, } from './model-switch.js';
 import { parseModelSelectionIntent, resolveModelSelectionIntent } from './model-selection-intent.js';
-import { describeCodexDeviceLoginStart, describeLoginOutcome, describeLoginStart, describeLogout, describeProviderLogout, } from './login-prompt.js';
+import { describeCodexDeviceLoginStart, describeLoginOutcome, describeLoginStart, describeAllCredentialsLogout, describeProviderLogout, } from './login-prompt.js';
 import { selectPrimaryProvider } from './provider-selection.js';
 import { eraseLastChoiceGrapheme } from './terminal-choice-text.js';
 import { renderCheckpoints, renderRestore } from '../checkpoints/store.js';
@@ -94,6 +102,7 @@ import { moveSelection } from './selection-window.js';
 import { describeShellEscape, describeShellEscapeForModel, runShellEscape, shellEscapeCommand, } from './shell-escape.js';
 import { baseBranchReviewPrompt, commitReviewPrompt, hostCommandNames, kernelCommandDescriptors, mergeHostCommands, renderAgents, renderOutcome, reviewPrompt, runSlash, } from './slashCommands.js';
 import { splitCompleteBlocks, splitSafeCut } from './stream-blocks.js';
+import { terminalDisplayText } from './terminal-display.js';
 import { terminalSupportsHyperlinks } from './terminal-hyperlinks.js';
 import { theme } from './theme.js';
 import { useSelectionIndex } from './use-selection-index.js';
@@ -415,11 +424,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     // A session setting layered above effort, not a level a provider publishes
     // — see docs/cli/slash-commands.md's /effort section. In-memory and
     // per-session like reasoningEffort above; no preferences file involved.
-    const [orchestrateMode, setOrchestrateModeState] = useState(false);
-    const orchestrateModeRef = useRef(false);
-    const setOrchestrateMode = useCallback((next) => {
-        orchestrateModeRef.current = next;
-        setOrchestrateModeState(next);
+    const [hypermode, setHypermodeState] = useState(false);
+    const hypermodeRef = useRef(false);
+    const setHypermode = useCallback((next) => {
+        hypermodeRef.current = next;
+        setHypermodeState(next);
     }, []);
     const [activeSkills, setActiveSkills] = useState([]);
     // Read when the session comes up rather than on every keystroke: the
@@ -983,7 +992,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             ask: (question, signal) => scheduleLiveRef.current?.ask(question, signal) ?? Promise.resolve({ kind: 'skip' }),
             askPermission: (request) => scheduleLiveRef.current?.askPermission(request) ??
                 Promise.resolve({ kind: 'reject', feedback: 'Nobody can answer yet.' }),
-            submit: (text) => scheduleLiveRef.current?.submit(text),
+            submit: (text, createdBy) => scheduleLiveRef.current?.submit(text, createdBy),
         });
     }
     /**
@@ -1158,9 +1167,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     // outlived the row it named would resolve `/expand 3` to output the operator
     // can no longer see anywhere, which is the failure this surface is being
     // cleaned of, one layer up.
-    const resetTranscript = useCallback(() => {
+    const resetTranscript = useCallback((options = {}) => {
         if (stdout.isTTY)
             writeStdout('\x1b[2J\x1b[3J\x1b[H');
+        if (!options.preserveOutputViewer)
+            setOutputViewer(null);
         // 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.
@@ -1172,12 +1183,13 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         const previous = previousTerminalRef.current;
         previousTerminalRef.current = terminal;
         if (externalEditorRequestRef.current === null &&
-            (terminal.columns < previous.columns || terminal.rows < previous.rows)) {
-            // A contraction can reflow live rows into native scrollback before Ink
-            // receives resize. Its old row count cannot erase those rows. Rebuild
-            // Namzu's normal-buffer view at the committed size, retaining the same
-            // messages, draft and selected child. Regular frames remain incremental.
-            resetTranscript();
+            (terminal.columns !== previous.columns || terminal.rows < previous.rows)) {
+            // A contraction can move live rows into native scrollback before Ink
+            // receives resize; expansion leaves already-printed Static rows wrapped
+            // at their old width. Rebuild the normal-buffer transcript at the new
+            // width, retaining messages, draft and selected child. Regular frames
+            // remain incremental.
+            resetTranscript({ preserveOutputViewer: true });
         }
     }, [terminal, resetTranscript]);
     const requestExternalEditor = useCallback((seed) => {
@@ -1297,6 +1309,46 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const learningRef = useRef({ generation: -1, proposed: false, skillUsed: false });
     /** `/skills save off|on` in this session, over whatever the config files say. */
     const skillSuggestOverrideRef = useRef(undefined);
+    /** `/config triggers on|off` in this session, over whatever the config files say. */
+    const [composerTriggersOverride, setComposerTriggersOverride] = useState();
+    const composerTriggerSettings = useMemo(() => resolveComposerTriggers(ctx.composerTriggers), [ctx.composerTriggers]);
+    const composerTriggerRegistry = useMemo(() => compileRegistry(BUILTIN_TRIGGERS, {
+        arming: composerTriggerSettings.arming,
+        locales: composerTriggerSettings.languages,
+    }), [composerTriggerSettings]);
+    const composerTriggersOn = composerTriggersOverride ?? composerTriggerSettings.enabled;
+    /**
+     * Whether the model can run `skill-creator` here, which save-as-skill
+     * needs. Read once for the tag row; read again when a turn starts and when
+     * its follow-up would run, in case the skills changed meanwhile.
+     */
+    const readSkillCreator = useCallback(() => {
+        try {
+            const creator = discoverSkills({
+                cwd: ctx.cwd,
+                ...(ctx.skills ? { config: ctx.skills } : {}),
+            }).find((skill) => skill.name === SKILL_CREATOR_SKILL);
+            return Boolean(creator && !creator.problem && creator.invocation !== 'operator');
+        }
+        catch {
+            return false;
+        }
+    }, [ctx.cwd, ctx.skills]);
+    const skillCreatorAvailable = useMemo(() => readSkillCreator(), [readSkillCreator]);
+    /** The session as the triggers see it right now, for a check at a turn's start or end. */
+    const triggerContextNow = useCallback(() => ({
+        permissionMode: permissionModeRef.current,
+        sessionHypermode: hypermodeRef.current,
+        effortMenu: (session?.reasoningEffortLevels?.length ?? 0) > 0,
+        // The interactive session always mounts `Agent` and the `schedule`
+        // tool; only scheduled runs withhold them, and those never read
+        // composer triggers.
+        agentTool: true,
+        skillCreator: readSkillCreator(),
+        scheduleTool: true,
+    }), [readSkillCreator, session]);
+    /** A turn's hand-off to its after-turn triggers; assigned below, where the queue lives. */
+    const triggerFollowUpsRef = useRef(null);
     const conversationLearning = useCallback(() => {
         if (learningRef.current.generation !== conversationGenRef.current) {
             learningRef.current = {
@@ -1613,22 +1665,28 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         pushMessage('system', `Reasoning: ${effort} (this session).`);
     }, [hasUnsettledTurn, pushMessage, session, setReasoningEffort, state]);
     /**
-     * Turn the session's orchestrate mode on or off.
+     * Turn the session's hypermode on or off.
      *
      * On: pins effort to the model's highest published level (last entry of
      * `reasoningEffortLevels`, which every provider publishes low-to-high) and
-     * strengthens delegation guidance for future turns via `SendOptions.orchestrate`
+     * strengthens delegation guidance for future turns via `SendOptions.hypermode`
      * — see `applyReasoningEffort` above for the mirrored guard shape. When the
      * model publishes no exact menu, effort is left alone and the notice says
      * so explicitly rather than silently doing nothing.
      */
-    const applyOrchestrateMode = useCallback((enabled, selectedSession) => {
+    /**
+     * The effort in force before hypermode pinned the highest level, and the
+     * level it pinned. Turning the mode off puts the effort back — unless the
+     * operator chose another level meanwhile, which then stays.
+     */
+    const hypermodePinRef = useRef(null);
+    const applyHypermode = useCallback((enabled, selectedSession) => {
         if (!session?.hasProvider) {
-            pushMessage('system', 'No active session — pick a provider before turning orchestrate mode on.');
+            pushMessage('system', 'No active session — pick a provider before turning hypermode on.');
             return;
         }
         if (selectedSession !== undefined && selectedSession !== session) {
-            pushMessage('system', 'Orchestrate mode was not changed: the selected model is no longer active.');
+            pushMessage('system', 'Hypermode was not changed: the selected model is no longer active.');
             return;
         }
         if (state !== 'idle' ||
@@ -1637,22 +1695,38 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             (queuedRef.current.length > 0 && selectedSession !== session) ||
             permissionResolveRef.current !== null ||
             compactingRef.current) {
-            pushMessage('system', 'Orchestrate mode was not changed: wait for the active turn, prompt, compaction, and queued work to settle.');
+            pushMessage('system', 'Hypermode was not changed: wait for the active turn, prompt, compaction, and queued work to settle.');
             return;
         }
-        setOrchestrateMode(enabled);
+        if (!enabled && !hypermodeRef.current) {
+            pushMessage('system', 'Hypermode is off.');
+            return;
+        }
+        setHypermode(enabled);
         if (!enabled) {
-            pushMessage('system', 'Orchestrate mode is off.');
+            const pin = hypermodePinRef.current;
+            hypermodePinRef.current = null;
+            if (pin && reasoningEffortRef.current === pin.pinned) {
+                setReasoningEffort(pin.before);
+                pushMessage('system', `Hypermode is off — effort back to ${pin.before ?? 'the provider default'}.`);
+                return;
+            }
+            pushMessage('system', 'Hypermode is off.');
             return;
         }
-        const highest = highestReasoningEffort(session.reasoningEffortLevels);
-        if (highest !== undefined) {
-            setReasoningEffort(highest);
-            pushMessage('system', `Orchestrate mode is on — effort pinned to ${highest} for ${session.modelSummary ?? 'this model'}, and delegation guidance is strengthened for this session.`);
+        const pinned = hypermodeEffort(session.reasoningEffortLevels);
+        if (pinned !== undefined) {
+            // Turning it on twice keeps the effort from before the first time.
+            if (!hypermodePinRef.current)
+                hypermodePinRef.current = { before: reasoningEffortRef.current, pinned };
+            else
+                hypermodePinRef.current = { ...hypermodePinRef.current, pinned };
+            setReasoningEffort(pinned);
+            pushMessage('system', `Hypermode is on — effort pinned to ${pinned} for ${session.modelSummary ?? 'this model'}, and delegation guidance is strengthened for this session.`);
             return;
         }
-        pushMessage('system', `Orchestrate mode is on — ${session.modelSummary ?? 'this model'} does not publish an exact effort menu, so effort was left as is. Delegation guidance is still strengthened for this session.`);
-    }, [hasUnsettledTurn, pushMessage, session, setOrchestrateMode, setReasoningEffort, state]);
+        pushMessage('system', `Hypermode is on — ${session.modelSummary ?? 'this model'} does not publish an exact effort menu, so effort was left as is. Delegation guidance is still strengthened for this session.`);
+    }, [hasUnsettledTurn, pushMessage, session, setHypermode, setReasoningEffort, state]);
     const stepReasoningEffort = useCallback((direction) => {
         const levels = session?.reasoningEffortLevels;
         if (!session?.hasProvider || levels === undefined || levels.length === 0) {
@@ -1733,26 +1807,44 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         }
     }, [conversationLearning, ctx.cwd, ctx.skills, pushMessage]);
     const removeStoredCredential = useCallback((target) => {
-        const path = credentialsPath();
+        const path = target === 'google' ? googleApiKeyPath() : credentialsPath();
         const hadClaude = readStoredSubscriptionCredential() !== null;
         const hadCodex = readStoredCodexCredential() !== null;
+        const hadGoogleKey = readStoredGoogleApiKey() !== null;
+        if (target === 'all') {
+            const failures = [];
+            try {
+                clearAllStoredCredentials();
+            }
+            catch (error) {
+                failures.push(`${credentialsPath()}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            try {
+                clearStoredGoogleApiKey();
+            }
+            catch (error) {
+                failures.push(`${googleApiKeyPath()}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (failures.length > 0) {
+                pushMessage('system', `Some stored credentials could not be removed: ${failures.join('; ')}. Check both stores before retrying.`);
+                return;
+            }
+            pushMessage('system', describeAllCredentialsLogout(path, googleApiKeyPath(), hadClaude || hadCodex || hadGoogleKey));
+            return;
+        }
         try {
             if (target === 'anthropic')
                 clearStoredSubscriptionCredential();
             else if (target === 'codex')
                 clearStoredCodexCredential();
             else
-                clearAllStoredCredentials();
+                clearStoredGoogleApiKey();
         }
         catch (error) {
             pushMessage('system', `Could not remove ${path}: ${error instanceof Error ? error.message : String(error)}`);
             return;
         }
-        if (target === 'all') {
-            pushMessage('system', describeLogout(path, hadClaude || hadCodex));
-            return;
-        }
-        pushMessage('system', describeProviderLogout(path, target, target === 'anthropic' ? hadClaude : hadCodex));
+        pushMessage('system', describeProviderLogout(path, target, target === 'anthropic' ? hadClaude : target === 'codex' ? hadCodex : hadGoogleKey));
     }, [pushMessage]);
     /** Publish one recoverable, read-only tombstone before leaving the TUI. */
     const archiveCurrentConversation = useCallback(() => {
@@ -1795,7 +1887,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 closeAndExit();
             }
             catch (error) {
-                pushMessage('system', `Could not archive this conversation: ${error instanceof Error ? error.message : String(error)}`);
+                pushMessage('system', error instanceof ConversationIndexRefreshError
+                    ? error.message
+                    : `Could not archive this conversation: ${error instanceof Error ? error.message : String(error)}`);
             }
             finally {
                 if (!archived && conversationMutationRef.current === 'archive') {
@@ -2214,8 +2308,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             removeStoredCredential(value);
             return;
         }
-        if (picker.kind === 'reasoning-effort' && value === ORCHESTRATE_MODE_VALUE) {
-            applyOrchestrateMode(!orchestrateModeRef.current, picker.selectedSession);
+        if (picker.kind === 'reasoning-effort' && value === HYPERMODE_VALUE) {
+            applyHypermode(!hypermodeRef.current, picker.selectedSession);
             return;
         }
         applyReasoningEffort(value, picker.selectedSession);
@@ -2223,7 +2317,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         activateSkill,
         advanceQueueContinuation,
         appLifetime.signal,
-        applyOrchestrateMode,
+        applyHypermode,
         applyPermissionMode,
         applyReasoningEffort,
         archiveCurrentConversation,
@@ -2546,11 +2640,15 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         // 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. Orchestrate
+        // above, so they leave the current session selection untouched. Hypermode
         // mode survives the switch: re-pin to the new model's highest published
         // level instead of clearing, exactly as it pinned when first turned on.
         if (signal !== undefined) {
-            setReasoningEffort(orchestrateModeRef.current ? highestReasoningEffort(s.reasoningEffortLevels) : undefined);
+            const repinned = hypermodeRef.current ? hypermodeEffort(s.reasoningEffortLevels) : undefined;
+            // A new model starts at its own default; that is what turning
+            // hypermode off returns to now.
+            hypermodePinRef.current = repinned ? { before: undefined, pinned: repinned } : null;
+            setReasoningEffort(repinned);
         }
         // Re-hydration (a provider switch via /model) builds a second session;
         // without this the first one's tool-server child processes stay alive
@@ -2559,9 +2657,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         void previousSessionRef.current?.close();
         previousSessionRef.current = s;
         setSession(s);
-        // Orchestrate mode already re-pinned effort above; reopening this picker
+        // Hypermode already re-pinned effort above; reopening this picker
         // would ask the operator to redo a choice the mode just made for them.
-        if (!orchestrateModeRef.current && options.chooseReasoningEffort && s.reasoningEffortLevels?.length) {
+        if (!hypermodeRef.current && options.chooseReasoningEffort && s.reasoningEffortLevels?.length) {
             // Own input before publishing ready or releasing a paused queue. The
             // menu closes only after choosing an effort or keeping the new default.
             setSelectedChoice(0);
@@ -2575,10 +2673,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 setMentionCandidates(files);
         });
         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)
+        // Failed and superseded provider choices returned above. A usable
+        // provider change can recover a failed turn's dependent queue, but a
+        // paused turn still owns the conversation's durable active slot. Keep
+        // that queue held until its checkpoint is resumed and settles.
+        if (signal !== undefined && queuePauseRef.current?.outcome !== 'paused')
             advanceQueueContinuation();
         if (s.hasProvider) {
             setTranscriptOwned(true);
@@ -2971,9 +3070,6 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     // terminal scrollback; the live tail stays deliberately small so an activity
     // tick never repaints the whole conversation.
     //
-    useEffect(() => {
-        setOutputViewer(null);
-    }, [resetKey]);
     useEffect(() => {
         if (permission !== null)
             setOutputViewer(null);
@@ -3112,7 +3208,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         const scope = scopeRef.current;
         if (!sessions || !scope || !conversationMaterializedRef.current || !session?.hasProvider)
             return false;
-        const active = await activeConversationTurn(sessions, scope.sessionId).catch(() => undefined);
+        const resumedSessionId = scope.sessionId;
+        const active = await activeConversationTurn(sessions, resumedSessionId).catch(() => undefined);
         if (!active)
             return false;
         if (abortRef.current || state !== 'idle') {
@@ -3193,7 +3290,19 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 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);
+            modelHistoryRef.current = await loadConversation(sessions, resumedSessionId);
+            // A successfully completed checkpoint frees the conversation's active
+            // slot. Only then may prompts queued behind the paused turn start. A
+            // repeated pause, failed resume, unreadable log, or conversation switch
+            // keeps dependent work held for an explicit operator decision.
+            if (st.completed &&
+                queuePauseRef.current?.outcome === 'paused' &&
+                scopeRef.current?.sessionId === resumedSessionId &&
+                (await activeConversationTurn(sessions, resumedSessionId)
+                    .then((next) => next === undefined)
+                    .catch(() => false))) {
+                advanceQueueContinuation();
+            }
         }
         catch (err) {
             pushMessage('system', `Could not resume the turn: ${err instanceof Error ? err.message : String(err)}`);
@@ -3210,7 +3319,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             await restoreBrowser?.().catch(() => undefined);
         }
         return true;
-    }, [detected, finalizeMessage, flushStream, pushMessage, session, setHandoffPark, state]);
+    }, [advanceQueueContinuation, detected, finalizeMessage, flushStream, pushMessage, session, setHandoffPark, state]);
     // `namzu resume <id>` of a scheduled run parked on a decision: what the
     // notification and `/schedule` tell the operator to run. Continue it once
     // the screen is ready, exactly as `/resume` would, so the parked call is on
@@ -3258,6 +3367,35 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             pushMessage('system', `Could not list conversations: ${err instanceof Error ? err.message : String(err)}`);
         }
     }, [ensureSessions, pushMessage, resumeActiveTurn]);
+    const doUnarchive = useCallback(async () => {
+        if (state !== 'idle' ||
+            abortRef.current !== null ||
+            hasUnsettledTurn() ||
+            queuedRef.current.length > 0 ||
+            compactingRef.current ||
+            exportingRef.current) {
+            pushMessage('system', 'Finish the current turn and queued work before restoring a conversation.');
+            return;
+        }
+        const sessions = sessionsRef.current ?? (await ensureSessions(), sessionsRef.current);
+        if (!sessions) {
+            pushMessage('system', 'Conversation history is unavailable in this folder.');
+            return;
+        }
+        try {
+            const archived = await listArchived(sessions, 100);
+            if (archived.length === 0) {
+                pushMessage('system', 'No archived conversations in this project.');
+                return;
+            }
+            setResumeList(archived);
+            setSelectedResume(0);
+            setPhase('unarchive');
+        }
+        catch (err) {
+            pushMessage('system', `Could not list archived conversations: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }, [ensureSessions, hasUnsettledTurn, pushMessage, state]);
     // 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) => {
@@ -3438,6 +3576,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         resumeCommittedRef.current = true;
         let msgs;
         try {
+            await requireWritableConversation(sessions, conv.id, 'resume conversation');
             msgs = await loadConversation(sessions, conv.id);
         }
         catch (err) {
@@ -3507,6 +3646,42 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         resetTranscript,
         wakeGoalDriver,
     ]);
+    const restoreArchivedConversation = useCallback(async (conv) => {
+        const sessions = sessionsRef.current;
+        if (!sessions) {
+            setPhase('ready');
+            return;
+        }
+        if (state !== 'idle' ||
+            abortRef.current !== null ||
+            hasUnsettledTurn() ||
+            queuedRef.current.length > 0 ||
+            compactingRef.current ||
+            exportingRef.current) {
+            setPhase('ready');
+            pushMessage('system', 'Finish the current turn and queued work before restoring a conversation.');
+            return;
+        }
+        resumeCommittedRef.current = true;
+        try {
+            await unarchiveConversation(sessions, conv.id);
+        }
+        catch (err) {
+            resumeCommittedRef.current = false;
+            setPhase('ready');
+            pushMessage('system', err instanceof ConversationIndexRefreshError
+                ? err.message
+                : `Could not restore: ${err instanceof Error ? err.message : String(err)}`);
+            return;
+        }
+        pushMessage('system', `Restored: ${conv.title}`);
+        try {
+            await resumeConversation(conv);
+        }
+        finally {
+            resumeCommittedRef.current = false;
+        }
+    }, [hasUnsettledTurn, pushMessage, resumeConversation, state]);
     /**
      * Start a new conversation without deleting the one being left.
      *
@@ -3961,6 +4136,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 ...question.options.map((option) => ({
                     label: option.label,
                     description: option.description ?? '',
+                    // A badge, not label text: the SDK already took any
+                    // "(Recommended)" the model wrote out of the label.
+                    ...(option.recommended === true ? { recommended: true } : {}),
                 })),
                 ...(question.allowFreeText
                     ? [{ label: 'Something else…', description: 'Answer in your own words' }]
@@ -4433,7 +4611,10 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     if (closing)
                         pushMessage('system', closing, false, '✻', undefined, theme.text.muted);
                 }
-                offerSkillSuggestion(st);
+                // A save the operator asked for in words takes the place of
+                // the proposal to save it.
+                if (!triggerFollowUpsRef.current?.(st, st.completed ? 'completed' : 'stopped'))
+                    offerSkillSuggestion(st);
                 break;
             }
             case 'paused':
@@ -4445,6 +4626,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 st.outcome = 'stopped';
                 st.queuePauseOutcome = 'paused';
                 st.notification = { kind: 'turn-settled', outcome: 'stopped' };
+                triggerFollowUpsRef.current?.(st, 'paused');
                 if (event.handoff) {
                     // Nothing failed and nothing needs approving: a tool needs the
                     // operator to do something first. Continuing is one key.
@@ -4459,12 +4641,14 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         `${describeTurnInterruption(event)}\nWhen that is done, press Enter to continue · Esc to stop.`, false, '‖');
                     setHandoffPark({ turnId: event.turnId, reason: event.handoff.reason });
                 }
-                else
-                    pushMessage('system', describeTurnInterruption(event), false, '‖');
+                else {
+                    pushMessage('system', `${describeTurnInterruption(event)}\nUse /resume to continue this checkpoint on the selected provider, or /abandon to start a new turn.`, false, '‖');
+                }
                 break;
             case 'error':
                 closeAssistant();
                 st.outcome = event.message === 'aborted' ? 'cancelled' : 'failed';
+                triggerFollowUpsRef.current?.(st, st.outcome);
                 if (event.message !== 'aborted') {
                     st.notification = { kind: 'turn-settled', outcome: 'failed' };
                     pushMessage('system', describeTurnInterruption(event), false, '!');
@@ -4581,11 +4765,29 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         // 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();
+        // The composer triggers the operator armed for this message, checked
+        // again now: the mode or the session may have changed while it waited
+        // in the queue. None of them changes the operator's words.
+        const requestedTriggers = prompt.kind === 'human' ? (prompt.triggers ?? []) : [];
+        const triggerContext = triggerContextNow();
+        const turnTriggers = requestedTriggers.filter((id) => triggerUnavailable(id, triggerContext) === undefined);
+        const pinnedEffort = triggerEffort(turnTriggers, session.reasoningEffortLevels);
         if (goalRound) {
             pushMessage('system', `Goal round ${goalRound.round} / ${goalRound.maxGoalRounds}`, false, '◎', [`Objective: ${goalRound.objective}`]);
         }
         else {
             pushMessage('user', text, false, undefined, undefined, undefined, humanPromptMeta(attached.length, attachments));
+            const tagLine = transcriptTagLine(turnTriggers, {
+                effort: pinnedEffort,
+                steered: false,
+            });
+            if (tagLine)
+                pushMessage('system', tagLine, false, '✦', undefined, theme.accent.trigger);
+            for (const id of requestedTriggers) {
+                const reason = triggerUnavailable(id, triggerContext);
+                if (reason)
+                    pushMessage('system', `${triggerDefinition(id).label} · not applied: ${reason}`, false, '✧', undefined, theme.text.muted);
+            }
         }
         // A plan is scoped to the request it was made for. Cleared here, at
         // the start of the next one, rather than when the previous turn
@@ -4617,6 +4819,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     startedInPlanMode: permissionModeRef.current === 'plan',
                 }
                 : {}),
+            followUps: turnTriggers.filter((id) => triggerDefinition(id).scope === 'after-turn'),
+            contextTexts: triggerContextTexts(turnTriggers),
         };
         liveStreamRef.current = st;
         // A skill activated with /skills <name> stays in the prompt of every
@@ -4792,7 +4996,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         activeTurnInboxRef.current = inbox;
         const turnPermissionMode = permissionModeRef.current;
         const turnReasoningEffort = reasoningEffortRef.current;
-        const turnOrchestrateMode = orchestrateModeRef.current;
+        const turnHypermode = hypermodeRef.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
@@ -4840,8 +5044,15 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     // while this turn runs, and the change governs what follows.
                     currentPermissionMode: () => permissionModeRef.current,
                     limits: turnLimits,
-                    ...(turnReasoningEffort !== undefined ? { effort: turnReasoningEffort } : {}),
-                    ...(turnOrchestrateMode ? { orchestrate: true } : {}),
+                    // A trigger that pins the highest effort does so for this
+                    // turn only; the session's own setting is untouched.
+                    ...((pinnedEffort ?? turnReasoningEffort) !== undefined
+                        ? { effort: pinnedEffort ?? turnReasoningEffort }
+                        : {}),
+                    ...(turnHypermode ? { hypermode: true } : {}),
+                    // Read at every iteration, so an after-turn trigger a steer
+                    // binds to this turn is said from the next one on.
+                    hostContext: () => st.contextTexts ?? [],
                     ...(goalRound ? { goalRound } : {}),
                     // The mode above decides whether this callback is consulted.
                     onPermission: askPermission,
@@ -5055,6 +5266,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         sendTerminalNotification,
         session,
         setQueuePause,
+        triggerContextNow,
         wakeGoalDriver,
     ]);
     const selectModelIntent = useCallback(async (query) => {
@@ -5176,7 +5388,31 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             pushMessage('system', `Could not save memory: ${err instanceof Error ? err.message : String(err)}`);
         }
     }, [ctx.cwd, pushMessage, session]);
-    const handleSubmit = useCallback((value, attachments, mode = 'submit') => {
+    /**
+     * Enter steered a message into the running turn. Its after-turn triggers
+     * (save as skill) bind to that turn and are told to the model from its next
+     * iteration; its turn triggers do not apply to a turn already running —
+     * the tag row said so before Enter, and Tab would have queued it instead.
+     */
+    const bindSteeredTriggers = useCallback((ids) => {
+        if (ids.length === 0)
+            return;
+        const live = liveStreamRef.current;
+        const afterTurn = ids.filter((id) => triggerDefinition(id).scope === 'after-turn');
+        const turnOnly = ids.filter((id) => triggerDefinition(id).scope === 'turn');
+        if (live && afterTurn.length > 0) {
+            live.followUps = [...new Set([...(live.followUps ?? []), ...afterTurn])];
+            live.contextTexts = [
+                ...new Set([...(live.contextTexts ?? []), ...triggerContextTexts(afterTurn)]),
+            ];
+            const line = transcriptTagLine(afterTurn, { effort: undefined, steered: true });
+            if (line)
+                pushMessage('system', line, false, '✦', undefined, theme.accent.trigger);
+        }
+        if (turnOnly.length > 0)
+            pushMessage('system', `${turnOnly.map((id) => triggerDefinition(id).label).join(', ')} · not applied: Enter steered this message into the running turn. Tab queues a message as a new turn with it.`, false, '✧', undefined, theme.text.muted);
+    }, [pushMessage]);
+    const handleSubmit = useCallback((value, attachments, mode, meta) => {
         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;
@@ -5200,8 +5436,19 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         }
         // The operator moved on; a parked turn is still there for /resume.
         setHandoffPark(null);
-        setHistory((prev) => [...prev, value]);
-        const selectionIntent = !attachments?.length ? parseModelSelectionIntent(value) : undefined;
+        // A loop is not something the operator typed here, so it is not a line
+        // Up should bring back.
+        const fromLoop = meta.source === 'operator-loop' || meta.source === 'model-loop';
+        if (!fromLoop)
+            setHistory((prev) => [...prev, value]);
+        // What the model wrote is never the operator acting. A loop the model
+        // made (`session_loop`) fires this path on a timer, for up to a week,
+        // after one review of its creation — so its text must not reach the
+        // host-side meanings of `/`, `!`, `#` or a model switch: `!` runs on
+        // the host outside the sandbox with no review, and `#` writes memory
+        // every later turn reads. It is sent as the prompt it looks like.
+        const operatorText = meta.source !== 'model-loop';
+        const selectionIntent = operatorText && !attachments?.length ? parseModelSelectionIntent(value) : undefined;
         if (selectionIntent) {
             void selectModelIntent(selectionIntent.query);
             return;
@@ -5209,12 +5456,12 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         // `#` remembers, `!` runs — neither is a prompt. Both are the
         // operator acting directly, the way other coding agents spell it,
         // and both leave a row the model reads on its next turn.
-        if (value.startsWith('#') && value.slice(1).trim().length > 0) {
+        if (operatorText && value.startsWith('#') && value.slice(1).trim().length > 0) {
             const note = value.slice(1).trim();
             void rememberProjectNote(note);
             return;
         }
-        const escaped = shellEscapeCommand(value);
+        const escaped = operatorText ? shellEscapeCommand(value) : null;
         if (escaped !== null) {
             pushMessage('user', value);
             const rowId = pushMessage('tool', `! ${escaped}`, true, '…');
@@ -5235,13 +5482,33 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             });
             return;
         }
+        // Composer triggers (`./triggers/`). Only the composer's own submit
+        // carries them, so nothing a loop, a picker or the model sends can
+        // arm one. A message that is nothing but a trigger with a command of
+        // its own (`bunu skill olarak kaydet`) runs that command here, in this
+        // same call, so history holds the operator's words once; a trigger
+        // that needs a task and got none is not applied, and says so.
+        let armedTriggers = meta.source === 'composer' ? meta.triggers.map((trigger) => trigger.id) : [];
+        let dispatch = value;
+        if (meta.source === 'composer' && meta.onlyTriggers && armedTriggers.length > 0) {
+            const command = armedTriggers
+                .map((id) => triggerDefinition(id).standalone)
+                .find((standalone) => standalone !== undefined);
+            const needTask = armedTriggers.filter((id) => triggerDefinition(id).standalone === undefined);
+            if (needTask.length > 0)
+                pushMessage('system', `${needTask.map((id) => triggerDefinition(id).label).join(', ')} · not applied: the message has no task. Put the task in the same message${needTask.includes('hypermode') ? ', e.g. “hypermode fix the flaky test”' : ''}.`, false, '✧', undefined, theme.text.muted);
+            armedTriggers = [];
+            if (!command)
+                return;
+            dispatch = command;
+        }
         // What actually gets sent. A `prompt` action replaces it with text the
         // command composed, and then takes the ordinary send path below —
         // including the queue — so a command-driven turn is not a second way
         // to run one.
-        let outgoing = value;
+        let outgoing = dispatch;
         let skillFlow = false;
-        const slash = runSlash(value, slashCtx, hostCommands);
+        const slash = operatorText ? runSlash(dispatch, slashCtx, hostCommands) : null;
         if (slash) {
             switch (slash.kind) {
                 case 'message':
@@ -5380,6 +5647,13 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                             description: `${session?.webSearchSummary ?? 'Not resolved'} · view tools, workspace and usage.`,
                         },
                         { name: 'setup', label: 'Provider setup', description: 'Check installed CLIs and access; connect or install without leaving Namzu.' },
+                        {
+                            name: `config triggers ${composerTriggersOn ? 'off' : 'on'}`,
+                            label: 'Composer triggers',
+                            description: composerTriggersOn
+                                ? 'On · hypermode and save-as-skill words act for their message. Select to turn off.'
+                                : 'Off · words in a message are only words. Select to turn on.',
+                        },
                         {
                             name: 'config sources',
                             label: 'Setting sources',
@@ -5397,7 +5671,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                             description: command.description,
                             disabledReason: command.problem,
                         })),
-                        windowSize: 7,
+                        windowSize: 8,
                     });
                     return;
                 }
@@ -5631,7 +5905,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     const values = [undefined, ...levels];
                     const current = reasoningEffortRef.current;
                     setSelectedChoice(Math.max(0, values.findIndex((value) => value === current)));
-                    setChoicePicker(reasoningEffortPicker(session, current, false, orchestrateModeRef.current) ?? null);
+                    setChoicePicker(reasoningEffortPicker(session, current, false, hypermodeRef.current) ?? null);
                     return;
                 }
                 case 'login':
@@ -5645,6 +5919,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     const choices = [
                         ...(readStoredSubscriptionCredential() ? ['anthropic'] : []),
                         ...(readStoredCodexCredential() ? ['codex'] : []),
+                        ...(readStoredGoogleApiKey() ? ['google'] : []),
                     ];
                     if (choices.length === 0) {
                         removeStoredCredential('all');
@@ -5657,14 +5932,16 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     setSelectedChoice(0);
                     setChoicePicker({
                         kind: 'credential-logout',
-                        title: 'Choose a stored subscription to remove',
+                        title: 'Choose a stored credential to remove',
                         notice: 'Only credentials created by Namzu are listed. Device sessions owned by other tools are left alone.',
                         values: choices,
                         options: choices.map((choice) => ({
-                            label: choice === 'anthropic' ? 'Claude' : 'Codex',
+                            label: choice === 'anthropic' ? 'Claude' : choice === 'codex' ? 'Codex' : 'Gemini API key',
                             description: choice === 'anthropic'
                                 ? 'Remove only Namzu’s Claude subscription.'
-                                : 'Remove only Namzu’s Codex subscription.',
+                                : choice === 'codex'
+                                    ? 'Remove only Namzu’s Codex subscription.'
+                                    : 'Remove only Namzu’s saved Gemini API key.',
                         })),
                     });
                     return;
@@ -5821,12 +6098,80 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 case 'resume':
                     void doResume();
                     return;
+                case 'unarchive':
+                    void doUnarchive();
+                    return;
                 case 'title':
                     void doTitle(slash.title, slash.clear);
                     return;
                 case 'fork':
                     void doFork();
                     return;
+                case 'worktree': {
+                    const [verb = 'list', label, extra] = slash.args;
+                    const notice = (content) => pushMessage('system', terminalDisplayText(content));
+                    if (!((verb === 'list' && label === undefined) ||
+                        (verb === 'create' && extra === undefined) ||
+                        (verb === 'fork' && extra === undefined) ||
+                        (verb === 'resume' &&
+                            label !== undefined &&
+                            extra === undefined))) {
+                        pushMessage('system', 'Usage: /worktree [list|create [name]|fork [name]|resume <name>]');
+                        return;
+                    }
+                    if (verb === 'fork' &&
+                        (abortRef.current ||
+                            hasUnsettledTurn() ||
+                            queuedRef.current.length > 0)) {
+                        pushMessage('system', 'Wait for the current turn and queued prompts to finish before forking to a worktree.');
+                        return;
+                    }
+                    if (conversationMutationRef.current)
+                        return;
+                    if (verb === 'fork') {
+                        conversationMutationRef.current = 'fork';
+                        setConversationMutation('fork');
+                    }
+                    void (async () => {
+                        try {
+                            const manager = await openManagedWorktrees(ctx.cwd);
+                            if (verb === 'list') {
+                                const items = await manager.list();
+                                notice(items.length === 0
+                                    ? 'No managed worktrees in this repository.'
+                                    : items
+                                        .map((item) => `${item.label}: ${item.path}${item.dirty ? ' (uncommitted files)' : ''}`)
+                                        .join('\n'));
+                            }
+                            else if (verb === 'create') {
+                                const created = await manager.create(label);
+                                notice(`Created ${created.branch}. Open it in a new terminal: ${worktreeOpenHint(created.path)}${created.sourceDirty ? '\nUncommitted files stayed in this checkout.' : ''}`);
+                            }
+                            else if (verb === 'fork') {
+                                const scope = await materializeConversation();
+                                if (!scope)
+                                    throw new Error('Conversation history is unavailable in this folder.');
+                                await persistenceTailRef.current;
+                                const forked = await manager.fork(scope.sessionId, label);
+                                notice(`Forked ${forked.copied} messages into ${forked.title}. Open the new checkout in a new terminal: ${worktreeOpenHint(forked.path, forked.conversationId)}${forked.sourceDirty ? '\nUncommitted files stayed in this checkout.' : ''}`);
+                            }
+                            else if (label) {
+                                const target = await manager.resume(label);
+                                notice(`Open ${label} in a new terminal: ${worktreeOpenHint(target.worktree.path, target.conversationId)}`);
+                            }
+                        }
+                        catch (error) {
+                            notice(`Worktree: ${error instanceof Error ? error.message : String(error)}`);
+                        }
+                        finally {
+                            if (verb === 'fork') {
+                                conversationMutationRef.current = null;
+                                setConversationMutation(null);
+                            }
+                        }
+                    })();
+                    return;
+                }
                 case 'restore':
                     void doRestore(slash.turn);
                     return;
@@ -6153,9 +6498,25 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         : 'Raw output mode off — rich transcript rendering restored.');
                     return;
                 }
-                case 'orchestrate-mode': {
-                    const enabled = slash.enabled === 'toggle' ? !orchestrateModeRef.current : slash.enabled;
-                    applyOrchestrateMode(enabled);
+                case 'composer-triggers': {
+                    const profile = ctx.configDebug?.selectedProfile?.name;
+                    const cascade = { cwd: ctx.cwd, ...(profile ? { profile } : {}) };
+                    if (slash.setting === 'list') {
+                        pushMessage('system', describeComposerTriggers(composerTriggersOn, cascade));
+                        return;
+                    }
+                    const on = slash.setting === 'on';
+                    // The session follows the choice whatever the files say; the
+                    // message says whether a later start will too.
+                    setComposerTriggersOverride(on);
+                    pushMessage('system', setComposerTriggers(on, cascade));
+                    return;
+                }
+                case 'hypermode': {
+                    if (slash.via === 'orchestrate')
+                        pushMessage('system', ORCHESTRATE_ALIAS_NOTICE);
+                    const enabled = slash.enabled === 'toggle' ? !hypermodeRef.current : slash.enabled;
+                    applyHypermode(enabled);
                     return;
                 }
                 case 'export-picker': {
@@ -6225,6 +6586,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             text: outgoing,
             ...(attachments && attachments.length > 0 ? { attachments: [...attachments] } : {}),
             ...(skillFlow ? { skillFlow: true } : {}),
+            ...(armedTriggers.length > 0 && !skillFlow ? { triggers: armedTriggers } : {}),
         };
         // `/skills save` and `/skills new` are turns of their own: steered into
         // a running turn, they would lose the flag that keeps the skill-making
@@ -6242,8 +6604,10 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     message: createUserMessage(expanded.sendText, prompt.attachments),
                     attachedFiles: expanded.attached.length,
                     queueBoundary: queuedRef.current.length,
-                }))
+                })) {
+                    bindSteeredTriggers(armedTriggers);
                     return;
+                }
             }
         }
         enqueueQueued(prompt);
@@ -6251,17 +6615,21 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         activeSkills,
         advanceQueueContinuation,
         applyPermissionMode,
+        bindSteeredTriggers,
+        composerTriggersOn,
         conversationLearning,
         applyReasoningEffort,
         appLifetime,
         ctx.cwd,
         doResume,
+        doUnarchive,
         enqueueQueued,
         exitWithSummary,
         hasUnsettledTurn,
         goalActivation,
         goalStatus,
         hostCommands,
+        materializeConversation,
         nextId,
         openAgentCockpit,
         runAgentsCommand,
@@ -6287,7 +6655,48 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     // picker is also used by review/export flows. Keep only this dispatch hop in
     // a ref so selecting a help row re-enters the one ordinary slash-command
     // path instead of growing a second command executor.
-    commandPickerSubmitRef.current = handleSubmit;
+    commandPickerSubmitRef.current = (command) => handleSubmit(command, undefined, 'submit', { source: 'command-picker' });
+    // A turn's after-turn triggers, when it ends. Save as skill runs exactly the
+    // prompt `/skills save` sends, at the front of the queue, only when the
+    // turn completed, did tool work, did not already save a skill, and saving
+    // is still possible now. Otherwise one row says why, and `/skills save`
+    // still works. Returns whether the turn had one, so the proposal to save
+    // it is not also printed.
+    triggerFollowUpsRef.current = (st, ending) => {
+        const followUps = st.followUps ?? [];
+        st.followUps = [];
+        if (!followUps.includes('save-skill'))
+            return false;
+        const reason = ending === 'cancelled'
+            ? 'the turn was cancelled'
+            : ending === 'failed'
+                ? 'the turn failed'
+                : ending === 'paused'
+                    ? 'the turn paused'
+                    : ending === 'stopped'
+                        ? 'the turn stopped before it finished'
+                        : !st.learning || st.learning.steps < 1
+                            ? 'the turn did no tool work'
+                            : st.learning.savedSkill
+                                ? 'the turn already saved a skill'
+                                : triggerUnavailable('save-skill', triggerContextNow());
+        if (reason) {
+            pushMessage('system', `save as skill · not run: ${reason} · /skills save runs it anyway`, false, '✧', undefined, theme.text.muted);
+            return true;
+        }
+        // The proposal was taken up, as `/skills save` records it.
+        conversationLearning().proposed = true;
+        const home = resolveNamzuHome();
+        const ledger = readSuggestionLedger(home);
+        if (ledger.unanswered > 0)
+            writeSuggestionLedger(home, { ...ledger, unanswered: 0 });
+        replaceQueued([
+            { kind: 'human', text: learnSkillPrompt(), skillFlow: true },
+            ...queuedRef.current,
+        ]);
+        pushMessage('system', 'save as skill · running /skills save for this turn', false, '✦', undefined, theme.accent.trigger);
+        return true;
+    };
     saveSkillNotifyRef.current = () => sendTerminalNotification({ kind: 'approval-required' });
     scheduleLiveRef.current = {
         ...(scheduleLiveRef.current?.model ? { model: scheduleLiveRef.current.model } : {}),
@@ -6297,7 +6706,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         },
         ask: askQuestion,
         askPermission: onPermission,
-        submit: (text) => handleSubmit(text),
+        submit: (text, createdBy) => handleSubmit(text, undefined, 'submit', {
+            source: createdBy === 'operator' ? 'operator-loop' : 'model-loop',
+        }),
     };
     // Scheduled work since the TUI last looked: one line, after the first
     // paint, never blocking it. Loops fire when a turn ends, and on their timer.
@@ -6543,29 +6954,24 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 announce: true,
                 chooseReasoningEffort: options.chooseReasoningEffort,
             });
+            return !signal.aborted;
         }
         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;
+                return false;
             if (options.revealAllOnFailure) {
                 setPickerDetected(null);
                 setPickerSelectionKind('provider-and-model');
                 setPickerInitialView('providers');
             }
             setPickerNotice(`Could not start the selected provider: ${err instanceof Error ? err.message : String(err)}`);
+            return false;
         }
     }, [hydrateSession]);
-    /**
-     * A credential the operator typed. Held in memory for this process only.
-     *
-     * Deliberately does NOT call `writePreferences`: preferences are a file, and
-     * the whole contract of this entry point is that nothing lands on disk. The
-     * provider choice is not persisted either, because persisting it would leave
-     * a preference pointing at a credential that will not exist next launch.
-     */
+    /** A typed Google API key is saved only after its provider session opens. */
     const handleTypedCredential = useCallback((credential, disposition, signal) => {
         const next = [credential, ...detected.filter((d) => d.entry.id !== credential.entry.id)];
         setDetected(next);
@@ -6581,7 +6987,32 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         const prefs = saved && primaryProvider(saved).id === credential.entry.id
             ? saved
             : selectPrimaryProvider(saved, { id: credential.entry.id });
-        void hydrateFromPicker(prefs, next, signal);
+        void (async () => {
+            const started = await hydrateFromPicker(prefs, next, signal);
+            if (!started || credential.entry.id !== 'google')
+                return;
+            let path;
+            try {
+                path = writeStoredGoogleApiKey(credential.apiKey ?? '');
+            }
+            catch (error) {
+                pushMessage('system', `Gemini is connected, but its API key could not be saved privately: ${error instanceof Error ? error.message : String(error)}. It is usable only in this session.`);
+                return;
+            }
+            setDetected((current) => current.map((provider) => provider.entry.id === 'google' &&
+                provider.source.kind === 'session' &&
+                provider.apiKey === credential.apiKey
+                ? { ...provider, source: { kind: 'stored-gemini-key', path } }
+                : provider));
+            try {
+                writePreferences(prefs);
+            }
+            catch (error) {
+                pushMessage('system', `Gemini API key was saved privately at ${path}, but the provider preference could not be saved: ${error instanceof Error ? error.message : String(error)}. Run /logout gemini to remove the key.`);
+                return;
+            }
+            pushMessage('system', `Gemini API key saved privately at ${path} for future launches. Run /logout gemini to remove it.`);
+        })();
     }, [detected, hydrateFromPicker, pushMessage]);
     const handlePickerSubmit = useCallback((selection, signal) => {
         const prefs = selectPrimaryProvider(savedPrefsRef.current, {
@@ -6688,7 +7119,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             return;
         }
         // Resume picker owns the keyboard while open.
-        if (phase === 'resume') {
+        if (phase === 'resume' || phase === 'unarchive') {
             // Once a conversation is being read, the keyboard does nothing here.
             // The choice is already being acted on; a second Enter would start a
             // second read and an Esc would hand back a screen that is about to be
@@ -6705,7 +7136,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             else if (key.return) {
                 const conv = resumeList[selectedResumeRef.current];
                 if (conv)
-                    void resumeConversation(conv);
+                    void (phase === 'unarchive' ? restoreArchivedConversation(conv) : resumeConversation(conv));
             }
             else if (key.escape || (key.ctrl && input === 'c'))
                 setPhase('ready');
@@ -7226,6 +7657,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const lifecycleOwnsViewport = outputViewer !== null ||
         phase === 'trust' ||
         phase === 'resume' ||
+        phase === 'unarchive' ||
         phase === 'edit' ||
         phase === 'picker' ||
         agentSurface !== null;
@@ -7292,6 +7724,24 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             : `Session: ${permissionSource}`
         : undefined;
     const displayedPermissionMode = effectivePermissionMode(permissionMode, session?.approvalLatched() ?? false);
+    const highestEffort = highestReasoningEffort(session?.reasoningEffortLevels);
+    const hypermodeLevel = hypermodeEffort(session?.reasoningEffortLevels);
+    const composerTriggers = composerTriggersOn
+        ? {
+            registry: composerTriggerRegistry,
+            suggest: composerTriggerSettings.suggest,
+            context: {
+                permissionMode: displayedPermissionMode,
+                sessionHypermode: hypermode,
+                effortMenu: highestEffort !== undefined,
+                agentTool: true,
+                skillCreator: skillCreatorAvailable,
+                scheduleTool: true,
+            },
+            ...(highestEffort ? { highestEffort } : {}),
+            ...(hypermodeLevel ? { hypermodeEffort: hypermodeLevel } : {}),
+        }
+        : undefined;
     // True exactly when the phase ternary below renders its final branch — the
     // normal composer view, as opposed to provider setup or a lifecycle
     // picker/prompt. The agent rail is a feature of that view: computing this
@@ -7315,7 +7765,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                         setPickerSelectionKind('provider-and-model');
                         setPhase('picker');
                         void discoverProviders({ skipProbes: true }).then(setPickerDetected).catch((error) => setPickerNotice(String(error)));
-                    } })) : phase === 'trust' ? (_jsx(TrustPrompt, { cwd: ctx.cwd })) : phase === 'unhealthy' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: theme.status.error, bold: true, children: "Startup stopped" }), _jsx(Text, { color: theme.text.secondary, children: "Resolve the error above, then restart Namzu." })] })) : phase === 'resume' ? (_jsx(ResumePicker, { conversations: resumeList, selected: selectedResume })) : phase === 'edit' ? (_jsx(EditPromptPicker, { prompts: editList, selected: selectedEdit })) : phase === 'picker' ? (_jsx(Picker, { detected: pickerDetected ?? detected, currentProvider: currentProvider, selectionKind: pickerSelectionKind, currentModel: session?.modelSummary ?? null, initialView: pickerInitialView, onSubmit: handlePickerSubmit, onCancel: handlePickerCancel, onSetup: () => setProviderSetup(true), onCredential: handleTypedCredential, onLogin: startLoginFromPicker, onLoginComplete: finishLoginFromPicker, keyEntryFor: keyEntryFor, notice: pickerNotice, 
+                    } })) : phase === 'trust' ? (_jsx(TrustPrompt, { cwd: ctx.cwd })) : phase === 'unhealthy' ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: theme.status.error, bold: true, children: "Startup stopped" }), _jsx(Text, { color: theme.text.secondary, children: "Resolve the error above, then restart Namzu." })] })) : phase === 'resume' || phase === 'unarchive' ? (_jsx(ResumePicker, { conversations: resumeList, selected: selectedResume, mode: phase === 'unarchive' ? 'restore' : 'resume' })) : phase === 'edit' ? (_jsx(EditPromptPicker, { prompts: editList, selected: selectedEdit })) : phase === 'picker' ? (_jsx(Picker, { detected: pickerDetected ?? detected, currentProvider: currentProvider, selectionKind: pickerSelectionKind, currentModel: session?.modelSummary ?? null, initialView: pickerInitialView, onSubmit: handlePickerSubmit, onCancel: handlePickerCancel, onSetup: () => setProviderSetup(true), onCredential: handleTypedCredential, onLogin: startLoginFromPicker, onLoginComplete: finishLoginFromPicker, keyEntryFor: keyEntryFor, notice: pickerNotice, 
                     // The same condition `handlePickerCancel` branches on, read
                     // where it is decided rather than guessed on the screen: with no
                     // session behind the picker, esc exits namzu and the footer says
@@ -7332,7 +7782,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                             agentSurface === null &&
                             outputViewer === null &&
                             choicePicker?.kind === 'reasoning-effort' &&
-                            effortSlider ? (_jsx(EffortSlider, { title: choicePicker.title, notice: choicePicker.notice, options: choicePicker.options, selected: selectedChoice, layout: effortSlider, columns: Math.max(1, (terminal.columns ?? 80) - 2), highest: choicePicker.options.at(-2)?.label === 'default' ? undefined : choicePicker.options.at(-2)?.label })) : permission === null && agentSurface === null && outputViewer === null && choicePicker ? (_jsx(ChoicePicker, { busy: 'busy' in choicePicker && choicePicker.busy === true, columns: Math.max(1, (terminal.columns ?? 80) - 2), title: choicePicker.title, notice: choicePicker.notice, options: filterChoiceOptions(choicePicker.options, choiceQuery), query: choicePickerSearchable(choicePicker) ? choiceQuery : undefined, selected: selectedChoice, windowSize: choicePicker.kind === 'command' ? choicePicker.windowSize : undefined })) : permission === null && agentSurface === null && outputViewer === null && copyPicker ? (_jsx(CopyPicker, { targets: copyPicker.targets, selected: selectedCopy })) : null, _jsxs(ComposerFrame, { working: state === 'thinking' || state === 'tool' || visibleActiveTools.length > 0, ...(orchestrateMode ? { mode: 'orchestrate' } : {}), focus: phase === 'ready' &&
+                            effortSlider ? (_jsx(EffortSlider, { title: choicePicker.title, notice: choicePicker.notice, options: choicePicker.options, selected: selectedChoice, layout: effortSlider, columns: Math.max(1, (terminal.columns ?? 80) - 2) })) : permission === null && agentSurface === null && outputViewer === null && choicePicker ? (_jsx(ChoicePicker, { busy: 'busy' in choicePicker && choicePicker.busy === true, columns: Math.max(1, (terminal.columns ?? 80) - 2), title: choicePicker.title, notice: choicePicker.notice, options: filterChoiceOptions(choicePicker.options, choiceQuery), query: choicePickerSearchable(choicePicker) ? choiceQuery : undefined, selected: selectedChoice, windowSize: choicePicker.kind === 'command' ? choicePicker.windowSize : undefined })) : permission === null && agentSurface === null && outputViewer === null && copyPicker ? (_jsx(CopyPicker, { targets: copyPicker.targets, selected: selectedCopy })) : null, _jsxs(ComposerFrame, { working: state === 'thinking' || state === 'tool' || visibleActiveTools.length > 0, ...(hypermode ? { mode: HYPERMODE } : {}), focus: phase === 'ready' &&
                                 state !== 'awaiting-permission' &&
                                 !compacting &&
                                 externalEditorRequest === null &&
@@ -7360,7 +7810,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                                 ? queuePause.outcome === 'paused'
                                                     ? '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 ||
+                                                : 'sending when ready', queuedTriggerLabels(queued)] }) })) : null, _jsx(Composer, { reasoningEffortLevels: session?.reasoningEffortLevels, onCycleMode: cyclePermissionMode, disabled: outputViewer !== null ||
                                         phase !== 'ready' ||
                                         state === 'awaiting-permission' ||
                                         compacting ||
@@ -7381,7 +7831,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                         (handoffPark !== null && state === 'idle'), onSubmit: handleSubmit, onNotice: (text) => pushMessage('system', text), onStepReasoningEffort: stepReasoningEffort, onExternalEdit: requestExternalEditor, onEditPrevious: openPromptEditor, draftToRestore: composerDraft, onDraftRestored: (token) => setComposerDraft((draft) => (draft?.token === token ? null : draft)), onDraftPresenceChange: setComposerHasDraft, onOpenAgentPanel: openAgentCockpit, userCommands: userCommands, builtins: hostCommands.map((command) => ({
                                         ...command,
                                         description: command.unavailable?.(slashCtx) ?? command.description,
-                                    })), mentionCandidates: mentionCandidates, history: history })] })] })), _jsx(StatusBar, { cwd: ctx.cwd, provider: session?.providerSummary ?? null, model: session?.modelSummary ?? null, effort: reasoningEffort, orchestrate: orchestrateMode, goal: statusGoal, state: state, hint: statusHint, permissionMode: displayedPermissionMode, canCycleMode: true }), showComposerSurface &&
+                                    })), mentionCandidates: mentionCandidates, history: history, ...(composerTriggers ? { triggers: composerTriggers } : {}), turnActive: !compacting && (state === 'thinking' || state === 'tool') })] })] })), _jsx(StatusBar, { cwd: ctx.cwd, provider: session?.providerSummary ?? null, model: session?.modelSummary ?? null, effort: reasoningEffort, hypermode: hypermode, goal: statusGoal, state: state, hint: statusHint, permissionMode: displayedPermissionMode, canCycleMode: true }), showComposerSurface &&
                     permission === null &&
                     agentSurface === null &&
                     outputViewer === null ? (_jsx(AgentNarrationBand, { lines: narration })) : null, showComposerSurface &&
@@ -7434,6 +7884,8 @@ hasDraft = false) {
         return 'y trust this folder · n / esc exit';
     if (phase === 'resume')
         return '↑↓ navigate · enter resume · esc cancel';
+    if (phase === 'unarchive')
+        return '↑↓ navigate · enter restore · esc cancel';
     if (phase === 'edit')
         return '← older · → newer · enter fork and edit · esc cancel';
     if (phase === 'probing')
@@ -7596,25 +8048,36 @@ function permissionPicker(mode, approvedAll, more = false) {
     };
 }
 /**
- * The picker's sentinel for the orchestrate-mode row, below the rule.
+ * The picker's sentinel for the hypermode row, below the rule.
  *
  * A plain string outside the `ReasoningEffort` union by construction — never
  * added to any model's published menu — so it can share the same picker
  * without ever being mistaken for a level `/effort <token>` could select.
  */
-const ORCHESTRATE_MODE_VALUE = 'orchestrate';
+const HYPERMODE_VALUE = 'hypermode';
+/** ` · ✦ save as skill` when queued messages carry composer triggers, so the queue line says so. */
+function queuedTriggerLabels(queued) {
+    const labels = new Set();
+    for (const prompt of queued) {
+        if (prompt.kind !== 'human')
+            continue;
+        for (const id of prompt.triggers ?? [])
+            labels.add(triggerDefinition(id).label);
+    }
+    return labels.size > 0 ? ` · ✦ ${[...labels].join(', ')}` : '';
+}
 /** Last entry of a low-to-high menu every provider publishes in that order; `undefined` when none is known. */
 function highestReasoningEffort(levels) {
     return levels && levels.length > 0 ? levels[levels.length - 1] : undefined;
 }
-function reasoningEffortPicker(session, current, afterModelSelection = false, orchestrateOn = false) {
+function reasoningEffortPicker(session, current, afterModelSelection = false, hypermodeOn = false) {
     const levels = session.reasoningEffortLevels;
     if (!session.hasProvider || levels === undefined)
         return undefined;
     const effortValues = [undefined, ...levels];
     const values = [
         ...effortValues,
-        ORCHESTRATE_MODE_VALUE,
+        HYPERMODE_VALUE,
     ];
     return {
         kind: 'reasoning-effort',
@@ -7635,12 +8098,11 @@ function reasoningEffortPicker(session, current, afterModelSelection = false, or
             })),
             {
                 // Below a rule, visually apart from the levels above: a session
-                // setting, not a sixth level the provider published.
-                label: 'orchestrate',
-                description: orchestrateOn
-                    ? 'On · highest level and delegate by default'
-                    : 'Off · highest level and delegate by default',
-                current: orchestrateOn,
+                // setting, not a sixth level the provider published. The label
+                // names the level it pins, then the mode.
+                label: hypermodeStopLabel(hypermodeEffort(levels)),
+                description: `${hypermodeOn ? 'On' : 'Off'} · ${HYPERMODE_SUMMARY}`,
+                current: hypermodeOn,
                 ruleBefore: true,
             },
         ],