mixdog 0.9.94 → 0.9.95

package/src/runtime/channels/lib/output-forwarder.mjs

@@ -299,7 +299,12 @@ class OutputForwarder {
   /** Extract new assistant text + tool logs from transcript since readFileSize */
   extractNewText(uncapped = false) {
     const { lines: newLines, nextFileSize } = this.readNewLines(uncapped);
-    let newText = "";
+    // One JSONL assistant entry is one semantic output block. Joining entries
+    // with a single newline glued a preamble directly onto its following tool
+    // card, and glued consecutive Run/Update cards into one dense script wall.
+    // Preserve every block's internal Markdown, but put exactly one blank line
+    // between visible entry blocks.
+    const blocks = [];
     for (const l of newLines) {
       try {
         const entry = JSON.parse(l);
@@ -323,7 +328,7 @@ class OutputForwarder {
               let diffContent = shown.join("\n");
               if (diffLines.length > 15) diffContent += "\n... +" + (diffLines.length - 15) + " lines";
               const block = safeCodeBlock(diffContent, "diff");
-              newText += block + "\n";
+              blocks.push(block);
             }
           }
           continue;
@@ -368,12 +373,15 @@ class OutputForwarder {
               }
             }
           }
-          if (parts.length) newText += parts.join("\n") + "\n";
+          if (parts.length) {
+            const block = parts.join("\n").trim();
+            if (block) blocks.push(block);
+          }
         }
       } catch {
       }
     }
-    return { text: newText.trim(), nextFileSize };
+    return { text: blocks.join("\n\n"), nextFileSize };
   }
   // ── Single-send gate ──────────────────────────────────────────────
   // All Discord sends pass through sendOnce() so duplicate concurrent sends are avoided.
@@ -410,6 +418,13 @@ class OutputForwarder {
       this.commitReadProgress(item.nextFileSize);
       return;
     }
+    // The active transcript/turn owns Discord continuation spacing. A daemon
+    // backend is shared by every client and scheduler, so backend-global send
+    // counts cannot decide whether THIS session's item is its first response.
+    // Freeze the decision on the queue item so retries remain byte-identical.
+    if (typeof item._continuation !== "boolean") {
+      item._continuation = this.sentCount > 0;
+    }
     // Backend owns chunking + send retry: pass the whole (unchunked) text once.
     // On failure the backend has already exhausted its per-chunk retries and
     // throws; we re-throw so drainQueue/scheduleRetry requeues the whole item.
@@ -418,7 +433,10 @@ class OutputForwarder {
       // failure so the backend resumes at the failed chunk instead of
       // re-sending chunks that already landed. The token is opaque here —
       // the forwarder only stores/passes/clears it, never interprets it.
-      await this.cb.send(targetChannelId, formatted, item._resumeToken ? { resumeToken: item._resumeToken } : undefined);
+      await this.cb.send(targetChannelId, formatted, {
+        continuation: item._continuation,
+        ...(item._resumeToken ? { resumeToken: item._resumeToken } : {}),
+      });
       dropTrace("discord.send.ok", null);
       // A zombie completion (send abandoned past the settlement cap, gen bumped)
       // must not mutate ANY item/queue state — including the resume token.
@@ -426,6 +444,7 @@ class OutputForwarder {
       // Full success — drop any stale token so a later reuse of this item
       // object can't carry a dead token.
       item._resumeToken = undefined;
+      item._continuation = undefined;
     } catch (err) {
       // Persist the opaque resume token (if any) on the item so the requeued
       // retry resumes from the failed chunk.

package/src/runtime/channels/lib/scheduler.mjs

@@ -115,7 +115,7 @@ class Scheduler {
   setSendHandler(fn) {
     this.sendFn = fn;
   }
-  /** Probe for a live Lead bridge seat. When set, the CC-parity interactive
+  /** Probe for a live Lead bridge seat. When set, the interactive
    *  inject only fires while it reports true; otherwise the visible-session
    *  fallback keeps the fire from being lost. Unset → inject when wired. */
   setInjectReadyCheck(fn) {

package/src/runtime/channels/lib/worker-main.mjs

@@ -435,7 +435,7 @@ function forwardLifecycleToDiscord(channelId, content) {
 scheduler.setInjectHandler((channelId, name, content, options) => {
   injectAndRecord(channelId, name, content, options);
 });
-// CC-parity interactive schedule fires may only inject while this process
+// Interactive schedule fires may only inject while this process
 // actually holds the live bridge seat; otherwise the scheduler falls back to
 // the visible-session run so the fire is never lost.
 scheduler.setInjectReadyCheck(() => bridgeRuntimeConnected && currentOwnerState().owned);

package/src/runtime/media/renditions.mjs

@@ -219,6 +219,24 @@ async function grabVideoFrame(sourcePath, spec) {
 // Two tiles asking for the same missing rendition must not both encode it.
 const inflight = new Map();
 const failedUntil = new Map();
+const FAILED_RENDITION_CACHE_MAX = 256;
+
+function pruneFailedRenditions(now = Date.now()) {
+  for (const [key, expiresAt] of failedUntil) {
+    if (expiresAt <= now) failedUntil.delete(key);
+  }
+  while (failedUntil.size > FAILED_RENDITION_CACHE_MAX) {
+    const oldest = failedUntil.keys().next().value;
+    if (oldest === undefined) break;
+    failedUntil.delete(oldest);
+  }
+}
+
+function rememberFailedRendition(key) {
+  failedUntil.delete(key);
+  failedUntil.set(key, Date.now() + FAILED_RENDITION_COOLDOWN_MS);
+  pruneFailedRenditions();
+}
 
 async function generate({ id, kind, sourcePath, variant, spec, cacheDir }) {
   if (kind === 'video') {
@@ -254,6 +272,7 @@ export async function ensureRendition({
   if (cached) return cached;
   if (!generate) return null;
   const key = `${variant}:${id}`;
+  pruneFailedRenditions();
   if ((failedUntil.get(key) || 0) > Date.now()) return null;
   const pending = inflight.get(key)
     ?? scheduleRendition(
@@ -262,11 +281,11 @@ export async function ensureRendition({
     )
       .then((result) => {
         if (result) failedUntil.delete(key);
-        else failedUntil.set(key, Date.now() + FAILED_RENDITION_COOLDOWN_MS);
+        else rememberFailedRendition(key);
         return result;
       })
       .catch(() => {
-        failedUntil.set(key, Date.now() + FAILED_RENDITION_COOLDOWN_MS);
+        rememberFailedRendition(key);
         return null;
       })
       .finally(() => { inflight.delete(key); });

package/src/runtime/memory/tool-defs.mjs

@@ -34,12 +34,10 @@ export const TOOL_DEFS = [
         status: { type: 'string', enum: ['pending','active','archived'], description: 'Lifecycle status.' },
         limit: { type: 'number', description: 'Max rows/items.' },
         confirm: { type: 'string', description: 'Exact confirmation phrase for destructive actions.' },
-        project_id: { type: 'string', description: 'Optional core pool override: common or slug. Omitted values are inferred from cwd/session, then fall back to common.' },
+        project_id: { type: 'string', description: 'Core pool: common or slug; inferred from cwd/session when omitted.' },
       },
-      anyOf: [
-        { properties: { action: { const: 'status' } }, required: ['action'] },
-        { properties: { action: { const: 'core' } }, required: ['action', 'op'] },
-      ],
+      // `op` is required for action=core — stated in its own description and
+      // enforced by the handler; the anyOf branches only restated that.
       additionalProperties: false,
       required: ['action'],
     },
@@ -58,7 +56,9 @@ export const TOOL_DEFS = [
         limit: { type: 'number', description: 'Max entries.' },
         offset: { type: 'number', description: 'Skip entries.' },
         sort: { type: 'string', enum: ['importance', 'date'], description: 'importance or date.' },
-        category: { anyOf: [{ type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, { type: 'array', items: { type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, minItems: 1 }], description: 'Category filter.' },
+        // Categories are listed once here instead of twice as enums; the
+        // handler validates against VALID_CATEGORY.
+        category: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Category filter, string or array: rule|constraint|decision|fact|goal|preference|task|issue.' },
         includeArchived: { type: 'boolean', description: 'Include archived entries.' },
         includeMembers: { type: 'boolean', description: 'Include chunk members.' },
         includeRaw: { type: 'boolean', description: 'Include raw/episode rows.' },

package/src/runtime/shared/atomic-file.mjs

@@ -24,6 +24,7 @@ import { dirname, basename, join } from 'path';
 import { randomBytes } from 'crypto';
 import { execFile, execFileSync } from 'child_process';
 import { promisify } from 'util';
+import { AsyncLocalStorage } from 'node:async_hooks';
 
 const _execFileAsync = promisify(execFile);
 
@@ -44,6 +45,14 @@ const DEFAULT_LOCK_TIMEOUT_MS = Number.isFinite(_configuredLockTimeoutMs)
 // current lock apart from a same-pid prior/other instance's leftover.
 const _OWNER_TOKEN = randomBytes(12).toString('hex');
 
+// Lock paths whose OS lock is currently held by an ASYNC holder in THIS
+// process. That holder releases from the event loop, so a sync waiter which
+// parks the loop in Atomics.wait can never observe the release: the wait is a
+// self-deadlock that always burns the full timeout (observed: the shared
+// session-pending-messages spool freezing the daemon — PTYs, engines, IPC —
+// for 2s per poll). Sync callers fail fast against it instead of waiting.
+const _osHeldPaths = new Set();
+
 function sleepSync(ms) {
   try {
     const buf = new SharedArrayBuffer(4);
@@ -111,6 +120,13 @@ export async function renameWithRetry(src, dst, opts = {}) {
 export function withFileLockSync(lockPath, fn, opts = {}) {
   const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : DEFAULT_LOCK_TIMEOUT_MS;
   const staleMs = Number.isFinite(opts.staleMs) ? opts.staleMs : 30000;
+  // A WAITING sync acquire can never win against this process's async holder.
+  // try-once callers keep the OS-level path so their contract is unchanged.
+  if (timeoutMs > 0 && _osHeldPaths.has(lockPath)) {
+    const selfErr = new Error(`atomic lock contended (async holder in this process): ${lockPath} [${_describeLockHolder(lockPath)}]`);
+    selfErr.code = 'ELOCKCONTENDED';
+    throw selfErr;
+  }
   const deadline = Date.now() + timeoutMs;
   mkdirSync(dirname(lockPath), { recursive: true });
   let attempt = 0;
@@ -306,7 +322,42 @@ function _asyncSleep(ms) {
   return new Promise((resolve) => { setTimeout(resolve, Math.max(1, Number(ms) || 1)); });
 }
 
+// ── In-process serialization ────────────────────────────────────────
+// The file lock arbitrates between PROCESSES. Inside one process (the engine
+// daemon now hosts every session, the TUI and the desktop) several callers
+// reach the same path concurrently, and an OS-level lock cannot express
+// "already mine": contenders spun until ELOCKTIMEOUT, and a nested call inside
+// a holder waited for itself forever (observed: session-pending-messages and
+// mixdog-config held by our own pid for minutes while every submit hung).
+// One async queue per lock path removes that class of failure entirely — no
+// retry loop involved — and a re-entrant call runs straight through.
+const _lockQueues = new Map();
+const _heldLockPaths = new AsyncLocalStorage();
+
 export async function withFileLock(lockPath, fn, opts = {}) {
+  const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : DEFAULT_LOCK_TIMEOUT_MS;
+  const held = _heldLockPaths.getStore();
+  // Re-entrant: this async context already owns the path. Waiting here would
+  // be waiting for ourselves.
+  if (held?.has(lockPath)) return fn();
+  // try-once callers must keep failing fast on contention, so they skip the
+  // queue and contend for the OS lock directly.
+  if (timeoutMs <= 0) return _withOsFileLock(lockPath, fn, opts);
+  const nextHeld = new Set(held || []);
+  nextHeld.add(lockPath);
+  const previous = _lockQueues.get(lockPath) ?? Promise.resolve();
+  const task = previous
+    .catch(() => {})
+    .then(() => _heldLockPaths.run(nextHeld, () => _withOsFileLock(lockPath, fn, opts)));
+  const settled = task.then(() => {}, () => {});
+  _lockQueues.set(lockPath, settled);
+  void settled.then(() => {
+    if (_lockQueues.get(lockPath) === settled) _lockQueues.delete(lockPath);
+  });
+  return task;
+}
+
+async function _withOsFileLock(lockPath, fn, opts = {}) {
   const timeoutMs = Number.isFinite(opts.timeoutMs) ? opts.timeoutMs : DEFAULT_LOCK_TIMEOUT_MS;
   const staleMs = Number.isFinite(opts.staleMs) ? opts.staleMs : 30000;
   const deadline = Date.now() + timeoutMs;
@@ -342,6 +393,7 @@ export async function withFileLock(lockPath, fn, opts = {}) {
       continue;
     }
     try { writeFileSync(fd, `${process.pid} ${Date.now()} ${_OWNER_TOKEN}\n`, 'utf8'); } catch {}
+    _osHeldPaths.add(lockPath);
     try {
       // Async ACL enforcement (promisified execFile) so a secret-bearing
       // async holder never blocks the event loop on icacls; identical
@@ -349,6 +401,7 @@ export async function withFileLock(lockPath, fn, opts = {}) {
       if (opts.secret === true) await _enforceOwnerOnlyAclWin32Async(lockPath);
       return await fn();
     } finally {
+      _osHeldPaths.delete(lockPath);
       try { closeSync(fd); } catch {}
       try {
         if (_lockOwnedBySelf(lockPath)) unlinkSync(lockPath);

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

@@ -128,14 +128,14 @@ function hasScopeCriteria(scope) {
   return Boolean(scope?.callerSessionId || scope?.routingSessionId || scope?.clientHostPid);
 }
 
-function taskMatchesScope(task, options = {}) {
+function taskMatchesScope(task, options = {}, { includeUnattributed = true } = {}) {
   if (!task) return false;
   const scope = normalizeTaskScope(options);
   if (!hasScopeCriteria(scope)) return true;
   const taskSessionId = task.ownerSessionId || task.notifyContext?.callerSessionId || task.notifyContext?.routingSessionId || null;
   const taskClientHostPid = task.clientHostPid || task.notifyContext?.clientHostPid || null;
   // Legacy/unattributed tasks remain visible so old async jobs are still recoverable.
-  if (!taskSessionId && !taskClientHostPid) return true;
+  if (!taskSessionId && !taskClientHostPid) return includeUnattributed;
   if (scope.callerSessionId && taskSessionId === scope.callerSessionId) return true;
   if (scope.routingSessionId && taskSessionId === scope.routingSessionId) return true;
   if (scope.clientHostPid && taskClientHostPid === scope.clientHostPid) return true;
@@ -278,7 +278,10 @@ export function cancelBackgroundTasks(options = {}) {
   let cancelled = 0;
   for (const task of [...tasks.values()]) {
     if (wanted && task.surface !== wanted) continue;
-    if (!taskMatchesScope(task, options)) continue;
+    // Scoped teardown must be exact. Legacy tasks without ownership stay
+    // visible/recoverable, but may not be claimed by whichever session happens
+    // to close first.
+    if (!taskMatchesScope(task, options, { includeUnattributed: false })) continue;
     if (TERMINAL_STATUSES.has(task.status)) continue;
     try { task.cancel?.(); } catch {}
     completeBackgroundTask(task.taskId, { status: 'cancelled', error: reason, notify: options.notify === true });

package/src/runtime/shared/resource-admission.mjs

@@ -54,6 +54,19 @@ function abortError(signal) {
     : new Error(String(signal?.reason || 'resource admission canceled'));
 }
 
+function sleep(ms, signal) {
+  return new Promise((resolve) => {
+    const finish = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener?.('abort', finish);
+      resolve();
+    };
+    const timer = setTimeout(finish, ms);
+    timer.unref?.();
+    signal?.addEventListener?.('abort', finish, { once: true });
+  });
+}
+
 class ResourcePressureError extends Error {
   constructor(message, details = {}) {
     super(`resource pressure: ${message}`);
@@ -93,6 +106,14 @@ export class ResourceAdmissionController {
     // Live leases for saturation diagnostics only (labels/ages in snapshot()).
     this.activeLeases = new Set();
     this.context = new AsyncLocalStorage();
+    // Host free memory is an INSTANTANEOUS sample: a GC pause or a just-exited
+    // child can dip it below the floor for a few hundred ms. Re-measure a
+    // bounded number of times before refusing, so a transient dip costs
+    // latency instead of a failed tool call.
+    this.memoryRetry = {
+      attempts: nonNegativeInt(env.MIXDOG_MEMORY_PRESSURE_RETRIES, 3),
+      delayMs: nonNegativeInt(env.MIXDOG_MEMORY_PRESSURE_RETRY_MS, 400),
+    };
   }
 
   _memoryError(kind) {
@@ -231,11 +252,29 @@ export class ResourceAdmissionController {
     return this.context.run(lease, task);
   }
 
+  async _acquireAfterMemoryDip(kind, options, pressure) {
+    const lane = kind === 'shell' ? 'shell' : 'agent';
+    const { attempts, delayMs } = this.memoryRetry;
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+      await sleep(delayMs, options.signal);
+      if (options.signal?.aborted) throw abortError(options.signal);
+      if (!this._memoryError(lane)) return this.acquire(kind, options);
+    }
+    throw this._memoryError(lane) || pressure;
+  }
+
   acquire(kind, { signal = null, label = null, dependency = 'scoped' } = {}) {
     const lane = kind === 'shell' ? 'shell' : 'agent';
     if (signal?.aborted) return Promise.reject(abortError(signal));
     const pressure = this._memoryError(lane);
-    if (pressure) return Promise.reject(pressure);
+    if (pressure) {
+      // Only host free memory self-heals on this timescale; our own RSS does
+      // not, so RSS pressure still rejects immediately.
+      if (pressure.metric !== 'free-memory' || this.memoryRetry.attempts < 1) {
+        return Promise.reject(pressure);
+      }
+      return this._acquireAfterMemoryDip(kind, { signal, label, dependency }, pressure);
+    }
     const ambientParent = this.context.getStore();
     const detachedDependency = dependency === 'detached' && ambientParent?.controller === this;
     const parent = detachedDependency ? null : this._suspendParent(ambientParent);

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

@@ -23,5 +23,14 @@ export function toolResultTerminalStatus(text) {
   const bracketed = body.match(/^\[status:\s*([^\]]*)\]/mi)?.[1]?.trim();
   if (bracketed) return normalizeToolTerminalStatus(bracketed);
   const inline = body.match(/^(?:status|state):\s*([^\s·,;]+)/mi)?.[1]?.trim();
-  return normalizeToolTerminalStatus(inline);
+  const fromInline = normalizeToolTerminalStatus(inline);
+  if (fromInline) return fromInline;
+  // Bare control bodies written on cancel/crash (current + legacy).
+  const trimmed = body.trim();
+  if (/^(?:cancelled|canceled)$/i.test(trimmed)) return 'cancelled';
+  if (/^(?:interrupted by (?:user|process restart)|tool execution aborted|\[tool execution was interrupted\])$/i.test(trimmed)) {
+    return 'cancelled';
+  }
+  if (/^the user doesn't want to proceed with this tool use\b/i.test(trimmed)) return 'cancelled';
+  return '';
 }

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

@@ -467,15 +467,15 @@ export function toolWorkUnit(name, args = {}, category = '') {
           noun: 'file',
         });
       }
-      // post_shell runs a verification command inside the SAME tool call after
-      // the patch applies; without the suffix the spinner sits on "Editing 1
-      // file" for the whole (possibly long) verify run and reads like a stuck
-      // edit. Surface both phases in the active label.
-      const verifying = typeof a.post_shell === 'string' && a.post_shell.trim() !== '';
       return unitDescriptor('Patch', {
         count: patchFileCount(a) || 1,
-        active: (creating ? 'Creating' : deleting ? 'Deleting' : 'Editing') + (verifying ? ' & verifying' : ''),
-        done: (creating ? 'Created' : deleting ? 'Deleted' : 'Edited') + (verifying ? ' & verified' : ''),
+        // post_shell is NOT named here: the turn engine already splits such a
+        // call into this edit card plus a trailing Shell card that carries the
+        // real command, its output and its failure banner (turn.mjs
+        // postShellTwins). Repeating "& verifying" in the header declared the
+        // verify phase twice and truncated the label on narrow panes.
+        active: creating ? 'Creating' : deleting ? 'Deleting' : 'Editing',
+        done: creating ? 'Created' : deleting ? 'Deleted' : 'Edited',
         noun: 'file',
       });
     }