march-cli 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "march-cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "March CLI — terminal-native coding agent with context reconstruction",
   "type": "module",
   "main": "./src/main.mjs",
@@ -19,6 +19,7 @@
     "test:shell-tui-real": "node test/shell-tui-real.acceptance.mjs",
     "test:tui-key-real": "node test/tui-key-real.acceptance.mjs",
     "context": "cd .. && node march-cli/bin/march.mjs --dump-context",
+    "notify:experiment": "node scripts/notify-experiment.mjs",
     "publish:env": "node scripts/npm-publish-from-env.mjs"
   },
   "dependencies": {
@@ -28,6 +29,7 @@
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@xterm/headless": "^5.5.0",
     "marked": "^18.0.3",
+    "node-notifier": "^10.0.1",
     "node-pty": "^1.1.0",
     "typebox": "^1.0.58",
     "web-tree-sitter": "^0.26.8"

package/src/agent/runner.mjs

@@ -9,7 +9,7 @@ import { createMarchLifecycleAdapter } from "../extensions/lifecycle-adapter.mjs
 import { syncPiSessionSidecar } from "../session/sidecar-sync.mjs";
 import { LspService } from "../lsp/service.mjs";
 import { formatRecallHints } from "../memory/markdown-store.mjs";
-import { appendProviderUserMessage, installModelPayloadDumper, replaceProviderContextMessages } from "./model-payload-dumper.mjs";
+import { appendProviderUserMessage, estimateProviderPayloadTokens, installModelPayloadDumper, replaceProviderContextMessages } from "./model-payload-dumper.mjs";
 import { resolveInitialModel, resolveRunnerSessionManager } from "./runner/runner-init.mjs";
 import { runRunnerCleanup } from "./runner/runner-cleanup.mjs";
 import { createRunnerRuntimeHost } from "./runtime/runner-runtime-host.mjs";
@@ -18,7 +18,7 @@ import { resolveRunnerSessionOptions } from "./session/session-options.mjs";
 import { createSessionBinding } from "./session/session-binding.mjs";
 import { maybeAutoNameSession } from "./session/session-auto-name.mjs";
 import { MARCH_BASE_TOOL_NAMES } from "./tool-names.mjs";
-import { runRunnerTurn } from "./turn/turn-runner.mjs";
+import { isModelStreamIdleTimeoutError, runRunnerTurn } from "./turn/turn-runner.mjs";
 import { appendFastVariants, createFastModelEntry, fromFastEntryModel, isFastProvider } from "./runner/fast-model.mjs";
 import { registerSuperGrokProvider } from "../supergrok/provider.mjs";
 
@@ -27,7 +27,7 @@ export { installModelPayloadDumper } from "./model-payload-dumper.mjs";
 export { createDefaultSessionManager, resolveRunnerSessionManager } from "./runner/runner-init.mjs";
 export { getRunnerSessionStats, syncEngineSessionState } from "./runner/runner-session-state.mjs";
 
-export async function createRunner({ cwd, modelId = null, provider = null, providers = {}, stateRoot, ui, memoryRoot = null, memoryStore = null, memoryTools = [], shellRuntime = null, mcpTools = [], mcpInjections = [], mcpClientManager = null, webTools = [], namespace = "", sessionManager = null, useRuntimeHost = false, projectMarchDir = null, syncPiSidecar = false, extensionPaths = [], lifecycleHooks = [], lifecycleDiagnostics = [], authStorage = null, permissionController = null, modelContextDumper = null, turnNotifier = null, onModelPayload = null, createAgentSessionImpl = createAgentSession, createAgentSessionRuntimeImpl, createRuntimeServices, createRuntimeSessionFromServices, maxTurns, trimBatch, serviceTier = null }) {
+export async function createRunner({ cwd, modelId = null, provider = null, providers = {}, stateRoot, ui, memoryRoot = null, centerMemoryPath = null, memoryStore = null, memoryTools = [], shellRuntime = null, mcpTools = [], mcpInjections = [], mcpClientManager = null, webTools = [], namespace = "", sessionManager = null, useRuntimeHost = false, projectMarchDir = null, syncPiSidecar = false, extensionPaths = [], lifecycleHooks = [], lifecycleDiagnostics = [], authStorage = null, permissionController = null, modelContextDumper = null, turnNotifier = null, onModelPayload = null, createAgentSessionImpl = createAgentSession, createAgentSessionRuntimeImpl, createRuntimeServices, createRuntimeSessionFromServices, maxTurns, trimBatch, serviceTier = null, modelStreamIdleTimeoutMs = 7000, modelStreamIdleMaxRetries = 5 }) {
   if (!useRuntimeHost && extensionPaths.length > 0) {
     throw new Error("--extension requires the default pi runtime host path");
   }
@@ -47,7 +47,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
     retry: { enabled: true, maxRetries: 3, baseDelayMs: 2000 },
   });
   const lspService = new LspService({ cwd });
-  const engine = new ContextEngine({ cwd, modelId, provider, namespace, memoryRoot, shellRuntime, lspService, injections: mcpInjections, maxTurns, trimBatch });
+  const engine = new ContextEngine({ cwd, modelId, provider, namespace, memoryRoot, centerMemoryPath, shellRuntime, lspService, injections: mcpInjections, maxTurns, trimBatch });
   const resolvedSessionManager = resolveRunnerSessionManager(cwd, sessionManager);
   const sessionBinding = createSessionBinding(null);
   let currentModelCallKind = "model";
@@ -55,6 +55,7 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
   let currentTurnContextMode = "rebuild";
   let nextTurnContextMode = "rebuild";
   let pendingMidTurnRecallHints = [];
+  let lastNotificationResult = null;
   let runtimeHost = null;
   let lifecycleAdapter = null;
   let _currentFastEntry = null;
@@ -109,9 +110,10 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       currentTurnContextMode = contextMode;
       nextTurnContextMode = "rebuild";
       pendingMidTurnRecallHints = [];
+      const turnStartedAt = Date.now();
       try {
         const result = await runRunnerTurn({
-          prompt, userMessage, options: { userRecallHints, currentProject },
+          prompt, userMessage, options: { userRecallHints, currentProject, modelStreamIdleTimeoutMs, modelStreamIdleMaxRetries },
           sessionBinding, engine, ui, projectMarchDir, memoryStore,
           setModelCallKind: (kind) => { currentModelCallKind = kind; },
           onMidTurnRecallHints: (hints) => { pendingMidTurnRecallHints.push(...hints); },
@@ -119,17 +121,22 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
           autoNameSession,
           contextMode,
         });
-        await notifyTurnEndBestEffort(turnNotifier, {
+        lastNotificationResult = await notifyTurnEndBestEffort(turnNotifier, {
           status: "success",
           sessionName: engine.sessionName,
           draft: result?.draft ?? "",
+          durationMs: Date.now() - turnStartedAt,
         });
         return result;
       } catch (err) {
-        await notifyTurnEndBestEffort(turnNotifier, {
+        if (isModelStreamIdleTimeoutError(err)) {
+          nextTurnContextMode = "continueExistingPiTranscript";
+        }
+        lastNotificationResult = await notifyTurnEndBestEffort(turnNotifier, {
           status: "error",
           sessionName: engine.sessionName,
           errorMessage: err?.message ?? String(err),
+          durationMs: Date.now() - turnStartedAt,
         });
         throw err;
       } finally {
@@ -176,6 +183,20 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
       return [...new Set([...configured, ...available])];
     },
     getSessionStats() { return getRunnerSessionStats(sessionBinding.get(), runtimeHost); },
+    getLastNotificationResult() { return lastNotificationResult; },
+    async notifyTest({ title = "March", message = "If you see this, March runtime notifications work." } = {}) {
+      lastNotificationResult = await notifyTurnEndBestEffort(turnNotifier, {
+        status: "success",
+        sessionName: engine.sessionName,
+        title,
+        message,
+        durationMs: 0,
+      });
+      return lastNotificationResult;
+    },
+    estimateContextTokens(userMessage = "") {
+      return estimateProviderPayloadTokens(providerContextToPayload(engine.buildProviderContext(userMessage)));
+    },
     setSessionName(name) {
       const activeSession = sessionBinding.get();
       activeSession.setSessionName?.(name);
@@ -256,11 +277,21 @@ export async function createRunner({ cwd, modelId = null, provider = null, provi
   }
 }
 
+function providerContextToPayload(providerContext) {
+  return {
+    messages: [
+      { role: "system", content: providerContext.system },
+      ...(providerContext.userMessages ?? []).map((message) => ({ role: "user", content: message.content })),
+    ],
+  };
+}
+
 async function notifyTurnEndBestEffort(turnNotifier, event) {
-  if (!turnNotifier?.notifyTurnEnd) return;
+  if (!turnNotifier?.notifyTurnEnd) return { ok: false, reason: "not-configured", results: [] };
   try {
-    await turnNotifier.notifyTurnEnd(event);
-  } catch {
+    return await turnNotifier.notifyTurnEnd(event);
+  } catch (err) {
     // Notification must never change turn behavior.
+    return { ok: false, reason: err?.message ?? String(err), results: [] };
   }
 }

package/src/agent/turn/turn-runner.mjs

@@ -1,6 +1,10 @@
 import { resolveImageAttachmentReferences } from "../../session/attachment-references.mjs";
 import { closeAssistantReply, createTurnEventState, handleRunnerSessionEvent } from "./turn-events.mjs";
 
+export function isModelStreamIdleTimeoutError(err) {
+  return err?.code === "MODEL_STREAM_IDLE_TIMEOUT";
+}
+
 export async function runRunnerTurn({
   prompt,
   userMessage,
@@ -16,19 +20,31 @@ export async function runRunnerTurn({
   autoNameSession,
   contextMode = "rebuild",
 }) {
-  const { userRecallHints = [], currentProject = "" } = options;
+  const {
+    userRecallHints = [],
+    currentProject = "",
+    modelStreamIdleTimeoutMs = 7000,
+    modelStreamIdleMaxRetries = 5,
+  } = options;
   const activeSession = sessionBinding.get();
   const turnState = createTurnEventState();
   const midTurnRecallHints = [];
+  const modelIdleWatchdog = createModelStreamIdleWatchdog({
+    session: activeSession,
+    ui,
+    timeoutMs: modelStreamIdleTimeoutMs,
+  });
   ui.turnStart();
 
   const unsubscribe = activeSession.subscribe((event) => {
+    modelIdleWatchdog.handleEvent(event);
     handleRunnerSessionEvent(event, { ui, engine, state: turnState });
     if (event.type === "tool_execution_start") {
       const hints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
       if (hints.length > 0) {
         midTurnRecallHints.push(...hints);
         onMidTurnRecallHints?.(hints);
+        ui.memoryHint?.({ source: "assistant", hints });
       }
     }
   });
@@ -40,29 +56,48 @@ export async function runRunnerTurn({
     });
     setModelCallKind("user");
     try {
-      if (contextMode === "rebuild") resetPiMessageHistory(activeSession);
-      await activeSession.prompt(
-        contextMode === "continueExistingPiTranscript" ? (userMessage ?? prompt) : prompt,
-        attachmentReferences.images.length > 0 ? { images: attachmentReferences.images } : undefined,
-      );
+      await promptWithModelIdleRetry({
+        session: activeSession,
+        prompt: contextMode === "continueExistingPiTranscript" ? (userMessage ?? prompt) : prompt,
+        promptOptions: attachmentReferences.images.length > 0 ? { images: attachmentReferences.images } : undefined,
+        resetBeforeAttempt: contextMode === "rebuild",
+        maxRetries: modelStreamIdleMaxRetries,
+        watchdog: modelIdleWatchdog,
+      });
+    } catch (err) {
+      if (!isModelStreamIdleTimeoutError(err)) throw err;
+      finalizeTurn({
+        prompt,
+        userMessage,
+        userRecallHints,
+        currentProject,
+        memoryStore,
+        engine,
+        ui,
+        turnState,
+        midTurnRecallHints,
+        syncCurrentPiSidecar,
+        autoNameSession,
+      });
+      throw err;
     } finally {
+      modelIdleWatchdog.stop();
       setModelCallKind("model");
     }
 
-    closeAssistantReply({ ui, state: turnState });
-    const assistantRecallHints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
-    const recordedAssistantRecallHints = uniqueHints([...midTurnRecallHints, ...assistantRecallHints]);
-    ui.memoryHint?.({ source: "assistant", hints: recordedAssistantRecallHints });
-
-    engine.recordTurn({
-      userMessage: userMessage ?? prompt.slice(0, 300),
-      assistantMessage: turnState.draft,
+    finalizeTurn({
+      prompt,
+      userMessage,
       userRecallHints,
-      assistantRecallHints: recordedAssistantRecallHints,
+      currentProject,
+      memoryStore,
+      engine,
+      ui,
+      turnState,
+      midTurnRecallHints,
+      syncCurrentPiSidecar,
+      autoNameSession,
     });
-
-    autoNameSession?.();
-    syncCurrentPiSidecar();
     return { draft: turnState.draft };
   } finally {
     ui.turnEnd();
@@ -70,6 +105,144 @@ export async function runRunnerTurn({
   }
 }
 
+async function promptWithModelIdleRetry({ session, prompt, promptOptions, resetBeforeAttempt, maxRetries, watchdog }) {
+  let attempt = 0;
+  while (true) {
+    attempt += 1;
+    if (resetBeforeAttempt) resetPiMessageHistory(session);
+    const messageHistorySnapshot = clonePiMessageHistory(session);
+    watchdog.startAttempt({ attempt, maxAttempts: maxRetries + 1 });
+    let idleTimedOut = false;
+    try {
+      await session.prompt(prompt, promptOptions);
+      idleTimedOut = watchdog.consumeTimedOut();
+      if (!idleTimedOut) {
+        if (attempt > 1) watchdog.reportRecovered({ attempt: attempt - 1 });
+        return;
+      }
+    } catch (err) {
+      idleTimedOut = watchdog.consumeTimedOut();
+      if (!idleTimedOut) throw err;
+    } finally {
+      watchdog.stop();
+    }
+
+    if (attempt > maxRetries) {
+      const err = createModelStreamIdleTimeoutError(watchdog.timeoutMs);
+      watchdog.reportExhausted({ attempt, error: err });
+      throw err;
+    }
+    restorePiMessageHistory(session, messageHistorySnapshot);
+    watchdog.reportRetry({ attempt, maxAttempts: maxRetries + 1 });
+  }
+}
+
+function finalizeTurn({ prompt, userMessage, userRecallHints, currentProject, memoryStore, engine, ui, turnState, midTurnRecallHints, syncCurrentPiSidecar, autoNameSession }) {
+  closeAssistantReply({ ui, state: turnState });
+  const assistantRecallHints = flushAssistantRecall({ memoryStore, engine, turnState, currentProject });
+  engine.setPendingAssistantRecallHints?.(assistantRecallHints);
+  const recordedAssistantRecallHints = uniqueHints([...midTurnRecallHints, ...assistantRecallHints]);
+
+  engine.recordTurn({
+    userMessage: userMessage ?? prompt.slice(0, 300),
+    assistantMessage: turnState.draft,
+    userRecallHints,
+    assistantRecallHints: recordedAssistantRecallHints,
+  });
+
+  autoNameSession?.();
+  syncCurrentPiSidecar();
+}
+
+function createModelStreamIdleTimeoutError(timeoutMs) {
+  const err = new Error(`Model stream idle for ${timeoutMs}ms`);
+  err.code = "MODEL_STREAM_IDLE_TIMEOUT";
+  return err;
+}
+
+function createModelStreamIdleWatchdog({ session, ui, timeoutMs }) {
+  let timer = null;
+  let active = false;
+  let inTool = false;
+  let timedOut = false;
+
+  return {
+    timeoutMs,
+    startAttempt() {
+      timedOut = false;
+      inTool = false;
+      active = true;
+      arm();
+    },
+    handleEvent(event) {
+      if (!active || timedOut) return;
+      if (event.type === "tool_execution_start") {
+        inTool = true;
+        clear();
+        return;
+      }
+      if (event.type === "tool_execution_end") {
+        inTool = false;
+        arm();
+        return;
+      }
+      if (event.type === "message_update") arm();
+    },
+    stop() {
+      active = false;
+      clear();
+    },
+    consumeTimedOut() {
+      const value = timedOut;
+      timedOut = false;
+      return value;
+    },
+    reportRetry({ attempt, maxAttempts }) {
+      ui.retryStart?.({
+        attempt,
+        maxAttempts,
+        delayMs: 0,
+        errorMessage: `Model stream idle for ${timeoutMs}ms; retrying request`,
+      });
+    },
+    reportRecovered({ attempt }) {
+      ui.retryEnd?.({ success: true, attempt });
+    },
+    reportExhausted({ attempt, error }) {
+      ui.retryEnd?.({ success: false, attempt, finalError: error.message });
+    },
+  };
+
+  function arm() {
+    clear();
+    if (!active || inTool || timeoutMs <= 0) return;
+    timer = setTimeout(() => {
+      timedOut = true;
+      active = false;
+      clear();
+      session.abortRetry?.();
+      session.abort();
+    }, timeoutMs);
+  }
+
+  function clear() {
+    if (!timer) return;
+    clearTimeout(timer);
+    timer = null;
+  }
+}
+
+function clonePiMessageHistory(session) {
+  const messages = session?.agent?.state?.messages;
+  if (!Array.isArray(messages)) return null;
+  return JSON.parse(JSON.stringify(messages));
+}
+
+function restorePiMessageHistory(session, messages) {
+  if (!Array.isArray(session?.agent?.state?.messages) || !Array.isArray(messages)) return;
+  session.agent.state.messages = JSON.parse(JSON.stringify(messages));
+}
+
 function flushAssistantRecall({ memoryStore, engine, turnState, currentProject }) {
   if (!memoryStore) return [];
   const text = assistantRecallDeltaText(turnState);

package/src/cli/repl-loop.mjs

@@ -18,16 +18,21 @@ export async function runSingleShotPrompt({
   modeState = null,
 }) {
   memoryStore.beginTurn();
+  const carryoverAlreadyRendered = runner.engine.hasRenderedPendingAssistantRecallHints?.() ?? false;
+  const carryoverRecallHints = runner.engine.takePendingAssistantRecallHints?.() ?? [];
   const userRecallHints = memoryStore.recallForUser(prompt, { currentProject, excludedIds: runner.engine.getRecentRecallMemoryIds?.() ?? [] });
   const recallBlock = formatRecallHints("user", userRecallHints);
+  const carryoverRecallBlock = formatRecallHints("assistant", carryoverRecallHints);
   const shellHints = formatShellHints(runner.shellRuntime);
   const modePrompt = appendModeReminder(prompt, modeState?.get?.());
-  const fullPrompt = appendPromptBlocks(modePrompt, recallBlock, shellHints);
+  const fullPrompt = appendPromptBlocks(modePrompt, recallBlock, carryoverRecallBlock, shellHints);
   ui.writeln(formatUserDisplayMessage(prompt));
   ui.memoryHint?.({ source: "user", hints: userRecallHints });
+  if (carryoverRecallHints.length > 0 && !carryoverAlreadyRendered) ui.memoryHint?.({ source: "assistant", hints: carryoverRecallHints });
   refreshStatusBar.startWorking?.();
   try {
     await runner.runTurn(fullPrompt, prompt, { userRecallHints, currentProject });
+    renderPendingAssistantRecallPreview({ runner, ui });
   } finally {
     refreshStatusBar.stopWorking?.();
     memoryStore.endTurn();
@@ -87,7 +92,7 @@ export async function runInteractiveRepl({
     });
     if (slashResult.exit) break;
     if (slashResult.handled) {
-      refreshStatusBar();
+      refreshStatusBar(contextTokenRefreshOptions(slashResult, runner));
       continue;
     }
 
@@ -111,6 +116,12 @@ export async function runInteractiveRepl({
   }
 }
 
+export function contextTokenRefreshOptions(slashResult, runner) {
+  if (!slashResult?.refreshContextTokens) return undefined;
+  if (typeof runner.estimateContextTokens !== "function") return undefined;
+  return { contextTokens: runner.estimateContextTokens("") };
+}
+
 function handleInlineCommand(trimmed, { cwd, ui, lastInlineShellCommand }) {
   const inlineShell = parseInlineShellInput(trimmed, lastInlineShellCommand);
   if (inlineShell.type === "error") {
@@ -126,17 +137,22 @@ function handleInlineCommand(trimmed, { cwd, ui, lastInlineShellCommand }) {
 
 async function runReplTurn({ prompt, args, runner, memoryStore, currentProject, ui, refreshStatusBar, setTurnRunning, modeState = null }) {
   memoryStore.beginTurn();
+  const carryoverAlreadyRendered = runner.engine.hasRenderedPendingAssistantRecallHints?.() ?? false;
+  const carryoverRecallHints = runner.engine.takePendingAssistantRecallHints?.() ?? [];
   const userRecallHints = memoryStore.recallForUser(prompt, { currentProject, excludedIds: runner.engine.getRecentRecallMemoryIds?.() ?? [] });
   const recallBlock = formatRecallHints("user", userRecallHints);
+  const carryoverRecallBlock = formatRecallHints("assistant", carryoverRecallHints);
   const shellHints = formatShellHints(runner.shellRuntime);
   const modePrompt = appendModeReminder(prompt, modeState?.get?.());
-  const fullPrompt = appendPromptBlocks(modePrompt, recallBlock, shellHints);
+  const fullPrompt = appendPromptBlocks(modePrompt, recallBlock, carryoverRecallBlock, shellHints);
   try {
     ui.writeln(formatUserDisplayMessage(prompt));
     ui.memoryHint?.({ source: "user", hints: userRecallHints });
+    if (carryoverRecallHints.length > 0 && !carryoverAlreadyRendered) ui.memoryHint?.({ source: "assistant", hints: carryoverRecallHints });
     setTurnRunning(true);
     refreshStatusBar.startWorking?.();
     await runner.runTurn(fullPrompt, prompt, { userRecallHints, currentProject });
+    renderPendingAssistantRecallPreview({ runner, ui });
     ui.writeln("");
   } catch (err) {
     ui.writeln(`Error: ${err.message}`);
@@ -155,3 +171,11 @@ export function formatUserDisplayMessage(prompt) {
 function appendPromptBlocks(prompt, ...blocks) {
   return [prompt, ...blocks.filter(Boolean)].join("\n\n");
 }
+
+function renderPendingAssistantRecallPreview({ runner, ui }) {
+  if (runner.engine.hasRenderedPendingAssistantRecallHints?.()) return;
+  const hints = runner.engine.peekPendingAssistantRecallHints?.() ?? [];
+  if (hints.length === 0) return;
+  ui.memoryHint?.({ source: "assistant", hints });
+  runner.engine.markPendingAssistantRecallHintsRendered?.();
+}

package/src/cli/slash-commands.mjs

@@ -40,11 +40,13 @@ export async function handleSlashCommand(trimmed, {
       ui.writeln("Error: pi runtime host is not enabled");
       return { handled: true };
     }
+    let refreshContextTokens = false;
     try {
       const result = await runner.startNewSession();
       if (result?.cancelled) {
         ui.writeln("New session cancelled");
       } else {
+        refreshContextTokens = true;
         ui.clearOutput?.();
         const bannerLines = typeof renderStartupBanner === "function" ? renderStartupBanner() : [];
         if (bannerLines.length > 0) {
@@ -56,7 +58,7 @@ export async function handleSlashCommand(trimmed, {
     } catch (err) {
       ui.writeln(`Error: ${err.message}`);
     }
-    return { handled: true };
+    return { handled: true, refreshContextTokens };
   }
 
   if (trimmed === "/help") {
@@ -120,6 +122,12 @@ export async function handleSlashCommand(trimmed, {
     return { handled: true };
   }
 
+  if (trimmed === "/notify") {
+    const result = await runner.notifyTest?.();
+    ui.writeln(formatNotificationResult(result));
+    return { handled: true };
+  }
+
   const shellCommand = parseShellCommand(trimmed);
   if (shellCommand.type !== "none") {
     for (const line of handleShellCommand(shellCommand, { shellRuntime: runner.shellRuntime })) ui.writeln(line);
@@ -174,3 +182,11 @@ export async function handleSlashCommand(trimmed, {
 
   return { handled: false };
 }
+
+function formatNotificationResult(result) {
+  if (!result) return "notification: unavailable";
+  const channels = (result.results ?? [])
+    .map((entry) => `${entry.channel}:${entry.ok ? "ok" : entry.reason ?? "failed"}`)
+    .join(", ");
+  return `notification: ${result.ok ? "ok" : result.reason ?? "failed"}${channels ? ` (${channels})` : ""}`;
+}

package/src/cli/tui/input/mouse-selection-controller.mjs

@@ -1,6 +1,8 @@
 import { parseMouseEvent } from "./mouse-tracking.mjs";
 import { brightBlack } from "../ui-theme.mjs";
 
+const OUTPUT_WHEEL_SCROLL_LINES = 3;
+
 export function createMouseSelectionController({
   terminal,
   output,
@@ -49,7 +51,7 @@ export function createMouseSelectionController({
         if (shellDrawer.isVisible?.() && mouse.col > Math.floor((terminal.columns || 80) * 0.64)) {
           shellDrawerControls.scroll(mouse.delta);
         } else {
-          output.scroll(mouse.delta);
+          output.scroll(mouse.delta, { step: OUTPUT_WHEEL_SCROLL_LINES });
         }
         requestRender();
         return { consume: true };

package/src/cli/tui/markdown-renderer.mjs

@@ -167,6 +167,12 @@ function appendWrappedRuns(lines, runs, width, indent = 0, firstPrefix = null) {
   const maxWidth = Math.max(1, width);
   for (const run of runs) {
     for (const ch of run.text) {
+      if (ch === "\n") {
+        lines.push(current);
+        current = restPrefix;
+        currentWidth = visibleWidth(restPrefix);
+        continue;
+      }
       const charWidth = visibleWidth(ch);
       if (currentWidth + charWidth > maxWidth && currentWidth > visibleWidth(stripAnsi(prefix))) {
         lines.push(current);

package/src/cli/tui/output/scroll-state.mjs

@@ -17,11 +17,11 @@ export class OutputScrollState {
     this.totalLines = Math.max(0, Math.trunc(total));
   }
 
-  scroll(delta) {
+  scroll(delta, { step = this.getStep() } = {}) {
     const total = this.totalLines;
     const win = this._windowHeight();
     const maxOffset = this.getMaxOffset();
-    const step = this.getStep();
+    step = Math.max(1, Math.trunc(step));
     const currentStart = this.anchorStart ?? Math.max(0, total - this.offset - win);
     const maxStart = Math.max(0, total - win);
     const nextStart = clamp(currentStart + (delta < 0 ? -step : step), 0, maxStart);

package/src/cli/tui/output/text-line-renderer.mjs

@@ -0,0 +1,50 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+import { R } from "../ui-theme.mjs";
+
+export function appendTextLines(lines, textLines, width) {
+  for (const line of textLines) {
+    for (const part of String(line ?? "").split(/\r?\n/)) {
+      for (const wrapped of wrapLine(part, width)) lines.push(wrapped);
+    }
+  }
+}
+
+export function wrapLine(text, maxWidth) {
+  if (maxWidth <= 0) return [""];
+  const result = [];
+  let cur = "";
+  let curW = 0;
+  let activeSgr = "";
+  for (let i = 0; i < text.length;) {
+    if (text[i] === "\x1b") {
+      const match = text.slice(i).match(/^\x1b\[[0-?]*[ -/]*[@-~]/);
+      if (match) {
+        const seq = match[0];
+        cur += seq;
+        activeSgr = updateActiveSgr(activeSgr, seq);
+        i += seq.length;
+        continue;
+      }
+    }
+    const ch = text[i];
+    const w = visibleWidth(ch);
+    if (curW + w > maxWidth) {
+      result.push(activeSgr ? `${cur}${R}` : cur);
+      cur = activeSgr + ch;
+      curW = w;
+    } else {
+      cur += ch;
+      curW += w;
+    }
+    i += 1;
+  }
+  if (cur) result.push(cur);
+  return result.length > 0 ? result : [""];
+}
+
+function updateActiveSgr(activeSgr, seq) {
+  if (!seq.endsWith("m")) return activeSgr;
+  const body = seq.slice(2, -1);
+  if (body === "" || body.split(";").includes("0")) return "";
+  return seq;
+}