@namzu/cli 29.0.1 → 30.0.0

package/dist/tui/App.js

@@ -16,8 +16,8 @@ import { TURN_LIMIT_FIELDS, turnLimitCommands } from './turn-limits-settings.js'
 import { discoverProviders } from '../integrations/providers/discover.js';
 import { ProviderSetup } from './ProviderSetup.js';
 import { ToolOutputViewer } from './ToolOutputViewer.js';
-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 { 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 { pinTrustedProjectPath, resolveTrustedProjectContext, } from '../config/trusted-project-context.js';
@@ -35,7 +35,7 @@ import { checkUpdates } from '../integrations/updates.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';
+import { NO_SKILLS_FOUND, composeSkillsPrompt, discoverSkills, loadSkillBody, renderSkillRoster, skillTierLabel, } from '../skills/store.js';
 import { discoverUserCommands } from '../user-commands/store.js';
 import { AgentCockpit, AgentNarrationBand, AgentTaskPanel, AgentTranscript, activeSubagentCohorts, agentCockpitIsWide, agentPhasePageSize, agentPhases, agentPickerPageSize, agentTranscriptPageSize, agentWorkflowPageSize, agentWorkflows, maxAgentTranscriptTailOffset, } from './AgentExplorer.js';
 import { completionRow, launchReceipt, settleLine } from './agent-transcript-rows.js';
@@ -49,9 +49,16 @@ import { CopyPicker } from './CopyPicker.js';
 import { EditPromptPicker } from './EditPromptPicker.js';
 import { LiveActivity, formatElapsed } from './LiveActivity.js';
 import { webCallTitle, webLiveStatus, webSettledLine } from './web-activity.js';
-import { PermissionOverlay } from './PermissionOverlay.js';
+import { PermissionOverlay, permissionAnswers } from './PermissionOverlay.js';
 import { Picker } from './Picker.js';
 import { ResumePicker } from './ResumePicker.js';
+import { resolveNamzuHome } from '../integrations/state/home.js';
+import { createScheduleIntegration } from './schedule/integration.js';
+import { SaveSkillOverlay } from './SaveSkillOverlay.js';
+import { SKILL_CREATOR_SKILL, buildSaveSkillTool, learnSkillPrompt, newSkillPrompt, } from '../skills/save.js';
+import { SUGGESTIONS_STOPPED_NOTICE, createTurnActivity, judgeSkillSuggestion, observeTurnEvent, skillSuggestionNotice, } from './skills/learning.js';
+import { FRESH_LEDGER, admitSuggestion, readSuggestionLedger, writeSuggestionLedger, } from './skills/suggestion-ledger.js';
+import { setSkillSuggestions } from './skills/suggest-setting.js';
 import { StatusBar } from './StatusBar.js';
 import { isRepeatedNotice } from './notices.js';
 import { checklistProgress } from './Checklist.js';
@@ -81,7 +88,8 @@ 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, releasedByApproveAll, } from './permission-review.js';
-import { describeTurnInterruption, describeTurnStop } from './turn-interruption.js';
+import { PAUSED_TURN_LINES, describeTurnInterruption, describeTurnStop, handoffContinuationNote, } from './turn-interruption.js';
+import { browserSiteNotes, describeBrowserHandoff, runBrowserSlash } from './browser-notices.js';
 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';
@@ -314,6 +322,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const initialConversationIdRef = useRef(initialCtx.initialConversationId);
     const [history, setHistory] = useState([]);
     const [state, setState] = useState('idle');
+    /** For the scheduler integration's loop timer, which reads it outside render. */
+    const stateRef = useRef(state);
+    stateRef.current = state;
     const [phase, setPhase] = useState('probing');
     const [session, setSession] = useState(null);
     // Once a usable session publishes the transcript, temporary lifecycle
@@ -617,6 +628,25 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     }, []);
     const [composerDraft, setComposerDraft] = useState(null);
     const [composerHasDraft, setComposerHasDraft] = useState(false);
+    // A turn a tool paused for a person (`ToolResult.handoff`), while its
+    // notice is the newest thing on screen: Enter continues it, Esc stops it.
+    // The ref is what the key handler reads; the state is what the footer shows.
+    /**
+     * The stream of the turn running now, so a tool's own screen can close the
+     * reply it streamed before the tool ran. The kernel hands the tool's start
+     * to this loop only when its batch settles, so a reply streamed with a
+     * tool call stays pending while that tool asks the operator something; a
+     * row written then (the schedule tool's confirmation) cannot reach
+     * scrollback past the pending reply, and the top of a tall one was cut
+     * off while the operator was asked about it.
+     */
+    const liveStreamRef = useRef(null);
+    const [handoffPark, setHandoffParkState] = useState(null);
+    const handoffParkRef = useRef(null);
+    const setHandoffPark = useCallback((value) => {
+        handoffParkRef.current = value;
+        setHandoffParkState(value);
+    }, []);
     const composerDraftTokenRef = useRef(0);
     /** Bounded child session projection published by the current AgentSession. */
     const [subagents, setSubagentsState] = useState([]);
@@ -837,6 +867,16 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
      * server's child process outlives the object that opened it.
      */
     const previousSessionRef = useRef(null);
+    /** The profile `/browser profile` chose, kept across session rebuilds. */
+    const browserProfileRef = useRef(undefined);
+    /** The current session's browser, for notices written from event handlers. */
+    const browserControlRef = useRef(undefined);
+    /** The current session, for the review screen to name a computer-use control by its ref. */
+    const reviewSessionRef = useRef(null);
+    useEffect(() => {
+        browserControlRef.current = session?.browser;
+        reviewSessionRef.current = session;
+    }, [session]);
     useEffect(() => {
         const source = session?.subagents;
         setAgentSurface(null);
@@ -910,6 +950,89 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     // turns attribute to the resumed conversation.
     const sessionsRef = useRef(null);
     const scopeRef = useRef(null);
+    /**
+     * Scheduled jobs and session loops (`./schedule/`). Built once; what it
+     * reads later — the transcript writer, the question and permission
+     * screens, the submit path, the session's model — is filled in each
+     * render through `scheduleLiveRef`.
+     */
+    const scheduleLiveRef = useRef(null);
+    const scheduleRef = useRef(null);
+    if (scheduleRef.current === null) {
+        scheduleRef.current = createScheduleIntegration({
+            home: () => sessionsRef.current?.root ?? resolveNamzuHome(),
+            cwd: () => ctxRef.current.cwd,
+            extraRoots: () => ctxRef.current.additionalDirectories ?? [],
+            config: () => ctxRef.current,
+            model: () => scheduleLiveRef.current?.model,
+            sessionId: () => (conversationMaterializedRef.current ? scopeRef.current?.sessionId : undefined),
+            loopsFile: () => {
+                const sessions = sessionsRef.current;
+                const scope = scopeRef.current;
+                if (!sessions || !scope || !conversationMaterializedRef.current)
+                    return undefined;
+                try {
+                    return join(sessions.paths.sessionDir({ sessionId: scope.sessionId }), 'loops.json');
+                }
+                catch {
+                    return undefined;
+                }
+            },
+            isIdle: () => stateRef.current === 'idle' && abortRef.current === null,
+            say: (text) => scheduleLiveRef.current?.say(text),
+            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),
+        });
+    }
+    /**
+     * `save_skill`'s confirmation. The tool is the TUI's alone (never exec, a
+     * scheduled run or a sub-agent), and its question is this screen, not the
+     * permission gate, so no permission mode answers it for the operator.
+     */
+    const [saveSkillPrompt, setSaveSkillPromptState] = useState(null);
+    const saveSkillPromptRef = useRef(null);
+    const setSaveSkillPrompt = useCallback((next) => {
+        saveSkillPromptRef.current = next;
+        setSaveSkillPromptState(next);
+    }, []);
+    const saveSkillNotifyRef = useRef(null);
+    const saveSkillToolRef = useRef(null);
+    if (saveSkillToolRef.current === null) {
+        saveSkillToolRef.current = buildSaveSkillTool({
+            cwd: () => ctxRef.current.cwd,
+            config: () => ctxRef.current.skills,
+            sessionId: () => conversationMaterializedRef.current ? scopeRef.current?.sessionId : undefined,
+            confirm: (request, signal) => new Promise((resolve) => {
+                if (signal?.aborted) {
+                    resolve('cancel');
+                    return;
+                }
+                const entry = {
+                    request,
+                    resolve: (answer) => {
+                        signal?.removeEventListener('abort', onAbort);
+                        // The screen answers from its own key handler, which Ink calls
+                        // before App's (a child subscribes first). Clearing the ref now
+                        // would hand the same Esc or Ctrl+C to App, which reads it as
+                        // an interrupt of the turn this answer is for. Let the key's
+                        // dispatch finish first.
+                        queueMicrotask(() => {
+                            if (saveSkillPromptRef.current === entry)
+                                setSaveSkillPrompt(null);
+                        });
+                        resolve(answer);
+                    },
+                };
+                const onAbort = () => entry.resolve('cancel');
+                signal?.addEventListener('abort', onAbort, { once: true });
+                setSaveSkillPrompt(entry);
+                saveSkillNotifyRef.current?.();
+            }),
+            saved: ({ name, path }) => scheduleLiveRef.current?.say(`✎ Saved skill ${name} to ${path}. The model is offered it from the next turn; /skills ${name} activates it now.`),
+        });
+    }
     /**
      * A provider session can be ready before a person has started a conversation.
      * The scope still needs a mutable session cursor, but its generated id is
@@ -948,6 +1071,12 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const [goalDriveVersion, setGoalDriveVersion] = useState(0);
     const [goalStatus, setGoalStatus] = useState(null);
     const pendingGoalResumeRef = useRef(null);
+    /**
+     * The conversation `namzu resume <id>` opened, until the screen is ready to
+     * look at it once: a scheduled run parked on a decision there is continued
+     * then, so its permission prompt is on screen without typing `/resume`.
+     */
+    const pendingScheduledResumeRef = useRef(null);
     const wakeGoalDriver = useCallback(() => setGoalDriveVersion((version) => version + 1), []);
     /**
      * Conversation writes in the order the operator produced them.
@@ -1160,6 +1289,56 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             ]);
         return id;
     }, [nextId]);
+    /**
+     * The skill proposal's per-conversation facts: whether this conversation
+     * has proposed one, and whether it has used a skill. Keyed by the
+     * conversation generation, so `/clear`, `/resume` and a fork start over.
+     */
+    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);
+    const conversationLearning = useCallback(() => {
+        if (learningRef.current.generation !== conversationGenRef.current) {
+            learningRef.current = {
+                generation: conversationGenRef.current,
+                proposed: false,
+                skillUsed: false,
+            };
+        }
+        return learningRef.current;
+    }, []);
+    /**
+     * After a turn settles: one dim line proposing to save it as a skill, when
+     * the turn earned it (`judgeSkillSuggestion`) and the anti-nag ledger lets
+     * it through. Costs nothing and saves nothing; `/skills save` does that.
+     */
+    const offerSkillSuggestion = useCallback((st) => {
+        if (!st.learning)
+            return;
+        const conversation = conversationLearning();
+        const config = ctxRef.current.skills;
+        const verdict = judgeSkillSuggestion(st.learning, {
+            suggest: skillSuggestOverrideRef.current ?? config?.suggest,
+            ...(config?.suggestMinToolCalls !== undefined
+                ? { minToolCalls: config.suggestMinToolCalls }
+                : {}),
+            planMode: st.startedInPlanMode === true || permissionModeRef.current === 'plan',
+            skillUsedInConversation: conversation.skillUsed,
+            proposedInConversation: conversation.proposed,
+            skillFlowTurn: st.skillFlow === true,
+        });
+        if (!verdict.suggest)
+            return;
+        const home = resolveNamzuHome();
+        const admission = admitSuggestion(readSuggestionLedger(home));
+        if (admission.show === 'nothing')
+            return;
+        conversation.proposed = true;
+        writeSuggestionLedger(home, admission.next);
+        pushMessage('system', admission.show === 'proposal'
+            ? skillSuggestionNotice(verdict.steps, verdict.tools)
+            : SUGGESTIONS_STOPPED_NOTICE, false, '✻', undefined, theme.text.muted);
+    }, [conversationLearning, pushMessage]);
     /**
      * `/agents [running|available|batches]`, answered by the delegation UI's
      * `agentsSlashCommand` over this session's live monitor and the batches the
@@ -1532,7 +1711,10 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         })();
     }, [pushMessage]);
     const activateSkill = useCallback((name) => {
-        const info = discoverSkills({ cwd: ctx.cwd }).find((skill) => skill.name === name);
+        const info = discoverSkills({
+            cwd: ctx.cwd,
+            ...(ctx.skills ? { config: ctx.skills } : {}),
+        }).find((skill) => skill.name === name);
         if (!info) {
             pushMessage('system', `No skill named "${name}". See /skills.`);
             return;
@@ -1543,12 +1725,13 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 ...previous.filter((skill) => skill.name !== info.name),
                 { name: info.name, body },
             ]);
+            conversationLearning().skillUsed = true;
             pushMessage('system', `Activated skill: ${info.name}`);
         }
         catch (error) {
             pushMessage('system', `Could not load skill "${name}": ${error instanceof Error ? error.message : String(error)}`);
         }
-    }, [ctx.cwd, pushMessage]);
+    }, [conversationLearning, ctx.cwd, ctx.skills, pushMessage]);
     const removeStoredCredential = useCallback((target) => {
         const path = credentialsPath();
         const hadClaude = readStoredSubscriptionCredential() !== null;
@@ -2151,6 +2334,23 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     const finalizeMessage = useCallback((id, finalContent) => {
         setMessages((prev) => prev.map((m) => m.id === id ? { ...m, content: finalContent ?? m.content, pending: false } : m));
     }, []);
+    /**
+     * Close the reply the running turn streamed before a tool took over, as a
+     * tool's start does. For a tool that shows the operator something of its
+     * own while it runs: the reply is complete by then (tools run after the
+     * model's response ends), and left pending it holds every later row out
+     * of scrollback. Text that arrives later starts a new reply.
+     */
+    const closeLiveReply = useCallback(() => {
+        const st = liveStreamRef.current;
+        if (!st)
+            return;
+        flushStream(st);
+        if (st.assistantId) {
+            finalizeMessage(st.assistantId);
+            st.assistantId = null;
+        }
+    }, [finalizeMessage, flushStream]);
     // Open the SDK session store and select the durable conversation once.
     // This is an admission gate for every startup, not optional persistence: a
     // corrupt or split estate must not silently widen into cwd-local state and
@@ -2172,6 +2372,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 ? { text: persistedOutput, provenance: 'persisted' }
                 : null;
             pendingGoalResumeRef.current = requestedConversationId;
+            pendingScheduledResumeRef.current = requestedConversationId;
             initialConversationIdRef.current = undefined;
             conversationMaterializedRef.current = true;
         }
@@ -2243,21 +2444,50 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         if (signal?.aborted)
             return;
         const activeCtx = ctxRef.current;
+        const primary = prefs.providers[0];
+        if (primary && scheduleLiveRef.current) {
+            scheduleLiveRef.current.model = {
+                provider: primary.id,
+                ...(primary.model ? { model: primary.model } : {}),
+            };
+        }
+        const browserConfig = activeCtx.browser;
+        const browserProfile = browserProfileRef.current ?? browserConfig?.defaultProfile;
+        const browserOptions = browserConfig
+            ? {
+                ...(browserProfile ? { profile: browserProfile } : {}),
+                ...(browserConfig.engine ? { engine: browserConfig.engine } : {}),
+                ...(browserConfig.headless ? { headless: browserConfig.headless } : {}),
+                ...(browserConfig.sites ? { sites: browserConfig.sites } : {}),
+                ...(browserConfig.keepOpen ? { keepOpen: true } : {}),
+                ...(sessionsRef.current ? { home: sessionsRef.current.root } : {}),
+            }
+            : undefined;
         const s = await createAgentSession(prefs, detectedNow, {
             scope,
             cwd: activeCtx.cwd,
+            // A person is here to confirm: the model may propose scheduled jobs
+            // and session loops (never in exec, a scheduled run or a sub-agent).
+            extraTools: [
+                ...(scheduleRef.current?.tools() ?? []),
+                ...(saveSkillToolRef.current ? [saveSkillToolRef.current] : []),
+            ],
             ...(activeCtx.structuredOutput ? { structuredOutput: activeCtx.structuredOutput } : {}),
             ...(activeCtx.additionalDirectories
                 ? { additionalDirectories: activeCtx.additionalDirectories }
                 : {}),
             ...(sessionsRef.current ? { stateRoot: sessionsRef.current.root } : {}),
             enableComputerUse: true,
+            // The browser tools, when the config did not switch them off. The
+            // profile is the one `/browser profile` chose, else the config's.
+            ...(browserOptions ? { browser: browserOptions } : {}),
             rules: activeCtx.rules,
             ...(sessionsRef.current
                 ? { sessionGoals: sessionsRef.current.goals, conversationSessions: sessionsRef.current }
                 : {}),
             ...(activeCtx.mcpServers ? { mcpServers: activeCtx.mcpServers } : {}),
             ...(activeCtx.plugins ? { plugins: activeCtx.plugins } : {}),
+            ...(activeCtx.skills ? { skills: activeCtx.skills } : {}),
             ...(activeCtx.web ? { web: activeCtx.web } : {}),
             ...(activeCtx.hooks ? { hooks: activeCtx.hooks } : {}),
             ...(activeCtx.compaction ? { compaction: activeCtx.compaction } : {}),
@@ -2276,6 +2506,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             // question when a decision is genuinely theirs.
             askUser: true,
             allowModelSwitch: true,
+            // The user is at this desktop, so the model may open a page for them.
+            openUrl: true,
         });
         if (signal?.aborted) {
             void s.close();
@@ -2862,7 +3094,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 return;
             }
             await session.abandonTurn(active.turnId, reason);
-            pushMessage('system', `Abandoned turn ${active.turnId}. The next prompt starts a new turn in this conversation.`);
+            pushMessage('system', PAUSED_TURN_LINES.abandoned);
         }
         catch (err) {
             pushMessage('system', `Could not abandon the turn: ${err instanceof Error ? err.message : String(err)}`);
@@ -2875,7 +3107,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
      */
     // `applyEvent` is declared further down; the resume path reads it at call time.
     const applyEventRef = useRef(null);
-    const resumeActiveTurn = useCallback(async () => {
+    const resumeActiveTurn = useCallback(async (resume) => {
         const sessions = sessionsRef.current;
         const scope = scopeRef.current;
         if (!sessions || !scope || !conversationMaterializedRef.current || !session?.hasProvider)
@@ -2887,6 +3119,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             pushMessage('system', 'Wait for the running turn to finish before resuming the parked one.');
             return true;
         }
+        setHandoffPark(null);
         const ac = new AbortController();
         abortRef.current = ac;
         setState('thinking');
@@ -2900,15 +3133,58 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             sessionId: scope.sessionId,
             notification: null,
         };
-        pushMessage('system', `Resuming turn ${active.turnId} from its checkpoint.`, false, '▶');
+        liveStreamRef.current = st;
+        let scheduledRun = false;
+        let restoreBrowser;
         try {
+            // A scheduled run parked on a decision: the operator answers the
+            // parked batch here, and the turn continues under the job's rules.
+            const scheduled = active.paused
+                ? await scheduleRef.current?.prepareResume(permissionModeRef.current, {
+                    cwd: ctxRef.current.cwd,
+                    roots: session.directories?.list() ?? [],
+                    sandboxed: session.sandbox.workspace !== 'host',
+                    // The resumed turn runs on the job's provider: one this
+                    // session has no credential for is refused before asking.
+                    providers: detected.map((item) => item.entry.id),
+                    browser: session.browser !== undefined,
+                })
+                : undefined;
+            if (scheduled && 'leave' in scheduled) {
+                pushMessage('system', 'The scheduled run stays waiting. /resume asks again.');
+                return true;
+            }
+            if (scheduled && 'abandon' in scheduled) {
+                scheduledRun = true;
+                if (!session.abandonTurn)
+                    throw new Error('this session cannot abandon turns');
+                await session.abandonTurn(active.turnId, scheduled.abandon);
+                pushMessage('system', PAUSED_TURN_LINES.abandonedScheduled);
+                return true;
+            }
+            scheduledRun = scheduled !== undefined;
+            const { browser: jobBrowser, ...scheduledParams } = scheduled ?? {};
+            // A job's browser grant: this turn drives the job's profile, held
+            // to its sites, and the session's own comes back when it ends.
+            if (jobBrowser && session.browser) {
+                restoreBrowser = await session.browser.runAs(jobBrowser);
+                pushMessage('system', `The browser uses the job’s profile ${jobBrowser.profile} for this run, on its sites only.`);
+            }
+            // Said once the turn really continues: a scheduled park can still
+            // be left waiting or abandoned above.
+            pushMessage('system', PAUSED_TURN_LINES.resuming, false, '▶');
             for await (const event of session.resumePaused({
                 turnId: active.turnId,
                 signal: ac.signal,
-                // The operator's mode, read at every decision like a new turn's:
-                // `/resume` in plan mode stays read-only, and so do its children.
-                permissionMode: permissionModeRef.current,
-                currentPermissionMode: () => permissionModeRef.current,
+                ...(scheduled ? scheduledParams : {
+                    // The operator's mode, read at every decision like a new turn's:
+                    // `/resume` in plan mode stays read-only, and so do its children.
+                    permissionMode: permissionModeRef.current,
+                    currentPermissionMode: () => permissionModeRef.current,
+                    ...(resume?.handoffReason
+                        ? { systemNote: handoffContinuationNote(resume.handoffReason) }
+                        : {}),
+                }),
             })) {
                 applyEventRef.current?.(event, st);
             }
@@ -2926,9 +3202,38 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             if (abortRef.current === ac)
                 abortRef.current = null;
             setState('idle');
+            // A scheduled run answered here records its end in its job now —
+            // completed, failed or cancelled — not at a scheduler's next tick,
+            // which may never come. One that parked again stays waiting.
+            if (scheduledRun)
+                await scheduleRef.current?.settleAnswered();
+            await restoreBrowser?.().catch(() => undefined);
         }
         return true;
-    }, [finalizeMessage, flushStream, pushMessage, session, state]);
+    }, [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
+    // the permission screen; the job and session checks in `prepareResume`
+    // still refuse a session that does not run as the job does. Any other
+    // parked or interrupted turn is left for the operator's own `/resume`.
+    useEffect(() => {
+        const requested = pendingScheduledResumeRef.current;
+        if (!requested || phase !== 'ready' || state !== 'idle' || !session?.hasProvider)
+            return;
+        const sessions = sessionsRef.current;
+        if (!sessions || scopeRef.current?.sessionId !== requested || abortRef.current)
+            return;
+        pendingScheduledResumeRef.current = null;
+        void (async () => {
+            const active = await activeConversationTurn(sessions, asSessionId(requested)).catch(() => undefined);
+            if (!active?.paused || !(await scheduleRef.current?.isParked()))
+                return;
+            if (scopeRef.current?.sessionId !== requested)
+                return;
+            await resumeActiveTurn();
+        })();
+    }, [phase, resumeActiveTurn, session, state]);
     const doResume = useCallback(async () => {
         const sessions = sessionsRef.current ?? (await ensureSessions(), sessionsRef.current);
         if (!sessions) {
@@ -2979,7 +3284,10 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             // only on its own.
             const kept = [];
             for (const pending of permissionQueueRef.current.splice(0)) {
-                if (releasedByApproveAll(pending.permission.toolCalls))
+                // Nor a question about sharing the screen, which only its own
+                // answer settles.
+                if (pending.permission.screenConsent !== true &&
+                    releasedByApproveAll(pending.permission.toolCalls))
                     pending.resolve(decision);
                 else
                     kept.push(pending);
@@ -3595,11 +3903,14 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 feedback: permissionReviewRefusal(review.reason),
             });
         }
-        const summary = buildPermissionSummary(review.text);
+        const summary = buildPermissionSummary(review.text, {
+            describeUiRef: (ref) => reviewSessionRef.current?.describeComputerUseRef?.(ref),
+        });
+        const siteNotes = browserSiteNotes(req.toolCalls, browserControlRef.current?.status());
         return new Promise((resolve) => {
             if (permissionResolveRef.current) {
                 permissionQueueRef.current.push({
-                    permission: { ...req, review: review.text, summary },
+                    permission: { ...req, review: review.text, summary, siteNotes },
                     resolve,
                 });
                 setQueuedPermissionCount(permissionQueueRef.current.length);
@@ -3609,7 +3920,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             permissionOpenedAtRef.current = Date.now();
             setPermissionReviewOffset(0);
             setPermissionDetailsOpen(!summary.complete);
-            setPermission({ ...req, review: review.text, summary });
+            setPermission({ ...req, review: review.text, summary, siteNotes });
             setState('awaiting-permission');
             sendTerminalNotification({ kind: 'approval-required' });
         });
@@ -3620,15 +3931,26 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
      * and the tool's promise waits on the row the operator picks. One question
      * at a time: the tool is not concurrency-safe, so a second cannot arrive
      * while the first is up.
+     *
+     * `signal`, when the caller has one (the `schedule` tool's confirmation,
+     * which waits on a person and so is given the tool's own abort signal),
+     * is honoured the way `save_skill`'s screen honours the same signal: an
+     * abort — the tool's own deadline elapsing, or the turn stopping —
+     * answers as `abort` and takes the picker off screen, rather than
+     * leaving it live after the tool has already given up on the answer.
      */
-    const askQuestion = useCallback((question) => new Promise((resolve) => {
+    const askQuestion = useCallback((question, signal) => new Promise((resolve) => {
+        if (signal?.aborted) {
+            resolve({ kind: 'abort' });
+            return;
+        }
+        closeLiveReply();
         questionRef.current = { question, resolve };
         const values = [
             ...question.options.map((option) => option.id),
             ...(question.allowFreeText ? [FREE_TEXT_ANSWER] : []),
         ];
-        setSelectedChoice(0);
-        setChoicePicker({
+        const picker = {
             kind: 'user-question',
             title: question.question,
             notice: question.header
@@ -3644,9 +3966,17 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     ? [{ label: 'Something else…', description: 'Answer in your own words' }]
                     : []),
             ],
-        });
+        };
+        const onAbort = () => {
+            if (choicePickerRef.current === picker)
+                setChoicePicker(null);
+            resolveQuestion({ kind: 'abort' });
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        setSelectedChoice(0);
+        setChoicePicker(picker);
         sendTerminalNotification({ kind: 'approval-required' });
-    }), [sendTerminalNotification, setChoicePicker, setSelectedChoice]);
+    }), [closeLiveReply, sendTerminalNotification, setChoicePicker, setSelectedChoice, resolveQuestion]);
     /**
      * Grow this turn's open task block, or open one. The whole plan rides along
      * so the block shows the checklist as it stood after the operation; a
@@ -3670,6 +4000,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     // `st` carries the streaming-assistant bubble id + accumulated text across
     // events within a turn/stream.
     const applyEvent = useCallback((event, st) => {
+        if (st.learning)
+            observeTurnEvent(st.learning, event);
+        if (event.kind === 'tool-start' && event.toolName === SKILL_TOOL_NAME) {
+            conversationLearning().skillUsed = true;
+        }
         const ensureAssistant = () => {
             if (!st.assistantId)
                 st.assistantId = pushMessage('assistant', '', true);
@@ -3935,6 +4270,13 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     setState(activeToolsRef.current.length > 0 ? 'tool' : 'thinking');
                     break;
                 }
+                if (event.cancelled) {
+                    // A No on the tool's own screen: the person's answer, not a failure.
+                    pushMessage('tool', done?.label ?? formatToolCall(event.toolName, event.summary), false, '○', undefined, theme.text.muted, event.durationMs !== undefined ? formatElapsed(event.durationMs) : undefined);
+                    pushMessage('tool', event.resultLabel ?? 'Cancelled', false, '⎿');
+                    setState(activeToolsRef.current.length > 0 ? 'tool' : 'thinking');
+                    break;
+                }
                 const catalogue = !event.isError && event.toolName === 'agent_models' && event.output !== undefined
                     ? modelCatalogueView(event.output) : undefined;
                 if (catalogue !== undefined) {
@@ -4091,6 +4433,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     if (closing)
                         pushMessage('system', closing, false, '✻', undefined, theme.text.muted);
                 }
+                offerSkillSuggestion(st);
                 break;
             }
             case 'paused':
@@ -4102,7 +4445,22 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 st.outcome = 'stopped';
                 st.queuePauseOutcome = 'paused';
                 st.notification = { kind: 'turn-settled', outcome: 'stopped' };
-                pushMessage('system', describeTurnInterruption(event), false, '‖');
+                if (event.handoff) {
+                    // Nothing failed and nothing needs approving: a tool needs the
+                    // operator to do something first. Continuing is one key.
+                    const browser = browserControlRef.current;
+                    const browserStatus = browser?.status();
+                    const browserNotice = describeBrowserHandoff(event.handoff, browserStatus);
+                    // Without a window the sign-in happens in `namzu browser
+                    // login`, which needs the profile this session holds.
+                    if (browserNotice && browser && browserStatus?.headless)
+                        void browser.release();
+                    pushMessage('system', browserNotice ??
+                        `${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, '‖');
                 break;
             case 'error':
                 closeAssistant();
@@ -4115,7 +4473,16 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     st.notification = null;
                 break;
         }
-    }, [appendToMessage, finalizeMessage, flushStream, pushMessage, writeTaskBlock]);
+    }, [
+        appendToMessage,
+        conversationLearning,
+        finalizeMessage,
+        flushStream,
+        offerSkillSuggestion,
+        pushMessage,
+        setHandoffPark,
+        writeTaskBlock,
+    ]);
     applyEventRef.current = applyEvent;
     const runTurn = useCallback(async (prompt) => {
         // A passive queue effect can still hold the previous render's session
@@ -4243,7 +4610,19 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             outcome: null,
             sessionId: destination,
             notification: null,
+            ...(prompt.kind === 'human'
+                ? {
+                    learning: createTurnActivity(),
+                    ...(prompt.skillFlow ? { skillFlow: true } : {}),
+                    startedInPlanMode: permissionModeRef.current === 'plan',
+                }
+                : {}),
         };
+        liveStreamRef.current = st;
+        // A skill activated with /skills <name> stays in the prompt of every
+        // later conversation too; a turn run under one already used a skill.
+        if (st.learning && activeSkills.length > 0)
+            st.learning.skillUsed = true;
         const ac = new AbortController();
         const turnToken = {};
         let abnormalTerminal;
@@ -4819,6 +5198,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             pushMessage('system', `Conversation history is being ${operation}. Wait for it to finish before sending another command or prompt.`);
             return;
         }
+        // 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;
         if (selectionIntent) {
@@ -4859,6 +5240,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         // including the queue — so a command-driven turn is not a second way
         // to run one.
         let outgoing = value;
+        let skillFlow = false;
         const slash = runSlash(value, slashCtx, hostCommands);
         if (slash) {
             switch (slash.kind) {
@@ -5330,20 +5712,16 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     // distinction the headless commands get from `--cwd`. They are
                     // the same value today, and were the same value in `exec --json`
                     // too until they were not.
-                    const skills = discoverSkills({ cwd: ctx.cwd });
+                    const skills = discoverSkills({
+                        cwd: ctx.cwd,
+                        ...(ctx.skills ? { config: ctx.skills } : {}),
+                    });
                     if (skills.length === 0) {
-                        pushMessage('system', 'No skills found. Add one at ~/.namzu/skills/<name>/SKILL.md or ./skills/<name>/SKILL.md.');
+                        pushMessage('system', NO_SKILLS_FOUND);
                         return;
                     }
                     const activeNames = new Set(activeSkills.map((s) => s.name));
-                    const lines = skills.map((s) => 
-                    // A refused skill is shown with its reason rather than hidden.
-                    // Dropping it silently would leave someone wondering where a
-                    // file they can see on disk went.
-                    s.problem
-                        ? `! ${s.name} — ${s.problem}`
-                        : `${activeNames.has(s.name) ? '● ' : '○ '}${s.name} — ${s.description}`);
-                    pushMessage('system', `Skills (● active):\n  ${lines.join('\n  ')}`);
+                    pushMessage('system', renderSkillRoster(skills, activeNames));
                     return;
                 }
                 case 'plugins': {
@@ -5372,9 +5750,12 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     return;
                 }
                 case 'skill-picker': {
-                    const skills = discoverSkills({ cwd: ctx.cwd });
+                    const skills = discoverSkills({
+                        cwd: ctx.cwd,
+                        ...(ctx.skills ? { config: ctx.skills } : {}),
+                    });
                     if (skills.length === 0) {
-                        pushMessage('system', 'No skills found. Add one at ~/.namzu/skills/<name>/SKILL.md or ./skills/<name>/SKILL.md.');
+                        pushMessage('system', NO_SKILLS_FOUND);
                         return;
                     }
                     const activeNames = new Set(activeSkills.map((skill) => skill.name));
@@ -5387,7 +5768,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                             label: skill.name,
                             description: skill.problem
                                 ? `Unavailable: ${skill.problem}`
-                                : `${skill.description} · ${skill.source}`,
+                                : `${skill.description} · ${skill.source} (${skillTierLabel(skill.tier)})`,
                             current: activeNames.has(skill.name),
                         })),
                     });
@@ -5397,6 +5778,46 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     activateSkill(slash.name);
                     return;
                 }
+                case 'new-skill':
+                case 'save-skill': {
+                    const creator = discoverSkills({
+                        cwd: ctx.cwd,
+                        ...(ctx.skills ? { config: ctx.skills } : {}),
+                    }).find((skill) => skill.name === SKILL_CREATOR_SKILL);
+                    if (!creator || creator.problem || creator.invocation === 'operator') {
+                        pushMessage('system', `The ${SKILL_CREATOR_SKILL} skill is not available to the model here${creator?.problem ? ` (${creator.problem})` : ''}. Turn the built-in skills back on (skills.builtin) or write a SKILL.md by hand under ~/.namzu/skills/<name>/.`);
+                        return;
+                    }
+                    // Falls through to the queue-or-send a typed message takes, as
+                    // `prompt` does below.
+                    skillFlow = true;
+                    if (slash.kind === 'new-skill')
+                        outgoing = newSkillPrompt(slash.idea);
+                    else {
+                        outgoing = learnSkillPrompt(slash.name);
+                        // The proposal was taken up: this conversation proposes no
+                        // more, and the ignored-in-a-row count starts again.
+                        conversationLearning().proposed = true;
+                        const home = resolveNamzuHome();
+                        const ledger = readSuggestionLedger(home);
+                        if (ledger.unanswered > 0)
+                            writeSuggestionLedger(home, { ...ledger, unanswered: 0 });
+                    }
+                    break;
+                }
+                case 'skill-suggestions': {
+                    // The session follows the choice whatever the files say; the
+                    // message says whether a later start will too.
+                    skillSuggestOverrideRef.current = slash.on;
+                    if (slash.on)
+                        writeSuggestionLedger(resolveNamzuHome(), FRESH_LEDGER);
+                    const profile = ctx.configDebug?.selectedProfile?.name;
+                    pushMessage('system', setSkillSuggestions(slash.on, {
+                        cwd: ctx.cwd,
+                        ...(profile ? { profile } : {}),
+                    }).message);
+                    return;
+                }
                 case 'resume':
                     void doResume();
                     return;
@@ -5457,6 +5878,8 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                 case 'none':
                     return;
                 case 'host-command': {
+                    if (scheduleRef.current?.handleSlash(slash.name, slash.args))
+                        return;
                     // Dispatched through the kernel's registry, built with what
                     // THIS session can answer from. The descriptors used for
                     // the merge above carry no store — they are names — so the
@@ -5761,6 +6184,21 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     runConversationExport({ kind: 'file', path: slash.path });
                     return;
                 }
+                case 'browser': {
+                    const generation = conversationGenRef.current;
+                    void runBrowserSlash(session?.browser, slash.args, {
+                        busy: state !== 'idle' || abortRef.current !== null,
+                    }).then((answer) => {
+                        // A later session keeps the operator's choice: `/model`
+                        // rebuilds the session, and the profile goes with it.
+                        if (answer.profile)
+                            browserProfileRef.current = answer.profile;
+                        if (conversationGenRef.current !== generation)
+                            return;
+                        pushMessage('system', answer.text);
+                    });
+                    return;
+                }
                 default: {
                     // Exhaustive on purpose. Without it a `SlashAction` kind added
                     // and not handled here falls out of the switch into the send
@@ -5786,8 +6224,16 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             kind: 'human',
             text: outgoing,
             ...(attachments && attachments.length > 0 ? { attachments: [...attachments] } : {}),
+            ...(skillFlow ? { skillFlow: true } : {}),
         };
-        if (mode === 'submit') {
+        // `/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
+        // turn from being proposed as a skill, and the model would read them
+        // mid-task. They wait in the queue for the turn to end.
+        if (skillFlow && activeTurnInboxRef.current) {
+            pushMessage('system', 'Queued: this runs when the current turn ends.');
+        }
+        if (mode === 'submit' && !skillFlow) {
             const inbox = activeTurnInboxRef.current;
             if (inbox) {
                 const expanded = expandFileMentions(outgoing, ctx.cwd);
@@ -5805,6 +6251,7 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
         activeSkills,
         advanceQueueContinuation,
         applyPermissionMode,
+        conversationLearning,
         applyReasoningEffort,
         appLifetime,
         ctx.cwd,
@@ -5841,6 +6288,40 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     // 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;
+    saveSkillNotifyRef.current = () => sendTerminalNotification({ kind: 'approval-required' });
+    scheduleLiveRef.current = {
+        ...(scheduleLiveRef.current?.model ? { model: scheduleLiveRef.current.model } : {}),
+        say: (text) => {
+            closeLiveReply();
+            pushMessage('system', text);
+        },
+        ask: askQuestion,
+        askPermission: onPermission,
+        submit: (text) => handleSubmit(text),
+    };
+    // 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.
+    useEffect(() => {
+        const timer = setTimeout(() => {
+            const line = scheduleRef.current?.startupLine();
+            if (line)
+                scheduleLiveRef.current?.say(line);
+        }, 250);
+        return () => {
+            clearTimeout(timer);
+            scheduleRef.current?.dispose();
+        };
+    }, []);
+    useEffect(() => {
+        if (state !== 'idle')
+            return;
+        try {
+            scheduleRef.current?.loops.tick();
+        }
+        catch {
+            // A loop that cannot be read never takes the screen down with it.
+        }
+    }, [state]);
     // Keep the footer on the same durable goal record the driver mutates. A ref
     // alone cannot repaint React, so every goal mutation bumps goalDriveVersion;
     // generation/session checks stop a late disk read labelling a resumed chat.
@@ -6149,6 +6630,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
     useInput((input, key) => {
         if (outputViewer !== null)
             return;
+        // The save-skill screen owns its keys, Esc and Ctrl+C included: neither
+        // may interrupt the turn that is waiting on its answer. A permission
+        // request (an agent's, say) takes the screen over it and gets the keys.
+        if (saveSkillPromptRef.current && permission === null)
+            return;
         // Startup has refused admission, so there is no draft or active turn to
         // protect with the ready screen's two-press exit ladder.
         if (phase === 'unhealthy') {
@@ -6262,7 +6748,11 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             }
             if (permission && (key.upArrow || key.downArrow)) {
                 const current = permissionChoiceRef.current;
-                const next = key.upArrow ? Math.max(0, current - 1) : Math.min(2, current + 1);
+                const last = permissionAnswers(permission.toolCalls, {
+                    batchOnly: permission.batchOnly === true,
+                    screenConsent: permission.screenConsent === true,
+                }).length - 1;
+                const next = key.upArrow ? Math.max(0, current - 1) : Math.min(last, current + 1);
                 setPermissionChoice(next);
                 return;
             }
@@ -6301,14 +6791,26 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             // the operator never looked at. Refusals above never wait.
             if (!approvalIsDeliberate(permissionOpenedAtRef.current, Date.now()))
                 return;
-            const numbered = ch === '1' ? 0 : ch === '2' ? 1 : ch === '3' ? 2 : null;
+            // The answers on screen, so a digit or Enter means what it is next
+            // to: a batch-only prompt (a scheduled run) has no "allow all", and
+            // neither its `a` nor a `3` answers it.
+            const answers = permissionAnswers(permission?.toolCalls ?? [], {
+                batchOnly: permission?.batchOnly === true,
+                screenConsent: permission?.screenConsent === true,
+            });
+            const numbered = /^[1-9]$/.test(ch) ? Number(ch) - 1 : null;
             const chosen = key.return ? permissionChoiceRef.current : numbered;
-            if (ch === 'y' || chosen === 0)
-                resolvePermission({ kind: 'approve' });
-            else if (ch === 'a' || chosen === 1)
-                resolvePermission({ kind: 'approve-all' });
-            else if (chosen === 2)
-                resolvePermission({ kind: 'reject' });
+            const kind = ch === 'y'
+                ? 'approve'
+                : ch === 'a'
+                    ? answers.some((answer) => answer.kind === 'approve-all')
+                        ? 'approve-all'
+                        : undefined
+                    : chosen !== null
+                        ? answers[chosen]?.kind
+                        : undefined;
+            if (kind)
+                resolvePermission({ kind });
             return;
         }
         // The active child count already advertises this key beside Working.
@@ -6614,6 +7116,21 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
             resetTranscript();
             return;
         }
+        // A turn a tool paused for a person: Enter on an empty composer
+        // continues it, Esc stops it (the turn is abandoned, like /abandon).
+        if (handoffParkRef.current &&
+            phase === 'ready' &&
+            state === 'idle' &&
+            !abortRef.current &&
+            ((key.return && !composerHasDraft) || key.escape)) {
+            const parked = handoffParkRef.current;
+            setHandoffPark(null);
+            if (key.return)
+                void resumeActiveTurn({ handoffReason: parked.reason });
+            else
+                void abandonActiveTurn('The operator stopped the turn a tool paused for them.');
+            return;
+        }
         // Esc interrupts a running turn (Ctrl+C stays reserved for exit). Mirrors
         // the Ctrl+C interrupt path: abort, drop the queue, one "Interrupted." line.
         if (key.escape && (abortRef.current || pendingModelSwitchRef.current)) {
@@ -6738,29 +7255,33 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     ? 'starting a fresh conversation — input is paused'
                     : compacting
                         ? 'compacting conversation — input is paused'
-                        : permission
-                            ? hintForPhase(phase, state, session?.hasProvider === true)
-                            : agentSurface?.kind === 'cockpit'
-                                ? agentSurface.focus === 'workflows'
-                                    ? 'workflows — enter select · esc return'
-                                    : agentSurface.focus === 'phases'
-                                        ? 'agent phases — enter agents · esc return'
-                                        : 'agents — enter inspect · left phases · esc return'
-                                : agentSurface?.kind === 'transcript'
-                                    ? 'observing agent — esc agents · q parent'
-                                    : textPrompt
-                                        ? 'editor open · enter apply · esc cancel'
-                                        : choicePicker
-                                            ? choicePickerSearchable(choicePicker)
-                                                ? 'type to filter · ↑↓ select · enter apply · esc back'
-                                                : effortSlider
-                                                    ? '←/→ adjust · 1–9 select · enter apply · esc back'
-                                                    : '↑↓ / 1–9 select · enter apply · esc back'
-                                            : copyPicker
-                                                ? 'copy target open — ↑↓ / 1–9 select · esc cancel'
-                                                : goalStatus && phase === 'ready' && state === 'idle'
-                                                    ? undefined
-                                                    : hintForPhase(phase, state, session?.hasProvider === true, composerHasDraft);
+                        : saveSkillPrompt
+                            ? 'save skill — ←/→ choose · enter apply · esc cancel'
+                            : permission
+                                ? hintForPhase(phase, state, session?.hasProvider === true)
+                                : agentSurface?.kind === 'cockpit'
+                                    ? agentSurface.focus === 'workflows'
+                                        ? 'workflows — enter select · esc return'
+                                        : agentSurface.focus === 'phases'
+                                            ? 'agent phases — enter agents · esc return'
+                                            : 'agents — enter inspect · left phases · esc return'
+                                    : agentSurface?.kind === 'transcript'
+                                        ? 'observing agent — esc agents · q parent'
+                                        : textPrompt
+                                            ? 'editor open · enter apply · esc cancel'
+                                            : choicePicker
+                                                ? choicePickerSearchable(choicePicker)
+                                                    ? 'type to filter · ↑↓ select · enter apply · esc back'
+                                                    : effortSlider
+                                                        ? '←/→ adjust · 1–9 select · enter apply · esc back'
+                                                        : '↑↓ / 1–9 select · enter apply · esc back'
+                                                : copyPicker
+                                                    ? 'copy target open — ↑↓ / 1–9 select · esc cancel'
+                                                    : handoffPark && phase === 'ready' && state === 'idle' && !composerHasDraft
+                                                        ? 'enter continue · esc stop'
+                                                        : goalStatus && phase === 'ready' && state === 'idle'
+                                                            ? undefined
+                                                            : hintForPhase(phase, state, session?.hasProvider === true, composerHasDraft);
     const permissionSource = reviewSource(permission, scopeRef.current?.sessionId);
     const permissionOwner = permissionSource
         ? subagents.find((agent) => agent.sessionId === permissionSource)
@@ -6799,7 +7320,15 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                     // where it is decided rather than guessed on the screen: with no
                     // session behind the picker, esc exits namzu and the footer says
                     // so instead of offering a cancel nobody will see.
-                    cancelExits: !session?.hasProvider })) : (_jsxs(_Fragment, { children: [agentSurface === null && outputViewer === null ? (_jsx(LiveActivity, { compact: compactWork, activeTools: visibleActiveTools, working: state === 'thinking' || state === 'tool', interruptible: abortRef.current !== null, animate: stdout.isTTY === true && permission === null && textPrompt === null, thinking: thinking, tokens: turnTokens })) : null, agentSurface === null && outputViewer === null && permission === null ? (_jsx(TaskList, { tasks: liveTasks })) : null, permission ? (_jsx(PermissionOverlay, { toolCalls: permission.toolCalls, review: permission.review, summary: permission.summary, detailsOpen: permissionDetailsOpen, reviewOffset: permissionReviewOffset, choice: permissionChoice, queuedCount: queuedPermissionCount, sourceLabel: permissionSourceLabel, columns: terminal.columns, rows: terminal.rows })) : null, textPrompt ? (_jsx(TextPrompt, { columns: Math.max(1, (terminal.columns ?? 80) - 2), title: textPrompt.title, placeholder: textPrompt.placeholder, initialValue: textPrompt.initialValue, emptyNotice: textPrompt.emptyNotice, hidden: permission !== null || (agentSurface !== null || outputViewer !== null), onSubmit: submitTextPrompt, onCancel: cancelTextPrompt }, textPrompt.token)) : permission === null &&
+                    cancelExits: !session?.hasProvider })) : (_jsxs(_Fragment, { children: [agentSurface === null && outputViewer === null ? (_jsx(LiveActivity, { compact: compactWork, activeTools: visibleActiveTools, working: state === 'thinking' || state === 'tool', interruptible: abortRef.current !== null, animate: stdout.isTTY === true &&
+                                permission === null &&
+                                textPrompt === null &&
+                                saveSkillPrompt === null, thinking: thinking, tokens: turnTokens, waitingForYou: choicePicker !== null ||
+                                permission !== null ||
+                                textPrompt !== null ||
+                                saveSkillPrompt !== null })) : null, agentSurface === null && outputViewer === null && permission === null ? (_jsx(TaskList, { tasks: liveTasks })) : null, permission ? (_jsx(PermissionOverlay, { toolCalls: permission.toolCalls, review: permission.review, summary: permission.summary, detailsOpen: permissionDetailsOpen, reviewOffset: permissionReviewOffset, choice: permissionChoice, queuedCount: queuedPermissionCount, sourceLabel: permissionSourceLabel, columns: terminal.columns, rows: terminal.rows, batchOnly: permission.batchOnly === true, siteNotes: permission.siteNotes, ...(permission.screenConsent === true
+                                ? { screenConsent: { provider: session?.providerSummary ?? null } }
+                                : {}) })) : null, saveSkillPrompt && permission === null ? (_jsx(SaveSkillOverlay, { request: saveSkillPrompt.request, cwd: ctx.cwd, columns: Math.max(1, (terminal.columns ?? 80) - 2), rows: terminal.rows, onAnswer: saveSkillPrompt.resolve }, saveSkillPrompt.request.markdown)) : null, textPrompt ? (_jsx(TextPrompt, { columns: Math.max(1, (terminal.columns ?? 80) - 2), title: textPrompt.title, placeholder: textPrompt.placeholder, initialValue: textPrompt.initialValue, emptyNotice: textPrompt.emptyNotice, hidden: permission !== null || (agentSurface !== null || outputViewer !== null), onSubmit: submitTextPrompt, onCancel: cancelTextPrompt }, textPrompt.token)) : permission === null &&
                             agentSurface === null &&
                             outputViewer === null &&
                             choicePicker?.kind === 'reasoning-effort' &&
@@ -6811,7 +7340,9 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                 textPrompt === null &&
                                 choicePicker === null &&
                                 copyPicker === null &&
+                                saveSkillPrompt === null &&
                                 agentSurface === null && outputViewer === null, hidden: permission !== null ||
+                                saveSkillPrompt !== null ||
                                 textPrompt !== null ||
                                 choicePicker !== null ||
                                 copyPicker !== null ||
@@ -6836,14 +7367,18 @@ export function App({ ctx: initialCtx, onExitSummary, externalEditor = defaultEx
                                         conversationMutation !== null ||
                                         externalEditorRequest !== null ||
                                         (agentSurface !== null || outputViewer !== null), hidden: permission !== null ||
+                                        saveSkillPrompt !== null ||
                                         textPrompt !== null ||
                                         choicePicker !== null ||
                                         copyPicker !== null ||
                                         (agentSurface !== null || outputViewer !== null), 
                                     // A turn is running, so Esc is the interrupt and not
                                     // the composer's clear.
-                                    escapeInterrupts: !compacting &&
-                                        (state === 'thinking' || state === 'tool' || pendingModelSwitchRef.current !== null), 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) => ({
+                                    escapeInterrupts: (!compacting &&
+                                        (state === 'thinking' ||
+                                            state === 'tool' ||
+                                            pendingModelSwitchRef.current !== null)) ||
+                                        (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 &&