mixdog 0.9.1 → 0.9.2

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/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]) : '',

package/src/runtime/shared/transcript-writer.mjs

@@ -0,0 +1,129 @@
+/**
+ * Transcript writer for remote (Discord) mode.
+ *
+ * The channel worker's OutputForwarder tails a newline-delimited JSON
+ * transcript and forwards the "surface" view (assistant text + one-line tool
+ * summaries) to Discord. Nothing wrote that file for standalone sessions, so
+ * remote outbound never worked. This module writes the JSONL in the exact
+ * schema the forwarder parses (see channels/lib/output-forwarder.mjs
+ * extractNewText) plus a session record the forwarder's discovery reads
+ * (channels/lib/session-discovery.mjs readSessionRecord).
+ *
+ * All writes are best-effort: a failure must never break the ask() turn. We
+ * log the FIRST occurrence of each distinct failure string to stderr (prefix
+ * `mixdog: transcript-writer: `) and suppress duplicates so a broken path
+ * cannot spam the terminal.
+ */
+import { appendFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+
+// Byte-identical to cwdToProjectSlug() in
+// src/runtime/channels/lib/session-discovery.mjs. Inlined to avoid a
+// shared -> channels import coupling; keep the two in sync if either changes.
+function cwdToProjectSlug(cwd) {
+  return resolve(cwd).replace(/\\/g, '/').replace(/^([A-Za-z]):/, '$1-').replace(/\//g, '-');
+}
+
+export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid } = {}) {
+  if (!mixdogHome) throw new Error('transcript-writer: mixdogHome is required');
+  if (!sessionId) throw new Error('transcript-writer: sessionId is required');
+  if (!cwd) throw new Error('transcript-writer: cwd is required');
+
+  const resolvedCwd = resolve(cwd);
+  const projectDir = join(mixdogHome, 'projects', cwdToProjectSlug(resolvedCwd));
+  const transcriptPath = join(projectDir, `${sessionId}.jsonl`);
+  const sessionRecordPath = join(mixdogHome, 'sessions', `${pid ?? process.pid}.json`);
+  const startedAt = Date.now();
+
+  // Repeated-failure guard: log the first time each distinct message is seen,
+  // then stay quiet so a persistently-broken path does not flood stderr.
+  const seenErrors = new Set();
+  function logOnce(err) {
+    const msg = err && err.message ? err.message : String(err);
+    if (seenErrors.has(msg)) return;
+    seenErrors.add(msg);
+    try { process.stderr.write(`mixdog: transcript-writer: ${msg}\n`); } catch { /* stderr broken */ }
+  }
+
+  let projectDirReady = false;
+  function ensureProjectDir() {
+    if (projectDirReady) return;
+    try {
+      mkdirSync(projectDir, { recursive: true });
+      projectDirReady = true;
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
+  function appendLine(entry) {
+    ensureProjectDir();
+    try {
+      appendFileSync(transcriptPath, `${JSON.stringify(entry)}\n`);
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
+  function writeSessionRecord() {
+    try {
+      mkdirSync(dirname(sessionRecordPath), { recursive: true });
+      writeFileSync(sessionRecordPath, JSON.stringify({
+        sessionId,
+        cwd: resolvedCwd,
+        transcriptPath,
+        startedAt,
+        updatedAt: Date.now(),
+        kind: 'interactive',
+        entrypoint: 'cli',
+      }));
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
+  // Refresh only the session record's updatedAt so discovery keeps ranking
+  // this session as live across long-lived remote sessions.
+  function refresh() {
+    writeSessionRecord();
+  }
+
+  function appendAssistant(text) {
+    const value = typeof text === 'string' ? text : (text == null ? '' : String(text));
+    if (!value.trim()) return;
+    appendLine({
+      type: 'assistant',
+      sessionId,
+      message: { content: [{ type: 'text', text: value }] },
+    });
+  }
+
+  function appendToolUse(name, input) {
+    if (!name) return;
+    appendLine({
+      type: 'assistant',
+      sessionId,
+      message: { content: [{ type: 'tool_use', name, input: input || {} }] },
+    });
+  }
+
+  function appendToolResult(toolUseResult) {
+    if (!toolUseResult) return;
+    appendLine({
+      type: 'user',
+      sessionId,
+      message: { content: [{ type: 'tool_result' }] },
+      toolUseResult,
+    });
+  }
+
+  return {
+    transcriptPath,
+    sessionRecordPath,
+    writeSessionRecord,
+    refresh,
+    appendAssistant,
+    appendToolUse,
+    appendToolResult,
+  };
+}