mixdog 0.9.2 → 0.9.4

package/src/runtime/shared/background-tasks.mjs

@@ -5,7 +5,7 @@ import {
   normalizeToolNotifyContext,
   notifyToolCompletion,
 } from './tool-execution-contract.mjs';
-import { presentErrorText } from './err-text.mjs';
+import { presentErrorText, errorLine } from './err-text.mjs';
 
 export {
   TOOL_ASYNC_EXECUTION_CONTRACT,
@@ -465,8 +465,7 @@ export function renderBackgroundTask(taskOrId, { includeResult = false } = {}) {
     if (body) {
       lines.push('', body);
     } else if (TERMINAL_STATUSES.has(task.status) && task.error) {
-      const errorText = String(task.error || '').trim();
-      lines.push('', /^error\s*:/i.test(errorText) ? errorText : `Error: ${errorText}`);
+      lines.push('', errorLine(task.error, { surface: task.surface }));
     } else if (TERMINAL_STATUSES.has(task.status) && task.status === 'completed') {
       // Terminal-completed task with no extractable body: surface a placeholder
       // instead of silently omitting the result so the owner isn't left with a

package/src/runtime/shared/buffered-appender.mjs

@@ -0,0 +1,149 @@
+/**
+ * Per-file buffered append queue.
+ *
+ * Hot paths (transcript writer, channel worker stderr log, etc.) previously
+ * called appendFileSync per entry/chunk, which blocks the event loop on
+ * every write. This module coalesces writes per path into an in-memory
+ * buffer and flushes asynchronously via fs.promises.appendFile once the
+ * buffer reaches BUFFER_FLUSH_BYTES or after DEBOUNCE_MS of inactivity.
+ * Flushes are serialized per path so ordering is preserved. On process
+ * exit, any remaining buffered bytes for every path are drained with one
+ * synchronous appendFileSync call each (best-effort, matching the
+ * agent-trace.mjs local spool exit-drain pattern).
+ */
+import { appendFileSync } from 'node:fs';
+import { appendFile } from 'node:fs/promises';
+
+const BUFFER_FLUSH_BYTES = 32 * 1024;
+const DEBOUNCE_MS = 50;
+
+// path -> { chunks: string[], bytes: number, timer, flushing, inFlight, failCount }
+const queues = new Map();
+
+function getQueue(path) {
+    let q = queues.get(path);
+    if (!q) {
+        q = { chunks: [], bytes: 0, timer: null, flushing: false, inFlight: null, failCount: 0 };
+        queues.set(path, q);
+    }
+    return q;
+}
+
+function scheduleFlush(path, q) {
+    if (q.timer) return;
+    q.timer = setTimeout(() => {
+        q.timer = null;
+        _flush(path, q);
+    }, DEBOUNCE_MS);
+    q.timer.unref?.();
+}
+
+function _flush(path, q) {
+    if (q.flushing) return;
+    if (q.chunks.length === 0) return;
+    const data = q.chunks.join('');
+    q.chunks = [];
+    q.bytes = 0;
+    // Hold the in-flight payload until the write settles so an exit-time
+    // sync drain can still recover it if it fires mid-write (fix: exit
+    // drain must not miss data that was dequeued but not yet persisted).
+    q.inFlight = data;
+    q.flushing = true;
+    appendFile(path, data, 'utf8')
+        .then(() => {
+            q.failCount = 0;
+        })
+        .catch(() => {
+            // Requeue the failed data so a later flush/exit-drain retries
+            // once, instead of silently dropping. Cap retries so a
+            // permanently broken path (e.g. deleted dir) cannot loop
+            // forever accumulating the same failing chunk.
+            q.failCount += 1;
+            if (q.failCount <= 3) {
+                q.chunks.unshift(data);
+                q.bytes += Buffer.byteLength(data, 'utf8');
+            }
+        })
+        .finally(() => {
+            q.inFlight = null;
+            q.flushing = false;
+            if (q.chunks.length > 0) {
+                if (q.bytes >= BUFFER_FLUSH_BYTES) _flush(path, q);
+                else scheduleFlush(path, q);
+            }
+        });
+}
+
+/**
+ * Queue text for buffered append to `path`. Flushes async once the buffer
+ * for that path crosses BUFFER_FLUSH_BYTES, or after DEBOUNCE_MS of
+ * inactivity, whichever comes first.
+ */
+export function appendBuffered(path, text) {
+    if (!path || !text) return;
+    const q = getQueue(path);
+    q.chunks.push(text);
+    q.bytes += Buffer.byteLength(text, 'utf8');
+    if (q.bytes >= BUFFER_FLUSH_BYTES) {
+        if (q.timer) { clearTimeout(q.timer); q.timer = null; }
+        _flush(path, q);
+    } else {
+        scheduleFlush(path, q);
+    }
+}
+
+/**
+ * Synchronously drain any remaining buffered bytes for every known path.
+ * Intended for process exit hooks only — best-effort, never throws.
+ */
+export function drainAllSync() {
+    for (const [path, q] of queues) {
+        drainPathSync(path);
+    }
+}
+
+/**
+ * Synchronously drain the queue for a single path. Writes any in-flight
+ * (already-dequeued but not yet persisted) payload FIRST, then any
+ * still-queued chunks, so nothing buffered is lost. Best-effort, never
+ * throws.
+ */
+export function drainPathSync(path) {
+    const q = queues.get(path);
+    if (!q) return;
+    if (q.timer) { clearTimeout(q.timer); q.timer = null; }
+    if (q.inFlight) {
+        try {
+            appendFileSync(path, q.inFlight, 'utf8');
+        } catch {
+            // Best-effort; nothing to recover from here.
+        }
+        q.inFlight = null;
+    }
+    if (q.chunks.length === 0) return;
+    const data = q.chunks.join('');
+    q.chunks = [];
+    q.bytes = 0;
+    try {
+        appendFileSync(path, data, 'utf8');
+    } catch {
+        // Best-effort exit drain; nothing to recover from here.
+    }
+}
+
+/**
+ * True if a path currently has an async write in flight. Callers that need
+ * to rename/rotate the underlying file (which would race a concurrent
+ * appendFile on some platforms, notably Windows) should check this and
+ * defer the rename to a later tick rather than racing it.
+ */
+export function hasInFlightWrite(path) {
+    const q = queues.get(path);
+    return Boolean(q && q.inFlight);
+}
+
+try {
+    process.on('exit', drainAllSync);
+} catch {
+    // Ignore lifecycle hook failures in embedded runtimes.
+}

package/src/runtime/shared/launcher-control.mjs

@@ -4,7 +4,7 @@
 // path. A `mixdog`-launched session can be "managed": the launcher
 // (setup/mixdog.mjs) owns the child process and exposes a file-based
 // command queue under the runtime root. Internal commands (/clear,
-// /reload-plugins) are enqueued by the MCP server (inject_command / inject_input)
+// /reload-plugins) are enqueued by the MCP server (inject_input)
 // and the launcher delivers them to the child's stdin — no terminal keystroke
 // injection, no new window. Works on Windows / macOS / Linux.
 //
@@ -166,7 +166,7 @@ export function managedLaunchId() {
 
 let enqueueSequence = 0;
 
-// Writer side (inject_command / inject_input): publish one command for the
+// Writer side (inject_input): publish one command for the
 // launcher to deliver. Prefers the canonical Rust backend; the JS writer (temp
 // name + rename so the watcher never sees a partial file) is the fallback.
 // Returns the published path.

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/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-primitives.mjs

@@ -0,0 +1,308 @@
+import { displayModelName as sharedDisplayModelName } from '../../ui/model-display.mjs';
+
+// 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.
+export 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;
+export const STATUS_SEPARATOR = ' · ';
+
+export function stripToolPrefix(name) {
+  const text = rawToolName(name);
+  const mcp = parseMcpToolName(text);
+  return mcp ? mcp.tool : text;
+}
+
+function rawToolName(name) {
+  return String(name || 'tool').replace(/^functions\./, '');
+}
+
+export function parseMcpToolName(name) {
+  const text = rawToolName(name);
+  const match = /^mcp__(.+?)__(.+)$/.exec(text);
+  if (!match) return null;
+  return { server: match[1], tool: match[2] };
+}
+
+export function isMcpToolName(name) {
+  return Boolean(parseMcpToolName(name));
+}
+
+export function normalizeToolName(name) {
+  return stripToolPrefix(name).replace(/-/g, '_').toLowerCase();
+}
+
+export function truncateToolText(value, max = DEFAULT_SUMMARY_MAX) {
+  const text = String(value ?? '').trim();
+  return text.length > max ? `${text.slice(0, max)}...` : text;
+}
+
+export function truncateSingleLine(value, max = DEFAULT_SUMMARY_MAX) {
+  return truncateToolText(String(value ?? '').replace(/\s+/g, ' '), max);
+}
+
+export function truncateCommand(value, max = DEFAULT_SUMMARY_MAX) {
+  const text = String(value ?? '').trim();
+  if (!text) return '';
+  const lines = text.split('\n');
+  let out = lines.length > 2 ? `${lines.slice(0, 2).join(' ')}...` : lines.join(' ');
+  out = out.replace(/\s+/g, ' ').trim();
+  return out.length > max ? `${out.slice(0, Math.max(1, max - 3))}...` : out;
+}
+
+export function parseToolArgs(args) {
+  if (!args) return {};
+  if (typeof args === 'string') {
+    try {
+      const parsed = JSON.parse(args);
+      return parsed && typeof parsed === 'object' ? parsed : { value: args };
+    } catch {
+      return { value: args };
+    }
+  }
+  if (typeof args === 'object') {
+    if (args.input && typeof args.input === 'object') return args.input;
+    return args;
+  }
+  return { value: args };
+}
+
+export function displayToolPath(path) {
+  const text = String(path ?? '');
+  return text.replace(/\\/g, '/').split('/').filter(Boolean).at(-1) || text;
+}
+
+export function compactParts(parts) {
+  return parts.filter((part) => part != null && String(part).trim()).map((part) => String(part).trim()).join(STATUS_SEPARATOR);
+}
+
+export function compactSlash(left, right) {
+  const a = String(left ?? '').trim();
+  const b = String(right ?? '').trim();
+  return a && b ? `${a}/${b}` : a || b;
+}
+
+export function mcpToolTarget(name, max = DEFAULT_SUMMARY_MAX) {
+  const mcp = parseMcpToolName(name);
+  if (!mcp) return '';
+  return truncateToolText(compactSlash(mcp.server, mcp.tool), max);
+}
+
+export function quoted(value, max) {
+  const text = truncateToolText(value || '', max);
+  return text ? `"${text}"` : '';
+}
+
+export function firstText(...values) {
+  for (const value of values) {
+    if (value != null && String(value).trim()) return String(value).trim();
+  }
+  return '';
+}
+
+export function splitToolSearchSelection(value) {
+  if (Array.isArray(value)) return value.map((item) => String(item || '').trim()).filter(Boolean);
+  return String(value || '')
+    .split(/[,\s]+/)
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function toolSearchTargetKind(value) {
+  const lower = String(value || '').trim().toLowerCase();
+  if (!lower) return '';
+  if (lower.startsWith('mcp__') || lower.includes('_mcp_') || lower.includes('mcp')) return 'MCP';
+  if (lower === 'skill' || lower.startsWith('skill:') || lower.startsWith('skill_') || lower.startsWith('skills_') || lower.includes('skill')) return 'Skills';
+  return 'Tools';
+}
+
+function orderedToolSearchKinds(kinds) {
+  const set = new Set((kinds || []).filter(Boolean));
+  const order = ['Tools', 'MCP', 'Skills'];
+  const out = order.filter((kind) => set.has(kind));
+  return out.length ? out : ['Tools'];
+}
+
+function inferToolSearchKinds(args = {}) {
+  const selected = splitToolSearchSelection(args.select);
+  if (selected.length) return orderedToolSearchKinds(selected.map(toolSearchTargetKind));
+
+  const query = firstText(args.query, args.q, args.text).toLowerCase();
+  const kinds = [];
+  if (/\bmcp\b|mcp__|mcp[-_\s]?server/.test(query)) kinds.push('MCP');
+  if (/\bskills?\b|skill_|use[-_\s]?skill/.test(query)) kinds.push('Skills');
+  return orderedToolSearchKinds(kinds);
+}
+
+export function toolSearchDisplayLabel(args = {}) {
+  return `Load ${inferToolSearchKinds(args).join('/')}`;
+}
+
+export function displayToolSearchTarget(value) {
+  const text = String(value || '').trim();
+  if (/^skill:/i.test(text)) return text.slice('skill:'.length);
+  const mcp = /^mcp__(.*?)__(.+)$/.exec(text);
+  if (mcp) return `${mcp[1]}.${mcp[2]}`;
+  return stripToolPrefix(text);
+}
+
+export function titleizeToolName(name) {
+  return stripToolPrefix(name)
+    .split(/[_\s-]+/)
+    .filter(Boolean)
+    .map((part) => {
+      const lower = part.toLowerCase();
+      if (lower === 'ui') return 'UI';
+      if (lower === 'mcp') return 'MCP';
+      if (lower === 'id') return 'ID';
+      return `${lower.slice(0, 1).toUpperCase()}${lower.slice(1)}`;
+    })
+    .join(' ') || 'Tool';
+}
+
+const AGENT_DISPLAY_NAMES = new Map([
+  ['explore', 'Explore'],
+  ['maintainer', 'Maintainer'],
+  ['worker', 'Worker'],
+  ['heavy-worker', 'Heavy Worker'],
+  ['reviewer', 'Reviewer'],
+  ['debugger', 'Debugger'],
+]);
+
+function titleizeDisplayName(value) {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  return text
+    .replace(/[_-]+/g, ' ')
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((part) => {
+      const lower = part.toLowerCase();
+      if (lower === 'ui') return 'UI';
+      if (lower === 'mcp') return 'MCP';
+      if (lower === 'id') return 'ID';
+      return `${lower.slice(0, 1).toUpperCase()}${lower.slice(1)}`;
+    })
+    .join(' ');
+}
+
+export function displayAgentName(value) {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  const key = text.toLowerCase().replace(/[\s_]+/g, '-');
+  return AGENT_DISPLAY_NAMES.get(key) || titleizeDisplayName(text);
+}
+
+export function displayModelName(model, provider, displayHint) {
+  const text = String(model ?? '').trim();
+  const modelId = text
+    ? (text.includes('/') ? (text.split('/').filter(Boolean).at(-1) || text) : text)
+    : '';
+  const shown = sharedDisplayModelName(modelId, provider, displayHint);
+  return shown || modelId;
+}
+
+export function bridgeAgentModelSummary(args) {
+  const provider = firstText(args.provider, args.providerId, args.provider_id);
+  const modelId = firstText(args.model);
+  const displayHint = firstText(args.modelDisplay, args.model_display, args.displayModel);
+  return compactParts([
+    displayAgentName(firstText(args.agent, args.name, args.subagent_type)),
+    displayModelName(modelId, provider, displayHint),
+  ]);
+}
+
+export function summarizeLineWindow(a) {
+  const offset = a.offset ?? a.start_line ?? a.startLine ?? a.line;
+  const limit = a.limit ?? a.line_count ?? a.lineCount ?? a.lines;
+  if (offset == null && limit == null) return '';
+  const start = Number(offset);
+  const count = Number(limit);
+  if (Number.isFinite(start) && Number.isFinite(count) && count > 0) {
+    return `lines ${start}-${Math.max(start, start + count - 1)}`;
+  }
+  if (Number.isFinite(start)) return `from line ${start}`;
+  if (Number.isFinite(count)) return `${count} lines`;
+  return '';
+}
+
+export function summarizePatch(patch, basePath) {
+  const text = String(patch ?? '');
+  const files = [];
+  for (const line of text.split('\n')) {
+    const match = /^\*\*\*\s+(?:Update|Add|Delete) File:\s+(.+)\s*$/.exec(line);
+    if (match) files.push(displayToolPath(match[1]));
+  }
+  if (files.length === 1) return files[0];
+  if (files.length > 1) return `${files.length} files`;
+  if (basePath) return displayToolPath(basePath);
+  return text ? 'patch' : '';
+}
+
+export function collectionCount(...values) {
+  for (const value of values) {
+    if (Array.isArray(value)) {
+      const count = value.filter((item) => item != null && String(item).trim()).length;
+      return count || value.length || 0;
+    }
+    if (value && typeof value === 'object') return 1;
+    if (value != null && String(value).trim()) return 1;
+  }
+  return 0;
+}
+
+export function formatCountedUnit(count, singular, pluralText = `${singular}s`) {
+  const n = Math.max(0, Number(count || 0));
+  return n > 0 ? `${n} ${pluralize(n, singular, pluralText)}` : '';
+}
+
+export function patchFileCount(args = {}) {
+  const patchText = String(args.patch ?? '');
+  if (patchText) {
+    const files = new Set();
+    for (const line of patchText.split('\n')) {
+      const match = /^\*\*\*\s+(?:Update|Add|Delete) File:\s+(.+)\s*$/.exec(line);
+      if (match) files.add(match[1].trim());
+    }
+    if (files.size > 0) return files.size;
+  }
+  return collectionCount(args.path, args.file, args.file_path, args.base_path);
+}
+
+export function codeGraphLabel(args) {
+  const mode = String(args.mode || args.action || '').toLowerCase();
+  if (mode === 'prewarm' || mode === 'index' || mode === 'build' || mode === 'refresh') return 'Setup';
+  if (mode === 'search' || mode === 'find_symbol' || mode === 'references' || mode === 'callers' || mode === 'callees') return 'Search';
+  return 'Read';
+}
+
+export function codeGraphSummary(args, max) {
+  return compactParts([
+    args.mode || args.action || '',
+    truncateToolText(firstText(args.symbol, Array.isArray(args.symbols) ? args.symbols.join(', ') : '', args.file, args.path, args.query), max),
+  ]);
+}
+
+export function pluralize(count, singular, pluralText = `${singular}s`) {
+  return count === 1 ? singular : pluralText;
+}
+
+export function titleWord(value) {
+  const text = String(value || '');
+  return text ? `${text.charAt(0).toUpperCase()}${text.slice(1).toLowerCase()}` : '';
+}
+
+export function titleStatus(value) {
+  const text = String(value || '').trim();
+  if (!text) return '';
+  if (/^ok$/i.test(text)) return 'Ok';
+  if (/^(done|success|completed)$/i.test(text)) return 'Finished';
+  if (/^(error|failed|fail|killed|timeout)$/i.test(text)) return 'Failed';
+  if (/^(cancelled|canceled|cancel)$/i.test(text)) return 'Cancelled';
+  return titleWord(text);
+}