quoxcli 0.3.1 → 0.4.0

package/lib/quoxon/app.js

@@ -11,15 +11,15 @@ import { mkdtempSync, writeFileSync, writeSync, readFileSync, unlinkSync } from
 import { tmpdir, hostname as osHostname } from 'node:os';
 import { join } from 'node:path';
 import { bufferReducer, initialBuffer, sanitizeForSend, wordAt, selection, selectedText, atVisualEdge } from './textBuffer.js';
-import { MOUSE_ON, MOUSE_OFF, DSR, DOUBLE_MS, DSR_TIMEOUT_MS, mouseOnNote, screenHit, classifyClick, composerIndexAt } from './mouse.js';
+import { MOUSE_ON, MOUSE_OFF, DSR, DOUBLE_MS, DSR_TIMEOUT_MS, mouseOnNote, lineAt, MOUSE_HINT, screenHit, classifyClick, composerIndexAt } from './mouse.js';
 import { parseChunk, initialKeyState, flushDangling, hasDangling, PASTE_ON, PASTE_OFF, PASTE_DANGLING_MS } from './keys.js';
 import { isHeldFromBulk, heldReason } from './bulkRisk.js';
-import { walkCard, walkReply, walkNotYesNo, walkNoCatch, walkSummary, parseDecision, matchesAgent, filterPredicate, approvalRow, approvalDetail, isDecision, parseAnswer, parsePairs } from './approvalsView.js';
+import { walkCard, walkReply, walkNotYesNo, walkNoCatch, walkSummary, parseDecision, matchesAgent, filterPredicate, approvalRow, approvalDetail, isDecision, approvalAsWalkItem, parseAnswer, parsePairs } from './approvalsView.js';
 import { dividerLive, GREEN_MS, RED_MS } from './dividerAocl.js';
-import { reduce, initialState, approvalKeyAllowed, groupApprovals, isPrivileged, approvalSourceLabel, approvalWhat, describeInboxItem, textGate } from './events.js';
+import { reduce, initialState, approvalKeyAllowed, groupApprovals, orderApprovals, otherSessionsCount, isPrivileged, approvalSourceLabel, approvalWhat, describeInboxItem, textGate } from './events.js';
 import { turnTokens } from './indicator.js';
 import {
-  Composer, RingComposer, Pending, ApprovalCard, AskCard, StatusLine, RowsBar, NotifyBar, Working, HistoryItem, liveRows, Intro, Roster, WaitingNotice, historyGap, INTRO_FRAMES, introAnimates, describeActivity, clampCols, clip, COLORS, revealTimingFor
+  Composer, RingComposer, Pending, ApprovalCard, LoopCardView, AskCard, StatusLine, RowsBar, NotifyBar, Working, HistoryItem, liveRows, Intro, Roster, WaitingNotice, historyGap, INTRO_FRAMES, introAnimates, describeActivity, clampCols, clip, COLORS, revealTimingFor
 , endsInRule } from './render.js';
 import { c, mono } from './theme.js';
 import { strayCardAnswer, strayQuestion, alreadyQueued } from './stray.js';
@@ -34,18 +34,22 @@ import { nextTip, normaliseMode, tipSettingsReply, tipsReply, DEFAULT_MODE, TIPS
 import { findSkill, skillRows, skillDetail, skillPrompt } from './skills.js';
 import { createScreenContext } from './screenContext.js';
 import { askText, askQuestion, askAnswer, askChatMessage, settledAskLine, settledAskTone, askOutcomeOf, isAskClarification, askClock } from './ask.js';
+import { objectiveFromEvent, objectiveAskText, objectiveStartedNote, objectiveWatchLine, objectiveFailedNote, watchObjective } from './objectiveOffer.js';
 import { createHandoffStreak, handoffBiggerAskText, handoffFromEvent, handoffAskText, handoffAnsweredNote, handoffSupersededNote, handoffSkippedNote } from './handoffOffer.js';
 import * as selfUpdate from '../core/selfUpdate.js';
+import { parseDone, todoDoneLine, parseTodo, todoAddedLine, todoBoardText, numberBoard, resolveRef, todoMovedLine } from './slash/todoCmd.js';
 import { runRequest, runAnswer, handOverRun, runFooter } from './slotRun.js';
 import { profileChooserRows, liveApi, switchAskLine, slotCreateAskLine, loginRunRequest, okProfileName } from './profileSwitch.js';
 import { rosterView, peekLines, selectRows, backgroundAlerts, isExpired, applyProgress, SPIN_MS } from './roster.js';
 import { runObjectCommand } from './objects/index.js';
+import { runEvidenceCommand } from './slash/evidenceCmd.js';
 import { peekLines as peekIdLines } from '../core/peek.js';
 import { turnsFromItems, asideNoteText } from './asideView.js';
 import { createMentionCache, loadMentions, receiptMentions } from './mentions.js';
 const OBJECT_CMDS = new Set(['/skills', '/agents', '/workflow', '/crystal', '/memory', '/rules', '/proof', '/reconcile', '/fleet', '/prove', '/replay', '/health', '/core']);
 import { intentHint } from './intent.js';
 import { observerLines } from './observers.js';
+import { inboxBarText, arrivals, arrivalLine, inboxTable, inboxDetail, parseInbox, INBOX_USAGE, newestFirst, isApprovalItem } from './inboxView.js';
 import { devObserverOn, DEV_OBSERVER_REFUSAL } from './devObserver.js';
 import { mindLines, mindErrorLines, mindHelpLines, MIND_HELP_ARGS } from './mind.js';
 import { packageVersion } from './welcome.js';
@@ -53,7 +57,7 @@ import { feedbackPayload, feedbackPreview } from './feedback.js';
 import { vetSuggestion, namedCommand } from './suggestCommand.js';
 import { modeReply, normMode, PLAN_GO, MODES, MODE_ROWS } from './mode.js'; // PLAN MODE (owner 2026-10-16)
 import { echoLine } from './echo.js';
-import { inviteText, cleanName, loadNames, saveName, pickNamed, matchAgent, uniqueSquash, resolveSayTarget, addressLabel, sayMissText, parseTarget, nearest, listFailure, slotsTable } from './session.js';
+import { inviteText, cleanName, loadNames, saveName, pickNamed, matchAgent, uniqueSquash, resolveSayTarget, addressLabel, sayMissText, looksLikeAddress, sayWhoText, parseTarget, nearest, listFailure, slotsTable } from './session.js';
 import { pushHistory } from './promptHistory.js';
 import { termRows } from './term.js';
 import { cardTallerThanScreen } from './objects/view.js';
@@ -70,9 +74,9 @@ import { humanSessionLines } from '../core/sessionsOverview.js';
 import { activeLines, activeRows, ACTIVE_KINDS } from '../core/activeSummary.js';
 import { capabilityLines, offerFor, findCapability } from './capabilities.js';
 import { anyProviderConnected, NO_AI_CARD, NO_AI_STATUS, asksAddHost, asksWatchHosts, addHostLines } from './noai.js';
-import { DragonLive, playDragon, dragonActive, resetDragon } from './qmotion.js';
+import { DragonLive, playDragon, dragonActive, resetDragon, clipRoom, flyRoom } from './qmotion.js';
 import { AUTOPLAY, AUTOPLAY_REQUEST, AUTOPLAY_PROOF, typingPlan } from './demo.autoplay.js';
-import { motionLevel, levelFeatures, moodForEvent, ignitionGlow, normaliseLevel } from './motion/level.js';
+import { motionLevel, levelFeatures, ignitionGlow, normaliseLevel } from './motion/level.js';
 import { CLIPS as DRAGON_CLIPS } from './qdragonScenes.js';
 import { DRAGON_USAGE, DRAGON_EXPLAINS, DRAGON_ANSWERS, NOTHING_TO_EXPLAIN, ASK_PROMPT, WAKE_MS, explainPrompt, askPrompt, lastOutput, parseDragonArg, sourceLines } from './dragonModes.js';
 import { SleepScreen, DragonTalk, FlyLive } from './dragonView.js';
@@ -85,6 +89,7 @@ import { runBroadcast, runAck, parsePokeArgs } from './slash/broadcastRun.js';
 import { parseBroadcastText } from './slash/broadcast.js';
 import { isOwnBroadcast } from './ownBroadcast.js';
 import { orgLabel, isOrgId } from './orgLabel.js';
+import { enrichPlanItem } from './planSteps.js';
 import { parseRoomSend, roomName, roomLine, senderName, parseAtSend, senderLabel, slotLine, slotOfHolder, decodeEntities, fileMessage, prepareFile, createSlotListener, createReplyWatches, isHolderLine, loadLastSlot, saveLastSlot, presenceLine } from './slotChat.js';
 import { homedir as osHome } from 'node:os';
 import { createRowCmd } from './slash/rowCmd.js';
@@ -92,6 +97,13 @@ import { createKillerCmds } from './slash/killer.js';
 import { createUndoWish } from './slash/undoWish.js';
 import { createHatWalk } from './slash/hatWalk.js';
 import { createRowEngine, runShell } from './rows.js';
+import { qpeCommand, qpeRowsSetting, QPE_GRID } from './slash/qpeCmd.js';
+import { createExtensionHost, pickDraft as deckPickDraft, readExtList, extSetEnabled, extAdd } from './extensions.js';
+import { createLoopCards, rowsWithoutLoopCards } from './loopCards.js';
+import { initLoop, applySnapshot as applyLoopSnapshot, cardLines } from './loopCard.js';
+import { createCompanionController, companionCommand, DragonCompanionLive, takeGreeting, detachGreeting } from './dragonCompanion.js';
+import { dragonForAgent } from '../dragon/select.js';
+import { createDragonJobs } from '../dragon/jobs.js';
 import { createModelCmd } from './slash/modelCmd.js';
 import { createChallengeCmd } from './slash/challenge.js';
 import { createSpawnCmd } from './slash/spawn.js';
@@ -101,10 +113,10 @@ import { createLedger, costModel } from './slash/ledger.js';
 import { statusModel, contextModel, doctorModel, chatChecks, modelText } from './slash/panels.js';
 import { parseAgentsArgs, filterAgents, agentPickerRow, toolLines, whichReply, looseCommand } from './slash/agents.js';
 import { createPicker } from './slash/picker.js';
-import { resumeRows, pickerRow, matchConversation, turnsToHistory } from './slash/resume.js';
+import { resumeRows, pickerRow, matchConversation, turnsToHistory, cleanTitle, titleFromTurns } from './slash/resume.js';
 import { settingsList, applySettings, configRows, cycle } from './slash/settings.js';
 import { countdownLine } from './countdownLine.js';
-import { startBuildWatch, DIFFERENT_NOTICE } from './slash/restart.js';
+import { startBuildWatch, DIFFERENT_NOTICE, waitForHealthy, SERVER_WAIT_EVERY_MS, SERVER_WAIT_MAX_MS } from './slash/restart.js';
 import { dashboardLines } from './slash/dashboard.js';
 import { supportsHyperlinks } from './markdown.js';
 import { compactResult, compactError, contextFacts, compactShowLines } from './slash/compact.js';
@@ -119,6 +131,7 @@ import { FrameContext, useFrame } from './motion/frame.js';
 import { ringMode, ringAnimating } from './motion/ring.js';
 import { TIMING, revealSpan } from './motion/reveal.js';
 import { matchOrg, orgLines, orgRows } from './orgSwitch.js';
+import { INSTALL_TOOLS, SUGGEST_LINE, planLine, offerQuestion, runInstall, missingTools } from './installCli.js';
 import { matchHat, hatLines, hatChoices, isPrivileged as hatIsPrivileged, mintConversationId } from './hatSwitch.js';
 import { isServerDown, waitForServer, SERVER_RESTARTING, explainTermination, RETRY_HINT, isResumeRetryable, RESUME_RETRY_DELAYS, RESUME_RECONNECTING } from './resend.js';
 
@@ -157,7 +170,7 @@ const byId = (id) => CHOICES.find(x => x.id === id) || null;
 // the status line shows the new ask until the server answers
 const NO_RAN = { provider: null, model: null, endpoint: null };
 
-export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTimeoutMs = 120000, rosterMs = 15000, api: apiProp, profile: profileProp = 'default', org = null, version = '0.1.0', cwd = '', columns, demoLabel = null, verbose = 'on', mode = 'ask', editor = openEditor, introNote = null, animateIntro, earlyInput = null, startup = null, blocked: blockedProp = null, signedOut: signedOutProp = null, autoplay = null, rules = null, welcome = false, sessionName = null, invite = false, slotsAvailable = true, namesPath, transcript = null, modelChoice = null, resumeConversation = null, resume = null, restartSlot = null, restartAttach = null, slotRetryDelays = [2000, 5000, 10000, 20000, 30000], resumeRetryDelays = RESUME_RETRY_DELAYS, onRestart = null, onDemo = null, healthRecheck = null, healthRecheckDelays = [5000, 10000, 20000, 40000, 60000], restartCheck = null, updater = null, startSha = null, buildWatch = startBuildWatch, autoRestartMs = null, autoTickMs = 1000, env = process.env, motion, motionStats = null, away = null, tipStartup = false, whatsNewStartup = false, interactive, resendDelays = null, demoAuto = null, agentLogin: agentLoginProp = false, humanProfiles = [], switchProfile = null, loginCandidates = [], slotRecordPath = undefined, spawnStatePath = undefined, noReplyMs = 90000, replyWatchMs = 30 * 60 * 1000, historyStore = null, runSpawn = spawnSync, runHandOverDelayMs = 60, mouseScreen = null, runNow = Date.now, whatsNewEntries = undefined }) {
+export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTimeoutMs = 120000, rosterMs = 15000, api: apiProp, profile: profileProp = 'default', org = null, version = '0.1.0', cwd = '', columns, demoLabel = null, verbose = 'on', mode = 'ask', editor = openEditor, introNote = null, animateIntro, earlyInput = null, startup = null, blocked: blockedProp = null, signedOut: signedOutProp = null, autoplay = null, rules = null, welcome = false, sessionName = null, invite = false, slotsAvailable = true, namesPath, transcript = null, modelChoice = null, resumeConversation = null, resume = null, restartSlot = null, restartAttach = null, slotRetryDelays = [2000, 5000, 10000, 20000, 30000], resumeRetryDelays = RESUME_RETRY_DELAYS, onRestart = null, onDemo = null, healthRecheck = null, healthRecheckDelays = [5000, 10000, 20000, 40000, 60000], restartCheck = null, updater = null, startSha = null, buildWatch = startBuildWatch, autoRestartMs = null, autoTickMs = 1000, serverProbe = null, serverPollMs = SERVER_WAIT_EVERY_MS, serverWaitMs = SERVER_WAIT_MAX_MS, env = process.env, motion, motionStats = null, away = null, tipStartup = false, whatsNewStartup = false, interactive, resendDelays = null, demoAuto = null, agentLogin: agentLoginProp = false, humanProfiles = [], switchProfile = null, loginCandidates = [], slotRecordPath = undefined, spawnStatePath = undefined, noReplyMs = 90000, replyWatchMs = 30 * 60 * 1000, historyStore = null, runSpawn = spawnSync, runHandOverDelayMs = 60, mouseScreen = null, runNow = Date.now, whatsNewEntries = undefined }) {
   // Z2H: signed-out is ONE state (card at the top + /login), not scattered errors. While it holds, `blocked` is the
   // one-line answer, so chat, /connect and the digest/approvals pollers stay quiet instead of printing raw 401s.
   // PROFILE-SWITCH (owner 2026-10-16): the window's api is swappable in place (profileSwitch.js liveApi); `who` is the
@@ -183,6 +196,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   const exit = (afterMs = 0) => {
     const R0 = R.current;
     if (R0.exiting) return undefined;
+    try { DK.current?.unloadAll(); } catch { /* closing the deck never blocks exit */ }
     R0.exiting = true; R0.sleep = null; R0.fly = null;
     R0.bang?.run.kill(); // QUOXON-FW8: a running ! command is killed with us, never left behind
     resetDragon();
@@ -232,6 +246,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   // Drop-in reveals: history items enter <Static> only once their reveal has ended (at most ~1 s); until then
   // they render in the live region. committedRef = how many history items <Static> has been given.
   const committedRef = React.useRef(introAnimating ? 0 : S.current.history.length);
+  const staticRef = React.useRef({ list: [], seen: 0, deferred: [] }); // what <Static> was given: committed items in order, minus loop cards still running (they join when they settle)
   const fxRef = React.useRef(new Map()); // item id -> { at, timing, running, settleAt }
   const rosterSeen = React.useRef(new Map()); // roster row key -> first seen (ms)
   const K = React.useRef({ keys: initialKeyState(), lastKeyAt: null, lastKeyCh: null, lastDataAt: 0, lastPasteAt: 0, lastEscAt: 0, ctrlC: 0, guard: null, dismissed: new Set(), cardFocus: false, confirm: false, cardGoneAt: 0, typed: '', danglingTimer: null });
@@ -252,7 +267,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
 
   const SND = React.useRef(null); SND.current ??= createSound({ api, stdout }); // QuoxSound: one subscription point (dispatch)
   /** QUOXON-FW15: the one card shown: the oldest waiting approval (this conversation first, then other sessions/plugins) not dismissed with Tab. */
-  const queueOf = (st) => { const all = [...st.approvals, ...st.waiting]; const live = new Set(all.map(x => x.callId)); for (const id of K.current.dismissed) if (!live.has(id)) K.current.dismissed.delete(id); return all.filter(x => !K.current.dismissed.has(x.callId)); };
+  const queueOf = (st) => { const all = orderApprovals([...st.approvals, ...st.waiting], LC.current.all().map((c) => c.id)); const live = new Set(all.map(x => x.callId)); for (const id of K.current.dismissed) if (!live.has(id)) K.current.dismissed.delete(id); return all.filter(x => !K.current.dismissed.has(x.callId)); };
   const headCard = (st) => queueOf(st)[0] || null;
   const SCX = React.useRef(null); SCX.current ??= createScreenContext(); // SCREEN-CONTEXT: the events ring + changed-only bookkeeping for the terminal block
   const dispatch = (a) => {
@@ -264,7 +279,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     }
     transcript?.action(a.redact !== undefined ? { ...a, text: a.redact } : a); // dev transcript capture (off by default; see transcript.js); `redact` is what the capture sees instead of a secret-bearing text
     const prevS = S.current; S.current = reduce(prevS, { now: Date.now(), ...a }); SND.current.observe(prevS, S.current, a);
-    if (motionOn && !mono() && feats().moods) { const m = moodForEvent(prevS, a, S.current); if (m) playDragon(m); } // cinematic: the dragon reacts
+    if (motionOn && !mono() && feats().moods) { const m = DC.current.moodFor(prevS, a, S.current); if (m) playDragon(m); } // cinematic: the dragon reacts (one moment engine: an attached companion owns the moment instead, dragonMoments.js)
     // Per shown card: remember the key that was already down when it appeared, and restart the typed word.
     const c0 = headCard(S.current);
     if (!c0 && K.current.guard) K.current.cardGoneAt = Date.now();
@@ -292,6 +307,33 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   };
   // QUOXON-ASK: every question for the human is ONE shape (▶ reason. question? keys), highlighted. Never say a raw y/N.
   const ask = (question, opts) => say(askText(question, opts), 'ask');
+  // LAZY-AI-CLI (owner 2026-10-19): when something needs Claude Code or Codex and this server lacks it, offer to
+  // install it THEN, as one y/N card (never "type this command"). The server installs the vendor's own npm package.
+  const offerInstall = async (tool) => {
+    const t = INSTALL_TOOLS[tool];
+    const plan = api.providerCliPlan ? await api.providerCliPlan(tool) : null;
+    if (!plan?.ok) {
+      if (plan?.status === 403) say(`${t.name} isn't installed on this server. An instance admin can install it from the Quox terminal.`, 'warn');
+      else if (plan?.status === 404 || plan?.status === 405 || !api.providerCliPlan) say(`${t.name} isn't installed on this server, and this server is too old to install it for you. Update the server first.`, 'warn');
+      else say(`${t.name} isn't installed on this server, and Quox could not check npm right now (${plan?.error || 'no answer'}).`, 'warn');
+      return nextInstallOffer();
+    }
+    say(planLine(plan), 'dim');
+    R.current.installAsk = { tool, plan, at: Date.now() };
+    return ask(offerQuestion(tool, plan), { action: `install ${t.name}`, reason: `${t.vendor}'s own package, downloaded from npm onto this server.` });
+  };
+  function nextInstallOffer() {
+    const q = R.current.installQueue;
+    if (!q || !q.length) return undefined;
+    return offerInstall(q.shift());
+  }
+  async function installNow(a) {
+    say(`◐ installing ${INSTALL_TOOLS[a.tool].name} ${a.plan?.version || ''} on the server (a minute or two)`.trim(), 'dim');
+    const r = await runInstall(api, a.tool, { onProgress: (l) => say(l, 'dim') });
+    for (const l of r.lines) say(l, r.ok ? 'ok' : 'warn');
+    if (r.ok) bump(n => n + 1);
+    return nextInstallOffer();
+  }
   // PLAN MODE: this window's mode ('ask' | 'plan'). Window-scoped: rides /restart, never the shared profile.
   const MD = React.useRef(null); MD.current ??= normMode(mode);
   const askerName = () => String(SN.current?.agent || where.current?.agent || 'Quox').toUpperCase(); // a model-suggested command: who asks
@@ -365,6 +407,56 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   const rowsLoaded = React.useRef(false);
   React.useEffect(() => { if (!blocked && !demoLabel && !rowsLoaded.current) { rowsLoaded.current = true; RW.current.load(); } }, [blocked]);
   React.useEffect(() => () => RW.current.stopEngine(), []);
+  // EXTENSIONS (extensions.js): optional npm packages listed in ~/.quox/extensions.json. They can open an approval or
+  // preselect an answer; the user confirms here. Core ships no extension-specific code.
+  const DK = React.useRef(null);
+  DK.current ??= createExtensionHost({
+    env,
+    getSettings: () => api.settings?.() || {},
+    handlers: {
+      openApproval: (n) => { command(`/approvals ${n}`); },
+      preselect: (n, option) => {
+        const it = (R.current.deckItems || [])[n - 1];
+        const draft = deckPickDraft(it, n, option);
+        if (!draft) return say(`Extension: no such option "${option}" for [${n}].`, 'warn');
+        edit({ type: 'set', text: draft }); // preselected only: the answer goes when the user presses Enter
+        say(`Preselected: ${draft.trim()}. Press Enter to confirm.`, 'accent');
+      },
+      changed: () => bump(n => n + 1)
+    },
+    log: () => {}
+  });
+  const extDispatch = async (cmd, restArg) => { // a loaded extension's own slash command; true when one handled it
+    const xr = await DK.current.runCommand(cmd, restArg, { say: (t, tone) => say(t, tone), org: orgShown(), host: DK.current });
+    if (!xr.handled) return false;
+    if (xr.error) say(`${cmd}: ${xr.error}`, 'warn'); else if (typeof xr.result === 'string') say(xr.result); else if (xr.result?.text) say(xr.result.text, xr.result.tone);
+    return true;
+  };
+  const extLoad = async (name, quiet) => { const r = await DK.current.load(name); if (!quiet || r.ok) say(r.text, r.ok ? 'ok' : 'warn'); return r; };
+  React.useEffect(() => {
+    if (!blocked && !demoLabel) for (const x of readExtList()) if (x.enabled) extLoad(x.name, true).catch(() => {});
+    return () => { DK.current.unloadAll(); };
+  }, []);
+  React.useEffect(() => { // fleet for extensions: a light 30 s poll of the existing host list, only while an extension is loaded
+    if (!DK.current.armed() || !api.mentionHosts) return undefined;
+    let dead = false;
+    const poll = () => api.mentionHosts().then((h) => { if (!dead) { R.current.fleetHosts = h; bump(n => n + 1); } }, () => { if (!dead) { R.current.fleetHosts = null; } });
+    poll(); const id = setInterval(poll, 30000);
+    return () => { dead = true; clearInterval(id); };
+  }, [DK.current.armed()]);
+  React.useEffect(() => { // push what this window already holds; the host dedupes and throttles to 1/s
+    if (!DK.current.armed()) return;
+    const rows = R.current.roster?.allRows || [];
+    DK.current.push({
+      org: { id: R.current.orgId ?? api.orgId?.() ?? null, name: orgShown() },
+      items: R.current.deckItems || [],
+      health: { collector: R.current.notify?.fails > 0 || S.current.notify?.error ? 'down' : 'ok', rows: rows.some(r => r.state === 'failed') ? 'warn' : 'ok' },
+      loops: LC.current.all().map(c => ({ id: c.state.id, title: c.state.title, turn: c.state.iteration ?? c.state.turn, max: c.state.maxTurns, status: c.state.done ? (c.state.state === 'failed' ? 'failed' : 'done') : 'running' })),
+      fleet: R.current.fleetHosts || null,
+      evidence: api.evidenceChain?.() || null, // quoxon holds no chain status today: 'unknown' unless the api provides one
+      sessions: { active: rows.filter(r => r.state === 'running').length }
+    });
+  });
   PL.current ??= createPalette({
     getDraft: () => B.current.text, setDraft: (t) => edit({ type: 'set', text: t }),
     run: (t) => { remember(t); command(t); }, say: (t, tone) => say(t, tone),
@@ -378,13 +470,47 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     flagged: modelChoice != null, off: Boolean(blocked || demoLabel),
     dispatchCtx: () => dispatch({ type: 'ctx', ctx: NO_RAN })
   }), []);
+  // TUI-STATUS: the registered server this runs on, read once at start (a restart re-reads); null = show nothing
+  const SV = React.useRef(null); SV.current ??= { chip: null };
+  React.useEffect(() => { // retry every 3 min (max 20) until the lookup succeeds: a collector restart at startup must not hide the chip for the whole session; failing shows nothing
+    if (blocked || demoLabel || !api.serverChip) return undefined;
+    let stopped = false, timer = null, tries = 0;
+    const attempt = () => { tries++; Promise.resolve().then(() => api.serverChip()).then((c) => { if (stopped) return; if (c?.name) { SV.current.chip = c; dispatch({ type: 'notify', patch: {} }); } else if (tries < 20) timer = setTimeout(attempt, 180000); }).catch(() => { if (!stopped && tries < 20) timer = setTimeout(attempt, 180000); }); };
+    attempt();
+    return () => { stopped = true; if (timer) clearTimeout(timer); };
+  }, []);
   const LG = React.useRef(null); LG.current ??= createLedger(); // /cost, /context: real usage only
   // /restart auto: saved per profile (profile.quoxon.restartAuto). `newId` = the newest installed build seen; `cancelledId` = the build whose countdown a key cancelled.
   const AR = React.useRef(null); AR.current ??= { on: (api.settings?.() || {}).restartAuto === true, newId: null, cancelledId: null, timer: null, endsAt: 0 };
   // Countdown length: the autoRestartMs prop (tests), else QUOX_RESTART_COUNTDOWN seconds (default 10; 0 = restart at once).
   const countdownMs = () => { if (autoRestartMs != null) return autoRestartMs; const n = Number(env.QUOX_RESTART_COUNTDOWN); return (env.QUOX_RESTART_COUNTDOWN != null && env.QUOX_RESTART_COUNTDOWN !== '' && Number.isFinite(n) && n >= 0 ? n : 10) * 1000; };
   const cdLog = (phase, seconds = null) => transcript?.action({ type: 'restart.countdown', phase, seconds, build: AR.current.newId }); // lifecycle in the dev transcript
-  const stopCountdown = () => { clearTimeout(AR.current.timer); AR.current.timer = null; AR.current.endsAt = 0; };
+  const stopCountdown = () => { clearTimeout(AR.current.timer); AR.current.timer = null; AR.current.endsAt = 0; AR.current.waiting = null; };
+  // A land refreshes the CLI and redeploys the collector together: an AUTO restart waits for the server's /health (every
+  // serverPollMs, up to serverWaitMs), then restarts anyway. Manual /restart and Enter never wait.
+  const serverUp = serverProbe || (api.health ? () => api.health(3000) : null);
+  const autoFire = () => {
+    const a = AR.current;
+    if (!serverUp) { cdLog('timed-out'); doRestart(); return; }
+    const token = {}; a.waiting = token; // set first: cancels and the idle check see a restart in flight
+    Promise.resolve().then(() => serverUp()).catch(() => null).then((first) => {
+      if (AR.current.waiting !== token || R.current.closed) return;
+      if (first?.ok === true) { stopCountdown(); cdLog('timed-out'); doRestart(); return; } // healthy: no waiting line, as before
+      beginWait(token);
+    });
+  };
+  const beginWait = (token) => {
+    const a = AR.current;
+    a.endsAt = Date.now() || 1;
+    a.timer = setTimeout(() => {}, serverWaitMs + 60000); // holds the countdown slot (keys, held-by-draft check); cleared by stopCountdown
+    cdLog('waiting-for-server');
+    bump(n => n + 1);
+    waitForHealthy({ probe: serverUp, everyMs: serverPollMs, maxMs: serverWaitMs, cancelled: () => AR.current.waiting !== token || R.current.closed }).then((up) => {
+      if (AR.current.waiting !== token || R.current.closed) return; // cancelled (Esc, Enter, a draft) or closed
+      stopCountdown();
+      if (AR.current.on && autoIdle()) { cdLog(up ? 'server-back' : 'wait-timed-out'); doRestart(); } else { cdLog('held'); bump(n => n + 1); }
+    });
+  };
   React.useEffect(() => (startSha ? buildWatch({ startSha, repeat: true, onNotice: (t, id) => {
     AR.current.newId = id || t;
     if (!AR.current.on) say(t === DIFFERENT_NOTICE ? t : 'a newer quox is installed: /restart (or /restart auto on)', 'dim');
@@ -397,14 +523,14 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   React.useEffect(() => {
     const id = setInterval(() => {
       const a = AR.current;
-      if (!a.on || !a.newId || a.newId === a.cancelledId || R.current.restarting) return;
+      if (!a.on || !a.newId || a.newId === a.cancelledId || R.current.restarting || (a.waiting && !a.timer)) return;
       if (a.timer) { if (!autoIdle()) { stopCountdown(); cdLog('held'); bump(n => n + 1); if (R.current.pendingWalk) say('Restart held: it waits until the walkthrough ends.', 'dim'); } else bump(n => n + 1); return; } // ticks the visible countdown
       if (!autoIdle()) return;
       const ms = countdownMs();
-      if (ms <= 0) { cdLog('timed-out', 0); doRestart(); return; }
+      if (ms <= 0) { cdLog('timed-out', 0); autoFire(); return; }
       a.endsAt = Date.now() + ms;
       cdLog('started', Math.round(ms / 1000));
-      a.timer = setTimeout(() => { stopCountdown(); if (AR.current.on && autoIdle()) { cdLog('timed-out'); doRestart(); } else { cdLog('held'); bump(n => n + 1); } }, ms);
+      a.timer = setTimeout(() => { if (AR.current.on && autoIdle()) { clearTimeout(a.timer); a.timer = null; a.endsAt = 0; autoFire(); } else { stopCountdown(); cdLog('held'); bump(n => n + 1); } }, ms);
       bump(n => n + 1);
     }, autoTickMs);
     return () => { clearInterval(id); stopCountdown(); };
@@ -412,18 +538,51 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   // /restart carried a slot: re-check it out under this window's label before the old one is gone. /restart auto tends to
   // fire just as a new build lands, which is often while the collector redeploys, so a timeout or 5xx is retried; if it
   // never answers, the "Reattach to slot X? y/N" ask is offered instead of leaving the window silently slotless.
-  React.useEffect(() => { if (restartSlot && !blocked && api.checkoutSlot) carrySlot(restartSlot); }, []);
+  React.useEffect(() => { if (restartSlot && !blocked && api.checkoutSlot) waitForHealthy({ probe: serverUp, everyMs: serverPollMs, maxMs: serverWaitMs, cancelled: () => R.current.closed }).then(() => { if (!R.current.closed) carrySlot(restartSlot); }); }, []);
   // /restart carried an /attach (agent or slot): re-attach once the window can act (owner 2026-10-15 "why dont u reattach").
   const attachCarried = React.useRef(false);
   React.useEffect(() => {
     if (!restartAttach || blocked || attachCarried.current) return;
     attachCarried.current = true;
     if (S.current.turn) { R.current.pendingAttach = restartAttach; say(`Re-attaching to ${restartAttach.replace(/^(agent|slot):/, '')} when this turn ends.`, 'dim'); return; } // a resumed turn would refuse it
-    command(`/attach ${restartAttach}`);
+    waitForHealthy({ probe: serverUp, everyMs: serverPollMs, maxMs: serverWaitMs, cancelled: () => R.current.closed }).then(() => { // the server may still be redeploying: attach only once it answers
+      if (R.current.closed) return;
+      if (S.current.turn) { R.current.pendingAttach = restartAttach; return; }
+      R.current.noGreeting = true; command(`/attach ${restartAttach}`);
+    });
   }, [blocked]);
   React.useEffect(() => { // any other way the resumed turn ends (reattach path, Esc): carry the attach then
     if (R.current.pendingAttach && !S.current.turn) { const a = R.current.pendingAttach; R.current.pendingAttach = null; command(`/attach ${a}`); }
   });
+  /**
+   * Move THIS window to org `t` ({ id, name }) now: new conversation, status bar, agent re-attach as on /restart.
+   * `quick` (picker / `/org <name>`): the pick is the authorization, so one short line, and `makeDefault` also
+   * changes the profile-wide default (the same change as `quox org switch` in a shell).
+   */
+  async function switchOrgNow(t, { quick = false, makeDefault = false } = {}) {
+    const R0 = R.current, curId = R0.orgId ?? api.orgId?.() ?? null;
+    if (S.current.turn) return say('Wait for the current turn or press Esc first.', 'warn');
+    if (!api.switchOrg) return say('Org switching is not available in this mode.', 'warn');
+    if (t.id === curId && !makeDefault) return say(`Already in ${t.name}.`);
+    let done;
+    try { done = await api.switchOrg(t.id); } catch (e) { return say(`Not switched. ${e?.message || 'The server refused.'} You are still in ${R0.orgName ?? org ?? 'the same org'}.`, 'warn'); }
+    const att = SN.current.agent ? `agent:${SN.current.agent}` : null;
+    if (t.id !== curId) R0.prevOrg = curId ? { id: curId, name: R0.orgName ?? org ?? curId } : null; // /org back returns here
+    R0.orgId = done.id; R0.orgName = done.name;
+    dispatch({ type: 'ctx', ctx: { conversationId: null } });
+    SN.current.name = null; SN.current.saved = null;
+    dispatch({ type: 'history.reset' });
+    if (stdout?.isTTY) stdout.write('\x1b[2J\x1b[3J\x1b[H');
+    setEpoch(e => e + 1); bump(n => n + 1);
+    let scope = 'this window only; the profile default is unchanged';
+    let tone = 'ok';
+    if (makeDefault) {
+      try { await api.makeOrgDefault(done.id); scope = 'this window and the profile default'; }
+      catch (e) { scope = `this window only; could not change the profile default (${e?.message || 'refused'})`; tone = 'warn'; }
+    }
+    if (att) { R.current.noGreeting = true; command(`/attach ${att}`); }
+    return say(quick ? `now in ${done.name} (${scope})` : `Switched to ${done.name}. New conversation in that org.`, tone);
+  }
   async function carrySlot(nm) {
     for (let i = 0; ; i++) {
       if (R.current.closed || SC.current.slot) return; // closed, or this window checked a slot out meanwhile (/slot); a slot merely inherited from a parent Claude session does not count
@@ -447,6 +606,11 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     return () => clearInterval(id);
   }, []);
   // ---- QUOXON-MESH: slot chat (slotChat.js) ----------------------------------------------------------------
+  // Dragon companion (Lucid, Hyperion, Seer, Sentinel, Drago, Cipher): attach state + real stream events; art and reducer live in dragonlab.
+  const DC = React.useRef(null); DC.current ??= createCompanionController({ settings: () => api.settings?.() || {}, isTTY: Boolean(stdout?.isTTY), typing: () => B.current.text !== '', jobs: createDragonJobs({ reads: api.dragonReads || {}, context: () => ({ envelopeId: receiptMentions([...S.current.history, ...S.current.blocks])[0]?.value || null }) }) }); // each dragon's one job: a real read (dragon/jobs.js)
+  const dispatchEv = (a) => { DC.current.tap(a); dispatch(a); };
+  // QLOOP-LIVE: live loop cards in the chat stream (loopCards.js). A card is held live (commitLimit) until its loop finishes.
+  const LC = React.useRef(null); LC.current ??= createLoopCards({ api, say: (t, tone) => say(t, tone), addItem: (it) => dispatch({ type: 'loopcard', card: it.card }), bump: () => { if (!R.current.closed) bump(n => n + 1); }, dragon: { summon: (d, cap) => DC.current.summon(d, cap) } });
   const SC = React.useRef(null); SC.current ??= { listener: null, slot: null, pendingFile: null, reattach: null, rooms: new Map(), active: null };
   const realCwd = () => (cwd ? String(cwd).replace(/^~(?=\/|$)/, osHome()) : process.cwd());
   const myDisplay = () => { try { return api.displayName?.() || null; } catch { return null; } };
@@ -502,6 +666,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   const runAskOpen = () => Boolean(SC.current.runAsk && runNow() < SC.current.runAsk.expiresAt); // one clock: the run-ask clock decides open and expired alike
   /** ASK-SETTLE: history may go to <Static> (scrollback, immutable) only up to the first armed run card. */
   function commitLimit(s0) {
+    // QLOOP-LIVE: a running loop's card is drawn pinned above the composer, so it never holds the history after it live (that re-laid-out every later row on every card tick); syncStatic defers the card itself until it settles
     const held = SC.current.runCards;
     if (held?.size) for (let i = committedRef.current; i < s0.history.length; i++) { const r = s0.history[i]?.line?.run; if (r?.askId && !r.settled && held.has(r.askId)) return i; }
     return s0.history.length;
@@ -627,6 +792,8 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     const r = await api.slotSay(slot, text, { from: myLabel(), fast: true, fromSlot: where.current.slot || null });
     if (!r.ok && r.status === 404 && api.slots) { let rows = []; try { rows = await api.slots(); } catch { /* the list is a hint only */ } return say(sayMissText(slot, rows), 'warn'); }
     if (!r.ok) return say(`slot ${slot}: ${r.message}`, 'warn');
+    R.current.lastSay = { slot, at: Date.now() }; // SAY-LAST-TARGET
+    if (r.viaOrgId) say(`${slot} lives in another of your orgs; sent there.`, 'dim');
     const ln = slotLine({ from: slot, text, created_at: r.message?.created_at || new Date().toISOString() });
     dispatch({ type: 'slotmsg', line: { ...ln, glyph: '→', who: target.label || slot, file: null, out: true, delivered: true } });
     announceDelivery(slot, r);
@@ -765,12 +932,13 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       }
     }).catch(() => { /* no ask when the server cannot say */ });
   }, []);
-  React.useEffect(() => { if (resume && !blocked) resumeCmd(resume === true ? '' : String(resume)); }, []);
+  React.useEffect(() => { if (resume && !blocked) resumeCmd(resume === true ? '' : String(resume), { fromRestart: Boolean(restartAttach) }); }, []);
   React.useEffect(() => { if (!blocked && !demoLabel) aiConnected().then((st) => { R.current.noAi = st === false ? true : st === true ? false : undefined; bump(n => n + 1); }); }, []);
   // Tips (tips.js): mode, rotation and "already used" persist on the profile (quoxon.tips / tipsSeen / tipsUsed).
-  // QUOXON-MOUSE: optional mouse (default off, saved per profile). `tty` = tracking is on at the terminal right now.
+  // QUOXON-MOUSE: optional mouse (default off, saved per profile; selection-safe.test.jsx forbids tracking by default). `tty` = tracking is on at the terminal right now.
   const MO = React.useRef(null);
   MO.current ??= { on: (api.settings?.() || {}).mouse === 'on', tty: false, chain: Promise.resolve(), drag: null, last: null, onCursor: null, exitFn: null };
+  const TODO_MAP = React.useRef(null); // /todos short ids (td1, do2, dn3) -> real item ids, as last shown
   const TP = React.useRef(null);
   TP.current ??= (() => { const q = api.settings?.() || {}; const arr = (v) => (Array.isArray(v) ? v.filter(x => typeof x === 'string') : []); return { mode: normaliseMode(q.tips) || DEFAULT_MODE, seen: arr(q.tipsSeen), used: arr(q.tipsUsed) }; })();
   const showTip = async ({ startup: atLaunch = false } = {}) => {
@@ -807,6 +975,20 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     const shown = showWhatsNew();
     if (tipStartup && !welcome && !shown) showTip({ startup: true });
   };
+  React.useEffect(() => { // LAZY-AI-CLI: first launch after setup: one line, then a y/N card per missing CLI (admins only; never a wall)
+    if (blocked || !welcome || !api.providerCliStatus || !api.providerCliPlan) return;
+    api.providerCliStatus().then(async (st) => {
+      const missing = missingTools(st);
+      if (!missing.length) return;
+      const first = await api.providerCliPlan(missing[0]);
+      if (!first?.ok) return; // not an instance admin (or npm unreachable): no suggestion they cannot act on
+      say(SUGGEST_LINE);
+      R.current.installQueue = missing.slice(1);
+      say(planLine(first), 'dim');
+      R.current.installAsk = { tool: missing[0], plan: first, at: Date.now() };
+      ask(offerQuestion(missing[0], first), { action: `install ${INSTALL_TOOLS[missing[0]].name}`, reason: `${INSTALL_TOOLS[missing[0]].vendor}'s own package, downloaded from npm onto this server.` });
+    }, () => {});
+  }, []); // eslint-disable-line react-hooks/exhaustive-deps
   React.useEffect(() => {
     if (!blocked && api.capabilities) api.capabilities().then((res) => { R.current.contract = capabilityMap(res); startupTip(); }, () => startupTip());
     else startupTip();
@@ -846,6 +1028,19 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       if (nm && !isOrgId(nm)) { R.current.orgName = nm; dispatch({ type: 'notify', patch: {} }); }
     } catch { /* still unknown: the next successful poll tries again */ } finally { R.current.orgLookup = false; }
   };
+  // HITL-INBOX-BAR: unread inbox items on the status area + one stream line per new arrival. A failed read keeps the last bar.
+  const refreshInboxBar = async () => {
+    if (!api.inboxItems) return;
+    try {
+      const items = await api.inboxItems({ limit: 30 });
+      const a = arrivals(items, R.current.inboxSeen || null);
+      R.current.inboxSeen = a.ids;
+      R.current.inboxList = newestFirst(items).slice(0, 10);
+      for (const it of a.fresh.slice(0, 3)) say(arrivalLine(it), 'warn');
+      if (a.fresh.length > 3) say(`📨 ${a.fresh.length - 3} more · /inbox`, 'warn');
+      dispatch({ type: 'notify', patch: { inboxBar: inboxBarText(items, cols) } });
+    } catch { /* last known bar stays; the approvals poll reports the outage */ }
+  };
   const refreshNotify = async () => {
     if (BL.current) return;
     const N = R.current.notify || (R.current.notify = { fails: 0, authLost: false });
@@ -854,12 +1049,17 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       if (N.authLost) say('Signed in again: approvals are back.', 'ok');
       else if (N.slow) say('Quox server is back.', 'ok');
       N.fails = 0; N.authLost = false; N.slow = false;
+      R.current.deckItems = groupApprovals(items, { conversationId: S.current.ctx.conversationId, cardIds: [...S.current.approvals, ...S.current.waiting].map(x => x.inboxItemId).filter(Boolean) }).flatMap(g => g.items.map(x => x.item)); // QUOXDECK: numbered as /approvals N
       dispatch({ type: 'notify', patch: { approvals: items.length, error: null } });
+      refreshInboxBar(); // HITL-INBOX-BAR: rides the same poll, never blocks it
       retryOrgName();
       dispatch({ type: 'inbox.sync', ids: items.map(i => i.id) });
       R.current.openIds = { ids: new Set(items.map(i => i.id)), at: Date.now() }; // a walk skips a card answered elsewhere since it started
       // Provider paths that emit no approval.requested still surface here, as the same card.
-      for (const item of items) dispatch({ type: 'approval.found', item, since: R.current.startedAt, userId: api.userId?.() || null });
+      for (const raw of items) {
+        const item = await enrichPlanItem(raw, { objectiveGet: api.objectiveGet, agents: api.agents, orgs: api.orgs, cache: (R.current.planCache ||= new Map()) });
+        dispatchEv({ type: 'approval.found', item, since: R.current.startedAt, userId: api.userId?.() || null });
+      }
     } catch (e) {
       N.fails++; // counted apart from an empty inbox
       const msg = e?.message || 'failed';
@@ -926,6 +1126,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       R0.allRows = r.rows; R0.alerts = backgroundAlerts(r.rows); R0.sources = r.sources;
       r = { ...r, rows: selectRows(r.rows, { all: R0.all }) };
       R0.rows = r.rows;
+      DC.current.watchRoster(rowsWithoutLoopCards(R0.allRows, (id) => LC.current.has(id))).then((shown) => { if (shown) bump(n => n + 1); }, () => {}); // an objective or loop that just finished or failed summons its dragon (companion mode on, not while typing)
       const at = r.rows.findIndex(x => x.key === prevKey);
       R0.sel = at >= 0 ? at : Math.min(R0.sel, Math.max(0, r.rows.length - 1));
       if (!r.rows.length) { R0.focus = false; R0.peek = false; R0.confirm = null; }
@@ -1008,6 +1209,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       d.push({ every: FRAME_MS });
       if (s0.divider.endedAt != null) d.push({ at: s0.divider.endedAt + (s0.divider.phase === 'done' ? GREEN_MS : RED_MS) + 1 });
     }
+    if (DC.current.animating()) d.push({ every: motionOn && !mono() ? FRAME_MS : 500 }); // companion dragon: paced like the classic one, frames come from the cache (dragon/frames.js)
     if (dragonActive(now, !motionOn || mono())) d.push({ every: motionOn && !mono() ? 40 : 500 }); // /dragon and the cinematic moods (qmotion DragonLive)
     if (motionOn && fxBusy(now)) d.push({ every: FRAME_MS }); // reveals in flight
     const sl = R.current.sleep;
@@ -1017,6 +1219,9 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     return d;
   };
   React.useEffect(() => { if (!R.current.closed) clockRef.current.schedule(demands()); });
+  // The companion dragon appears and leaves outside any App render (its own leaf and timers): re-arm the clock when it does, or it would get no frames until something else rendered.
+  const rearm = React.useRef(null); rearm.current = () => { if (!R.current.closed) clockRef.current.schedule(demands()); };
+  React.useEffect(() => DC.current.subscribe(() => rearm.current()), []);
 
   const fxEnd = (e) => Math.max(e.at + revealSpan(e.timing) * 1000, e.settleAt != null ? e.settleAt + revealSpan(TIMING.settle) * 1000 : 0);
   const fxActive = (item, now) => { const e = fxRef.current.get(item.id); return Boolean(e) && now < fxEnd(e); };
@@ -1153,6 +1358,19 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     queueMicrotask(() => reconcileAsks());
     return true;
   };
+  // TUI-WALK (owner 2026-10-19: he always runs /approvals again to confirm it is empty): the walk ends with a FRESH server
+  // read, never the local count. Empty is only ever claimed after a successful fetch.
+  const walkRecheck = async (W) => {
+    let items;
+    try { items = await api.approvals(); }
+    catch (e) { say(`⚠ couldn't re-check approvals (${clip(String(e?.message || e || 'unknown error').replace(/\s+/g, ' '), 80)}); /approvals to look again`, 'warn'); return; }
+    const gone = walkAnsweredIds();
+    const open = (Array.isArray(items) ? items : []).filter(x => x && !gone.has(x.id));
+    if (!open.length) { say('✔ Nothing else is currently waiting for you.', 'ok'); return; }
+    const fresh = open.filter(x => !W.ids.includes(x.id)).length;
+    if (fresh) say(`⏸ ${fresh} more arrived while you were answering · /approvals`, 'warn');
+    else say(`⏸ ${open.length} still waiting (skipped) · /approvals`, 'warn');
+  };
   const walkShow = () => {
     endAskEcho(); // TUI-INPUT: a new walk card is a new prompt; the last answer's echo must not sit in front of it
     const W = R.current.pendingWalk; if (!W) return;
@@ -1166,7 +1384,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       if (walkGoneElsewhere(W, id)) { W.done.add(id); say(`"${clip(W.items[id].title || id, 70)}" is no longer waiting (answered elsewhere or expired). Moving on.`, 'dim'); continue; }
       nextId = id; break;
     }
-    if (!nextId) { R.current.pendingWalk = null; R.current.focusedDecision = null; K.current.walkEndAt = Date.now(); say(' '); for (const l of walkSummaryLines(W).lines) say(l, l.startsWith('Walkthrough') ? 'ok' : undefined); queueMicrotask(() => reconcileAsks()); return; }
+    if (!nextId) { R.current.pendingWalk = null; R.current.focusedDecision = null; K.current.walkEndAt = Date.now(); say(' '); for (const l of walkSummaryLines(W).lines) say(l, l.startsWith('Walkthrough') ? 'ok' : undefined); walkRecheck(W); queueMicrotask(() => reconcileAsks()); return; }
     const live = W.ids.filter(id => !(W.dropped && W.dropped.has(id))); // expired or gone questions are not counted
     const it = W.items[nextId]; const c = walkCard(it, live.indexOf(nextId) + 1, live.length, { cols: cols - 2 });
     W.current = nextId; W.at = Date.now(); W.card = { at: W.at, walk: nextId };
@@ -1237,7 +1455,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     }
     R.current.lastAnswered = null;
     R.current.walkSend = true;
-    try { await command(`/answer ${n} ${rep.key}${rep.note ? ` "${rep.note}"` : ''}`); } finally { R.current.walkSend = false; }
+    try { await command(it.__approval ? (rep.key === 'y' ? `/approve ${n}` : `/deny ${n}${rep.note ? ` ${rep.note}` : ''}`) : `/answer ${n} ${rep.key}${rep.note ? ` "${rep.note}"` : ''}`); } finally { R.current.walkSend = false; }
     if (R.current.lastAnswered === it.id) {
       walkAnsweredIds().add(it.id);
       W.done.add(it.id); W.answered.push({ title: it.title, word: `${it.payload.options.find(o => o.key === rep.key).label}${rep.note ? ` (note: ${rep.note.length} characters)` : ''}` });
@@ -1257,7 +1475,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       }
       await respondWithStepUp(card, action, { proactive, reason, bulk });
       // The demo's stream carries on to its own tool result, so no "running, result later" note, no poll, no stale count.
-      dispatch({ type: 'approval.sent', callId: card.callId, action, tool: card.tool, target: card.target, approvalId: card.approvalId, inboxItemId: card.inboxItemId || null, quiet: Boolean(demoLabel), foreign: Boolean(card.foreign), batch });
+      dispatch({ type: 'approval.sent', callId: card.callId, action, tool: card.tool, target: card.target, what: card.what, who: card.facts?.who || card.origin || card.askedBy || null, where: card.facts?.where || null, approvalId: card.approvalId, inboxItemId: card.inboxItemId || null, quiet: Boolean(demoLabel), foreign: Boolean(card.foreign), batch });
       if (demoLabel) { B.current = initialBuffer(); dispatch({ type: 'notify', patch: { approvals: 0, error: null } }); } // (a stray early keystroke is not left in the composer)
       if (action === 'approve' && card.tool !== 'hat.switch' && !card.foreign && !demoLabel && !batch) pollResult({ callId: card.callId, approvalId: card.approvalId });
       return { ok: true };
@@ -1432,10 +1650,26 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     say(handoffAnsweredNote(a.h), 'dim');
     bump(n => n + 1);
   }
+  // QUOXON objective offer: the same path as `quox objective create <goal> --checkpoint` + start. Offered, never auto-run.
+  async function runObjective(a) {
+    say('Making the objective…', 'dim');
+    try {
+      if (typeof api.startObjective !== 'function') throw new Error('this build cannot create objectives from here');
+      const o = await api.startObjective(a.o.goal, a.o.loop || null);
+      say(objectiveStartedNote(o.id), 'dim');
+      say(objectiveWatchLine(o.id), 'dim');
+      if (a.o.loop && api.loopEvents) LC.current.watch(o.id, { title: a.o.goal }); // QLOOP-LIVE: the loop's live card appears in the chat stream
+      // Report back into this conversation when a plan objective ends (the owner inbox item covers a closed window).
+      if (!a.o.loop && typeof api.objectiveGet === 'function') {
+        watchObjective({ get: () => api.objectiveGet(o.id), say: (t) => { say(t, 'dim'); bump(n => n + 1); }, stopped: () => R.current.closed === true }).catch(() => {});
+      }
+    } catch (e) { say(objectiveFailedNote(a.o.goal, e), 'dim'); }
+    bump(n => n + 1);
+  }
   async function consumeTurn(turnId, open, { keepOnDown = false } = {}) {
     R.current.caps.steer = true; R.current.steerNoted = false; // steer support is learned per turn (provider paths differ)
     R.current.durable = false; // learned from the server: v1.1 events carry a seq
-    dispatch({ type: 'turn.begin', turnId });
+    dispatchEv({ type: 'turn.begin', turnId });
     const ctrl = new AbortController();
     R.current.abort = ctrl;
     let offered = false, sawEvent = false, down = false;
@@ -1446,8 +1680,14 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         sawEvent = true;
         if (typeof ev?.seq === 'number') R.current.durable = true;
         LG.current.observe(ev);
-        dispatch({ type: 'event', ev });
+        dispatchEv({ type: 'event', ev });
         if (ev.type === 'tool.finished' && ev.suggest_command) { suggested = true; offerSuggestion(ev); }
+        // QLOOP-LIVE: the chat's objective tool made a LOOP: open its live card in this conversation (the tool answer names the title, not the id)
+        if (ev.type === 'tool.finished' && /objective/i.test(String(ev.tool || '')) && ev.status === 'ok' && /^\s*Loop "/.test(String(ev.result_summary || '')) && api.loopEvents && !(ev.call_id && SC.current.loopSeen?.has(ev.call_id))) {
+          (SC.current.loopSeen ??= new Set()).add(ev.call_id);
+          LC.current.discover({ title: (/^\s*Loop "(.*?)(?:"|$)/.exec(String(ev.result_summary)) || [])[1] || '' }).catch(() => {});
+        }
+        if (ev.type === 'turn.objective_suggested') { const ob = objectiveFromEvent(ev, SN.current.agent || (ev.objective_suggested?.mode === 'loop' && ev.objective_suggested?.from === 'quox' ? 'quox' : null)); if (ob) R.current.objectivePending = { o: ob, text: R.current.lastSent || '' }; } // QUOXON objective offer; unattached chat is Quox itself, so its keep-going offer still shows
         if (ev.type === 'turn.handoff_suggested') { const ho = handoffFromEvent(ev, SN.current.agent); if (ho) R.current.handoffPending = { h: ho, text: R.current.lastSent || '' }; } // QUOXON handoff offer
         if (ev.type === 'chunk' || ev.type === 'text.delta') { const g = textGate(gate, ev); gate = g.st; if (g.append && answerText.length < 20000) answerText += String(ev.content); }
         // Z2H-3B: a server default that is not connected must not linger in the status bar.
@@ -1468,7 +1708,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       if (S.current.turn?.id === turnId) {
         // stream closed without a terminal event
         // never claim completion the server did not confirm
-        dispatch({ type: 'event', ev: { type: 'turn.finished', status: ctrl.signal.aborted ? 'interrupted' : 'unconfirmed' } });
+        dispatchEv({ type: 'event', ev: { type: 'turn.finished', status: ctrl.signal.aborted ? 'interrupted' : 'unconfirmed' } });
       }
     } catch (e) {
       if (keepOnDown && !sawEvent && !ctrl.signal.aborted && isServerDown(e)) { down = true; }
@@ -1479,15 +1719,15 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
           say(`Blocked by policy (${e.body.block_id}). A person can override this one action: /override last <reason>`, 'warn');
         }
         // TUI-DIVIDER: a refusal before the stream opened names the layers it really evaluated; the rule lights them.
-        if (Array.isArray(e?.body?.aocl_layers)) for (const l of e.body.aocl_layers) dispatch({ type: 'event', ev: { type: 'aocl.layer', ...l } });
+        if (Array.isArray(e?.body?.aocl_layers)) for (const l of e.body.aocl_layers) dispatchEv({ type: 'event', ev: { type: 'aocl.layer', ...l } });
         const why = sawEvent ? explainTermination(e) : null;
-        if (why) for (const b of S.current.blocks) if (b.kind === 'tool' && b.status === 'running') dispatch({ type: 'event', ev: { type: 'tool.finished', call_id: b.callId, tool: b.tool, status: 'interrupted', result_summary: 'connection lost before a result; verify before retrying' } });
+        if (why) for (const b of S.current.blocks) if (b.kind === 'tool' && b.status === 'running') dispatchEv({ type: 'event', ev: { type: 'tool.finished', call_id: b.callId, tool: b.tool, status: 'interrupted', result_summary: 'connection lost before a result; verify before retrying' } });
         const dead = !why && (e?.status === 401 || isSessionDead(e));
-        dispatch({ type: 'event', ev: { type: 'error', error: why || (dead ? SIGNED_OUT_LINE : friendlyError(e, profile)) } });
+        dispatchEv({ type: 'event', ev: { type: 'error', error: why || (dead ? SIGNED_OUT_LINE : friendlyError(e, profile)) } });
         if (dead) markSignedOut(e?.reason || null);
         if (why) say(RETRY_HINT, 'warn');
         // A lost reattach is not a failed turn: the server may still be finishing it (C5).
-        if (S.current.turn?.id === turnId) dispatch({ type: 'event', ev: { type: 'turn.finished', status: e?.code === 'reattach_failed' ? 'unconfirmed' : 'failed' } });
+        if (S.current.turn?.id === turnId) dispatchEv({ type: 'event', ev: { type: 'turn.finished', status: e?.code === 'reattach_failed' ? 'unconfirmed' : 'failed' } });
       }
     } finally {
       clearTimeout(R.current.fallbackTimer);
@@ -1499,6 +1739,9 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       // QUOXON handoff offer: the attached agent lacks the tools for this ask. The handoff card answers the actual question,
       // so it wins over the agent's own suggested command (owner live 22:42: "Run /vm list?" took the slot and the handoff
       // card was dropped silently). Nothing is dropped silently: a superseded or skipped card says so in one line.
+      const op = R.current.objectivePending; R.current.objectivePending = null;
+      const opOk = Boolean(op && !down && !ctrl.signal.aborted && !planDone);
+      if (opOk) { R.current.handoffPending = null; R.current.suggestLine = null; R.current.suggestAsk = null; } // one ask, not two: the objective card replaces the handoff and the agent's own command
       const hp = R.current.handoffPending; R.current.handoffPending = null;
       const hpOk = Boolean(hp && !down && !ctrl.signal.aborted && hp.text);
       if (hpOk && !planDone && R.current.suggestLine) {
@@ -1506,8 +1749,9 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         R.current.suggestLine = null; R.current.suggestAsk = null;
         say(handoffSupersededNote(hp.h, line), 'dim');
       }
-      const newOffer = Boolean(R.current.suggestLine) || planDone || (hpOk && !planDone);
+      const newOffer = Boolean(R.current.suggestLine) || planDone || (hpOk && !planDone) || opOk;
       flushSuggestion();
+      if (opOk) { R.current.objectiveAsk = { ...op, at: Date.now() }; say(objectiveAskText(op.o, cols), 'ask'); }
       if (hpOk && planDone) say(handoffSkippedNote(hp.h), 'dim');
       else if (hpOk) {
         const hs = (R.current.handoffStreak ??= createHandoffStreak()).offered(hp.h.from);
@@ -1616,6 +1860,20 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     R.current.fallbackTimer = setTimeout(local, INTERRUPT_FALLBACK_MS);
   }
 
+  // Stop the turn now, locally and for good: tell the server (best effort), abort the stream, and always leave busy cleared.
+  function stopTurnNow() {
+    const s = S.current, turn = s.turn;
+    try {
+      if (R.current.waitingServer) { R.current.abort?.abort(); return; }
+      if (!turn) return;
+      clearTimeout(R.current.fallbackTimer);
+      try { Promise.resolve(api.interrupt?.(s.ctx.conversationId, turn.id)).catch(() => {}); } catch { /* best effort */ }
+      R.current.abort?.abort();
+    } finally {
+      if (turn && S.current.turn?.id === turn.id) dispatch({ type: 'stopped.local' });
+    }
+  }
+
   // ---- L1 slash commands (models in slash/*.js) ------------------------------------------------
   const help = (model) => dispatch({ type: 'help', model });
   const leaveArmed = (kind) => { // a running turn would be disconnected: ask once, a second ask within 5 s goes ahead
@@ -1700,12 +1958,18 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     if (S.current.turn) return say('Wait for the current turn or press Esc first.', 'warn');
     let turns;
     try { turns = await reconnecting(() => api.conversationTurns(row.id), st); } catch (e) { if (R.current.closed) return undefined; if (e?.reconnectGaveUp) return resumeGaveUp(row.id); if (e?.status === 404) return say('That conversation is not on the server any more (it keeps them 7 days).', 'warn'); return dispatch({ type: 'error', text: `resume: ${e?.status ? `HTTP ${e.status}: ` : ''}${e?.message || 'failed'}` }); }
+    // RESUME: the attachment and the conversation must name the same agent. After a /restart the replayed attach is what the
+    // window held when it was saved; if the conversation was with someone else, warn once and start fresh rather than mix.
+    const wasAgent = st.fromRestart && /^agent:/.test(restartAttach || '') ? restartAttach.slice(6) : null;
+    if (st.fromRestart && wasAgent && row.agent && row.agent !== wasAgent) return say(`That conversation was with ${row.agent}, but this window was attached to ${wasAgent}. Starting a fresh conversation with ${wasAgent}; /resume brings the ${row.agent} one back.`, 'warn');
     const t = turnsToHistory(turns);
+    const shownTitle = cleanTitle(row.title) && row.title !== '(untitled)' ? cleanTitle(row.title) : (titleFromTurns(turns) || '(untitled)'); // never rendered UI
     dispatch({ type: 'ctx', ctx: { conversationId: row.id } });
     SN.current.name = loadNames(namesPath)[row.id]?.name || null; SN.current.saved = null;
     if (!t.total && SN.current.name) SN.current.saved = `${row.id}|${SN.current.name}`; // nothing found: do not re-stamp the saved name
-    say(`Resumed "${clip(row.title, cols - 20)}"${row.agent ? ` with ${row.agent}` : ''}.`, 'ok');
+    say(`Resumed "${clip(shownTitle, cols - 20)}"${row.agent ? ` with ${row.agent}` : ''}.`, 'ok');
     dispatch({ type: 'history.add', items: t.items, answers: t.answers });
+    if (!st.fromRestart && row.agent && row.agent !== SN.current.agent) { R.current.noGreeting = true; await command(`/attach agent:${row.agent}`); } // next turns go to the agent this conversation was with
     if (!t.total && agentLogin && row.byName) {
       const h = humanProfiles.find(x => x !== profile);
       return say(`${row.byName} was saved by another profile. Start with quox -p ${h || '<human profile>'} to resume it.`, 'warn');
@@ -1713,9 +1977,9 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     say(t.total ? `Showing the last ${t.shown} of ${t.total} stored messages. Your next message continues this conversation.` : 'The server has no stored messages for it (it keeps them 7 days). Your next message continues it anyway.', 'dim');
     return reattachIfRunning(row.id);
   }
-  async function resumeCmd(q) {
+  async function resumeCmd(q, { fromRestart = false } = {}) {
     if (!api.conversations || !api.conversationTurns) return say('Resume is not available in this mode.', 'warn');
-    let rows; const st = {};
+    let rows; const st = { fromRestart };
     try {
       const [list, index] = await reconnecting(() => Promise.all([api.conversations(30), api.sessionsIndex ? api.sessionsIndex().catch(() => null) : null]), st);
       rows = resumeRows(list, index, loadNames(namesPath));
@@ -1770,6 +2034,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     bump(n => n + 1); return true;
   }
   function dragonFly() { // one pass of the dragon in flight in the live region; Esc stops it, a new call restarts it
+    const room = flyRoom(termRows(stdout), chromeH.current ?? 10); if (!room.ok) return say(room.note, 'warn'); // too small: say so, never silently nothing
     R.current.fly = { startedAt: Date.now(), still: !motionOn || mono() };
     bump(n => n + 1); return true;
   }
@@ -1882,6 +2147,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   }
 
   function cliSlashRun(hit) {
+    if (hit.error) return say(`${hit.error}`, 'warn');
     if (hit.cls === 'never') return say(`${hit.display} will not run from here (credentials, install or other never-from-chat commands). Run it in your own terminal if you mean it.`, 'warn');
     const bang = { kind: 'quox', args: hit.args, cmd: hit.display };
     if (hit.cls === 'write') { R.current.cliAsk = { bang, at: Date.now() }; say(hit.display, 'accent'); return ask('Run it?', { action: hit.display, reason: 'This quox command writes.' }); }
@@ -1980,12 +2246,12 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   }
 
   async function command(line) {
-    if (/^\/\/(\s|$)/.test(line.trim())) line = line.trim().replace(/^\/\//, '/note');
+    if (/^\/\/(\s|$)/.test(line.trim())) line = line.trim().replace(/^\/\//, '/devnote');
     const [cmd0, arg] = line.trim().split(/\s+/);
     const cmd = cmd0 === '/agent' ? '/agents' : cmd0; // /agent is the same command
     if (!['/afk', '/sleep', '/back', '/away'].includes(cmd)) markPresent(`slash ${cmd}`); // PRESENCE: any slash command but /afk and /sleep is the owner being back
-    if (cmd !== '/note' && cmd !== '/context') SCX.current.command(line.trim());
-    if (cmd !== '/note') transcript?.command(/^\/(authenticate|authorise|authorize)$/.test(cmd) && !/^[\d,\s-]*$/.test(line.trim().replace(/^\S+\s*/, '')) ? cmd : line); // QUOXON-STEPUP: never record a stray argument that might be a PIN
+    if (cmd !== '/devnote' && cmd !== '/context') SCX.current.command(line.trim());
+    if (cmd !== '/devnote') transcript?.command(/^\/(authenticate|authorise|authorize)$/.test(cmd) && !/^[\d,\s-]*$/.test(line.trim().replace(/^\S+\s*/, '')) ? cmd : line); // QUOXON-STEPUP: never record a stray argument that might be a PIN
     const restArg = line.trim().replace(/^\S+\s*/, '');
     touchSeen();
     if (TIPS.some(x => tryCommand(x) === cmd) && !TP.current.used.includes(cmd)) { TP.current.used = [...TP.current.used, cmd]; api.saveSetting?.('tipsUsed', TP.current.used); } // using a thing retires its tip
@@ -1998,8 +2264,8 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       objArg = p.name;
     }
     if (OBJECT_CMDS.has(cmd) && !(cmd === '/rules' && arg)) { // inline object views (objects/): a card into history, or an honest note
-      const r = await runObjectCommand(cmd, objArg, { objects: api.objects, rules, rulesOn: R.current.rulesOn, items: [...S.current.history, ...S.current.blocks], conversationId: S.current.ctx?.conversationId });
-      if (r) return r.object ? dispatch({ type: 'object', obj: r.object }) : say(clip(r.note, cols - 4), r.tone);
+      const r = await runObjectCommand(cmd, objArg, { objects: api.objects, rules, rulesOn: R.current.rulesOn, items: [...S.current.history, ...S.current.blocks], conversationId: S.current.ctx?.conversationId, cols });
+      if (r) return r.object ? dispatch({ type: 'object', obj: r.object }) : r.lines ? r.lines.forEach(l => say(l, r.tone)) : say(r.note, r.tone); // wrap, never clip: notes carry ids and hints
     }
     switch (cmd) {
       case '/copy': {
@@ -2009,13 +2275,22 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         return say(`copied ${r.text.length.toLocaleString('en-US')} chars to the clipboard (needs a terminal that allows OSC 52)`, 'dim');
       }
       case '/share': return shareCommand(arg);
-      case '/note': {
+      case '/devnote': {
         if (!devObserverOn()) return say(DEV_OBSERVER_REFUSAL, 'warn');
-        if (!restArg) return say('Usage: /note <text>  (or // text). Nothing to note.', 'warn');
+        if (!restArg) return say('Usage: /devnote <text>  (or // text). Nothing to note.', 'warn');
         if (!transcript?.note) return say('notes need dev transcripts on (touch ~/.config/quox/dev-transcripts)', 'warn');
         transcript.note(restArg.slice(0, 2000));
         return say('noted for the observer', 'dim');
       }
+      case '/note': { // TUI-NOTE: a NotesQ note, same backend as `quox notes new`
+        if (!restArg) return say('Usage: /note <text>  (saves a NotesQ note; /notes lists them).', 'warn');
+        if (!api.createNote) return say('NotesQ is not available in this window. Run quox notes new from a signed-in terminal, or enable NotesQ for your org in the dashboard.', 'warn');
+        const r = await api.createNote(restArg);
+        if (!r.ok) return say(r.message, 'warn');
+        return say(`Saved note "${r.title}" (${r.id}). /notes lists your notes (or quox notes ls).`, 'ok');
+      }
+      case '/notes': return cliSlashRun(resolveCliSlash('/notes', 'ls'));
+      case '/contact': return cliSlashRun(resolveCliSlash('/contact', restArg)); // registered command; runs as the quox contacts leaf
       case '/rename': {
         if (!restArg) return say(SN.current.name ? `Session name: ${SN.current.name}` : 'This session has no name. Use /rename <name>.');
         const n = cleanName(restArg);
@@ -2033,7 +2308,21 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         const m = /^(\S+)\s+([\s\S]*\S[\s\S]*)$/.exec(restArg || '');
         if (!m) return say('Usage: /say <slot>[,<slot>...] <text>', 'warn');
         const to = [...new Set(m[1].split(',').map(x => x.trim().toLowerCase()).filter(Boolean))];
-        if (to.length < 2) return sendToSlot(to[0] || m[1].toLowerCase(), m[2].trim());
+        if (to.length < 2) { // SAY-LAST-TARGET: a first word that is not a slot is part of the message when a recent target exists
+          const first = to[0] || m[1].toLowerCase();
+          let rows = [];
+          if (api.slots) { try { rows = await api.slots(); } catch { rows = []; } }
+          const known = !looksLikeAddress(m[1]) && !!resolveSayTarget(first, Array.isArray(rows) ? rows : [], SC.current.senders);
+          const last = R.current.lastSay;
+          if (!known && (looksLikeAddress(m[1]) || last)) {
+            if (last && Date.now() - last.at < 2 * 3600000) {
+              R.current.sayLastAsk = { slot: last.slot, text: restArg.trim(), at: Date.now() };
+              return say(askText(`Send to ${last.slot}?`, { keys: 'y send · n cancel', action: `send the whole message to ${last.slot}` }), 'ask');
+            }
+            return say(sayWhoText(rows), 'warn');
+          }
+          return sendToSlot(first, m[2].trim());
+        }
         // QUOXON-SAY-CC: one line to several slots; each copy names everyone it went to, so they know who else has it
         const slots = await Promise.all(to.map(t => canonSlot(t, { senders: true })));
         const head = `(to ${slots.join(', ')}) `;
@@ -2078,6 +2367,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         return takeSlot(nm, take);
       }
       case '/attach': {
+        const greetThis = takeGreeting(R.current); // read and clear first: an early return below must not leave a quiet flag armed for the next typed /attach
         if (!restArg) return say(SN.current.agent ? `Attached to ${SN.current.agent}. /detach returns to CommanderQ.` : 'Talking to CommanderQ. Use /attach <agent> to pick one.');
         if (S.current.turn) return say('Wait for the current turn or press Esc first.', 'warn');
         if (!api.agents) return say('Agents are not available in this mode.', 'warn');
@@ -2094,7 +2384,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         const m = pt.kind === 'slot' ? { matches: [] } : matchAgent(pt.name, list);
         const slotLive = !!(slotRow && slotRow.holder_session);
         let choice = null; // 'slot' | 'agent'
-        if (slotRow && m.agent) choice = pt.kind === 'slot' || slotLive ? 'slot' : 'agent';
+        if (slotRow && m.agent) choice = pt.kind === 'slot' ? 'slot' : 'agent'; // a bare name that is both defaults to the AGENT; slot: is the explicit override
         else if (slotRow) choice = 'slot';
         else if (m.agent) choice = 'agent';
         if (!choice) {
@@ -2107,7 +2397,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         const both = !!(slotRow && m.agent);
         if (choice === 'slot') {
           if (!api.slotSay) return say('Talking to a slot is not available in this mode.', 'warn');
-          SN.current.agent = null; SN.current.slotTarget = slotRow.name;
+          SN.current.agent = null; SN.current.slotTarget = slotRow.name; DC.current.detach();
           where.current = { ...where.current, agent: SN.current.baseAgent }; bump(x => x + 1);
           const host = slotRow.holder_identity ? String(slotRow.holder_identity).replace(/^resident:/, '') : (slotRow.host_name || slotRow.hostname || null); // RESTORE-TUI: a named host from an older server row still shows
           const lbl = `slot ${slotRow.name}${host ? ` (${host})` : ''}`;
@@ -2119,11 +2409,20 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         }
         SN.current.slotTarget = null;
         SN.current.agent = m.agent.id; where.current = { ...where.current, agent: m.agent.id }; bump(x => x + 1);
-        const alt = both ? ` To pick the slot instead: /attach slot:${pt.name}` : '';
-        say(`Attached to ${m.agent.id}. Your next turns go to it. /detach returns to CommanderQ.${alt}`, 'ok');
+        DC.current.attach(m.agent.id, { greet: greetThis }).then(() => { const n = DC.current.takeArtNotice(); if (n) say(n, 'warn'); });
+        say(`Attached to ${m.agent.id}. Your next turns go to it. /detach returns to CommanderQ.`, 'ok');
+        if (both && pt.kind !== 'agent') say(`${pt.name} is also a slot: /attach slot:${pt.name} for that`, 'warn');
         if (pt.rest) { dispatch({ type: 'user', text: pt.rest }); remember(pt.rest); runTurn(pt.rest); }
         return undefined;
       }
+      case '/evidence': case '/ward': case '/volt': {
+        for (const l of await runEvidenceCommand({ cmd, api, conversationId: S.current.ctx?.conversationId, cols })) say(l.text, l.tone);
+        return undefined;
+      }
+      case '/envelope': case '/envelopes': case '/aee': { // pointers to /proof (the envelope ids) and /evidence (the bundle)
+        say('Envelope ids are what /proof lists; /evidence exports them all as a signed bundle.', 'dim');
+        return command(`/proof${restArg ? ` ${restArg}` : ''}`);
+      }
       case '/peek': { // PEEK: the same lookup as `quox peek <id>`, in this window's org
         const pid = restArg.trim().split(/\s+/)[0] || '';
         if (!api.peek) return say('Peek is not available in this mode. In a terminal: quox peek <id>', 'warn');
@@ -2180,6 +2479,8 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
           if (!api.connections) return say('Connections are not available in this mode.', 'warn');
           const [vault, caps] = await Promise.all([api.connections(), api.capabilities ? api.capabilities() : null]);
           for (const [t, tone] of connectionLines(vault, caps)) say(clip(t, cols - 4), tone);
+          // LAZY-AI-CLI: no Claude Code on this server = the Claude sign-in cannot work yet; offer it as a y/N card here
+          if (api.providerCliStatus && missingTools(await api.providerCliStatus()).includes('claude-code')) { R.current.installQueue = []; return offerInstall('claude-code'); }
           return undefined;
         }
         if (S.current.turn) return say('Wait for the current turn or press Esc first.', 'warn');
@@ -2229,6 +2530,11 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
           return undefined;
         }
         let r = selectModel(res, restArg, caps);
+        // LAZY-AI-CLI: the Claude sign-in runs through the claude binary; no binary on this server = offer to install it now
+        if ((r.choice?.via === 'subscription' || /^(claude-cli|claude-subscription|subscription|claude-code)\b/i.test(String(restArg).trim())) && api.providerCliStatus) {
+          const st = await api.providerCliStatus();
+          if (missingTools(st).includes('claude-code')) { R.current.installQueue = []; return offerInstall('claude-code'); }
+        }
         let installed = null;
         if (r.ok && r.choice?.provider === 'ollama' && api.ollamaModels) { // B3: check against what that Ollama has installed
           r = selectOllamaModel(await api.ollamaModels(), r.choice.model || null);
@@ -2256,6 +2562,28 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         return undefined;
       }
       case '/row': return RW.current.handle(restArg);
+      case '/qpe': { // TUI-QPE: how many proof engine rows show (a CLI setting)
+        const r = qpeCommand(restArg, api.settings?.() || {});
+        if (r.save != null) { api.saveSetting?.('qpeRows', r.save); bump(n => n + 1); }
+        return say(r.text, r.tone);
+      }
+      case '/deck': { // provided by the quoxdeck extension when loaded; otherwise says where it comes from (the registry entry carries ext)
+        if (await extDispatch(cmd, restArg)) return undefined;
+        return say('/deck comes from the quoxdeck extension, which is not loaded. npm i -g quoxdeck, then /ext on quoxdeck.', 'warn');
+      }
+      case '/ext': { // EXTENSIONS: /ext list|on|off <name>
+        const [w, nm] = restArg.trim().split(/\s+/);
+        const list = readExtList();
+        if (!w || w === 'list') {
+          if (!list.length) return say('No extensions listed. Install one (npm i -g <pkg>) and list it: quox ext add <pkg>.');
+          return say(list.map(x => `${x.name}: ${DK.current.isLoaded(x.name) ? `on (found: ${DK.current.where(x.name)})` : x.enabled ? 'listed, not loaded' : 'off'}`).join('\n'));
+        }
+        if ((w === 'on' || w === 'off') && nm) {
+          if (w === 'on') { if (!list.some(x => x.name === nm)) extAdd(nm); else extSetEnabled(nm, true); await extLoad(nm, false); return undefined; }
+          extSetEnabled(nm, false); const r = DK.current.unload(nm); return say(r.text, 'ok');
+        }
+        return say('Usage: /ext list|on|off <name>', 'warn');
+      }
       case '/watch': return KC.current.watch(restArg);
       case '/automate': return KC.current.automate(restArg);
       case '/crystallize': return KC.current.crystallize(restArg);
@@ -2277,9 +2605,15 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       case '/workflow': case '/crystal': case '/memory': case '/proof': case '/reconcile': case '/fleet': case '/prove': case '/replay': return undefined; // answered above (runObjectCommand)
       case '/agent': case '/agents': return undefined; // answered above (picker, tools, card)
       case '/which': return showWhich(arg);
-      case '/detach':
+      case '/detach': {
+        const hadAgent = Boolean(SN.current.agent);
         SN.current.agent = null; SN.current.slotTarget = null; where.current = { ...where.current, agent: SN.current.baseAgent }; bump(x => x + 1);
-        return say('Back to CommanderQ.');
+        DC.current.detach();
+        say('Back to CommanderQ.');
+        const g = detachGreeting({ settings: api.settings?.() || {}, env, rows: termRows(stdout), chromeH: chromeH.current ?? 10, hadAgent }); // dragons on: the Q dragon greets the return
+        if (g?.clip) { playDragon(g.clip, undefined); bump(n => n + 1); } else if (g?.note) say(g.note, 'dim');
+        return true;
+      }
       case '/sessions': {
         // SESSIONS (owner 2026-10-15): name and where first; ids only with `refs`.
         const flags = new Set(String(restArg || '').toLowerCase().split(/\s+/).filter(Boolean));
@@ -2444,8 +2778,22 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         if (!m) return say(DRAGON_USAGE);
         if (m.mode === 'explain') return dragonExplain();
         if (m.mode === 'ask') return dragonAsk(m.question);
+        if (m.mode === 'companion') {
+          const r = companionCommand(m.arg, { settings: api.settings?.() || {}, plan: DC.current.plan(), artProblem: DC.current.artProblem() });
+          if (r.save != null) { api.saveSetting?.('dragonCompanion', r.save); DC.current.refresh(); }
+          say(r.text, r.tone);
+          if (r.invoke && await DC.current.invoke()) bump(n => n + 1); // asking about the companion is also calling it
+          return true;
+        }
         if (m.mode === 'sleep') return dragonSleep();
         if (m.mode === 'fly') return dragonFly();
+        if (m.mode === 'pick') { // plain /dragon: the ATTACHED agent's own dragon when it has one, else the classic Quox dragon
+          const shown = await DC.current.invoke();
+          if (shown) { bump(n => n + 1); return true; }
+          const who = SN.current.agent;
+          if (who && !dragonForAgent(who)) say(`${who[0].toUpperCase()}${who.slice(1)} has no dragon of its own; here's Quox.`, 'dim');
+        }
+        const room = clipRoom(m.mode === 'idle' ? 'classic' : m.mode, termRows(stdout), chromeH.current ?? 10); if (!room.ok) return say(room.note, 'warn');
         playDragon(m.mode, undefined); bump(n => n + 1); return true;
       }
       case '/dragon-fly': return arg ? say('Usage: /dragon-fly', 'warn') : dragonFly();
@@ -2484,7 +2832,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       case '/about': return dispatch({ type: 'welcome', version: packageVersion() });
       case '/help': return dispatch({ type: 'help', model: helpModel(arg, R.current.caps) });
       case '/clear': case '/new': case '/reset': {
-        if (S.current.turn) return say('Wait for the current turn or press Esc first.', 'warn');
+        if (S.current.turn || R.current.waitingServer) stopTurnNow(); // cancel it exactly as Esc does, so busy and the divider reset
         const prev = S.current.ctx.conversationId;
         dispatch({ type: 'ctx', ctx: { conversationId: null } });
         SN.current.name = null; SN.current.saved = null;
@@ -2493,6 +2841,11 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         setEpoch(e => e + 1);
         return say(prev ? 'Previous conversation saved. /resume to go back.' : 'New conversation.');
       }
+      case '/stop': case '/cancel': { // same as Esc
+        if (!S.current.turn && !R.current.waitingServer) return say('Nothing is running.', 'dim');
+        stopTurnNow();
+        return say('Stopped.', 'ok');
+      }
       case '/aocl': return dispatch({ type: 'aocl.table' });
       case '/verbose':
         if (!['off', 'on', 'full'].includes(arg)) return say(`verbose is ${S.current.verbose}. Use /verbose off|on|full`);
@@ -2556,11 +2909,27 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         const query = (restArg.match(/^\S+\s+(.*)$/) || [])[1]?.trim() || '';
         let list;
         try { list = await api.orgs(); } catch (e) { return say(`Couldn't list your orgs: ${listFailure(e, profile)}`, 'warn'); }
+        const openOrgPicker = (rowsIn, title, { confirm = false } = {}) => { // confirm: the explicit `/org switch` chooser keeps its y/N
+          const orows = orgRows(rowsIn);
+          const ow = Math.min(30, Math.max(4, ...orows.map(x => [...x.name].length)));
+          PK.current.open({ title, rows: orows.map(x => ({ key: `${x.id === curId ? '* ' : '  '}${x.name.padEnd(ow)}`, text: `${x.slug || x.id}${x.role ? `  (${x.role})` : ''}` })), sel: Math.max(0, orows.findIndex(x => x.id === curId)),
+            hint: confirm ? '↑↓ select · Enter switch (you confirm first) · Esc cancel' : 'Enter: switch this window only · d: also make it the default · ↑↓ select · Esc cancel',
+            onChar: confirm ? undefined : (ch, i) => { if (ch !== 'd' && ch !== 'D') return false; switchOrgNow(orows[i], { quick: true, makeDefault: true }); PK.current.close(); return true; },
+            onPick: (_, i) => (confirm ? (orows[i].id === curId ? say(`Already in ${orows[i].name}.`) : command(`/org switch ${orows[i].slug || orows[i].id}`)) : switchOrgNow(orows[i], { quick: true })) });
+        };
         if (!sub || sub === 'list' || (sub === 'switch' && !query)) { // a bare /org switch offers the chooser, never a Usage line
           if (!list.length) return say('No orgs returned for this login.', 'warn');
-          const orows = orgRows(list);
-          const ow = Math.min(30, Math.max(4, ...orows.map(x => [...x.name].length)));
-          PK.current.open({ title: 'Move this session to an org', rows: orows.map(x => ({ key: `${x.id === curId ? '* ' : '  '}${x.name.padEnd(ow)}`, text: `${x.slug || x.id}${x.role ? `  (${x.role})` : ''}` })), sel: Math.max(0, orows.findIndex(x => x.id === curId)), hint: '↑↓ select · Enter switch (you confirm first) · Esc cancel', onPick: (_, i) => (orows[i].id === curId ? say(`Already in ${orows[i].name}.`) : command(`/org switch ${orows[i].slug || orows[i].id}`)) });
+          openOrgPicker(list, 'Move this session to an org', { confirm: sub === 'switch' });
+          return undefined;
+        }
+        if (!['yes', 'back', '-', 'switch'].includes(sub)) { // /org <name or slug fragment>: a unique match switches this window, else the picker opens filtered
+          const q = restArg.trim();
+          const m = matchOrg(q, list);
+          if (m.org) return switchOrgNow(m.org, { quick: true });
+          const words = q.toLowerCase().split(/[^a-z0-9]+/).filter(Boolean);
+          const part = orgRows(list).filter(o => words.every(w => `${o.name} ${o.slug || ''}`.toLowerCase().includes(w)));
+          if (!part.length) return say(`No org of yours matches "${q}". /org lists them.`, 'warn');
+          openOrgPicker(part, `Orgs matching "${q}"`);
           return undefined;
         }
         if (sub === 'yes') {
@@ -2568,16 +2937,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
           if (!t) return say('Nothing to confirm. /org switch <name> first.', 'warn');
           if (S.current.turn) return say('Wait for the current turn or press Esc first.', 'warn');
           if (!api.switchOrg) return say('Org switching is not available in this mode.', 'warn');
-          let done;
-          try { done = await api.switchOrg(t.id); } catch (e) { return say(`Not switched. ${e?.message || 'The server refused.'} You are still in ${R0.orgName ?? org ?? 'the same org'}.`, 'warn'); }
-          R0.prevOrg = curId ? { id: curId, name: R0.orgName ?? org ?? curId } : null; // /org back returns here
-          R0.orgId = done.id; R0.orgName = done.name;
-          dispatch({ type: 'ctx', ctx: { conversationId: null } });
-          SN.current.name = null; SN.current.saved = null;
-          dispatch({ type: 'history.reset' });
-          if (stdout?.isTTY) stdout.write('\x1b[2J\x1b[3J\x1b[H');
-          setEpoch(e => e + 1); bump(n => n + 1);
-          return say(`Switched to ${done.name}. New conversation in that org.`, 'ok');
+          return switchOrgNow(t);
         }
         if (sub === 'back' || sub === '-') { // owner 2026-10-15 "switch back": no "type /org switch <the org you were in>"
           const p = R0.prevOrg;
@@ -2599,6 +2959,63 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         if (R.current.preConfirmed === 'org') { R.current.preConfirmed = null; return command('/org yes'); }
         return ask(`Switch to ${m.org.name}?`, { action: `/org switch ${m.org.id} (${m.org.name})`, reason: 'This starts a new conversation in that org.' });
       }
+      case '/todo': case '/todos': {
+        if (!api.todoAdd || !api.todoList) return say('This server has no Action Tracker.', 'warn');
+        const t = parseTodo(cmd, restArg);
+        try {
+          if (t.kind === 'usage') return say(t.text, 'warn');
+          if (t.kind === 'add') return say(todoAddedLine(await api.todoAdd(t.text)), 'ok');
+          if (t.kind === 'move') {
+            if (!api.todoMove) return say('This server cannot move Action Tracker items.', 'warn');
+            const board = await api.todoList();
+            const many = (t.refs || [t.ref]).length > 1;
+            for (const ref of (t.refs || [t.ref])) {
+              const r = resolveRef(ref, TODO_MAP.current, board);
+              if (r.error) { say(r.error, 'warn'); continue; }
+              if (r.note) say(r.note);
+              const moved = await api.todoMove(r.id, t.to);
+              say(`${todoMovedLine({ ...moved, title: moved.title || r.title })}${many ? '' : ' /todos shows the new numbers.'}`, 'ok');
+            }
+            return undefined;
+          }
+          const board = await api.todoList();
+          const numbered = numberBoard(board);
+          TODO_MAP.current = numbered.map;
+          return say(todoBoardText(board, numbered));
+        } catch (e) { return say(`Action Tracker: ${e?.message || 'failed'}`, 'warn'); }
+      }
+      case '/done': {
+        if (!api.todoList || !api.todoMove) return say('This server cannot move Action Tracker items.', 'warn');
+        const d = parseDone(restArg);
+        if (d.kind === 'usage') return say(d.text, 'warn');
+        try {
+          const board = await api.todoList();
+          for (const ref of d.refs) {
+            const r = resolveRef(ref, TODO_MAP.current, board);
+            if (r.error) { say(r.error, 'warn'); continue; }
+            if (r.note) say(r.note);
+            const moved = await api.todoMove(r.id, 'done');
+            say(todoDoneLine(moved.title || r.title), 'ok');
+          }
+          return undefined;
+        } catch (e) { return say(`Action Tracker: ${e?.message || 'failed'}`, 'warn'); }
+      }
+      case '/plugin': case '/extensions': case '/extension': case '/addons': case '/apps': case '/plugins': {
+        if (!api.pluginList) return say('This server has no plugin list.', 'warn');
+        const want = /^(list|ls|all)?$/i.test(restArg.trim()) ? '' : restArg.trim().split(/\s+/)[0]; // "/extension list" is just the list
+        try {
+          if (want) {
+            const one = (api.pluginGet ? await api.pluginGet(want) : null) || (await api.pluginList()).find(r => r.plugin_id === want || r.id === want);
+            if (!one) return say(`No installed plugin named "${want}". /plugins lists them.`, 'warn');
+            const on = one.is_enabled !== false && one.is_enabled !== 0;
+            return say([`${one.plugin_id || want}  ${on ? 'enabled' : 'disabled'}  v${one.version || '?'}`, ...(one.installed_by ? [`installed by ${one.installed_by}${one.installed_at ? ` on ${String(one.installed_at).slice(0, 10)}` : ''}`] : []), ...(one.upgraded_at ? [`upgraded ${String(one.upgraded_at).slice(0, 10)}`] : [])].join('\n'));
+          }
+          const list = await api.pluginList();
+          if (!list.length) return say('No plugins installed for this org.');
+          const w = Math.max(...list.map(r => String(r.plugin_id || '').length));
+          return say([`${list.length} plugin${list.length === 1 ? '' : 's'} (extensions). /plugins <name> for detail:`, ...list.map(r => `  ${String(r.plugin_id || '?').padEnd(w)}  ${r.is_enabled === false || r.is_enabled === 0 ? 'disabled' : 'enabled '}  v${r.version || '?'}`)].join('\n'));
+        } catch (e) { return say(`Couldn't list plugins: ${e?.message || 'failed'}`, 'warn'); }
+      }
       case '/skills': {
         if (!api.skills) return say('This server has no skills list.', 'warn');
         try {
@@ -2631,6 +3048,36 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         }
         return submit(skillPrompt(arg, argRest));
       }
+      case '/loop': { // QLOOP-LIVE: list | watch <id> | peek <id> | focus
+        const [sub0, ...restW] = String(restArg || '').trim().split(/\s+/).filter(Boolean);
+        const lid = restW[0];
+        if (!sub0 || sub0 === 'list') {
+          const rows = (R.current.roster.allRows || []).filter(r => r.kind === 'loop');
+          if (!rows.length) return say('No loops running or recent. Ask Quox to run something until it is done, and say yes to the loop offer.');
+          for (const r of rows) say(`∞ ${r.id} │ ${r.name} │ ${r.state}${r.activity ? `, ${r.activity}` : ''}${LC.current.get(r.id) ? ' (card on screen)' : ''}`, r.state === 'failed' ? 'error' : undefined);
+          return say('/loop watch <id> puts a live card in this chat. /loop peek <id> prints one snapshot.');
+        }
+        if (sub0 === 'focus') { const c = LC.current.focus(lid || null); return c ? say(`Keys on the loop card: Enter expands the output, s halts (y confirms), Esc leaves.`) : say('No loop card on screen. /loop watch <id> starts one.', 'warn'); }
+        if (sub0 === 'watch') {
+          if (!lid) return say('Usage: /loop watch <id>', 'warn');
+          if (!api.loopEvents) return say('/loop watch is not available in this mode.', 'warn');
+          const known = (R.current.roster.allRows || []).find(r => r.id === lid);
+          const had = LC.current.get(lid);
+          LC.current.watch(lid, { title: known?.name || '' });
+          LC.current.focus(lid);
+          return had ? say('That loop already has a card above; it has focus. Enter expands, s halts, Esc leaves.') : undefined; // the card's own last line lists the keys
+        }
+        if (sub0 === 'peek') {
+          if (!lid) return say('Usage: /loop peek <id>', 'warn');
+          try {
+            const snap = await api.loopSnapshot(lid);
+            const st = applyLoopSnapshot(initLoop({ id: lid, title: snap?.title || '' }), snap);
+            for (const rs of cardLines(st, { cols: Math.max(40, cols - 4) })) say(rs.map(x => x.t).join(''));
+          } catch (e) { say(`loop ${lid}: ${e?.status ? `HTTP ${e.status} ` : ''}${e?.message || 'failed'}`, 'warn'); }
+          return undefined;
+        }
+        return say('Usage: /loop list | watch <id> | peek <id> | focus', 'warn');
+      }
       case '/roster': {
         const ro = R.current.roster;
         if (arg === 'all') {
@@ -2720,6 +3167,39 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         catch (e) { dispatch({ type: 'error', text: `observers: ${e.message}` }); }
         return undefined;
       }
+      case '/inbox': { // HITL-INBOX-BAR: the owner's Quox inbox, in the chat
+        if (!api.inboxItems) return say('The inbox is not available in this mode.', 'warn');
+        const q = parseInbox(restArg);
+        if (q.kind === 'usage') return say(INBOX_USAGE, 'warn');
+        let items;
+        try { items = await api.inboxItems({ limit: 30 }); }
+        catch (e) { return dispatch({ type: 'error', text: `Could not read the inbox (${e.message}). That does not mean it is empty; try again or run: quox inbox list` }); }
+        const top = newestFirst(items).slice(0, 10);
+        R.current.inboxList = top; R.current.inboxSeen = new Set(items.map((i) => i?.id).filter(Boolean));
+        dispatch({ type: 'notify', patch: { inboxBar: inboxBarText(items, cols) } });
+        const pick = (n) => { const it = top[n - 1]; if (!it) say(`No item ${n}: the list has ${top.length}. ${mark('/inbox')} shows it.`, 'warn'); return it; };
+        if (q.kind === 'list') { for (const l of inboxTable(items, Date.now(), cols)) say(l.text, l.tone === 'accent' ? 'warn' : l.tone); return undefined; }
+        if (q.kind === 'read') {
+          const targets = q.all ? top.filter((i) => !i.is_read) : [pick(q.n)].filter(Boolean);
+          if (!targets.length) return q.all ? say('Nothing unread.', 'dim') : undefined;
+          let ok = 0; const bad = [];
+          for (const it of targets) { try { await api.inboxMarkRead(it.id, true); ok++; } catch (e) { bad.push(e?.message || 'failed'); } }
+          if (bad.length) say(`Marked ${ok} read; ${bad.length} failed (${clip(bad[0], 60)}).`, 'warn'); else say(`✔ marked ${ok} read`, 'ok');
+          refreshInboxBar();
+          return undefined;
+        }
+        const it = pick(q.n); if (!it) return undefined;
+        if (q.kind === 'open' && isApprovalItem(it)) {
+          let flat = []; try { flat = groupApprovals(await api.approvals(), { conversationId: S.current.ctx.conversationId, cardIds: [] }).flatMap((g) => g.items.map((x) => x.item.id)); } catch { /* falls to /approvals below */ }
+          const at = flat.indexOf(it.id);
+          return command(at >= 0 ? `/approvals ${at + 1}` : '/approvals');
+        }
+        let full = it; try { full = (await api.inboxItem(it.id)) || it; } catch (e) { say(`Could not load the full item (${clip(e?.message || 'failed', 60)}); showing the list row.`, 'warn'); }
+        for (const l of inboxDetail(full)) say(l.text, l.tone === 'accent' ? 'ok' : l.tone === 'text' ? undefined : l.tone);
+        if (isApprovalItem(full)) say(`This is an approval: ${mark(`/inbox open ${q.n}`)} takes you to it.`, 'dim');
+        refreshInboxBar();
+        return undefined;
+      }
       case '/approvals': {
         if (/^help$/i.test(restArg.trim())) { // the syntax lives here, not above every list
           say(`${mark('/approve N')} ${mark('/deny N <reason>')} ${mark('/approvals N')} detail ${mark('/approvals walkthrough')} one at a time ${mark('/approvals mine|agents|old|<agent>')} filter (privileged: ${mark('/approve N confirm')})`);
@@ -2739,7 +3219,11 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         const hidden = stats ? Math.max(0, stats.awaiting - flat.length) : 0;
         if (!flat.length && !hidden && !statsErr) return say('Nothing waiting for you.', 'ok');
         const fArg = restArg.trim();
-        if (/^walkthrough$/i.test(fArg)) return walkStart(flat, { fresh: true });
+        if (/^walkthrough$/i.test(fArg)) { // plain approvals walk as cards too, after any session questions
+          const plain = flat.filter(x => !isDecision(x));
+          if (plain.length && plain.length === flat.length) say(`No session questions; ${plain.length} approval${plain.length === 1 ? '' : 's'} waiting, starting with the first.`, 'warn');
+          return walkStart(flat.map(approvalAsWalkItem), { fresh: true });
+        }
         if (/^\d+$/.test(fArg)) { // /approvals N: everything the item carries
           const it = flat[Number(fArg) - 1];
           if (!it) return say(`No such item: [${fArg}] (${flat.length} listed).`, 'warn');
@@ -2766,6 +3250,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         }
         if (flat.length && !shown.size) say(`Nothing matches "${fArg}".`, 'warn');
         if (flat.length) say(' ');
+        if (shown.size && !(nDec && !fArg)) R.current.listShownAt = Date.now(); // a list, not a card: a bare y/n right after it has no target
         if (nDec && !fArg) walkStart(flat, { fresh: true, quiet: true });
         if (hidden) {
           const others = humanProfiles.filter(h => h !== profile);
@@ -2786,7 +3271,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       }
       case '/mouse': {
         const v = arg.trim().toLowerCase();
-        if (!v) return say(`Mouse is ${MO.current.on ? 'on' : 'off'}. /mouse ${MO.current.on ? 'off' : 'on'} to change it.`);
+        if (!v) return say(`Mouse is ${MO.current.on ? 'on' : 'off'}. /mouse ${MO.current.on ? 'off' : 'on'} to change it.${MO.current.on ? ` ${MOUSE_HINT}` : ''}`);
         if (v !== 'on' && v !== 'off') return say('Usage: /mouse on|off', 'warn');
         MO.current.on = v === 'on'; MO.current.drag = null;
         api.saveSetting?.('mouse', v);
@@ -2820,6 +3305,19 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       case '/soar': return command(`/fleet${restArg ? ` ${restArg}` : ''}`);
       case '/summon': return command(`/attach${restArg ? ` ${restArg}` : ''}`);
       case '/huh': return command(`/dragon explain${restArg ? ` ${restArg}` : ''}`); // owner 2026-10-15: shortcut for /dragon explain
+      case '/devservers': { // DEVFLEET: list the dev servers. Handing the terminal to a remote session from inside the TUI is not done here: print the exact command.
+        if (!api.devServers) return say('/devservers is not available in this mode.', 'warn');
+        let rows; try { rows = await api.devServers(); } catch (e) { return say(`Couldn't list servers: ${e?.message || 'failed'}`, 'warn'); }
+        if (!rows.length) return say('No dev servers registered. In a terminal: quox server mark <host> --purpose "main dev"');
+        const pick = restArg.trim();
+        if (pick) {
+          const r = rows.find(x => x.name === pick);
+          if (!r) return say(`No dev server "${pick}". /devservers lists them.`, 'warn');
+          return say(`To open a Quox window on ${r.name}, run this in a terminal (the TUI does not hand over the terminal yet):\nquox server go ${r.name}`);
+        }
+        const lines = rows.map(r => `${r.current ? '*' : ' '} ${r.name}  ${r.purpose || '-'}  ${r.project || '-'}  ${r.reachable ? 'reachable' : 'unreachable'}`);
+        return say(`${lines.join('\n')}\n* this server. /devservers <name> shows the command to open a Quox window there (quox server go <name>).`);
+      }
       case '/slots': return listSlots(/^all$/i.test(restArg.trim()));
       case '/mirror': {
         // The Mirror itself: this org's server-built Mirror, what CommanderQ is told every turn (not /mind).
@@ -2903,7 +3401,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
               try { await go(); }
               catch (e) { if (!(e?.status === 403 && e?.body?.error === 'step_up_required')) throw e; SU.current.drop('approve'); await askPin(); await go(); }
               okIds.push(x.id); walkAnsweredIds().add(x.id);
-              say(`✔ answered [${k}] ${x.payload.session || 'session'}: ${clip(x.title || x.id, Math.max(20, cols - 40))} -> (${keyOf(k)})`, 'ok');
+              say(`✔ answered [${k}] ${x.payload.session || 'session'}: ${clip(decodeEntities(x.title || x.id), Math.max(20, cols - 40))} -> (${keyOf(k)})`, 'ok');
               if (x.payload.slot && api.slotSay) await api.slotSay(String(x.payload.slot).toLowerCase(), `Your question "${clip(x.title, 80)}" was answered: ${keyOf(k)}. Read it with: quox ask status ${x.id}`, { from: myLabel() });
             } catch (e) { failedK.push(`[${k}] ${e?.status === 404 || e?.status === 400 ? 'already handled or expired' : e.message}`); if (e?.stepUpDeclined) break; }
           }
@@ -2943,7 +3441,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
           return dispatch({ type: 'error', text: `answer: ${e.message}` });
         }
         say(' ');
-        say(`✔ answered [${pa.n}] ${it.payload.session || 'session'}: ${clip(it.title || it.id, Math.max(20, cols - 40))} -> (${pa.key}) ${it.payload.options.find(o => o.key === pa.key).label}${pa.note ? ` (note: ${clip(pa.note, 40)})` : ''}`, 'ok');
+        say(`✔ answered [${pa.n}] ${it.payload.session || 'session'}: ${clip(decodeEntities(it.title || it.id), Math.max(20, cols - 40))} -> (${pa.key}) ${decodeEntities(it.payload.options.find(o => o.key === pa.key).label)}${pa.note ? ` (note: ${clip(pa.note, 40)})` : ''}`, 'ok');
         say(' ');
         R.current.lastAnswered = it.id; walkAnsweredIds().add(it.id);
         if (it.payload.slot && api.slotSay) { // WALK-FIXES: the answer is already recorded; the slot post never holds up the next card
@@ -3011,7 +3509,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
           try {
             const dsc = describeInboxItem(it); // APPROVAL-WHAT: record the real action and target, not a clipped title
             const r = await answer({ callId: it.id, inboxItemId: it.id, approvalId: it.approval_id || it.approvalId || null, tool: dsc.tool || clip(it.title || it.id, cols - 40), target: dsc.target, raisedBy: approvalSourceLabel(it), risk: it.payload?.approval_context?.risk || null }, verb, { batch: true, reason, proactive: Boolean(R.current.authorising) && verb === 'approve', bulk: bulkish && isDecision(it) });
-            if (r?.gone) gone.push(k); else if (r?.ok) done.push(k);
+            if (r?.gone) gone.push(k); else if (r?.ok) { done.push(k); R.current.lastAnswered = it.id; }
           } catch (e) { failed.push(`[${k}] ${e.message}`); }
         }
         if (done.length || gone.length || failed.length || missing.length) say(' ');
@@ -3053,7 +3551,9 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         return undefined;
       }
       default: {
+        if (await extDispatch(cmd, restArg)) return undefined;
         const e = findEntry(cmd);
+        if (e?.ext) return say(`${e.usage.split(/\s/)[0]} comes from the ${e.ext} extension, which is not loaded. npm i -g ${e.ext}, then quox ext add ${e.ext}, or /ext on ${e.ext}.`, 'warn');
         if (e && e.status === 'planned') return say(`${e.usage} is planned, not built yet. /help shows what works today.`, 'warn');
         if (!e && await slotNameCommand(cmd, restArg)) return undefined;
         const cliHit = resolveCliSlash(cmd, restArg); // QUOXON-FW: slash words that name a real quox CLI leaf
@@ -3066,7 +3566,8 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         if (!near.length) return say(`Unknown command ${cmd}. Try /help`, 'warn');
         // spelling-only hints keep the plain "/a or /b" line; keyword hints say what each command does
         const byWords = near.some(x => x.kw);
-        say(`Unknown command ${cmd}. Did you mean ${byWords ? near.map(x => (x.desc ? `${x.name} (${x.desc})` : x.name)).join(', ') : near.map(x => x.name).join(' or ')}? (/help lists them)`, 'warn');
+        const viaAlias = (x) => { const en = findEntry(x.name); return en && en.id !== x.name.slice(1) ? `${x.name} (${en.id})` : x.name; }; // an alias names the command it runs
+        say(`Unknown command ${cmd}. Did you mean ${byWords ? near.map(x => (x.desc ? `${x.name} (${x.desc})` : x.name)).join(', ') : near.map(viaAlias).join(' or ')}? (/help lists them)`, 'warn');
         if (near.length === 1) { // one strong match: offer it as a y/N card (vetted, never a human-typed command)
           const v = vetSuggestion(near[0].name);
           if (v.ok) { R.current.suggestAsk = { line: v.line, at: Date.now() }; ask(`Run ${v.line}?`, { action: v.line, reason: 'Nearest command to what you typed.' }); }
@@ -3098,7 +3599,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   function openAskStates() {
     const fresh = (x) => (x && Date.now() - (x.at ?? 0) < ASK_TTL ? x : null);
     const W = R.current.pendingWalk; const walkCardSt = W && W.card && Date.now() - W.at < WALK_TTL ? W.card : null; // WALK-FIXES: one card per decision, open as long as the walk (30 min), not the 2-minute ask clock
-    return [walkCardSt, ...[R.current.wakeAsk, R.current.pendingGrant, R.current.feedbackAsk, R.current.slotAsk, R.current.slotCreateAsk, R.current.profileAsk, R.current.cliAsk, R.current.updateAsk, R.current.orgPending, R.current.hatPending, HW.current.card(), RW.current.walk.card(), R.current.suggestAsk && !R.current.suggestLine ? R.current.suggestAsk : null, R.current.handoffAsk, R.current.askQuox, R.current.strayAsk, R.current.planAsk, SC.current.pendingFile, SC.current.reattach, CH.current.pending, SPN.current.pending].map(fresh)].filter(Boolean);
+    return [walkCardSt, ...[R.current.wakeAsk, R.current.pendingGrant, R.current.feedbackAsk, R.current.slotAsk, R.current.slotCreateAsk, R.current.sayLastAsk, R.current.profileAsk, R.current.cliAsk, R.current.installAsk, R.current.updateAsk, R.current.orgPending, R.current.hatPending, HW.current.card(), RW.current.walk.card(), R.current.suggestAsk && !R.current.suggestLine ? R.current.suggestAsk : null, R.current.objectiveAsk, R.current.handoffAsk, R.current.askQuox, R.current.strayAsk, R.current.planAsk, SC.current.pendingFile, SC.current.reattach, CH.current.pending, SPN.current.pending].map(fresh)].filter(Boolean);
   }
   const askOpen = () => openAskStates().length > 0 || KC.current.pending?.() || UW.current.pending?.() || runAskOpen();
   function touchAsks() { for (const x of openAskStates()) x.at = Date.now(); KC.current.touch?.(); UW.current.touch?.(); }
@@ -3236,7 +3737,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     let askDismissed = false; // a chat line that is not a question about the offer answers it by moving on: the card closes itself
     if (askOpen() && !R.current.noteAsk) {
       const o = askOutcomeOf(text, { runWord: runAskOpen() }) || (askAnswer(text) === 'chat' && !S.current.turn && !R.current.pendingWalk && !isAskClarification(text) ? { kind: 'dismissed' } : null);
-      const OWN = ['wakeAsk', 'pendingGrant', 'feedbackAsk', 'slotAsk', 'slotCreateAsk', 'profileAsk', 'cliAsk', 'updateAsk', 'orgPending', 'hatPending', 'suggestAsk', 'askQuox', 'planAsk'];
+      const OWN = ['wakeAsk', 'pendingGrant', 'feedbackAsk', 'slotAsk', 'slotCreateAsk', 'sayLastAsk', 'profileAsk', 'cliAsk', 'installAsk', 'updateAsk', 'orgPending', 'hatPending', 'suggestAsk', 'askQuox', 'planAsk'];
       const foreign = KC.current.pending?.() || UW.current.pending?.() || HW.current.card() || SC.current.pendingFile || SC.current.reattach || CH.current.pending || SPN.current.pending || runAskOpen();
       if (o?.kind === 'dismissed' && foreign) { /* a card owned by another module keeps its own rules: the line is about it, as before */ }
       else if (o) {
@@ -3316,6 +3817,11 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       if (askAnswer(text) === 'yes' && Date.now() - a.at < 120000) { switchTo(a.name); return; }
       if (!text.startsWith('/')) { say(`Not switched. This window stays ${WHO.current.profile}.`, 'dim'); return; }
     }
+    if (R.current.sayLastAsk) { // SAY-LAST-TARGET "Send to <slot>? y send · n cancel": y sends the whole text
+      const a = R.current.sayLastAsk; R.current.sayLastAsk = null;
+      if (/^y(es)?$/i.test(text.trim()) && Date.now() - a.at < 120000) { sendToSlot(a.slot, a.text); return; }
+      if (!text.startsWith('/')) { say('Not sent.', 'dim'); return; }
+    }
     if (R.current.slotCreateAsk) { // "No slot X. Create it? y/N/c" from a /slot near miss: y runs /slot X --create
       const a = R.current.slotCreateAsk; R.current.slotCreateAsk = null;
       if (askAnswer(text) === 'yes' && Date.now() - a.at < 120000) { const l = `/slot ${a.nm} --create`; echoCmd(l); command(l); return; }
@@ -3336,6 +3842,11 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       }
       if (!text.startsWith('/')) { say('Not updated. Nothing was changed.', 'dim'); return; }
     }
+    if (R.current.installAsk) { // LAZY-AI-CLI: "Claude Code isn't installed on this server. Install it now? y/N" (typing y is the authorization)
+      const a = R.current.installAsk; R.current.installAsk = null;
+      if (/^y(es)?$/i.test(text.trim()) && Date.now() - a.at < 120000) { installNow(a); return; }
+      if (!text.startsWith('/')) { say(`Not installed. Nothing was downloaded.`, 'dim'); nextInstallOffer(); return; }
+    }
     if (R.current.cliAsk) { // QUOXON-FW: a slash word named a WRITE quox command: "Run it? y/N" (typing y is the authorization)
       const a = R.current.cliAsk; R.current.cliAsk = null;
       if (/^y(es)?$/i.test(text.trim()) && Date.now() - a.at < 120000) { if (R.current.bang) say('A command is still running. Ctrl+C stops it.', 'warn'); else bangCommand(a.bang); bump(n => n + 1); return; }
@@ -3356,6 +3867,11 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       if (/^y(es)?$/i.test(text.trim()) && Date.now() - a.at < 120000) { const v = vetSuggestion(a.line); if (v.ok) { R.current.preConfirmed = v.id === 'org' ? 'org' : null; echoCmd(v.line); command(v.line); bump(n => n + 1); } return; }
       if (!text.startsWith('/')) { say('Not run.', 'dim'); return; }
     }
+    if (R.current.objectiveAsk) { // "Make this an objective that runs until done?" (yes or no): yes creates + starts it, no does nothing
+      const a = R.current.objectiveAsk; R.current.objectiveAsk = null;
+      if (/^y(es)?$/i.test(text.trim()) && Date.now() - a.at < 120000) { runObjective(a); return; }
+      if (!text.startsWith('/')) { say('No objective made.', 'dim'); return; }
+    }
     if (R.current.handoffAsk) { // "Hand this question to CommanderQ?" (yes or no): yes asks it once, the attach stays
       const a = R.current.handoffAsk; R.current.handoffAsk = null;
       if (/^y(es)?$/i.test(text.trim()) && Date.now() - a.at < 120000) { runHandoff(a); return; }
@@ -3396,6 +3912,8 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       else if (v === 'needs-run') { say(`Not run yet. ${ra.danger}, so type run to run it, or n to skip.`, 'warn'); return; }
       else if (v === 'no') { SC.current.runAsk = null; transcript?.bang?.(ra.cmd, 'declined'); say('Not run.', 'dim'); return; }
     }
+    { const ls = R.current.listShownAt; R.current.listShownAt = null; // APPROVALS-UX: y/n right after a list (not a card) is not chat to the agent
+      if (ls && Date.now() - ls < 600000 && /^(y(es)?|no?)$/i.test(text.trim())) { remember(text); R.current.histIdx = -1; say('Which one? /approve 1 or /approvals 1 to see it.', 'warn'); R.current.listShownAt = ls; return; } }
     if (text.startsWith('/') && !text.includes('\n')) { remember(text); R.current.histIdx = -1; echoCmd(text); command(text); return; } // Up recalls commands too
     const roomSend = api.slotSay ? parseRoomSend(text) : null;
     if (roomSend) { // QUOXON-ROOMS: #room text posts, bare #room makes it the default target
@@ -3485,9 +4003,11 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     const now = Date.now();
     const idx = hit.inFrame ? composerIndexAt(hit.frameLines, hit.frameRow, e.x, B.current) : null;
     if (idx != null) {
-      const dbl = M.last && now - M.last.at < DOUBLE_MS && M.last.x === e.x && M.last.y === e.y;
-      M.last = dbl ? null : { at: now, x: e.x, y: e.y };
-      if (dbl) { const w = wordAt(B.current.text, idx); edit({ type: 'select', anchor: w.from, cursor: w.to }); copySelection(); return; }
+      const same = M.last && now - M.last.at < DOUBLE_MS && M.last.x === e.x && M.last.y === e.y;
+      const n = same ? M.last.n + 1 : 1;
+      M.last = n >= 3 ? null : { at: now, x: e.x, y: e.y, n };
+      if (n === 2) { const w = wordAt(B.current.text, idx); edit({ type: 'select', anchor: w.from, cursor: w.to }); copySelection(); return; }
+      if (n >= 3) { const l = lineAt(B.current.text, idx); edit({ type: 'select', anchor: l.from, cursor: l.to }); copySelection(); return; }
       edit({ type: 'place', index: idx }); K.current.composerClicked = true;
       M.drag = { anchor: B.current.cursor, cursorRow: hit.cursorRow ?? null };
       return;
@@ -3613,6 +4133,25 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   }
 
   /** COMPOSER-EDIT: cells the draft has per row (the composer box is `cols` wide, less the "› " prompt). */
+  /** QUOXON-HISTORY-UP: still on the entry Up recalled (unedited): Up/Down jump whole entries, not rows of a long recalled message. */
+  function browsingHistory() { return R.current.histIdx >= 0 && B.current.text === R.current.histText; }
+  /** QUOXON-HISTORY-UP: Ctrl+R reverse search. The composer shows "(reverse-i-search) q: match"; Enter accepts, Esc cancels, Ctrl+R again = next older. */
+  function rsShow() {
+    const rs = R.current.rs; const hist = R.current.history; const q = rs.q.toLowerCase(); let n = rs.skip; rs.hit = null;
+    for (let i = hist.length - 1; i >= 0; i--) if (hist[i].toLowerCase().includes(q) && n-- === 0) { rs.hit = hist[i]; break; }
+    B.current = bufferReducer(initialBuffer(), { type: 'set', text: `(reverse-i-search) ${rs.q}: ${rs.hit == null ? '' : rs.hit.replace(/\s*\n\s*/g, ' ')}` }); bump(n2 => n2 + 1);
+  }
+  function rsEvent(e) {
+    const rs = R.current.rs;
+    if (e.type === 'key') {
+      if (e.name === 'escape' || e.name === 'ctrl-c') { B.current = rs.saved; R.current.rs = null; bump(n => n + 1); return; }
+      if (e.name === 'enter') { const hit = rs.hit; B.current = rs.saved; R.current.rs = null; if (hit != null) { R.current.histIdx = -1; edit({ type: 'set', text: hit }); } else bump(n => n + 1); return; }
+      if (e.name === 'ctrl-r') { rs.skip++; return rsShow(); }
+      if (e.name === 'backspace') { rs.q = rs.q.slice(0, -1); rs.skip = 0; return rsShow(); }
+      return;
+    }
+    if (e.type === 'text' || e.type === 'paste') { rs.q += e.text.replace(/\s+/g, ' '); rs.skip = 0; rsShow(); }
+  }
   function composerWidth() { return Math.max(1, cols - 2); }
   /** COMPOSER-EDIT: copy the composer selection to the clipboard with OSC 52 (works over SSH; needs a terminal that allows it). */
   function copySelection() {
@@ -3635,6 +4174,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       return;
     }
     if (name === 'ctrl-d') { if (!B.current.text) exit(); return; }
+    if (LC.current.focused() && !s.approvals.length && !B.current.text && LC.current.key(name, e.text)) return; // QLOOP-LIVE: keys of a focused loop card
     if (R.current.roster.focus && !s.approvals.length && rosterKey(name)) return;
     // quick reply (owner 2026-10-15): Tab in an EMPTY composer pre-fills "/say <last sender> " (before the palette, which owns Tab otherwise)
     if (name === 'tab' && !B.current.text && R.current.lastSender && !headCard(s)) { edit({ type: 'set', text: `/say ${R.current.lastSender.toLowerCase()} ` }); return; }
@@ -3663,7 +4203,15 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       case 'delete': return edit({ type: 'delete' });
       case 'delete-word': return edit({ type: 'deleteWordBack' });
       case 'kill-line': return edit({ type: 'killLineBack' });
-      case 'left': case 'right': case 'home': case 'end': return edit({ type: name });
+      case 'home': { // Ctrl+A stays line-start; a second Ctrl+A within 600 ms selects the whole draft (and copies it)
+        if (e.via === 'ctrl-a') {
+          const k = K.current;
+          if (k.ctrlA && now - k.ctrlA.at < 600 && k.ctrlA.text === B.current.text && B.current.text) { k.ctrlA = 0; edit({ type: 'selectAll' }); copySelection(); return; }
+          k.ctrlA = { at: now, text: B.current.text };
+        }
+        return edit({ type: 'home' });
+      }
+      case 'left': case 'right': case 'end': return edit({ type: name });
       case 'word-left': case 'word-right': return edit({ type: name === 'word-left' ? 'wordLeft' : 'wordRight' });
       case 'kill-line-forward': return edit({ type: 'killLineForward' }); // Ctrl+K
       case 'delete-word-forward': return edit({ type: 'deleteWordForward' }); // Alt+D, Ctrl+Delete
@@ -3678,21 +4226,22 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       case 'redo': return edit({ type: 'redo' });
       case 'up': {
         if (B.current.text === '' && s.pending.length) { const last = s.pending[s.pending.length - 1]; dispatch({ type: 'queue.pop' }); edit({ type: 'set', text: last.text }); return; }
-        if (atVisualEdge(B.current, 'up', composerWidth())) { // COMPOSER-EDIT: Up walks wrapped rows first, history from the top row
+        if (browsingHistory() || atVisualEdge(B.current, 'up', composerWidth())) { // COMPOSER-EDIT: Up walks wrapped rows first, history from the top row
           const hist = R.current.history;
           if (B.current.text === '' || R.current.histIdx >= 0) {
             const i = R.current.histIdx < 0 ? hist.length - 1 : Math.max(0, R.current.histIdx - 1);
-            if (hist[i] !== undefined) { R.current.histIdx = i; edit({ type: 'set', text: hist[i] }); }
+            if (hist[i] !== undefined) { R.current.histIdx = i; R.current.histText = hist[i]; edit({ type: 'set', text: hist[i] }); }
           }
           return;
         }
         return edit({ type: 'up', width: composerWidth() });
       }
       case 'down': {
+        if (B.current.text === '' && R.current.histIdx < 0 && !s.approvals.length && LC.current.anyRunning() && !LC.current.focused()) { LC.current.focus(); return; } // QLOOP-LIVE: Down on an empty composer reaches the newest running card (its hint line says so)
         if (B.current.text === '' && R.current.histIdx < 0 && rosterOn()) { focusRoster(); return; }
-        if (atVisualEdge(B.current, 'down', composerWidth()) && R.current.histIdx >= 0) {
+        if ((browsingHistory() || atVisualEdge(B.current, 'down', composerWidth())) && R.current.histIdx >= 0) {
           const i = R.current.histIdx + 1;
-          if (i >= R.current.history.length) { R.current.histIdx = -1; edit({ type: 'clear' }); } else { R.current.histIdx = i; edit({ type: 'set', text: R.current.history[i] }); }
+          if (i >= R.current.history.length) { R.current.histIdx = -1; edit({ type: 'clear' }); } else { R.current.histIdx = i; R.current.histText = R.current.history[i]; edit({ type: 'set', text: R.current.history[i] }); }
           return;
         }
         return edit({ type: 'down', width: composerWidth() });
@@ -3746,6 +4295,8 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
       if (LI.current.isOpen()) { LI.current.onEvent(e); K.current.lastKeyAt = now; K.current.lastKeyCh = null; continue; } // the sign-in card takes every key
       if (CN.current.isOpen()) { CN.current.onEvent(e); K.current.lastKeyAt = now; K.current.lastKeyCh = null; continue; } // the secure card takes every key
       if (PK.current.isOpen() && !S.current.approvals.length && PK.current.onEvent(e) !== false) { K.current.lastKeyAt = now; K.current.lastKeyCh = null; continue; } // /resume, /config (typing closes it and falls through)
+      if (R.current.rs && (e.type === 'key' || e.type === 'text' || e.type === 'paste')) { rsEvent(e); K.current.lastKeyAt = now; K.current.lastKeyCh = null; continue; }
+      if (e.type === 'key' && e.name === 'ctrl-r' && !headCard(S.current) && R.current.history.length) { R.current.rs = { saved: B.current, q: '', skip: 0, hit: null }; rsShow(); K.current.lastKeyAt = now; K.current.lastKeyCh = null; continue; }
       const card = headCard(S.current);
       const g = K.current.guard;
       // any different key ends the "this key was already down" suppression
@@ -3761,6 +4312,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
         edit({ type: 'paste', text: e.text }); // a card never discards a paste
       } else if (e.type === 'text') {
         if (card && approvalKey('text', e.text, now)) { /* consumed by the approval dialog */ }
+        else if (!card && !B.current.text && LC.current.focused() && LC.current.key(null, e.text)) { /* consumed by the focused loop card (s halts, y confirms) */ }
         else if (!card && R.current.roster.focus && rosterKey(null, e.text)) { /* consumed by the roster */ }
         else if (!card && askKey(e.text, now)) { /* consumed by the open ask */ }
         else edit({ type: 'insert', text: e.text });
@@ -3774,6 +4326,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   };
   onData.current = (chunk) => {
     const now = Date.now();
+    DC.current.keypress(); // a keypress sends the companion dragon away, but not in its first moments
     finishIntroRef.current();
     // Enter is a newline only inside a real paste (bracketed, or several lines in one chunk: keys.js).
     // Its timing relative to the previous chunk says nothing: tmux, expect and SSH batch segments.
@@ -3888,6 +4441,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     stdin.on('data', fn);
     return () => {
       R.current.closed = true;
+      LC.current.dispose();
       R.current.abort?.abort(); // closing quoxon cancels the active stream (and its HTTP body)
       for (const k of ['fallbackTimer', 'ctrlCTimer']) clearTimeout(R.current[k]);
       clearTimeout(K.current.danglingTimer);
@@ -3930,6 +4484,16 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
     }
     pendingHist = s.history.slice(committedRef.current);
   }
+  const staticItems = (() => { // QLOOP-LIVE: the committed history for <Static>; append-only, a settled loop card joins at the end
+    let st = staticRef.current;
+    const upto = Math.min(committedRef.current, s.history.length);
+    if (st.seen > s.history.length) st = staticRef.current = { list: [], seen: 0, deferred: [] };
+    let list = st.list;
+    for (; st.seen < upto; st.seen++) { const it = s.history[st.seen]; if (LC.current.held(it)) st.deferred.push(it); else list = [...list, it]; }
+    if (st.deferred.length) { const done = st.deferred.filter((it) => !LC.current.held(it)); if (done.length) { st.deferred = st.deferred.filter((it) => !done.includes(it)); list = [...list, ...done]; } }
+    st.list = list;
+    return list;
+  })();
   lastAppRender.current = nowR;
   // Composer ring: motion and colour both on. Thinking/tools cyan-purple, writing green, approval amber.
   const ring = motionOn && !mono() ? { ref: ringRef, active: busy, mode: ringMode({ approvals: s.approvals.length, act: s.turn?.act }) } : null;
@@ -3939,7 +4503,7 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   R.current.cardMidAnim = Boolean(card && motionOn && nowR - (card.displayedAt ?? card.shownAt) < 1000); // this render draws the card mid-animation (appDue keeps it due until a settled draw)
   if (motionStats && motionOn && card && card.displayedAt != null && !(motionStats.cards ||= []).some(x => x.card.callId === card.callId)) motionStats.cards.push({ card, org: orgShown() || null }); // the card took the draw-in path (a test renders it at fixed motionE)
   R.current.armedShown = armed;
-  const ctxParts = [demoLabel && profile === 'demo' ? null : profile, orgShown(), (R.current.noAi && !s.ctx?.model ? NO_AI_STATUS : modelLabel(s.ctx, MC.current)), demoLabel ? (demoAuto ? 'demo data, nothing real runs' : null) : MD.current, R.current.rulesOn === false ? (rulesLabel(rules) ? 'rules: off' : null) : rulesLabel(rules), AR.current.on ? '↻ auto' : null]; // [5]: auto-restart, context row of the status
+  const ctxParts = [demoLabel && profile === 'demo' ? null : profile, orgShown(), (R.current.noAi && !s.ctx?.model ? NO_AI_STATUS : modelLabel(s.ctx, MC.current)), demoLabel ? (demoAuto ? 'demo data, nothing real runs' : null) : MD.current, R.current.rulesOn === false ? (rulesLabel(rules) ? 'rules: off' : null) : rulesLabel(rules), AR.current.on ? '↻ auto' : null, SV.current.chip ? { name: SV.current.chip.name, role: SV.current.chip.role } : null, SV.current.chip?.remote || null]; // [6],[7]: server chip, remote instance; [5]: auto-restart, context row of the status
   const caps = R.current.caps;
   const hint = (busy ? `${caps.steer ? 'Enter steer' : 'Enter queue'} · Tab queue · ${caps.interrupt ? 'Esc stop' : 'Esc disconnects'}` : ''); // owner 22:12 "Lose this: Enter send · /help": only the hint a running turn needs is shown
   const placeholder = busy ? (caps.steer ? 'Type to steer (Enter) or queue (Tab)' : 'Type to queue (Enter or Tab)') : R.current.askArmed ? ASK_PROMPT : 'Ask Quox anything…';
@@ -3983,39 +4547,41 @@ export function App({ slotAgent, notifyMs = 4000, resultPollMs = 3000, resultTim
   if (sleeping) { // the screensaver replaces the live region only; Static (scrollback) is frozen, the transcript untouched
     const rows = Math.max(8, (termRows(stdout) ?? 24) - 1), sl = R.current.sleep;
     return h(FrameContext.Provider, { value: framesRef.current }, h(Box, { flexDirection: 'column' },
-      h(Static, { key: `static-${epoch}`, items: s.history.slice(0, committedRef.current) }, (it, i) => h(Box, { key: it.id, flexDirection: 'column' }, h(HistoryItem, { item: it, cols, gap: historyGap(s.history[i - 1], it, termRows(stdout)) }))),
+      h(Static, { key: `static-${epoch}`, items: staticItems }, (it, i) => h(Box, { key: it.id, flexDirection: 'column' }, h(HistoryItem, { item: it, cols, gap: historyGap(staticItems[i - 1], it, termRows(stdout)) }))),
       h(SleepScreen, { lines: sourceLines(S.current, cols, rows), cols, rows, startedAt: sl.startedAt, wakeAt: sl.wakeAt, still: sl.still })));
   }
   const ruleAbove = endsInRule({ card, asks: s.asks || [], background: s.background, pending: s.pending, steering: s.steering, countdown: Boolean(AR.current.timer && AR.current.endsAt) }) && !(SU.current.isOpen() || LI.current.isOpen() || CN.current.isOpen());
   return h(FrameContext.Provider, { value: framesRef.current }, h(Box, { flexDirection: 'column' },
     // Nothing enters <Static> before the intro settles: Static is index-based, so prepending the intro to
     // already-printed items would drop it (and reprint the rest).
-    h(Static, { key: `static-${epoch}`, items: introDone.current ? s.history.slice(0, committedRef.current) : [] }, (it, i) => h(Box, { key: it.id, flexDirection: 'column' }, h(HistoryItem, { item: it, cols, gap: historyGap(s.history[i - 1], it, termRows(stdout)) }))),
+    h(Static, { key: `static-${epoch}`, items: introDone.current ? staticItems : [] }, (it, i) => h(Box, { key: it.id, flexDirection: 'column' }, h(HistoryItem, { item: it, cols, gap: historyGap(staticItems[i - 1], it, termRows(stdout)) }))),
     introDone.current ? null : h(Box, { key: 'intro-live', flexDirection: 'column' }, h(Intro, { item: introItem, cols, dragon: introDragon, progress: Math.min(1, (Date.now() - introStart.current) / introMs) })),
     liveRegion([
       ...pendingHist.map((it, i) => h(Box, { key: it.id, flexDirection: 'column' }, h(FxItem, { item: it, cols, fxFor, gap: historyGap(i ? pendingHist[i - 1] : s.history[committedRef.current - 1], it, termRows(stdout)), active: busy && it.kind === 'trace' && i === pendingHist.length - 1 && !s.blocks.length }))),
       ...s.blocks.map((b, i) => { const gap = historyGap(i ? s.blocks[i - 1] : (pendingHist[pendingHist.length - 1] ?? s.history[committedRef.current - 1]), b, termRows(stdout)); return h(Box, { key: b.id, flexDirection: 'column' }, motionOn && revealTimingFor(b) ? h(FxItem, { item: b, cols, live: true, fxFor, ignition: feats().ignition, gap }) : h(HistoryItem, { item: b, cols, live: true, gap })); })]),
     h(DragonLive, { key: 'dragon', cols }),
-    flyActive(nowR) ? h(FlyLive, { key: 'dragon-fly', cols, rows: termRows(stdout), startedAt: R.current.fly.startedAt, still: R.current.fly.still }) : null,
+    flyActive(nowR) ? h(FlyLive, { key: 'dragon-fly', cols, rows: termRows(stdout), startedAt: R.current.fly.startedAt, still: R.current.fly.still, chromeH: chromeH.current }) : null,
     dragonTalkVisible(nowR) ? h(DragonTalk, { key: 'dragon-talk', cols, label: R.current.dragonTalk.label, talking: !R.current.dragonTalk.armed && !R.current.dragonTalk.endedAt, since: R.current.dragonTalk.since, still: !motionOn || mono() }) : null,
+    h(DragonCompanionLive, { key: 'dragon-companion', ctl: DC.current, cols, rows: termRows(stdout) ?? 24 }),
     h(Box, { key: 'chrome', ref: chromeRef, flexDirection: 'column' },
     busy ? h(Working, { key: 'working', motion: motionOn && !R.current.exiting, handoff: feats().handoff, tokens: turnTokens(s.turn), act: s.turn.act, activity: describeActivity(s), since: s.turn.startedAt, interrupting: s.turn.status === 'interrupting', escLabel: caps.interrupt ? null : 'Esc disconnects' }) : null,
-    card ? h(ApprovalCard, { card, org: orgShown() || null, cols, armed, motionE: motionOn && nowR - (card.displayedAt ?? card.shownAt) < 1000 ? (nowR - (card.displayedAt ?? card.shownAt)) / 1000 : null, draftHint: K.current.cardFocus ? 'focus' : (B.current.text ? 'draft' : null), confirm: K.current.confirm, position: { i: 1, n: queue.length } }) : null,
+    ...LC.current.pinned().map((lc) => h(Box, { key: `loopcard-${lc.id}`, marginTop: 1 }, h(LoopCardView, { item: { card: lc }, cols, pinned: true }))), // QLOOP-LIVE: running loops are pinned above the composer
+    card ? h(ApprovalCard, { card, org: orgShown() || null, cols, armed, motionE: motionOn && nowR - (card.displayedAt ?? card.shownAt) < 1000 ? (nowR - (card.displayedAt ?? card.shownAt)) / 1000 : null, draftHint: K.current.cardFocus ? 'focus' : (B.current.text ? 'draft' : null), confirm: K.current.confirm, position: { i: 1, n: queue.length, others: otherSessionsCount(queue) } }) : null,
     ...(s.asks || []).map(a => h(Box, { key: a.id, flexDirection: 'column' }, h(AskCard, { text: a.text, cols }))), // ASK-SETTLE: open asks are live
     // TODO(contract v2): background agents. `background.status` is NOT in events v1, so nothing sets s.background today.
     s.background > 0 ? h(Box, { paddingLeft: 2 }, h(Text, { color: c('dim') }, `Waiting for ${s.background} background agent${s.background === 1 ? '' : 's'} to finish`)) : null,
     h(Pending, { pending: s.pending, steering: s.steering, cols }),
-    AR.current.timer && AR.current.endsAt ? h(Box, { key: 'restart-countdown', paddingLeft: 2 }, h(Text, { color: c('accent'), bold: true }, countdownLine(Math.max(1, Math.ceil((AR.current.endsAt - Date.now()) / 1000)), cols))) : null,
+    AR.current.timer && AR.current.endsAt ? h(Box, { key: 'restart-countdown', paddingLeft: 2 }, h(Text, { color: c('accent'), bold: true }, countdownLine(Math.max(1, Math.ceil((AR.current.endsAt - Date.now()) / 1000)), cols, { waiting: Boolean(AR.current.waiting) }))) : null,
     ruleAbove ? null : h(Box, { marginTop: 1 }),
     SU.current.isOpen() ? h(StepUpCard, { view: SU.current.view(), cols }) : LI.current.isOpen() ? h(LoginCard, { ...LI.current.view(), cols, profile }) : CN.current.isOpen() ? h(ConnectCard, { ...CN.current.view(), cols })
-      : ring ? h(RingComposer, { buf: B.current, cols, mode: demoLabel ? 'demo' : MD.current, busy, placeholder, name: SN.current.name, model: ctxParts[2], topRule: !ruleAbove, ring, divider: s.divider ? { d: s.divider, slow: dividerSlowRef.current } : null })
-        : h(Composer, { buf: B.current, cols, mode: demoLabel ? 'demo' : MD.current, busy, placeholder, name: SN.current.name, model: ctxParts[2], topRule: !ruleAbove }),
+      : ring ? h(RingComposer, { buf: B.current, cols, mode: demoLabel ? 'demo' : MD.current, busy, placeholder, name: SN.current.name, model: ctxParts[2], topRule: !ruleAbove, approvals: { count: s.notify.approvals, error: s.notify.error, signedOut: Boolean(blocked) }, ring, divider: s.divider ? { d: s.divider, slow: dividerSlowRef.current } : null })
+        : h(Composer, { buf: B.current, cols, mode: demoLabel ? 'demo' : MD.current, busy, placeholder, name: SN.current.name, model: ctxParts[2], topRule: !ruleAbove, approvals: { count: s.notify.approvals, error: s.notify.error, signedOut: Boolean(blocked) } }),
     !CN.current.isOpen() && PK.current.isOpen() && !card ? h(ListView, { ...PK.current.view(), cols }) : !CN.current.isOpen() && PL.current.isOpen() && !card ? h(ListView, { ...PL.current.view(), cols }) : null,
-    h(RowsBar, { rows: RW.current.view(), cols }),
+    h(RowsBar, { rows: RW.current.view(), cols, limit: { grid: QPE_GRID, n: qpeRowsSetting(api.settings?.()) } }),
     h(PresentBar, { stepUp: SU.current, cols }),
     h(StatusLine, { cols, slot: where.current.slot, agent: where.current.agent, groups: [...SC.current.rooms].map(([name, e]) => ({ name, unread: e.unread })), parts: ctxParts, right: hint }),
     h(WaitingNotice, { items: s.waiting.filter(x => K.current.dismissed.has(x.callId)), cols }),
-    h(NotifyBar, { approvals: s.notify.approvals, error: s.notify.error, cols, signedOut: Boolean(blocked), hideCount: approvalRowShown(), alerts: [...(s.notify.providerLines || []), ...(R.current.roster.all ? [] : R.current.roster.alerts)] }),
+    h(NotifyBar, { approvals: s.notify.approvals, error: s.notify.error, cols, signedOut: Boolean(blocked), hideCount: approvalRowShown(), inbox: s.notify.inboxBar || '', alerts: [...(s.notify.providerLines || []), ...(R.current.roster.all ? [] : R.current.roster.alerts)] }),
     rosterNode())));
 }