mixdog 0.9.1 → 0.9.3

package/src/runtime/shared/llm/http-agent.mjs

@@ -19,7 +19,14 @@
  * so a shared long-lived pool is appropriate here.
  */
 
-import { Agent, getGlobalDispatcher, setGlobalDispatcher, request as undiciRequest } from 'undici'
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+let _undici = null
+function undici() {
+  if (!_undici) _undici = require('undici')
+  return _undici
+}
 
 let _agent = null
 let _globalInstalled = false
@@ -53,7 +60,7 @@ function proxyConfigured() {
   if (env.HTTP_PROXY || env.HTTPS_PROXY || env.http_proxy || env.https_proxy) return true
   if (env.NODE_USE_ENV_PROXY) return true
   try {
-    const g = getGlobalDispatcher?.()
+    const g = undici().getGlobalDispatcher?.()
     // Any non-default global dispatcher (constructor name other than the plain
     // `Agent` undici installs by default) is treated as custom — ProxyAgent,
     // EnvHttpProxyAgent, MockAgent, or a user subclass — and we step aside.
@@ -77,7 +84,7 @@ function proxyConfigured() {
 export function getLlmDispatcher() {
   if (proxyConfigured()) return undefined
   if (!_agent) {
-    _agent = new Agent({
+    _agent = new (undici().Agent)({
       keepAliveTimeout: envInt('MIXDOG_LLM_KEEPALIVE_MS', 60_000),
       keepAliveMaxTimeout: envInt('MIXDOG_LLM_KEEPALIVE_MAX_MS', 90_000),
       connections: envInt('MIXDOG_LLM_CONNECTIONS', 16),
@@ -87,7 +94,7 @@ export function getLlmDispatcher() {
   // a per-request dispatcher throws UND_ERR_INVALID_ARG. Install globally once
   // and omit the per-request dispatcher. See port-plan D7.
   if (!_globalInstalled) {
-    try { setGlobalDispatcher(_agent); _globalInstalled = true } catch { /* fall back */ }
+    try { undici().setGlobalDispatcher(_agent); _globalInstalled = true } catch { /* fall back */ }
   }
   return _globalInstalled ? undefined : _agent
 }
@@ -130,7 +137,7 @@ export function preconnect(origin) {
     // A throwaway HEAD lands a pooled socket without fetching a body. Any
     // failure (offline, DNS, 4xx/5xx) is irrelevant — the handshake is the
     // point, and the real request will surface genuine errors.
-    undiciRequest(key, {
+    undici().request(key, {
       method: 'HEAD',
       dispatcher: getLlmDispatcher(),
       signal: AbortSignal.timeout(10_000),

package/src/runtime/shared/schedules-store.mjs

@@ -2,32 +2,29 @@
  * Canonical reader for registered schedules.
  *
  * `<Mixdog data dir>/schedules/<name>/` is the single source of truth.
- * Each schedule directory contains `config.json` (metadata) and
- * `instructions.md` (prompt body). Both the setup UI (POST /schedules)
- * and the `schedule-add` skill write the same two files; every reader —
+ * Each schedule directory contains a single `SCHEDULE.md` — YAML-ish
+ * frontmatter (metadata: time/timezone/days/channel/model/enabled) plus a
+ * markdown body (the prompt). Both the setup UI (POST /schedules) and the
+ * `schedule-add` skill write the same one file; every reader —
  * setup-server (GET /schedules), channels/lib/config.mjs (loadConfig),
  * status/aggregator.mjs — must go through listSchedules() so a single
  * entry shape is presented everywhere.
  *
  * The legacy `mixdog-config.json` `channels.schedules.items` /
  * `channels.nonInteractive` / `channels.interactive` arrays are no longer
- * consulted. Migration: rename any legacy `prompt.md` to `instructions.md`
- * — no in-code fallback.
+ * consulted. Clean cut: the old `config.json` + `instructions.md` pair is
+ * no longer read — no in-code fallback.
  */
 
 import { readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { resolvePluginData } from './plugin-paths.mjs';
+import { readMarkdownDocument } from './markdown-frontmatter.mjs';
 
 function schedulesDir() {
   return join(resolvePluginData(), 'schedules');
 }
 
-function readJsonFile(path) {
-  try { return JSON.parse(readFileSync(path, 'utf8')); }
-  catch { return null; }
-}
-
 function readTextFile(path) {
   try { return readFileSync(path, 'utf8'); }
   catch { return ''; }
@@ -36,13 +33,13 @@ function readTextFile(path) {
 /**
  * List every registered schedule.
  *
- * Return shape per entry: `{ name, ...config, prompt }`.
+ * Return shape per entry: `{ name, ...frontmatter, prompt }`.
  * - `name` is the directory name (slug).
- * - Spread of `config.json` keys (time/days/type/channel/model/enabled
- *   when written by the setup UI; cron/timezone/mode/role when written
- *   by the schedule-add skill).
- * - `prompt` carries `instructions.md` content (empty string when the
- *   file is missing — caller decides whether that is a hard error).
+ * - Spread of `SCHEDULE.md` frontmatter keys (time/timezone/days/channel/
+ *   model/enabled). All frontmatter values arrive as strings; `enabled` is
+ *   cast to a boolean here so downstream `s.enabled !== false` filters work.
+ * - `prompt` carries the `SCHEDULE.md` body (empty string when the file is
+ *   missing — caller decides whether that is a hard error).
  *
  * Returns an empty array when the directory does not exist (fresh
  * install with no schedules registered yet).
@@ -62,9 +59,14 @@ export function listSchedules() {
   for (const ent of entries) {
     if (!ent.isDirectory()) continue;
     const name = ent.name;
-    const cfg = readJsonFile(join(dir, name, 'config.json')) || {};
-    const prompt = readTextFile(join(dir, name, 'instructions.md'));
-    out.push({ name, ...cfg, prompt });
+    const { frontmatter, body } = readMarkdownDocument(readTextFile(join(dir, name, 'SCHEDULE.md')));
+    const cfg = { ...frontmatter };
+    // Frontmatter is all-strings; cast enabled so `s.enabled !== false`
+    // filters (config.mjs, scheduler.mjs) treat `enabled: false` correctly.
+    if (Object.prototype.hasOwnProperty.call(cfg, 'enabled')) {
+      cfg.enabled = cfg.enabled !== 'false' && cfg.enabled !== false;
+    }
+    out.push({ name, ...cfg, prompt: body });
   }
   return out;
 }

package/src/runtime/shared/task-notification-envelope.mjs

@@ -0,0 +1,98 @@
+// Shared production of background-task notification envelopes.
+//
+// Producers (shell-jobs fire()/prompt-stall) and consumers (session
+// ingest/manager detection, TUI parsers reading stored sessions) must agree
+// byte-for-byte on the emitted wire format: bracket header fields, the blank
+// line body separator, and the completion instruction wording. To keep one
+// source of truth, the render helpers and the detection regexes live here.
+
+import {
+  toolCompletionInstruction,
+  isInternalRuntimeNotificationText,
+  isBracketedShellNotificationEnvelope,
+  backgroundTaskHeaderStatus,
+} from './tool-execution-contract.mjs';
+
+// Re-export the envelope *detection* predicate so producers and consumers can
+// pull render + detect from one module. Detection primitives live in
+// tool-execution-contract.mjs (shouldPersistModelVisibleToolCompletion et al.
+// depend on them there); this keeps a single import surface without forking
+// the regexes.
+export {
+  isInternalRuntimeNotificationText,
+  isBracketedShellNotificationEnvelope,
+  backgroundTaskHeaderStatus,
+};
+
+// Render the bracketed shell *completion* envelope body.
+// Byte-compatible with the historical inline assembly in shell-jobs.fire().
+export function renderShellCompletionEnvelope({
+  jobId,
+  status,
+  exitCode = null,
+  elapsedMs = null,
+  command = null,
+  summary = null,
+  stdoutPreview = null,
+  stderrPreview = null,
+  mergeStderr = false,
+} = {}) {
+  const header = [
+    `[task_id: ${jobId}]`,
+    `[status: ${status}]`,
+    `[exit: ${exitCode === null ? 'n/a' : exitCode}]`,
+    elapsedMs !== null ? `[elapsed: ${elapsedMs} ms]` : null,
+    command ? `[command: ${command}]` : null,
+  ].filter((l) => l !== null);
+  const bodySections = [
+    summary ? `Summary: ${summary}` : null,
+    stdoutPreview ? `\n[stdout preview]\n${stdoutPreview}` : null,
+    (mergeStderr !== true && stderrPreview) ? `\n[stderr preview]\n${stderrPreview}` : null,
+  ].filter((l) => l !== null);
+  // Exactly one blank line separates the bracket header block from the body
+  // when any body section exists; no trailing blank line when there is none.
+  // (Previously the '' separator was filtered out by the value filter, so a
+  // summary-only envelope glued headers straight onto `Summary:` and read as
+  // bodyless to the `\n\s*\n` body detector.)
+  const lines = bodySections.length > 0
+    ? [...header, '', ...bodySections]
+    : header;
+  return lines.join('\n');
+}
+
+// Build the shell completion instruction via the shared wording so all async
+// surfaces read identically ("The async shell task … has finished …"). The
+// exit detail is folded into the shared detail slot.
+export function shellCompletionInstruction({ jobId, status, exitCode = null } = {}) {
+  return toolCompletionInstruction({
+    surface: 'shell',
+    id: jobId,
+    status,
+    detail: `exit ${exitCode === null ? 'n/a' : exitCode}`,
+  });
+}
+
+// Render the bracketed shell *prompt-stall* progress envelope body.
+// Byte-compatible with the historical inline assembly in maybeNotifyPromptStall.
+export function renderShellPromptStallEnvelope({
+  jobId,
+  stalledMs,
+  elapsedMs = null,
+  command = null,
+  tailText = null,
+} = {}) {
+  return [
+    `[task_id: ${jobId}]`,
+    '[status: running]',
+    `[stalled: no output growth for ${stalledMs} ms]`,
+    (elapsedMs !== null && elapsedMs >= 0) ? `[elapsed: ${elapsedMs} ms]` : null,
+    command ? `[command: ${command}]` : null,
+    '',
+    'This background shell task appears to be waiting for interactive input. Background tasks cannot answer prompts automatically; cancel it or rerun with non-interactive flags/input.',
+    tailText ? `\n${tailText}` : null,
+  ].filter((line) => line !== null && line !== '').join('\n');
+}
+
+export function shellPromptStallInstruction({ jobId } = {}) {
+  return `The background shell task ${jobId} appears to be waiting for interactive input; inspect the prompt, then cancel or rerun it non-interactively.`;
+}

package/src/runtime/shared/task-notification-envelope.test.mjs

@@ -0,0 +1,107 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  renderShellCompletionEnvelope,
+  shellCompletionInstruction,
+  renderShellPromptStallEnvelope,
+  shellPromptStallInstruction,
+  isInternalRuntimeNotificationText,
+  isBracketedShellNotificationEnvelope,
+} from './task-notification-envelope.mjs';
+
+test('completion envelope matches historical assembly plus the corrected blank-line separator', () => {
+  const jobId = 'shell_job_1';
+  const status = 'completed';
+  const exitCode = 0;
+  const elapsedMs = 1234;
+  const detail = {
+    command: 'npm test',
+    summary: 'ok',
+    stdoutPreview: 'out',
+    stderrPreview: 'err',
+    mergeStderr: false,
+  };
+  const expected = [
+    `[task_id: ${jobId}]`,
+    `[status: ${status}]`,
+    `[exit: ${exitCode === null ? 'n/a' : exitCode}]`,
+    elapsedMs !== null ? `[elapsed: ${elapsedMs} ms]` : null,
+    detail.command ? `[command: ${detail.command}]` : null,
+    // The historical inline assembly filtered this '' out, gluing `Summary:`
+    // onto the header block; the corrected renderer keeps exactly one blank
+    // line between the bracket headers and the body sections.
+    '',
+    detail.summary ? `Summary: ${detail.summary}` : null,
+    detail.stdoutPreview ? `\n[stdout preview]\n${detail.stdoutPreview}` : null,
+    (detail.mergeStderr !== true && detail.stderrPreview) ? `\n[stderr preview]\n${detail.stderrPreview}` : null,
+  ].filter((l) => l !== null).join('\n');
+  const actual = renderShellCompletionEnvelope({ jobId, status, exitCode, elapsedMs, ...detail });
+  assert.equal(actual, expected);
+  assert.equal(isInternalRuntimeNotificationText(actual), true);
+  assert.equal(isBracketedShellNotificationEnvelope(actual), true);
+});
+
+test('summary-only completion envelope keeps one blank line before the body', () => {
+  const actual = renderShellCompletionEnvelope({
+    jobId: 'shell_job_1',
+    status: 'completed',
+    exitCode: 0,
+    summary: 'ok',
+  });
+  const expected = [
+    '[task_id: shell_job_1]',
+    '[status: completed]',
+    '[exit: 0]',
+    '',
+    'Summary: ok',
+  ].join('\n');
+  assert.equal(actual, expected);
+  // The blank-line separator must survive so body detectors see a body.
+  assert.match(actual, /\n\s*\n/);
+});
+
+test('bodyless completion envelope has no trailing blank line', () => {
+  const actual = renderShellCompletionEnvelope({
+    jobId: 'shell_job_1',
+    status: 'completed',
+    exitCode: 0,
+  });
+  assert.equal(actual, ['[task_id: shell_job_1]', '[status: completed]', '[exit: 0]'].join('\n'));
+  assert.doesNotMatch(actual, /\n\s*\n/);
+});
+
+test('completion instruction uses shared async wording + exit detail', () => {
+  assert.equal(
+    shellCompletionInstruction({ jobId: 'shell_job_1', status: 'completed', exitCode: 0 }),
+    'The async shell task shell_job_1 has finished (completed, exit 0) - review this result in your next step.',
+  );
+  assert.match(shellCompletionInstruction({ jobId: 'x', status: 'failed', exitCode: null }), /exit n\/a/);
+});
+
+test('prompt-stall envelope is byte-compatible with historical inline assembly', () => {
+  const jobId = 'shell_job_1';
+  const stalledMs = 5000;
+  const elapsedMs = 6000;
+  const tail = { text: 'Password:' };
+  const detail = { command: 'ssh host' };
+  const expected = [
+    `[task_id: ${jobId}]`,
+    '[status: running]',
+    `[stalled: no output growth for ${stalledMs} ms]`,
+    elapsedMs >= 0 ? `[elapsed: ${elapsedMs} ms]` : null,
+    detail.command ? `[command: ${detail.command}]` : null,
+    '',
+    'This background shell task appears to be waiting for interactive input. Background tasks cannot answer prompts automatically; cancel it or rerun with non-interactive flags/input.',
+    tail.text ? `\n${tail.text}` : null,
+  ].filter((line) => line !== null && line !== '').join('\n');
+  const actual = renderShellPromptStallEnvelope({ jobId, stalledMs, elapsedMs, command: detail.command, tailText: tail.text });
+  assert.equal(actual, expected);
+  assert.equal(isInternalRuntimeNotificationText(actual), true);
+});
+
+test('prompt-stall instruction wording unchanged', () => {
+  assert.equal(
+    shellPromptStallInstruction({ jobId: 'shell_job_1' }),
+    'The background shell task shell_job_1 appears to be waiting for interactive input; inspect the prompt, then cancel or rerun it non-interactively.',
+  );
+});

package/src/runtime/shared/tool-execution-contract.mjs

@@ -33,7 +33,7 @@ function notificationResultBody(text) {
   return match ? String(match[1] || '').trim() : '';
 }
 
-function backgroundTaskHeaderStatus(text) {
+export function backgroundTaskHeaderStatus(text) {
   const match = /^status:\s*(\S+)/mi.exec(String(text || ''));
   return clean(match?.[1]).toLowerCase();
 }
@@ -86,7 +86,7 @@ export function shouldPersistModelVisibleToolCompletion(text, meta = {}) {
 
 const BRACKETED_SHELL_STATUS_RE = /^\[status:\s*(?:running|pending|queued|completed|failed|cancelled|canceled|error|timeout|done|success)\]/im;
 
-function isBracketedShellNotificationEnvelope(text) {
+export function isBracketedShellNotificationEnvelope(text) {
   const value = String(text ?? '').trim();
   if (!value) return false;
   if (!/^\[task_id:\s*\S+\]/im.test(value)) return false;

package/src/runtime/shared/tool-surface.mjs

@@ -1,8 +1,15 @@
 import { displayModelName as sharedDisplayModelName } from '../../ui/model-display.mjs';
 
-const DEFAULT_SUMMARY_MAX = 160;
-// Semantic cap for collapsed agent/task card one-liners (spawn, send, response).
-export const AGENT_SURFACE_BRIEF_MAX = 120;
+// Default cap for tool-arg summaries (header parenthetical, channel tool lines).
+// Unified at 80 so every tool surface line — header arg summary and collapsed
+// detail alike — shares one width ceiling; per-call sites still clamp lower
+// (header 48, channel 50) where a tighter line is wanted.
+const DEFAULT_SUMMARY_MAX = 80;
+// Semantic cap for collapsed tool/agent/task card one-liners — the second row
+// under the ⎿ gutter (spawn, send, response, generic/shell result summaries).
+// Kept at 80 so every collapsed detail line is truncated to the same width
+// regardless of terminal columns; ctrl+o expand still shows the full body.
+export const AGENT_SURFACE_BRIEF_MAX = 80;
 const STATUS_SEPARATOR = ' · ';
 
 export function stripToolPrefix(name) {
@@ -205,7 +212,7 @@ function bridgeAgentModelSummary(args) {
   const modelId = firstText(args.model);
   const displayHint = firstText(args.modelDisplay, args.model_display, args.displayModel);
   return compactParts([
-    displayAgentName(firstText(args.agent, args.role, args.name, args.subagent_type)),
+    displayAgentName(firstText(args.agent, args.name, args.subagent_type)),
     displayModelName(modelId, provider, displayHint),
   ]);
 }
@@ -584,6 +591,22 @@ function countNonEmptyLines(text) {
     .filter((line) => line.trim()).length;
 }
 
+// Zero-result recognizer (audit HIGH): result text that SAYS "nothing found"
+// must summarize as an explicit zero, not be line-counted into "1 match".
+// Matches the shapes emitted by grep/glob/find/list/recall backends:
+//   "(no matches)", "no matches found", "(no results)", "No results",
+//   "(no fuzzy match for \"...\")", "0 matches", "(empty)", "(no entries)".
+function looksLikeZeroResultText(text) {
+  const trimmed = String(text ?? '').trim();
+  if (!trimmed) return false;
+  // Only trust short, single-line-ish payloads — a real listing that merely
+  // CONTAINS the words "no matches" somewhere must not be zeroed.
+  if (trimmed.length > 200 || trimmed.includes('\n')) return false;
+  return /^\(?\s*(?:no|0)\s+(?:fuzzy\s+)?(?:match(?:es)?|results?|files?|entries|candidates?|hits?)\b/i.test(trimmed)
+    || /^\(?\s*(?:empty|none)\s*\)?$/i.test(trimmed)
+    || /^no\s+\S+\s+(?:found|matched)\b/i.test(trimmed);
+}
+
 function splitPathAndDelta(value, explicitDelta = '') {
   let path = String(value ?? '').trim();
   let delta = String(explicitDelta ?? '').trim();
@@ -734,8 +757,8 @@ function summarizeGenericResult(text) {
       if (Array.isArray(parsed)) return `${parsed.length} ${pluralize(parsed.length, 'item')}`;
       if (parsed && typeof parsed === 'object') {
         const status = firstText(parsed.status, parsed.state, parsed.result, parsed.message);
-        if (status) return truncateSingleLine(titleStatus(status), 120);
-        if (parsed.cwd) return truncateSingleLine(parsed.cwd, 120);
+        if (status) return truncateSingleLine(titleStatus(status), AGENT_SURFACE_BRIEF_MAX);
+        if (parsed.cwd) return truncateSingleLine(parsed.cwd, AGENT_SURFACE_BRIEF_MAX);
         if (typeof parsed.ok === 'boolean') return parsed.ok ? 'Ok' : 'Failed';
         for (const key of ['items', 'results', 'resources', 'templates', 'providers', 'schedules', 'channels', 'tools']) {
           if (Array.isArray(parsed[key])) return `${parsed[key].length} ${pluralize(parsed[key].length, (key.slice(0, -1) || 'item').toLowerCase())}`;
@@ -751,7 +774,36 @@ function summarizeGenericResult(text) {
   if (/^(ok|done|success|saved|sent|updated|reloaded|connected|enabled|disabled|active|inactive)$/i.test(line)) {
     return titleStatus(line);
   }
-  return truncateSingleLine(line, 120);
+  return truncateSingleLine(line, AGENT_SURFACE_BRIEF_MAX);
+}
+
+// Error-cause extractor (audit HIGH): when a tool result is an error, surface
+// the actual cause line instead of a bare "Failed"/raw first line. Handles
+// JSON error envelopes ({error|message|cause|detail}) and plain-text bodies
+// (first line that carries error-ish signal, else first non-empty line).
+// Exported for ToolExecution's collapsed detail row.
+export function extractErrorCause(resultText) {
+  const text = String(resultText ?? '').trim();
+  if (!text) return '';
+  // JSON envelope: prefer explicit error-ish keys.
+  if (text.startsWith('{') || text.startsWith('[')) {
+    try {
+      const parsed = JSON.parse(text);
+      const obj = Array.isArray(parsed) ? parsed[0] : parsed;
+      if (obj && typeof obj === 'object') {
+        const cause = firstText(
+          typeof obj.error === 'string' ? obj.error : obj.error?.message,
+          obj.message, obj.cause, obj.detail, obj.reason, obj.status,
+        );
+        if (cause) return truncateSingleLine(String(cause), AGENT_SURFACE_BRIEF_MAX);
+      }
+    } catch { /* fall through to text scan */ }
+  }
+  const lines = text.split('\n').map((l) => l.trim()).filter(Boolean);
+  // Prefer the first line that looks like an error statement.
+  const errorish = lines.find((l) => /\b(error|failed|failure|denied|refused|timed?\s*out|timeout|not\s+found|missing|invalid|cannot|can't|exception|exit\s+(?:code\s+)?[1-9])\b/i.test(l));
+  const picked = errorish || lines[0] || '';
+  return truncateSingleLine(stripInlineMarkdown(picked), AGENT_SURFACE_BRIEF_MAX);
 }
 
 /**
@@ -760,7 +812,13 @@ function summarizeGenericResult(text) {
  * reliable can be derived, so the caller falls back to the raw result block.
  */
 export function summarizeToolResult(name, args, resultText, isError = false) {
-  if (isError) return null;
+  if (isError) {
+    // Audit HIGH: errors used to disable semantic summaries entirely, leaving
+    // the UI with a raw first line or a bare "Failed". Surface the extracted
+    // cause so the collapsed card answers "why" without ctrl+o.
+    const cause = extractErrorCause(resultText);
+    return cause || null;
+  }
   const text = String(resultText ?? '');
   const trimmed = text.trim();
   if (/^(?:undefined|null)$/i.test(trimmed)) return null;
@@ -800,18 +858,21 @@ export function summarizeToolResult(name, args, resultText, isError = false) {
     }
     case 'grep': {
       if (!trimmed || !looksLineOriented(text)) return null;
+      if (looksLikeZeroResultText(text)) return '0 matches';
       const n = countNonEmptyLines(text);
       if (n === 0) return null;
       return `${n} ${pluralize(n, 'match', 'matches')}`;
     }
     case 'glob': {
       if (!trimmed || !looksLineOriented(text)) return null;
+      if (looksLikeZeroResultText(text)) return '0 files';
       const n = countNonEmptyLines(text);
       if (n === 0) return null;
       return `${n} ${pluralize(n, 'file')}`;
     }
     case 'find': {
       if (!trimmed || !looksLineOriented(text)) return null;
+      if (looksLikeZeroResultText(text)) return '0 candidates';
       const n = countNonEmptyLines(text);
       if (n === 0) return null;
       return `${n} ${pluralize(n, 'candidate')}`;
@@ -819,6 +880,7 @@ export function summarizeToolResult(name, args, resultText, isError = false) {
     case 'list':
     case 'ls': {
       if (!trimmed || !looksLineOriented(text)) return null;
+      if (looksLikeZeroResultText(text)) return '0 entries';
       const n = countNonEmptyLines(text);
       if (n === 0) return null;
       return `${n} ${pluralize(n, 'entry', 'entries')}`;
@@ -840,15 +902,30 @@ export function summarizeToolResult(name, args, resultText, isError = false) {
         ]);
       }
       const firstLine = trimmed.split('\n').map((line) => line.trim()).find(Boolean) || trimmed;
-      return truncateSingleLine(firstLine, 120);
+      return truncateSingleLine(firstLine, AGENT_SURFACE_BRIEF_MAX);
     }
     case 'code_graph': {
       const match = /(\d+)\s+(references|definitions|symbols|callers|callees|results|matches)/i.exec(text);
       if (match) return `${match[1]} ${String(match[2]).toLowerCase()}`;
+      if (looksLikeZeroResultText(text)) return 'No results';
       return null;
     }
     case 'web_fetch':
     case 'fetch': {
+      // Audit HIGH: channel `fetch` (Discord message fetch — args carry
+      // channel/messageId/limit, never url/uri) was summarized as a WEB fetch,
+      // so its result missed both the status/size probes and fell to raw JSON.
+      // Route it to the generic JSON/text summarizer instead.
+      if (normalized === 'fetch') {
+        const a = parseToolArgs(args);
+        const isChannelFetch = !firstText(a.url, a.uri)
+          && Boolean(firstText(a.channel, a.channelId, a.chatId, a.messageId) || a.limit != null);
+        if (isChannelFetch) {
+          const n = countNonEmptyLines(text);
+          if (trimmed && looksLineOriented(text) && n > 0) return `${n} ${pluralize(n, 'message')}`;
+          return summarizeGenericResult(text);
+        }
+      }
       // Status: require a status-like context (HTTP NNN, "Status: NNN",
       // or "NNN OK"/"NNN Not Found") rather than any bare 3-digit number.
       const status = /(?:HTTP[\s/]*\d?\.?\d?\s*|status[:\s]+)([1-5]\d{2})\b/i.exec(text)
@@ -885,7 +962,15 @@ export function summarizeToolResult(name, args, resultText, isError = false) {
     }
     case 'recall':
     case 'search_memories':
-    case 'memory':
+    case 'memory': {
+      if (!trimmed || trimmed === '(no results)' || looksLikeZeroResultText(text)) return 'No Results';
+      let n = 0;
+      for (const line of text.split('\n')) {
+        if (/#\d+\s*$/.test(line)) n += 1;
+      }
+      if (n > 0) return `${n} ${pluralize(n, 'Memory', 'Memories')}`;
+      return summarizeGenericResult(text);
+    }
     case 'remember':
     case 'save_memory':
     case 'update_memory':
@@ -948,18 +1033,18 @@ export function summarizeToolResult(name, args, resultText, isError = false) {
       if (answerLine) return truncateSingleLine(stripInlineMarkdown(answerLine), AGENT_SURFACE_BRIEF_MAX);
       const task = /^agent task:\s*(\S+)/mi.exec(text);
       const status = /^status:\s*([^\s(]+)/mi.exec(text);
-      const role = /^role:\s*(.+)$/mi.exec(text);
+      const agent = /^agent:\s*(.+)$/mi.exec(text);
       const preset = /^preset:\s*(.+)$/mi.exec(text);
       const model = /^model:\s*(.+)$/mi.exec(text);
       const limits = /^limits:\s*(.+)$/mi.exec(text);
       const agentModel = compactParts([
-        displayAgentName(role ? role[1] : ''),
+        displayAgentName(agent ? agent[1] : ''),
         displayModelName(model ? model[1] : ''),
       ]);
       if (agentModel) return agentModel;
       const parts = [
         task ? task[1] : '',
-        role ? role[1] : '',
+        agent ? agent[1] : '',
         preset ? preset[1] : '',
         model ? model[1] : '',
         status ? titleStatus(status[1]) : '',