mixdog 1.2.4 → 1.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "private": false,
   "type": "module",
   "description": "Open-source coding agent that matches Codex on Terminal-Bench 2.1 with 63% fewer tokens.",

package/scripts/mobile-release.mjs

@@ -9,9 +9,10 @@
 //   CLI: MOBILE_MODE=auto|force|skip MOBILE_BUMP=patch|minor node scripts/mobile-release.mjs plan
 //   appends mobile_release / mobile_version / mobile_tag to $GITHUB_OUTPUT.
 //
-// link: the Android release the relay's /app page links — the newest
-//   published (non-draft) mobile-v* release whose APK actually downloads, or
-//   the releases list when there is none. `--require=<tag>` instead fails
+// link: the Android APK the relay's /app page links — the direct download URL
+//   (.../releases/download/mobile-vX.Y.Z/<asset>.apk) of the newest published
+//   (non-draft) mobile-v* release whose APK actually downloads, or the
+//   releases list when there is none. `--require=<tag>` instead fails
 //   unless that exact release is the one that resolves (post-publish check).
 //   CLI: GITHUB_REPOSITORY=o/r GH_TOKEN=… node scripts/mobile-release.mjs link [--require=mobile-vX.Y.Z]
 //   appends url / tag to $GITHUB_OUTPUT.
@@ -148,7 +149,7 @@ export async function resolveAndroidLink({
   const candidates = androidReleaseCandidates(await listReleases(repository, { token, fetchImpl }));
   for (const candidate of requiredTag ? candidates.filter((item) => item.tag === requiredTag) : candidates) {
     if (await downloadable(candidate.apkUrl, { fetchImpl, attempts, delayMs })) {
-      return { url: candidate.url, tag: candidate.tag };
+      return { url: candidate.apkUrl, tag: candidate.tag };
     }
     if (!requiredTag) console.warn(`::warning::${candidate.tag} APK is not downloadable; trying an older release.`);
   }

package/src/defaults/shipped-history.json

@@ -104,6 +104,7 @@
   },
   "outputStyles": {
     "common.md": [
+      "2abd510eaeb6c83702b97a0ce215d348",
       "4e6134d60ee5c54c2888e874653bcdad",
       "4ecd89b0c07ad8a81aa1f84882cf1b00",
       "899529696b7d6d3373ae83a76976ab48",

package/src/output-styles/common.md

@@ -15,6 +15,7 @@ partial: true
 - Distinguish facts, inference, and uncertainty; keep exact literals and
   material risks. Caveats only when they change the reader's next step.
 - Never pad: no tangents, unsolicited offers, raw dumps, or process recaps.
-  Explicit depth requests win; depth applies to substantive answers only.
+  Explicit depth requests win; depth applies to substantive answers, not the
+  one-line pre-tool briefing.
 - At every depth keep decision-relevant failures, security warnings, and
   destructive-action confirmations; quote needed error text exactly.

package/src/rules/lead/LEAD.md

@@ -4,10 +4,12 @@
 - The user's latest explicit request overrides any internal rule; drive it to
   completion.
 - The user sees your text, and tool calls only as activity cards, never your
-  thinking. Before the first tool call, state in one line what you are about
-  to do; afterwards bring the user only material findings, direction or scope
-  changes, unapproved destructive actions, blockers or meaningful delays —
-  never per-call narration or plan repeats.
+  thinking. Before your first tool call, briefly state what you are about to
+  do. While working, give short updates at key moments: when you find
+  something, change direction, or make progress without an update for a
+  while. Otherwise bring the user only material findings, direction or scope
+  changes, unapproved destructive actions, blockers or meaningful delays — never per-call
+  narration or plan repeats.
 - Mid-task: a replacement supersedes, an addition folds in, a status question
   gets a brief answer while work continues.
 - Context is managed automatically: never stop or propose stopping because of

package/src/runtime/agent/orchestrator/session/store-agent-worker-rows.mjs

@@ -212,8 +212,13 @@ export function listStoredAgentWorkerLinks() {
 // The agent pool only reads top-level session fields, yet each refresh used to
 // JSON.parse every active worker's whole transcript (megabytes per worker,
 // every catalog publish). Cache the header per file fingerprint instead.
-const WORKER_HEADER_CACHE_MAX = 256;
+// The cache holds exactly the headers the latest pool assembly read: a fixed
+// LRU cap below the index size (263 headers against 256 slots) evicted every
+// entry just before its reuse, so each refresh re-parsed every worker
+// transcript synchronously (~130 MB, ~1 s of blocked daemon event loop).
 const workerSessionHeaderCache = new Map();
+/** Assembly the cache entries were last read by; older entries are dropped. */
+let headerPass = 0;
 // Pool rows need identity, routing, and lifecycle metadata only. Keeping the
 // rest of a session here also retained its tool catalogs and provider state.
 const WORKER_HEADER_FIELDS = [
@@ -251,9 +256,7 @@ function readWorkerSessionHeader(sessionId) {
   if (probe.state !== PROBE_PRESENT) return null;
   const cached = workerSessionHeaderCache.get(path);
   if (cached && cached.mtimeMs === probe.mtimeMs && cached.size === probe.size) {
-    // Refresh insertion order so the eviction below stays LRU-ish.
-    workerSessionHeaderCache.delete(path);
-    workerSessionHeaderCache.set(path, cached);
+    cached.pass = headerPass;
     return cached.header;
   }
   let session = null;
@@ -267,10 +270,7 @@ function readWorkerSessionHeader(sessionId) {
   for (const field of WORKER_HEADER_FIELDS) {
     if (Object.hasOwn(session, field)) header[field] = session[field];
   }
-  workerSessionHeaderCache.set(path, { mtimeMs: probe.mtimeMs, size: probe.size, header });
-  if (workerSessionHeaderCache.size > WORKER_HEADER_CACHE_MAX) {
-    workerSessionHeaderCache.delete(workerSessionHeaderCache.keys().next().value);
-  }
+  workerSessionHeaderCache.set(path, { mtimeMs: probe.mtimeMs, size: probe.size, header, pass: headerPass });
   return header;
 }
 
@@ -487,13 +487,21 @@ export function listStoredAgentWorkers({ runningSessionIds = null } = {}) {
     };
     return tombstoneBlocksWork(work, findTagTombstone(work, tombstones));
   };
-  return assembleStoredAgentWorkers({
-    now,
-    runningSessionIds,
-    storedAgentWorkerIndexRows: () => rows.filter((row) => !isReaped(cleanValue(row.sessionId))),
-    projectChildWorkerRow,
-    storedLeadWorkerRows,
-    projectLeadWorkerRow,
-    pruneOrphanChildRows,
-  });
+  headerPass += 1;
+  try {
+    return assembleStoredAgentWorkers({
+      now,
+      runningSessionIds,
+      storedAgentWorkerIndexRows: () => rows.filter((row) => !isReaped(cleanValue(row.sessionId))),
+      projectChildWorkerRow,
+      storedLeadWorkerRows,
+      projectLeadWorkerRow,
+      pruneOrphanChildRows,
+    });
+  } finally {
+    // Keep what this assembly read, whatever the index size; forget the rest.
+    for (const [path, entry] of workerSessionHeaderCache) {
+      if (entry.pass !== headerPass) workerSessionHeaderCache.delete(path);
+    }
+  }
 }

package/src/standalone/desktop-service-registry.mjs

@@ -165,6 +165,8 @@ export class DesktopServiceRegistry {
         moduleUrl: requestedModule,
         instance,
         subscribers: new Set(),
+        visibilityEpochs: new Map(),
+        nextVisibilityEpoch: 0,
       };
       this.#servicesById.set(requestedId, record);
       this.#servicesByModule.set(requestedModule, record);
@@ -187,7 +189,14 @@ export class DesktopServiceRegistry {
     const service = await this.#initialize(params);
     if (this.#closed) throw new Error('session service is closed');
     const token = subscriberToken(ctx);
-    if (token) service.subscribers.add(token);
+    if (token) {
+      service.subscribers.add(token);
+      // The adapter outlives desktop processes, whose request counters restart.
+      // Allocate the ordering namespace here, not from a client's wall clock.
+      if (!service.visibilityEpochs.has(token)) {
+        service.visibilityEpochs.set(token, ++service.nextVisibilityEpoch);
+      }
+    }
     this.#syncModelProxyPresence();
     return { desktopId: service.desktopId };
   }
@@ -215,14 +224,23 @@ export class DesktopServiceRegistry {
   }
 
   async invoke({ desktopId, method, args = [] } = {}, ctx = null) {
-    const { service } = this.#requireSubscribed(desktopId, ctx);
+    const { service, token } = this.#requireSubscribed(desktopId, ctx);
     const name = String(method || '');
     if (!name) throw new TypeError('desktop service method is required');
+    let callArgs = Array.isArray(args) ? args : [];
+    if (name === 'setVisibleSessions' && token) {
+      const epoch = service.visibilityEpochs.get(token);
+      if (epoch === undefined) {
+        service.subscribers.delete(token);
+        throw new Error('desktop service client is not initialized');
+      }
+      callArgs = [callArgs[0], callArgs[1], epoch];
+    }
     // `[slow-op] desktop.invoke` names the call it timed: a desktop operation
     // (Git reads) or a session capability, not only the generic route.
     const target = name === 'invokeDesktopOperation' || name === 'invokeCapability' ? String(args?.[0] || '') : '';
     annotateSpan(target ? `${name}:${target}` : name);
-    return sanitizeForWire(await service.instance.invoke(name, Array.isArray(args) ? args : [])) ?? null;
+    return sanitizeForWire(await service.instance.invoke(name, callArgs)) ?? null;
   }
 
   async control({ desktopId, message } = {}, ctx = null) {
@@ -241,7 +259,7 @@ export class DesktopServiceRegistry {
   async unsubscribe({ desktopId } = {}, ctx = null) {
     const service = this.#require(desktopId);
     const token = subscriberToken(ctx);
-    if (token) service.subscribers.delete(token);
+    if (token) await this.#releaseSubscriber(service, token);
     this.#syncModelProxyPresence();
     return { ok: true, unsubscribed: true };
   }
@@ -250,11 +268,20 @@ export class DesktopServiceRegistry {
     const token = String(clientToken || '');
     if (!token) return;
     for (const service of this.#servicesById.values()) {
-      service.subscribers.delete(token);
+      void this.#releaseSubscriber(service, token).catch((error) => {
+        this.#log(`desktop visibility release failed: ${error?.message || error}`);
+      });
     }
     this.#syncModelProxyPresence();
   }
 
+  async #releaseSubscriber(service, token) {
+    service.subscribers.delete(token);
+    const epoch = service.visibilityEpochs.get(token);
+    service.visibilityEpochs.delete(token);
+    if (epoch !== undefined) await service.instance.releaseClient?.(epoch);
+  }
+
   notifySessionRuntimeReleased(sessionId, reason) {
     // An evicted session has NO session subscribers. Its desktop resources
     // still belong to the desktop service and must be notified on that lane.

package/src/tui/dist/index.mjs

@@ -38488,19 +38488,34 @@ var HEALABLE_MARKDOWN_SYNTAX = /[`*_~[]/;
 function openFence(text) {
   let marker = "";
   let length = 0;
+  let start = 0;
+  let lineStart2 = 0;
   for (const rawLine of String(text ?? "").split("\n")) {
     const fence = FENCE_LINE.exec(rawLine.replace(/\r$/, ""));
-    if (!fence) continue;
-    const marks = fence[1];
-    if (!marker) {
-      marker = marks[0];
-      length = marks.length;
-    } else if (marks[0] === marker && marks.length >= length && !fence[2].trim()) {
-      marker = "";
-      length = 0;
+    if (fence) {
+      const marks = fence[1];
+      if (!marker) {
+        marker = marks[0];
+        length = marks.length;
+        start = lineStart2;
+      } else if (marks[0] === marker && marks.length >= length && !fence[2].trim()) {
+        marker = "";
+        length = 0;
+      }
     }
+    lineStart2 += rawLine.length + 1;
   }
-  return marker ? { marker, length } : null;
+  return marker ? { marker, length, start } : null;
+}
+function trimPartialOpeningFence(text, fence) {
+  const lineEnd2 = text.indexOf("\n", fence.start);
+  return lineEnd2 >= 0 && /\S/.test(text.slice(lineEnd2 + 1)) ? text : text.slice(0, fence.start);
+}
+var PENDING_BLOCK_MARKER_LINE = /(?:^|\n)[ \t]*(?:[-+*=_#>~`]+|\d{1,9}[.)]?)[ \t]*$/;
+function trimPendingBlockMarker(text) {
+  const pending = PENDING_BLOCK_MARKER_LINE.exec(text);
+  if (!pending) return text;
+  return text.slice(0, pending.index + (pending[0].startsWith("\n") ? 1 : 0));
 }
 function trimPartialClosingFence(text, fence) {
   const partial = /(?:^|\r?\n) {0,3}([`~]+)$/.exec(text);
@@ -38531,7 +38546,7 @@ function closeInlineCode(text, isPendingLocalPath) {
     } else if (run === open) open = 0;
     index = end;
   }
-  if (open && isPendingLocalPath?.(text.slice(openIndex + open))) {
+  if (open && (!text.slice(openIndex + open) || isPendingLocalPath?.(text.slice(openIndex + open)))) {
     return text.slice(0, openIndex);
   }
   return open > 0 ? `${text}${"`".repeat(open)}` : text;
@@ -38561,6 +38576,7 @@ function scanEmphasisRuns(masked) {
     let end = index + 1;
     while (masked[end] === marker) end += 1;
     const length = end - index;
+    const at = index;
     const before = index > 0 ? masked[index - 1] : "";
     const after = end < masked.length ? masked[end] : "";
     const beforeSpace = isMarkdownSpace(before);
@@ -38570,16 +38586,25 @@ function scanEmphasisRuns(masked) {
     const left = !afterSpace && (!afterPunctuation || beforeSpace || beforePunctuation);
     const right = !beforeSpace && (!beforePunctuation || afterSpace || afterPunctuation);
     if (marker === "~") {
-      if (length >= 2) runs.push({ marker, length: 2, canOpen: left, canClose: right });
+      runs.push({
+        marker,
+        length: Math.min(length, 2),
+        canOpen: left && length >= 2,
+        canClose: right && length >= 2,
+        at,
+        end
+      });
     } else if (marker === "_") {
       runs.push({
         marker,
         length,
         canOpen: left && (!right || beforePunctuation),
-        canClose: right && (!left || afterPunctuation)
+        canClose: right && (!left || afterPunctuation),
+        at,
+        end
       });
     } else {
-      runs.push({ marker, length, canOpen: left, canClose: right });
+      runs.push({ marker, length, canOpen: left, canClose: right, at, end });
     }
     index = end;
   }
@@ -38587,7 +38612,9 @@ function scanEmphasisRuns(masked) {
 }
 function closeEmphasis(text) {
   const open = [];
-  for (const run of scanEmphasisRuns(maskCode(text))) {
+  const runs = scanEmphasisRuns(maskCode(text));
+  const last = runs[runs.length - 1];
+  for (const run of runs) {
     let length = run.length;
     while (run.canClose && length > 0) {
       let match = -1;
@@ -38604,13 +38631,17 @@ function closeEmphasis(text) {
       length -= used;
       open.length = opener.length > 0 ? match + 1 : match;
     }
+    if (run === last && run.end === text.length && length === run.length) {
+      return closeEmphasis(text.slice(0, run.at));
+    }
     if (length > 0 && run.canOpen) open.push({ marker: run.marker, length });
   }
-  let healed = text;
+  const body = text.trimEnd();
+  let closers = "";
   for (let index = open.length - 1; index >= 0; index -= 1) {
-    healed += open[index].marker.repeat(Math.min(open[index].length, 3));
+    closers += open[index].marker.repeat(Math.min(open[index].length, 3));
   }
-  return healed;
+  return closers ? `${body}${closers}${text.slice(body.length)}` : text;
 }
 function linkDestinationEnd(text, start) {
   let depth = 1;
@@ -38694,8 +38725,9 @@ function trimPendingTableHead(text) {
 function healStreamingMarkdownTail(text, isPendingLocalPath) {
   const source = String(text ?? "");
   const fence = source.includes("`") || source.includes("~") ? openFence(source) : null;
-  if (fence) return trimPartialClosingFence(source, fence);
-  const value = source.includes("|") ? trimPendingTableHead(source) : source;
+  if (fence) return trimPartialOpeningFence(trimPartialClosingFence(source, fence), fence);
+  const unmarked = trimPendingBlockMarker(source);
+  const value = unmarked.includes("|") ? trimPendingTableHead(unmarked) : unmarked;
   const hasSyntax = HEALABLE_MARKDOWN_SYNTAX.test(value);
   if (!value || !hasSyntax && !isPendingLocalPath) return value;
   const healed = hasSyntax ? closeEmphasis(healIncompleteLink(closeInlineCode(value, isPendingLocalPath), isPendingLocalPath)) : value;

package/src/ui/streaming-markdown-heal.mjs

@@ -8,19 +8,47 @@ const HEALABLE_MARKDOWN_SYNTAX = /[`*_~[]/;
 function openFence(text) {
   let marker = '';
   let length = 0;
+  let start = 0;
+  let lineStart = 0;
   for (const rawLine of String(text ?? '').split('\n')) {
     const fence = FENCE_LINE.exec(rawLine.replace(/\r$/, ''));
-    if (!fence) continue;
-    const marks = fence[1];
-    if (!marker) {
-      marker = marks[0];
-      length = marks.length;
-    } else if (marks[0] === marker && marks.length >= length && !fence[2].trim()) {
-      marker = '';
-      length = 0;
+    if (fence) {
+      const marks = fence[1];
+      if (!marker) {
+        marker = marks[0];
+        length = marks.length;
+        start = lineStart;
+      } else if (marks[0] === marker && marks.length >= length && !fence[2].trim()) {
+        marker = '';
+        length = 0;
+      }
     }
+    lineStart += rawLine.length + 1;
   }
-  return marker ? { marker, length } : null;
+  return marker ? { marker, length, start } : null;
+}
+
+// The opening fence line arrives a token at a time: ``` → ```py → ```python.
+// Rendered at once, the card opened unlabelled and then relabelled (and
+// re-highlighted) per token. The card appears with its first code character:
+// an opening line alone would paint an empty box before any code.
+function trimPartialOpeningFence(text, fence) {
+  const lineEnd = text.indexOf('\n', fence.start);
+  return lineEnd >= 0 && /\S/.test(text.slice(lineEnd + 1)) ? text : text.slice(0, fence.start);
+}
+
+// A line holding only a block marker so far has no content to show, and the
+// marker alone parses as something else: `-` or `=` under a paragraph is a
+// setext underline (the paragraph flashed into a heading until the item text
+// arrived), `2` is a lazy paragraph continuation until its `.` arrives, `#`
+// grows into `##`, and a lone backtick run is literal text until it becomes a
+// fence. Hold the line back until its first content character.
+const PENDING_BLOCK_MARKER_LINE = /(?:^|\n)[ \t]*(?:[-+*=_#>~`]+|\d{1,9}[.)]?)[ \t]*$/;
+
+function trimPendingBlockMarker(text) {
+  const pending = PENDING_BLOCK_MARKER_LINE.exec(text);
+  if (!pending) return text;
+  return text.slice(0, pending.index + (pending[0].startsWith('\n') ? 1 : 0));
 }
 
 // A closing fence arrives a token at a time. Until its run is long enough to
@@ -57,7 +85,9 @@ function closeInlineCode(text, isPendingLocalPath) {
     } else if (run === open) open = 0;
     index = end;
   }
-  if (open && isPendingLocalPath?.(text.slice(openIndex + open))) {
+  // An opener with nothing after it yet closes into an empty span, which
+  // parses as a literal backtick run that then vanishes into code.
+  if (open && (!text.slice(openIndex + open) || isPendingLocalPath?.(text.slice(openIndex + open)))) {
     return text.slice(0, openIndex);
   }
   return open > 0 ? `${text}${'`'.repeat(open)}` : text;
@@ -93,6 +123,7 @@ function scanEmphasisRuns(masked) {
     let end = index + 1;
     while (masked[end] === marker) end += 1;
     const length = end - index;
+    const at = index;
     const before = index > 0 ? masked[index - 1] : '';
     const after = end < masked.length ? masked[end] : '';
     const beforeSpace = isMarkdownSpace(before);
@@ -102,16 +133,26 @@ function scanEmphasisRuns(masked) {
     const left = !afterSpace && (!afterPunctuation || beforeSpace || beforePunctuation);
     const right = !beforeSpace && (!beforePunctuation || afterSpace || afterPunctuation);
     if (marker === '~') {
-      if (length >= 2) runs.push({ marker, length: 2, canOpen: left, canClose: right });
+      // A single tilde is inert, but at the end it may be half of `~~`.
+      runs.push({
+        marker,
+        length: Math.min(length, 2),
+        canOpen: left && length >= 2,
+        canClose: right && length >= 2,
+        at,
+        end,
+      });
     } else if (marker === '_') {
       runs.push({
         marker,
         length,
         canOpen: left && (!right || beforePunctuation),
         canClose: right && (!left || afterPunctuation),
+        at,
+        end,
       });
     } else {
-      runs.push({ marker, length, canOpen: left, canClose: right });
+      runs.push({ marker, length, canOpen: left, canClose: right, at, end });
     }
     index = end;
   }
@@ -120,7 +161,9 @@ function scanEmphasisRuns(masked) {
 
 function closeEmphasis(text) {
   const open = [];
-  for (const run of scanEmphasisRuns(maskCode(text))) {
+  const runs = scanEmphasisRuns(maskCode(text));
+  const last = runs[runs.length - 1];
+  for (const run of runs) {
     let length = run.length;
     while (run.canClose && length > 0) {
       let match = -1;
@@ -137,13 +180,21 @@ function closeEmphasis(text) {
       length -= used;
       open.length = opener.length > 0 ? match + 1 : match;
     }
+    // A run ending the text that closed nothing has no content after it yet:
+    // it painted as literal `**` until the next token turned it into style.
+    if (run === last && run.end === text.length && length === run.length) {
+      return closeEmphasis(text.slice(0, run.at));
+    }
     if (length > 0 && run.canOpen) open.push({ marker: run.marker, length });
   }
-  let healed = text;
+  // Closers go before trailing whitespace: `**word ` closed after the space
+  // could not close (a closing run must follow non-space) and stayed literal.
+  const body = text.trimEnd();
+  let closers = '';
   for (let index = open.length - 1; index >= 0; index -= 1) {
-    healed += open[index].marker.repeat(Math.min(open[index].length, 3));
+    closers += open[index].marker.repeat(Math.min(open[index].length, 3));
   }
-  return healed;
+  return closers ? `${body}${closers}${text.slice(body.length)}` : text;
 }
 
 function linkDestinationEnd(text, start) {
@@ -246,8 +297,9 @@ function trimPendingTableHead(text) {
 export function healStreamingMarkdownTail(text, isPendingLocalPath) {
   const source = String(text ?? '');
   const fence = source.includes('`') || source.includes('~') ? openFence(source) : null;
-  if (fence) return trimPartialClosingFence(source, fence);
-  const value = source.includes('|') ? trimPendingTableHead(source) : source;
+  if (fence) return trimPartialOpeningFence(trimPartialClosingFence(source, fence), fence);
+  const unmarked = trimPendingBlockMarker(source);
+  const value = unmarked.includes('|') ? trimPendingTableHead(unmarked) : unmarked;
   const hasSyntax = HEALABLE_MARKDOWN_SYNTAX.test(value);
   if (!value || (!hasSyntax && !isPendingLocalPath)) return value;
   const healed = hasSyntax