lazyclaw 6.3.0 → 6.4.0

package/tui/repl.mjs

@@ -38,8 +38,11 @@ import { Splash, renderSplashToString } from './splash.mjs';
 import { Editor } from './editor.mjs';
 import { SlashPopup, filterSlashCommands } from './slash_popup.mjs';
 import { SLASH_COMMANDS } from './slash_commands.mjs';
+import { argSpecFor } from './slash_args.mjs';
 import { ModalPicker, filterModalItems, resolveModalPick } from './modal_picker.mjs';
 import { theme } from './theme.mjs';
+import { StatusBar } from './status_bar.mjs';
+import { onConversationReset, clearTerminalScreen } from './repl_reset.mjs'; export { StatusBar };
 
 // ─── Alt-buffer mount (DEC 1049) ─────────────────────────────────────────
 //
@@ -212,7 +215,7 @@ export function consumeNextTurnFirstMessage(state) {
 //   - runTurnFactory(writeFn) → runTurn(text, signal)   (sticky layout)
 //   - runTurn(text, signal)                              (legacy, stdout)
 // Legacy mode is preserved verbatim for the existing cli.mjs callsite.
-export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, onSlashCommand, statusInfo, getStatus, pickerRef }) {
+export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, onSlashCommand, onArgComplete, onArgList, statusInfo, getStatus, pickerRef }) {
   // statusInfo seeds the StatusBar's provider/model/ctx. getStatus (optional)
   // returns the live values so the bar refreshes after a /provider or /model
   // switch and after each turn (token/ctx gauge) — without it the bar would
@@ -255,7 +258,7 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
   // sticky-bottom Editor actually pins. Non-alt mode keeps the legacy
   // content-sized layout so existing tests + non-TTY fallbacks behave
   // identically. Listen for SIGWINCH-driven resize events.
-  const { stdout } = useStdout();
+  const { stdout, write: writeStdout } = useStdout();
   const [rows, setRows] = useState(() => (stdout && stdout.rows) || 24);
   useEffect(() => {
     if (!stdout) return undefined;
@@ -305,6 +308,7 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
         // when the user hits Esc (onEscape aborts state.controller).
         const result = await onSlashCommand(trimmed, controller.signal);
         if (result === 'EXIT') { exit(); return; }
+        if (result === 'NEW') { clearTerminalScreen(writeStdout); setState((s) => onConversationReset(s)); refreshStatus(); return; } // /new: wipe screen + scrollback so it visually starts over
         if (typeof result === 'string' && result.length > 0) {
           setState((s) => onStreamChunk(s, { chunk: result }));
         }
@@ -330,7 +334,7 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
         reason: err && err.name === 'AbortError' ? 'aborted' : 'error',
       }));
     }
-  }, [exit, onSlashCommand, refreshStatus]);
+  }, [exit, onSlashCommand, refreshStatus, writeStdout]);
 
   // Auto-submit queued mid-stream-interrupt message (spec §5.8). Read
   // state.nextTurnFirstMessage so the effect re-fires when promoted.
@@ -347,6 +351,11 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
     setState((s) => onEscape(s));
   }, []);
 
+  // v6.4 — 2-stage Ctrl+C exit handler. First Ctrl+C reuses onEscapeKey
+  // (cancel in-flight turn + clear, same reducer as Esc); a second press
+  // within the Editor's window calls onExit. Active when exitOnCtrlC:false.
+  const onExitKey = useCallback(() => { exit(); }, [exit]);
+
   // ─── Slash popup state (v5.4) ──────────────────────────────────────
   // The editor reports its current buffer via onBufferChange; we derive
   // the filtered command list from that and own the selection index.
@@ -357,44 +366,66 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
   );
   const [bufferPeek, setBufferPeek] = useState('');
   const [selectedSuggestion, setSelectedSuggestion] = useState(0);
+  const activeLenRef = useRef(0); // length of whatever popup list is active (commands or arg candidates)
   const filtered = useMemo(
     () => filterSlashCommands(bufferPeek, catalog),
     [bufferPeek, catalog]
   );
-  // Reset selection whenever the match list changes length (typing
-  // narrows results, so highlight the first row again).
-  const lastLenRef = useRef(0);
-  useEffect(() => {
-    if (filtered.length !== lastLenRef.current) {
-      setSelectedSuggestion(0);
-      lastLenRef.current = filtered.length;
-    } else if (selectedSuggestion >= filtered.length) {
-      setSelectedSuggestion(Math.max(0, filtered.length - 1));
-    }
-  }, [filtered.length, selectedSuggestion]);
 
   const handleBufferChange = useCallback((buf) => {
     setBufferPeek(buf || '');
   }, []);
   const handleSlashMove = useCallback((delta) => {
     setSelectedSuggestion((i) => {
-      const max = Math.max(0, filtered.length - 1);
+      const max = Math.max(0, activeLenRef.current - 1);
       const n = i + delta;
       if (n < 0) return 0;
       if (n > max) return max;
       return n;
     });
-  }, [filtered.length]);
+  }, []);
   const handleSlashDismiss = useCallback(() => {
     setBufferPeek('');
     setSelectedSuggestion(0);
   }, []);
 
-  // Hide the popup when the buffer already exactly matches the only
-  // remaining suggestion (with or without a trailing space). Otherwise
-  // the popup intercepts Enter and the fully-typed command (e.g.
-  // '/exit') never reaches handleSubmit. Belt-and-suspenders with the
-  // editor-side fall-through in tui/editor.mjs.
+  // ─── Slash-argument completion (v6.x) ──────────────────────────────
+  // argSpec resolves what (if anything) is completable after the command.
+  //   kind 'inline' → candidates render in the popup (onArgList → argList);
+  //                   ↑/↓ select, Tab/Enter fill the token (fillArgToken).
+  //   kind 'modal'  → a "↹ pick" hint shows; Tab opens the drill-in picker
+  //                   (handleArgComplete → onArgComplete → argInject).
+  const argSpec = useMemo(
+    () => argSpecFor(bufferPeek, catalog),
+    [bufferPeek, catalog],
+  );
+  const [argList, setArgList] = useState([]);
+  useEffect(() => {
+    let cancelled = false;
+    if (argSpec && argSpec.kind === 'inline' && typeof onArgList === 'function') {
+      Promise.resolve(onArgList(bufferPeek))
+        .then((items) => { if (!cancelled) setArgList(Array.isArray(items) ? items : []); })
+        .catch(() => { if (!cancelled) setArgList([]); });
+    } else {
+      setArgList((prev) => (prev.length ? [] : prev));
+    }
+    return () => { cancelled = true; };
+  }, [bufferPeek, argSpec, onArgList]);
+  const argCompletable = !!argSpec && argSpec.kind === 'modal' && typeof onArgComplete === 'function';
+  const [argInject, setArgInject] = useState(null);
+  const argNonceRef = useRef(0);
+  const handleArgComplete = useCallback(async (buf) => {
+    if (typeof onArgComplete !== 'function') return;
+    let value = null;
+    try { value = await onArgComplete(buf); } catch { value = null; }
+    if (typeof value === 'string' && value) {
+      argNonceRef.current += 1;
+      setArgInject({ value, nonce: argNonceRef.current });
+    }
+  }, [onArgComplete]);
+
+  // Hide the command popup when the buffer already exactly matches the only
+  // remaining suggestion (so Enter submits /exit etc. instead of re-filling).
   const _bufTrimmed = bufferPeek.replace(/\s+$/, '');
   const _exactOnly =
     filtered.length === 1 &&
@@ -434,6 +465,9 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
         subtitle: opts.subtitle || '',
         items: Array.isArray(opts.items) ? opts.items : [],
         searchable: opts.searchable !== false,
+        // Carry the secret flag so a credential entry (api-key / token) masks
+        // the typed query — dropping it here echoed the secret in plaintext.
+        secret: !!opts.secret,
         resolve,
       });
     });
@@ -478,16 +512,34 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
   }, []);
   const modalOpen = !!modal;
 
-  // Slash popup is suppressed whenever a modal picker is active so the
-  // overlays don't stack, AND once the buffer has a space (the user is typing
-  // ARGS, e.g. `/orchestrator off`). Without the space guard the popup stayed
-  // open as a one-row hint and the editor treated Enter as "fill the matched
-  // command", which dropped the args and reverted the buffer to the bare
-  // command. With args, Enter must submit the full line instead.
-  const showSlashPopup =
+  // Command popup (no space) vs inline-arg popup (has space + an inline spec) —
+  // mutually exclusive via the space. Both feed the same Editor/SlashPopup
+  // machinery; slashFillMode tells the Editor which fill to apply (whole
+  // command vs the arg token). Modal-kind args show a hint instead (Tab opens
+  // the drill-in picker). Suppressed entirely while a modal picker is up.
+  const cmdPopup =
     !modalOpen &&
     bufferPeek.startsWith('/') && bufferPeek.indexOf(' ') < 0 &&
     filtered.length > 0 && !_exactOnly;
+  const argPopup = !modalOpen && !cmdPopup && !!argSpec && argSpec.kind === 'inline' && argList.length > 0;
+  const popupRows = cmdPopup
+    ? filtered
+    : argPopup
+      ? argList.map((i) => ({ cmd: i.value, help: i.desc || '' }))
+      : [];
+  const showSlashPopup = popupRows.length > 0;
+  const slashFillMode = argPopup ? 'arg' : 'command';
+  activeLenRef.current = popupRows.length;
+  // Reset / clamp the highlighted row when the active list changes.
+  const lastLenRef = useRef(0);
+  useEffect(() => {
+    if (popupRows.length !== lastLenRef.current) {
+      setSelectedSuggestion(0);
+      lastLenRef.current = popupRows.length;
+    } else if (selectedSuggestion >= popupRows.length) {
+      setSelectedSuggestion(Math.max(0, popupRows.length - 1));
+    }
+  }, [popupRows.length, selectedSuggestion]);
 
   // Outer column height: pinned to rows-1 in alt-buffer mode so the
   // Editor truly sticks to the bottom. Non-alt keeps content-sized layout
@@ -554,10 +606,21 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
       showSlashPopup
         ? React.createElement(SlashPopup, {
             buffer: bufferPeek,
-            commands: filtered,
+            commands: popupRows,
             selectedIndex: selectedSuggestion,
+            forceChooser: slashFillMode === 'arg',
           })
         : null,
+      // 3a) Modal-kind arg hint — for 2-step specs (/model, /trainer set,
+      //     /orchestrator planner) Tab opens the drill-in picker. Inline-kind
+      //     args render their candidates in the popup above instead.
+      (!showSlashPopup && argSpec && argSpec.kind === 'modal' && !modalOpen)
+        ? React.createElement(
+            Box,
+            { paddingX: 1, key: 'arghint' },
+            React.createElement(Text, { dimColor: true }, `↹ pick ${argSpec.name}`)
+          )
+        : null,
       // 3b) Modal picker (v5.4.3) — flex sibling above StatusBar, only
       //     visible while ReplApp's `modal` state is set. Suppresses the
       //     slash popup so the overlays don't stack.
@@ -569,6 +632,7 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
             selectedIndex: modalIdx,
             query: modalQuery,
             searchable: modal.searchable,
+            secret: modal.secret,
           })
         : null,
       // 4) Status bar (sticky, single row above input). flexShrink:0 so
@@ -579,6 +643,7 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
         streaming: state.streaming,
         ctxUsed: _status.ctxUsed,
         ctxTotal: _status.ctxTotal,
+        hud: _status.hud,
       }),
       // 5) Editor — sticky bottom, content-sized. Wrapped in a flexShrink:0
       //    Box so Yoga doesn't squeeze the input row when scrollback fills.
@@ -590,10 +655,19 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
           onSubmit: handleSubmit,
           onEscape: onEscapeKey,
           onBufferChange: handleBufferChange,
-          slashSuggestions: showSlashPopup ? filtered : null,
+          // v6.4 — 2-stage Ctrl+C wiring (active when exitOnCtrlC:false).
+          onInterrupt: onEscapeKey,
+          onExit: onExitKey,
+          slashSuggestions: showSlashPopup ? popupRows : null,
           slashSelectedIndex: selectedSuggestion,
+          slashFillMode,
           onSlashMove: handleSlashMove,
           onSlashDismiss: handleSlashDismiss,
+          // v6.x slash-argument completion (inline fills the token; modal kind
+          // uses argCompletable+onArgComplete to open the drill-in picker).
+          argCompletable,
+          onArgComplete: handleArgComplete,
+          argInject,
           // v5.4.3 — modal picker key contract. When modalOpen the
           // Editor swallows all keys (no buffer mutation, no submit).
           modalOpen,
@@ -640,20 +714,8 @@ export const ScrollbackItem = React.memo(function ScrollbackItem({ item }) {
   return React.createElement(Text, { color: theme.fg }, item.text);
 });
 
-// StatusBar — single row, provider · model · ctx · streaming indicator.
-// Kept intentionally minimal in v5.3; token gauges land separately once
-// usage metrics flow into state.
-export function StatusBar({ provider, model, streaming, ctxUsed, ctxTotal }) {
-  const ctx = (ctxUsed != null && ctxTotal != null) ? `${ctxUsed}/${ctxTotal}` : '--';
-  const indicator = streaming ? theme.accent('● streaming') : theme.dim('○ idle');
-  const prov = provider || '?';
-  const mdl = model || '?';
-  return React.createElement(
-    Box,
-    { flexShrink: 0, paddingX: 1 },
-    React.createElement(Text, null, `${indicator}  ${prov} · ${mdl}  ctx ${ctx}`)
-  );
-}
+// StatusBar moved to ./status_bar.mjs (re-exported above) so the HUD row can
+// grow without pushing repl.mjs over the file-size ratchet.
 
 // Exported for tests that want to verify the splash snapshot without a TTY.
 export function _renderSplashToString(splashProps) {

package/tui/repl_reset.mjs

@@ -0,0 +1,37 @@
+// tui/repl_reset.mjs — pure reducer for the `/new` conversation reset.
+//
+// Lives in its own file (not repl.mjs) only because repl.mjs is at its
+// file-size ceiling (scripts/lint-file-size.mjs). It is the scrollback-clearing
+// counterpart to the dispatcher's in-memory reset: /new wiped ctx.setMessages
+// but left the <Static/> scrollback intact, so the old conversation stayed on
+// screen. This empties the scrollback back to the splash item (the established
+// fresh-start look) and drops any in-flight / live-region state.
+
+export function onConversationReset(state) {
+  // Keep the splash header so a reset screen looks like a fresh launch, not a
+  // blank void. Everything else (user lines, assistant replies, live partial)
+  // is discarded.
+  const splash = state.scrollback.find((it) => it && it.kind === 'splash') || null;
+  return {
+    ...state,
+    streaming: false,
+    controller: null,
+    pendingPrepend: null,
+    nextTurnFirstMessage: null,
+    liveAssistant: '',
+    history: [],
+    scrollback: splash ? [splash] : [],
+  };
+}
+
+// Erase the terminal screen + scrollback buffer. Resetting the React scrollback
+// state alone cannot un-print Ink's <Static/> output (it is write-once and
+// append-only), so /new must also wipe the physical terminal. `\x1b[3J` drops
+// the scrollback buffer so the old conversation can't be scrolled back to.
+// `write` is the Ink-provided useStdout().write (clears the live frame first).
+export const CLEAR_TERMINAL = '\x1b[2J\x1b[3J\x1b[H';
+export function clearTerminalScreen(write) {
+  if (typeof write === 'function') {
+    try { write(CLEAR_TERMINAL); } catch { /* swallow — stdout may be closed */ }
+  }
+}

package/tui/run_turn.mjs

@@ -25,6 +25,160 @@
 // turn-completion logic (ReplApp onTurnComplete, legacy `rl.prompt`)
 // runs unconditionally.
 
+import { Chalk } from 'chalk';
+import { chatAgenticGet, chatPlanModeGet, effectiveChatTools } from '../config_features.mjs';
+import { defaultSandboxSpec } from '../sandbox/index.mjs';
+
+// Force ANSI on these turn-status markers regardless of stdout TTY detection:
+// the Ink path routes them through React state (Ink preserves embedded SGR
+// and decides display), and the legacy stdout path always targets a terminal
+// for chat. Without forcing, chalk's auto-level strips color under the
+// non-TTY test/pipe sink and the red error / dim abort marker vanish.
+const _statusChalk = new Chalk({ level: 1 });
+
+// Classify a provider/turn error into a one-line actionable hint (or '' when
+// none applies). Checked auth → model → network so one hint at most. Advisory
+// only — rendered dim under the red error line.
+function _errorHint(err) {
+  const msg = String(err?.message || err || '');
+  const status = err?.status;
+  const code = err?.code;
+  if (status === 401 || status === 403 || /\b(401|403|unauthorized|forbidden|invalid[ _-]?api[ _-]?key|authentication|no api key|missing api key)\b/i.test(msg)) {
+    return 'hint: set a key with /provider, or `lazyclaw auth add <provider>`';
+  }
+  if (status === 404 || /\b(404|model[ _-]?not[ _-]?found|no such model|unknown model|model .* does not exist|not_found_error)\b/i.test(msg)) {
+    return 'hint: run /model to pick a valid model';
+  }
+  if (code === 'ENOTFOUND' || code === 'ECONNREFUSED' || code === 'ETIMEDOUT' || code === 'ECONNRESET' || code === 'EAI_AGAIN'
+      || /\b(ENOTFOUND|ECONNREFUSED|ETIMEDOUT|ECONNRESET|EAI_AGAIN|network|fetch failed|socket hang up|getaddrinfo)\b/i.test(msg)) {
+    return 'hint: check your connection / base URL (/provider to review the endpoint)';
+  }
+  return '';
+}
+
+// Plan-mode addendum — instructs the model to propose, not mutate. Appended
+// to the synthetic chat agent's system prompt only while plan mode is ON.
+const PLAN_MODE_ADDENDUM = 'You are in PLAN mode. Propose a plan; do not mutate '
+  + 'anything. List the steps you would take and the tools you would use, then stop.';
+
+// Per-turn recall injection (roadmap #7). The streaming chat path sends a fixed
+// system prompt, so it never surfaced context relevant to THIS message (only the
+// agentic path, which rebuilds the prompt stack per turn, did). Prepend a fresh
+// recall layer to the CURRENT user message — not the system — because a warm
+// claude-cli persistent session fixes its system at spawn, and every provider
+// reads the user turn. Transient: returns a COPY for the send; the stored
+// session keeps the original message. recallLayer is injected (lazy-imported by
+// the caller) so better-sqlite3 stays off this module's static graph.
+export function _injectRecall(messages, cfgDir, recallLayerFn) {
+  try {
+    if (typeof recallLayerFn !== 'function' || !Array.isArray(messages)) return messages;
+    let idx = -1;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i] && messages[i].role === 'user') { idx = i; break; }
+    }
+    if (idx < 0) return messages;
+    const layer = recallLayerFn(cfgDir, String(messages[idx].content || ''), 5);
+    if (!layer || !String(layer).trim()) return messages;
+    return messages.map((m, i) => (i === idx ? { ...m, content: `${layer}\n\n${m.content}` } : m));
+  } catch { return messages; }
+}
+
+// Fire the post-task learning loop on every successful chat turn (v5 Group A
+// C1). Fire-and-forget via queueMicrotask so the next prompt is never blocked
+// on trajectory write / synth. Shared by the streaming and agentic paths.
+// Decide whether a chat turn is worth a learning pass. The hook otherwise
+// spawns TWO extra `claude` processes (skill synth + user-model) on EVERY turn,
+// tripling per-message spawns and competing with the user's next turn for the
+// subscription. Skip greetings/acks, trivially short exchanges, and empty
+// (aborted/failed) replies — none warrant a durable SKILL.md or a user model.
+export function _shouldLearn(messages) {
+  const last2 = (messages || []).slice(-2);
+  const user = String(last2.find((m) => m && m.role === 'user')?.content || '').trim();
+  const reply = String(last2.find((m) => m && m.role !== 'user')?.content || '').trim();
+  if (!reply) return false;
+  if ((user + ' ' + reply).trim().length < 280) return false;
+  if (/^(hi|hey|hello|yo|thanks|thank you|thx|ty|ok|okay|k|sure|nice|cool|got it|ㅇㅇ|ㄱㅅ|ㄳ|고마워|감사|안녕|넵|네)\b/i.test(user)) return false;
+  return true;
+}
+
+function _fireLearningHook(ctx, messages, activeProvName, activeModel, transcript) {
+  try {
+    if (!_shouldLearn(messages)) return;
+    queueMicrotask(() => {
+      import('../mas/learning.mjs').then((mod) => mod.runLearning('post-task', {
+        agent: { name: 'chat', provider: activeProvName, model: activeModel, role: '' },
+        task: {
+          id: ctx.getSessionId() || ctx.syntheticChatSessionId,
+          title: '(chat turn)',
+          turns: messages.slice(-2).map((m) => ({
+            agent: m.role === 'user' ? 'user' : 'chat',
+            text: m.content,
+            ts: new Date().toISOString(),
+          })),
+        },
+        configDir: ctx.cfgDir,
+        cfg: ctx.cfg,
+        transcript: String(transcript || '').slice(0, 8000),
+      })).catch(() => { /* learning loop is best-effort */ });
+    });
+  } catch { /* never let learning hook break the chat */ }
+}
+
+// Drive one agentic chat turn through the MAS tool loop. Builds the synthetic
+// chat agent record, renders compact tool-activity status lines + the final
+// answer into writeChunk, and returns the final assistant text. The approval
+// hook is taken from ctx.approve when present (Ink: _makeInkApprove, legacy:
+// makeReadlineApprove) — when absent the fail-closed gate in tool_runner.mjs
+// simply denies any sensitive tool (no silent ungated execution).
+async function _runAgenticTurn({ ctx, messages, sysMsg, activeProvName, activeModel, planMode, writeChunk, signal }) {
+  const runAgentTurn = ctx.runAgentTurnImpl
+    || (await import('../mas/agent_turn.mjs')).runAgentTurn;
+  const tools = effectiveChatTools(ctx.cfg, { planMode });
+  let role = (sysMsg && sysMsg.content) || '';
+  if (planMode) role = role ? `${role}\n\n${PLAN_MODE_ADDENDUM}` : PLAN_MODE_ADDENDUM;
+  const agent = { name: 'chat', provider: activeProvName, model: activeModel, role, tools };
+  // History excludes the just-pushed user message and the system slot (the
+  // latter is threaded via agent.role); runAgentTurn appends userMessage.
+  const history = messages
+    .slice(0, -1)
+    .filter((m) => m.role !== 'system')
+    .map((m) => ({ role: m.role, content: m.content }));
+  const userMessage = messages[messages.length - 1]?.content || '';
+  let result;
+  try {
+    result = await runAgentTurn({
+      agent, userMessage, history,
+      configDir: ctx.cfgDir,
+      apiKey: ctx.resolveAuthKey(activeProvName),
+      approve: ctx.approve,
+      security: ctx.cfg?.security,
+      // Default-on isolation: an explicit --sandbox spec wins; otherwise confine
+      // by default (cwd-confined fs, secrets blocked, net allowed). Opt out via
+      // cfg.sandbox.confine=false → defaultSandboxSpec returns null (bare).
+      sandbox: ctx.sandboxSpec || defaultSandboxSpec(ctx.cfg, { cwd: process.cwd(), configDir: ctx.cfgDir }),
+      cache: true,
+      usePromptStack: false,
+      signal,
+    });
+  } catch (err) {
+    // No silent catch — surface as a status line; return empty so the caller
+    // still completes the turn (persist + learning) without a half reply.
+    try { writeChunk(`· agentic turn failed: ${err?.message || String(err)}\n`); } catch { /* sink */ }
+    return '';
+  }
+  // Compact tool-activity status lines (dim, not the red provider-error style).
+  for (const c of (result.toolCalls || [])) {
+    const ok = c.ok ? '✓' : '⚠';
+    try { writeChunk(`· ${ok} ${c.name}\n`); } catch { /* sink */ }
+  }
+  if (result.stoppedBy === 'budget') {
+    try { writeChunk(`· stopped after ${result.iterations} tool step(s)\n`); } catch { /* sink */ }
+  }
+  const text = result.text || '';
+  if (text) { try { writeChunk(text); } catch { /* sink */ } }
+  return text;
+}
+
 /**
  * @typedef {Object} RunTurnCtx
  * @property {Object} cfg                                  Active config.
@@ -79,17 +233,72 @@ export function makeRunTurn({ ctx, writeFn }) {
       const prov = ctx.getProv();
       const activeProvName = ctx.getActiveProvName();
       const activeModel = ctx.getActiveModel();
+      // Group 1 — agentic REPL. When cfg.chat.agentic (or plan mode) is ON,
+      // route the turn through the MAS tool loop (runAgentTurn) instead of
+      // the streaming sendMessage path. Plan mode forces agentic-on for the
+      // turn (read-only). Everything else (persistTurn, the post-task
+      // learning hook below) is shared. When OFF — the default — the
+      // streaming path below runs UNCHANGED.
+      const planMode = chatPlanModeGet(ctx.cfg);
+      if (chatAgenticGet(ctx.cfg) || planMode) {
+        const acc2 = await _runAgenticTurn({
+          ctx, messages, sysMsg, activeProvName, activeModel, planMode,
+          writeChunk: _writeChunk, signal,
+        });
+        if (_writeTimer) clearTimeout(_writeTimer);
+        _flush();
+        try { writeFn('\n'); } catch { /* sink failure must not kill the turn */ }
+        messages.push({ role: 'assistant', content: acc2 });
+        ctx.persistTurn('assistant', acc2);
+        _fireLearningHook(ctx, messages, activeProvName, activeModel, acc2);
+        return;
+      }
+      // Configurable max-output-tokens (config.json `maxTokens`). Only
+      // thread it through when it's a positive finite number; otherwise
+      // leave opts.maxTokens unset so each provider's DEFAULT_MAX_TOKENS
+      // applies.
+      const cfgMaxTokens = ctx.cfg?.maxTokens;
+      const maxTokens = (typeof cfgMaxTokens === 'number' && Number.isFinite(cfgMaxTokens) && cfgMaxTokens > 0)
+        ? cfgMaxTokens
+        : undefined;
+      // Roadmap #7 — per-turn recall: surface context relevant to THIS message
+      // by prepending a fresh recall layer to the current user turn (off via
+      // cfg.chat.recall=false). Best-effort + lazy-imported so an empty/missing
+      // index never blocks a reply and better-sqlite3 stays off the static graph.
+      let sendMessages = messages;
+      if (ctx.cfg?.chat?.recall !== false) {
+        try {
+          const { recalledLayer } = await import('../mas/prompt_stack.mjs');
+          sendMessages = _injectRecall(messages, ctx.cfgDir, recalledLayer);
+        } catch { /* recall is best-effort — never block a turn */ }
+      }
       // C8 — prompt-cache the static system prefix. The Anthropic
       // provider prefers `systemStatic` when present; non-Anthropic
       // providers ignore the field and fall back to the legacy
       // single-block path with `cache:true`.
-      for await (const chunk of prov.sendMessage(messages, {
+      let truncated = false;
+      for await (const chunk of prov.sendMessage(sendMessages, {
         apiKey: ctx.resolveAuthKey(activeProvName),
         model: activeModel,
         sandbox: ctx.sandboxSpec,
         signal,
         onUsage: ctx.accumulateUsage,
+        // Streaming providers fire this when a turn hits the model's output-token
+        // limit (finish_reason 'length' / MAX_TOKENS / stop_reason 'max_tokens' /
+        // done_reason 'length'). Warn the user instead of presenting a truncated
+        // answer as complete, mirroring the agentic path (mas/agent_turn.mjs).
+        onTruncated: () => { truncated = true; },
         cache: true,
+        // Default-ON (set cfg.chat.persistentSession=false to disable): reuse one
+        // warm `claude` per conversation so the harness boots once, not every
+        // turn (measured ~1.2s/turn / ~42% faster after the cold first turn).
+        // claude-cli-only (other providers ignore it); the provider falls back to
+        // a one-shot spawn on any session failure, and the session respawns if
+        // the system prompt changes (plan-mode toggle) so it can't go stale.
+        persistent: ctx.cfg?.chat?.persistentSession !== false,
+        sessionKey: (ctx.getSessionId && ctx.getSessionId()) || ctx.syntheticChatSessionId,
+        ...(sysMsg ? { sessionSystem: sysMsg.content } : {}),
+        ...(maxTokens !== undefined ? { maxTokens } : {}),
         ...(sysMsg ? { systemStatic: sysMsg.content } : {}),
       })) {
         _writeChunk(chunk);
@@ -99,39 +308,32 @@ export function makeRunTurn({ ctx, writeFn }) {
       _flush();
       try { writeFn('\n'); }
       catch { /* sink failure must not kill the turn */ }
+      if (truncated) {
+        try { writeFn('[truncated — the model hit its output-token limit; raise maxTokens]\n'); }
+        catch { /* sink failure must not kill the turn */ }
+      }
       messages.push({ role: 'assistant', content: acc });
       ctx.persistTurn('assistant', acc);
-      // v5 Group A (C1): close the post-task learning loop on every
-      // successful chat turn. Fire-and-forget via queueMicrotask so the
-      // next prompt is never blocked on trajectory write / synth.
-      try {
-        queueMicrotask(() => {
-          import('../mas/learning.mjs').then((mod) => mod.runLearning('post-task', {
-            agent: { name: 'chat', provider: activeProvName, model: activeModel, role: '' },
-            task: {
-              id: ctx.getSessionId() || ctx.syntheticChatSessionId,
-              title: '(chat turn)',
-              turns: messages.slice(-2).map((m) => ({
-                agent: m.role === 'user' ? 'user' : 'chat',
-                text: m.content,
-                ts: new Date().toISOString(),
-              })),
-            },
-            configDir: ctx.cfgDir,
-            cfg: ctx.cfg,
-            transcript: acc.slice(0, 8000),
-          })).catch(() => { /* learning loop is best-effort */ });
-        });
-      } catch { /* never let learning hook break the chat */ }
+      _fireLearningHook(ctx, messages, activeProvName, activeModel, acc);
     } catch (err) {
       if (_writeTimer) clearTimeout(_writeTimer);
       _flush();
       // ABORT errors are user-initiated; drop the partial reply (don't
       // push an incomplete assistant message — next turn would treat
-      // it as a complete reply and confuse the model).
-      if (err?.code !== 'ABORT' && !signal?.aborted) {
-        try { writeFn(`error: ${err?.message || String(err)}\n`); }
+      // it as a complete reply and confuse the model). Emit a visible dim
+      // [aborted] marker so the output doesn't just silently stop (the
+      // host onTurnComplete sees reason:'done' because we swallow ABORT).
+      if (err?.code === 'ABORT' || signal?.aborted) {
+        try { writeFn(`${_statusChalk.dim('[aborted]')}\n`); }
+        catch { /* sink failure must not kill the turn */ }
+      } else {
+        // Provider errors render in the red error style (not normal amber
+        // assistant text — the audit gap). The red SGR is embedded so the
+        // Ink scrollback <Text> preserves it and the legacy stdout path shows it.
+        try { writeFn(`${_statusChalk.red(`error: ${err?.message || String(err)}`)}\n`); }
         catch { /* sink failure must not mask err */ }
+        const _hint = _errorHint(err);
+        if (_hint) { try { writeFn(`${_statusChalk.dim(_hint)}\n`); } catch { /* sink */ } }
       }
     }
   };