mixdog 1.4.0 → 1.4.1

package/src/runtime/office/design/design-art-direction.mjs

@@ -236,34 +236,36 @@ export function resolveOfficeArtDirection(
     String(format || '').toLowerCase() === 'xlsx'
       ? DIRECTION_BLUEPRINTS.filter((blueprint) => blueprint.backgroundMode !== 'dark')
       : DIRECTION_BLUEPRINTS;
-  const candidates = blueprints.map((blueprint) => {
-    const palette = directionPalette(baseHue, blueprint);
-    const motif = rawSubject ? `${blueprint.motif} · ${rawSubject}` : blueprint.motif;
-    return {
-      id: blueprint.id,
-      label: blueprint.label,
-      rationale: `${blueprint.label} fits ${purpose} through ${blueprint.motif}.`,
-      motif,
-      palette,
-      typography: { ...blueprint.typography },
-      style: { ...blueprint.style, pageRhythm: [...blueprint.style.pageRhythm] },
-      creativeSystem: creativeSystemOf(blueprint),
-      deck: {
-        backgroundMode: blueprint.backgroundMode,
+  const candidates = blueprints
+    .map((blueprint) => {
+      const palette = directionPalette(baseHue, blueprint);
+      const motif = rawSubject ? `${blueprint.motif} · ${rawSubject}` : blueprint.motif;
+      return {
+        id: blueprint.id,
+        label: blueprint.label,
+        rationale: `${blueprint.label} fits ${purpose} through ${blueprint.motif}.`,
         motif,
-        imageTreatment: blueprint.imageTreatment,
-        layoutBias: [...blueprint.layoutBias],
-        ...creativeSystemOf(blueprint),
-      },
-      score: directionScore(blueprint, {
-        purpose,
-        expressionMode,
-        tone: String(request.tone || ''),
-        requestedId: String(requested.id || ''),
-        seed,
-      }),
-    };
-  }).sort((left, right) => right.score - left.score || left.id.localeCompare(right.id));
+        palette,
+        typography: { ...blueprint.typography },
+        style: { ...blueprint.style, pageRhythm: [...blueprint.style.pageRhythm] },
+        creativeSystem: creativeSystemOf(blueprint),
+        deck: {
+          backgroundMode: blueprint.backgroundMode,
+          motif,
+          imageTreatment: blueprint.imageTreatment,
+          layoutBias: [...blueprint.layoutBias],
+          ...creativeSystemOf(blueprint),
+        },
+        score: directionScore(blueprint, {
+          purpose,
+          expressionMode,
+          tone: String(request.tone || ''),
+          requestedId: String(requested.id || ''),
+          seed,
+        }),
+      };
+    })
+    .sort((left, right) => right.score - left.score || left.id.localeCompare(right.id));
   const selected = candidates[0];
   const hasSubject = Boolean(rawSubject || requested.seed || requested.id);
   const disabled = request.artDirection === false || requested.enabled === false;

package/src/runtime/office/pdf/pdf-writer.mjs

@@ -890,7 +890,12 @@ function drawChartBlock(flow, block, following) {
       });
       flow.y -= rowH;
     });
-    page.drawLine({ start: { x: left, y: top }, end: { x: left, y: flow.y }, thickness: 0.6, color: color(flow.ink.line) });
+    page.drawLine({
+      start: { x: left, y: top },
+      end: { x: left, y: flow.y },
+      thickness: 0.6,
+      color: color(flow.ink.line),
+    });
   } else {
     const baseline = flow.y - size * 1.6 - layout.plotH;
     values.forEach((value, index) => {

package/src/runtime/office/portable/portable-snapshot-docx.mjs

@@ -12,7 +12,13 @@ import {
   xmlDecode,
 } from './portable-xml.mjs';
 import { countDocxPropertyChanges, docxRevisionTree, flattenDocxRevisions } from './docx-revisions.mjs';
-import { docxParagraphSpacing, docxRunFont, nextPageOffset, softBreakFacts, statedRunFont } from './portable-snapshot-shared.mjs';
+import {
+  docxParagraphSpacing,
+  docxRunFont,
+  nextPageOffset,
+  softBreakFacts,
+  statedRunFont,
+} from './portable-snapshot-shared.mjs';
 
 const REVISION_TYPES = Object.freeze({
   ins: 'insertion',

package/src/runtime/office/portable/portable-snapshot-shared.mjs

@@ -123,7 +123,12 @@ export function populatedCellPagination({ options, page, selectedSheets, sheets,
 
 export function statedRunFont(xml) {
   const direct = docxRunFont(xml);
-  return direct.size || direct.bold || direct.name || direct.color || direct.caps !== undefined || direct.letterSpacing !== undefined
+  return direct.size ||
+    direct.bold ||
+    direct.name ||
+    direct.color ||
+    direct.caps !== undefined ||
+    direct.letterSpacing !== undefined
     ? { font: direct }
     : {};
 }

package/src/runtime/office/quality/assurance-rendered.mjs

@@ -152,7 +152,13 @@ export async function reviewRenderedOfficePages(
     // The cover/title page is short by design, and a page followed by a deliberate forced break ends where the
     // author ended it.
     const endsBeforeForcedBreak = forcedBreaks?.has(metric.page + 1) === true;
-    if (flowing && metric.page > 1 && !endsBeforeForcedBreak && metric.page < lastPage && metric.bodyEnd < PAGE_BODY_END_MIN) {
+    if (
+      flowing &&
+      metric.page > 1 &&
+      !endsBeforeForcedBreak &&
+      metric.page < lastPage &&
+      metric.bodyEnd < PAGE_BODY_END_MIN
+    ) {
       const empty = Math.round((1 - metric.bodyEnd) * 100);
       issues.push(
         issue(
@@ -166,7 +172,8 @@ export async function reviewRenderedOfficePages(
       continue;
     }
     // A short chapter is the author's: the page ends before a forced break, or it is the last page and opens with one.
-    const deliberateShort = endsBeforeForcedBreak || (forcedBreaks?.has(metric.page) === true && metric.page >= lastPage);
+    const deliberateShort =
+      endsBeforeForcedBreak || (forcedBreaks?.has(metric.page) === true && metric.page >= lastPage);
     if (
       ['docx', 'pdf'].includes(normalized) &&
       metric.page > 1 &&

package/src/runtime/office/quality/assurance-structure-docx.mjs

@@ -12,7 +12,9 @@ function paragraphSize(paragraph) {
 }
 
 const median = (values) => {
-  const sorted = values.filter((value) => value !== '' && value !== undefined && value !== null).sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
+  const sorted = values
+    .filter((value) => value !== '' && value !== undefined && value !== null)
+    .sort((left, right) => (left < right ? -1 : left > right ? 1 : 0));
   return sorted.length ? sorted[Math.floor(sorted.length / 2)] : undefined;
 };
 // Automatic colour is the effective default, black.

package/src/runtime/office/quality/design-review.mjs

@@ -12,11 +12,7 @@ import {
   saturatedHueFamilies,
 } from '../design/design-discipline.mjs';
 import { authoredBackgroundLadder, isCardGridSlide, isOrnamentalStripe, slideSize } from './design-review-authored.mjs';
-import {
-  reviewBriefPromises,
-  reviewFactCoverage,
-  reviewSourceGrounding,
-} from '../authoring/pptx-brief.mjs';
+import { reviewBriefPromises, reviewFactCoverage, reviewSourceGrounding } from '../authoring/pptx-brief.mjs';
 import { isAdvisoryOfficeIssue } from './quality-pipeline.mjs';
 import { issue } from './assurance-issue.mjs';
 import { isPptxSpecimenSlide, isPptxStatementSlide } from './pptx-slide-roles.mjs';

package/src/runtime/office/quality/document-brief.mjs

@@ -1,11 +1,7 @@
 // A Word document or workbook held to its brief, as an authored deck is: every figure its words show has a fact with
 // a source, and a fact cites where a reader can open it. The brief is the deck's (`design.brief`, key: value lines);
 // the readings are the deck's own (pptx-brief.mjs), over the document's text instead of its slides.
-import {
-  parseAuthoringBrief,
-  reviewFactCoverage,
-  reviewSourceGrounding,
-} from '../authoring/pptx-brief.mjs';
+import { parseAuthoringBrief, reviewFactCoverage, reviewSourceGrounding } from '../authoring/pptx-brief.mjs';
 import { htmlBriefScript } from '../authoring/pptx-html-runner.mjs';
 
 /** The brief a docx/xlsx call names in design.brief (the HTML BRIEF's key: value lines), or null. */

package/src/runtime/office/quality/forced-break-pages.mjs

@@ -25,9 +25,7 @@ const visibleText = (html) =>
 
 // A media query list reaches the printed page unless every query is screen-only.
 const appliesToPrint = (queries) =>
-  queries
-    .split(',')
-    .some((query) => !/^\s*(?:only\s+)?screen\b/i.test(query) && !/^\s*not\s+print\b/i.test(query));
+  queries.split(',').some((query) => !/^\s*(?:only\s+)?screen\b/i.test(query) && !/^\s*not\s+print\b/i.test(query));
 
 // Style rules in source order, flattened out of @media blocks that do not apply in print.
 function cssRules(css, active, rules) {
@@ -38,7 +36,10 @@ function cssRules(css, active, rules) {
     let depth = 1;
     let close = open + 1;
     for (; close < css.length && depth > 0; close += 1) depth += css[close] === '{' ? 1 : css[close] === '}' ? -1 : 0;
-    const head = css.slice(index, open).replace(/^(?:\s*@[^{;]*;)+/, '').trim();
+    const head = css
+      .slice(index, open)
+      .replace(/^(?:\s*@[^{;]*;)+/, '')
+      .trim();
     const inner = css.slice(open + 1, close - 1);
     if (/^@media\b/i.test(head)) cssRules(inner, active && appliesToPrint(head.slice(6)), rules);
     else if (active && head && !head.startsWith('@')) rules.push({ head, body: inner });
@@ -64,7 +65,8 @@ function breakDeclaration(body, rank) {
 }
 
 const beats = (a, b) => {
-  for (let index = 0; index < a.rank.length; index += 1) if (a.rank[index] !== b.rank[index]) return a.rank[index] > b.rank[index];
+  for (let index = 0; index < a.rank.length; index += 1)
+    if (a.rank[index] !== b.rank[index]) return a.rank[index] > b.rank[index];
   return true;
 };
 
@@ -80,7 +82,8 @@ function breakSelectors(html) {
         const classes = match[3].split('.').filter(Boolean);
         const specificity = (match[2] ? 100 : 0) + classes.length * 10 + (match[1] ? 1 : 0);
         const declaration = breakDeclaration(body, [0, specificity, order]);
-        if (declaration) selectors.push({ tag: (match[1] || '').toLowerCase(), id: match[2] || '', classes, declaration });
+        if (declaration)
+          selectors.push({ tag: (match[1] || '').toLowerCase(), id: match[2] || '', classes, declaration });
       }
     }
   }

package/src/runtime/office/quality/quality-pipeline.mjs

@@ -289,7 +289,7 @@ const POLISH_GUIDANCE = Object.freeze({
   theme_background_drift:
     'Use only the ladder backgrounds (paper, paperAlt, dark, darkAlt); recolor the drifting slide.',
   theme_body_backgrounds:
-    'Advisory: body slides use several background colours; keep them to the concept\'s declared palette ladder, or declare the concept or palette in the brief when the colour fields are the design.',
+    "Advisory: body slides use several background colours; keep them to the concept's declared palette ladder, or declare the concept or palette in the brief when the colour fields are the design.",
   excessive_slide_text: "Cut the copy to the reading mode's budget (composition.md §4) or split the slide.",
   decorative_stripe: 'Remove the ornamental bar; a stripe that encodes nothing is decoration (composition.md §10).',
   // Visual critique contract (finalize).

package/src/runtime/shared/bot-owned-work.mjs

@@ -0,0 +1,56 @@
+// Bot-owned work: the live work in a session that a bot sent. A bot's accepted
+// `session` send or create (session-runtime/agent-task-sessions.mjs) is the
+// bot's work in that session from its acceptance until it settles or is
+// cancelled — whether or not it reports back (`notify: false`, a report watch
+// that could not be stored). A turn nobody sent (the user typed it in the
+// task session) is owned by no bot, so it never reads as a bot being busy.
+// Process-wide and dependency-free like delegated-approval-host.mjs. The
+// registry is only this process's cache: what keeps the work owned across a
+// restart is stored apart (a reporting send's watch, any other send's record
+// of its work, both in agent-home-delivery.mjs) and re-noted by
+// agent-task-sessions.mjs recover. A change of which bots own a session's work
+// is announced (session-activity-signal.mjs onSessionBotWorkChange), so the
+// session catalog, which stamps them on each row, re-lists.
+import { emitSessionBotWorkChange } from './session-activity-signal.mjs';
+
+const KEY = Symbol.for('mixdog.botOwnedWork.v1');
+
+/** Map run id → `{ sessionId, agentId }`. */
+function registry() {
+  globalThis[KEY] ??= new Map();
+  return globalThis[KEY];
+}
+
+/** How many owned works of `agentId` run in `sessionId`. */
+function worksOf(sessionId, agentId) {
+  let count = 0;
+  for (const work of registry().values()) if (work.sessionId === sessionId && work.agentId === agentId) count += 1;
+  return count;
+}
+
+/** Every session with owned work and the bots owning it (each once, in noting
+ *  order): Map session → agent ids. */
+export function botWorkBySession() {
+  const bySession = new Map();
+  for (const { sessionId, agentId } of registry().values()) {
+    const agents = bySession.get(sessionId) ?? [];
+    if (!agents.includes(agentId)) agents.push(agentId);
+    bySession.set(sessionId, agents);
+  }
+  return bySession;
+}
+
+/** Agent `agentId`'s submission `runId` to `sessionId` was accepted. */
+export function noteBotWork({ runId, sessionId, agentId }) {
+  if (!runId || !sessionId || !agentId || registry().has(String(runId))) return;
+  registry().set(String(runId), { sessionId: String(sessionId), agentId: String(agentId) });
+  if (worksOf(String(sessionId), String(agentId)) === 1) emitSessionBotWorkChange(sessionId);
+}
+
+/** Submission `runId` settled or was cancelled: its work is nobody's now. */
+export function endBotWork(runId) {
+  const work = registry().get(String(runId));
+  if (!work) return;
+  registry().delete(String(runId));
+  if (worksOf(work.sessionId, work.agentId) === 0) emitSessionBotWorkChange(work.sessionId);
+}

package/src/runtime/shared/defaults-separation.mjs

@@ -176,10 +176,7 @@ function removeLegacyKeys(root, dataDir) {
  * not set the marker. `stripRouteDefaults` drops shipped presets and
  * maintenance routes (their defaults live with the agent config).
  */
-function separateDefaultsInConfig(
-  root,
-  { stripRouteDefaults = (agent) => agent, dataDir = resolvePluginData() } = {}
-) {
+function separateDefaultsInConfig(root, { stripRouteDefaults = (agent) => agent, dataDir = resolvePluginData() } = {}) {
   const from = Number(root?.[DEFAULTS_VERSION_KEY]) || 0;
   let next = { ...(root || {}) };
   if (from < 1) {

package/src/runtime/shared/fetch-safe-listen.d.mts

@@ -0,0 +1,16 @@
+import type { Server } from 'node:net';
+
+export const FETCH_BLOCKED_PORTS: ReadonlySet<number>;
+
+export const FETCH_SAFE_ATTEMPTS: number;
+
+export function listenOnFetchSafePort(
+  server: Server,
+  host: string,
+  onListening: () => void,
+  options?: {
+    attempts?: number;
+    isCurrent?: () => boolean;
+    portOf?: (server: Server) => number;
+  }
+): void;

package/src/runtime/shared/fetch-safe-listen.mjs

@@ -0,0 +1,50 @@
+// Ports the WHATWG Fetch spec blocks ("bad port"): fetch (undici) and Chromium
+// refuse to connect to them, so a loopback server that a fetch client or a
+// browser context must reach cannot live on one. https://fetch.spec.whatwg.org/#port-blocking
+export const FETCH_BLOCKED_PORTS = new Set([
+  0, 1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42, 43, 53, 69, 77, 79, 87, 95, 101, 102, 103, 104, 109, 110,
+  111, 113, 115, 117, 119, 123, 135, 137, 139, 143, 161, 179, 389, 427, 465, 512, 513, 514, 515, 526, 530, 531, 532,
+  540, 548, 554, 556, 563, 587, 601, 636, 989, 990, 993, 995, 1719, 1720, 1723, 2049, 3659, 4045, 4190, 5060, 5061,
+  6000, 6566, 6665, 6666, 6667, 6668, 6669, 6679, 6697, 10080,
+]);
+
+/** How many more OS-assigned ports a listener takes after a blocked one. */
+export const FETCH_SAFE_ATTEMPTS = 16;
+
+const assignedPort = (server) => {
+  const address = server.address();
+  return address && typeof address === 'object' ? address.port : 0;
+};
+
+/**
+ * `server.listen(0, host)` that never settles on a fetch-blocked port: when the
+ * OS assigns one, the server is closed and listened again, at most `attempts`
+ * more times. `onListening` runs once, on a safe port. When the attempts run
+ * out the server is closed and an 'error' is emitted, like a failed listen.
+ * `isCurrent` lets a caller that stopped the server meanwhile cancel the retry;
+ * `portOf` reads the assigned port.
+ */
+export function listenOnFetchSafePort(
+  server,
+  host,
+  onListening,
+  { attempts = FETCH_SAFE_ATTEMPTS, isCurrent = () => true, portOf = assignedPort } = {}
+) {
+  let retries = attempts;
+  const attempt = () => {
+    server.listen(0, host, () => {
+      if (!FETCH_BLOCKED_PORTS.has(portOf(server))) {
+        onListening();
+        return;
+      }
+      const exhausted = retries <= 0;
+      retries -= 1;
+      server.close(() => {
+        if (!isCurrent()) return;
+        if (exhausted) server.emit('error', new Error('no fetch-safe loopback port was assigned'));
+        else attempt();
+      });
+    });
+  };
+  attempt();
+}

package/src/runtime/shared/handoff-artifacts.d.mts

@@ -8,7 +8,8 @@ export interface HandoffFile {
   id?: string;
 }
 export function normalizeHandoffFiles(files: unknown): HandoffFile[];
-export function artifactLines(files: unknown, omitted?: number, options?: { ids?: boolean }): string[];
+export function artifactLines(files: unknown, omitted?: number): string[];
+export function producedFileLines(files: unknown, omitted?: number): string[];
 export interface HandoffRecord {
   id: string;
   attachmentRef: string;

package/src/runtime/shared/handoff-artifacts.mjs

@@ -31,20 +31,30 @@ export function normalizeHandoffFiles(files) {
     }));
 }
 
-/** The model-facing list of `files`, empty when there are none. `ids`: the
- *  row also records the stored files as its attachments (a task report), so
- *  their ids can be forwarded; a plain-text handoff (an agent completion)
- *  lists paths only — an id named in text is never trusted. */
-export function artifactLines(files, omitted = 0, { ids = true } = {}) {
+/** An agent completion's compact list of files it produced (name and path
+ *  only; the Lead forwards or links by path), empty when there are none. */
+export function producedFileLines(files, omitted = 0) {
   const list = normalizeHandoffFiles(files);
   if (!list.length) return [];
-  const attachable = (file) => (ids ? ` [attachment:${file.id}]` : ' (attachable: forward it by path)');
   return [
-    `Files from this turn (forward one with attachments: [${ids ? 'id or path' : 'path'}]; link a path to show it):`,
+    'Files produced:',
+    ...list.map((file) => `- ${oneLine(file.name)} — ${oneLine(file.path)}`),
+    ...(omitted > 0 ? [`- …and ${omitted} more`] : []),
+  ];
+}
+
+/** The model-facing list of a bot task report's `files`, empty when there are
+ *  none; the row also records the stored files as its attachments, so their
+ *  ids can be forwarded. */
+export function artifactLines(files, omitted = 0) {
+  const list = normalizeHandoffFiles(files);
+  if (!list.length) return [];
+  return [
+    'Files from this turn (forward one with attachments: [id or path]; link a path to show it):',
     ...list.map(
       (file) =>
         `- ${oneLine(file.name)} (${oneLine(file.mimeType)}, ${sizeLabel(file.size)}) — ${oneLine(file.path)}${
-          file.id ? attachable(file) : ' (too large or unsupported to attach; link the path)'
+          file.id ? ` [attachment:${file.id}]` : ' (too large or unsupported to attach; link the path)'
         }`
     ),
     ...(omitted > 0 ? [`- …and ${omitted} more file(s)`] : []),

package/src/runtime/shared/idle-auto-clear-gate.mjs

@@ -44,15 +44,37 @@ function hasModelVisibleConversation(session) {
   });
 }
 
-// When a session's prompt cache was last used by a successful cache warm (a
-// read with no write), registered by the warmer (cache-warm.mjs, from its
-// durable touch store); 0 when none.
-let lastCacheWarmUse = () => 0;
+// A session's last successful cache-warm use (a read with no write),
+// registered by the warmer (cache-warm.mjs, from its durable touch store):
+// `{ at, provider, model, accountId }` — when, and the route and account whose
+// cached prefix it read — or a bare epoch-ms time; null/0 when none.
+let lastCacheWarmUse = () => null;
 
 /** Register the source of a session's last successful cache-warm use
- *  (`(sessionId) => epoch ms | 0`); null restores none. */
+ *  (`(sessionId) => { at, provider, model, accountId } | epoch ms | null`);
+ *  null restores none. */
 export function setCacheWarmUseSource(source) {
-  lastCacheWarmUse = typeof source === 'function' ? source : () => 0;
+  lastCacheWarmUse = typeof source === 'function' ? source : () => null;
+}
+
+/** When a successful cache warm last used the session's prompt cache (epoch
+ *  ms), or 0: the warm read and refreshed the cached prefix without moving
+ *  any of the session's own timestamps. */
+export function lastCacheWarmUseAt(sessionId) {
+  const use = sessionId ? lastCacheWarmUse(sessionId) : null;
+  return timestampMs(use && typeof use === 'object' ? use.at : use);
+}
+
+/** When a successful cache warm last used the prefix a request on `provider`
+ *  / `model` / `accountId` reads (epoch ms), or 0: a warm on another route or
+ *  account refreshed an entry this request cannot read, and a use without a
+ *  recorded identity matches nothing. */
+export function cacheWarmUseFor(sessionId, { provider, model, accountId = '' } = {}) {
+  const use = sessionId ? lastCacheWarmUse(sessionId) : null;
+  if (!use || typeof use !== 'object' || !use.provider) return 0;
+  const matches =
+    use.provider === provider && use.model === model && String(use.accountId || '') === String(accountId || '');
+  return matches ? timestampMs(use.at) : 0;
 }
 
 /**
@@ -65,7 +87,7 @@ export function setCacheWarmUseSource(source) {
 export function sessionActivityTimestamp(session, fallback = 0) {
   if (!hasModelVisibleConversation(session)) return 0;
   const own = timestampMs(session?.lastUsedAt) || timestampMs(session?.updatedAt) || timestampMs(fallback);
-  return Math.max(own, timestampMs(lastCacheWarmUse(session?.id)));
+  return Math.max(own, lastCacheWarmUseAt(session?.id));
 }
 
 // A zero is often an unavailable/stale meter field, not an authoritative

package/src/runtime/shared/llm/cost.mjs

@@ -100,7 +100,11 @@ export function priceUsage(args) {
   // A provider-billed figure for a media request (e.g. xAI cost_in_usd_ticks)
   // is the price, with or without a catalog row.
   const media = args.media || null;
-  if (typeof media?.reportedCostUsd === 'number' && Number.isFinite(media.reportedCostUsd) && media.reportedCostUsd >= 0)
+  if (
+    typeof media?.reportedCostUsd === 'number' &&
+    Number.isFinite(media.reportedCostUsd) &&
+    media.reportedCostUsd >= 0
+  )
     return {
       input,
       costUsd: Number(media.reportedCostUsd.toFixed(6)),

package/src/runtime/shared/loopback-listener.mjs

@@ -1,3 +1,5 @@
+import { FETCH_BLOCKED_PORTS, FETCH_SAFE_ATTEMPTS } from './fetch-safe-listen.mjs';
+
 // One loopback listener owns each bind attempt, its event handlers, and stop.
 export function createLoopbackListener({
   server,
@@ -24,7 +26,15 @@ export function createLoopbackListener({
 
     const { promise, resolve, reject } = Promise.withResolvers();
     const controller = new AbortController();
-    const attempt = { promise, reject, controller, port: basePort, bound: false, detach };
+    const attempt = {
+      promise,
+      reject,
+      controller,
+      port: basePort,
+      bound: false,
+      blockedRetries: FETCH_SAFE_ATTEMPTS,
+      detach,
+    };
     current = attempt;
 
     function detach() {
@@ -35,6 +45,19 @@ export function createLoopbackListener({
     function onListening() {
       if (current !== attempt) return;
       const boundPort = server.address().port;
+      // An OS-assigned port can be one fetch clients refuse ("bad port"):
+      // close it and take another, a bounded number of times.
+      if (attempt.port === 0 && FETCH_BLOCKED_PORTS.has(boundPort)) {
+        const exhausted = attempt.blockedRetries <= 0;
+        attempt.blockedRetries -= 1;
+        server.close(() => {
+          if (current !== attempt) return;
+          if (exhausted) onError(new Error('no fetch-safe loopback port was assigned'));
+          else listen();
+        });
+        return;
+      }
+      server.off('listening', onListening);
       attempt.bound = true;
       reportListening(boundPort);
       resolve(boundPort);
@@ -67,7 +90,7 @@ export function createLoopbackListener({
     }
 
     server.on('error', onError);
-    server.once('listening', onListening);
+    server.on('listening', onListening);
     listen();
     return promise;
   }

package/src/runtime/shared/model-route-chain.d.mts

@@ -1,8 +1,13 @@
 export function canonicalRouteProvider(value: unknown): string;
 export function routeChain(route: Record<string, unknown>): Record<string, unknown>[];
-export function validateRouteChainProviders(routes: Record<string, unknown>[]): void;
+export function executionFallbacks(route: Record<string, unknown> | null | undefined): Record<string, unknown>[];
+export function validateRouteChainProviders(
+  routes: Record<string, unknown>[],
+  options?: { allowDuplicates?: boolean }
+): void;
 export function normalizeRouteChain(
   route: Record<string, unknown>,
   normalizeLeaf: (route: Record<string, unknown>, fallback: Record<string, unknown>) => Record<string, unknown> | null,
-  fallback?: Record<string, unknown>
+  fallback?: Record<string, unknown>,
+  options?: { strict?: boolean }
 ): Record<string, unknown> | null;

package/src/runtime/shared/model-route-chain.mjs

@@ -22,18 +22,36 @@ export function routeChain(route) {
   return [primary, ...fallbacks];
 }
 
-export function validateRouteChainProviders(routes) {
+/** The fallbacks a chain runs: those on a provider not already used by the
+ *  primary or an earlier fallback. The stored list is never changed; a fallback
+ *  on the main model's own provider (left there by a later main-model change)
+ *  is simply inactive. */
+export function executionFallbacks(route) {
+  const [primary, ...fallbacks] = routeChain(route);
+  if (!primary) return [];
+  const seen = new Set([canonicalRouteProvider(primary.provider)]);
+  return fallbacks.filter((entry) => {
+    const provider = canonicalRouteProvider(entry.provider);
+    if (seen.has(provider)) return false;
+    seen.add(provider);
+    return true;
+  });
+}
+
+/** `allowDuplicates` accepts a stored chain whose fallbacks repeat a provider
+ *  (see executionFallbacks); an explicit save validates without it. */
+export function validateRouteChainProviders(routes, { allowDuplicates = false } = {}) {
   const providers = new Set();
   for (const route of routes) {
     const provider = canonicalRouteProvider(route.provider);
     if (!provider || !String(route.model || '').trim()) throw new Error('route requires provider and model');
-    if (providers.has(provider)) throw new Error(`duplicate route provider "${provider}"`);
+    if (!allowDuplicates && providers.has(provider)) throw new Error(`duplicate route provider "${provider}"`);
     if (providers.size && provider === 'default') throw new Error('follow Main is only allowed as the primary route');
     providers.add(provider);
   }
 }
 
-export function normalizeRouteChain(route, normalizeLeaf, fallback = {}) {
+export function normalizeRouteChain(route, normalizeLeaf, fallback = {}, { strict = true } = {}) {
   const raw = routeChain({ ...fallback, ...route });
   const primary = normalizeLeaf(route, fallback);
   if (!primary) return null;
@@ -42,7 +60,7 @@ export function normalizeRouteChain(route, normalizeLeaf, fallback = {}) {
     if (!normalized) throw new Error('fallback route requires provider and model');
     return { ...normalized, provider: canonicalRouteProvider(normalized.provider) };
   });
-  validateRouteChainProviders(routes);
+  validateRouteChainProviders(routes, { allowDuplicates: !strict });
   const [first, ...rest] = routes;
   return rest.length ? { ...first, fallbacks: rest } : first;
 }

package/src/runtime/shared/open-url.mjs

@@ -2,6 +2,16 @@ import { spawn } from 'node:child_process';
 import { isWSL } from './wsl.mjs';
 import { detachedSpawnOpts } from './spawn-flags.mjs';
 
+/**
+ * Whether a browser can plausibly open on this machine: not inside an SSH
+ * session, and on non-WSL Linux a DISPLAY or WAYLAND_DISPLAY exists.
+ */
+export function canOpenBrowser(env = process.env, platform = process.platform, wsl = isWSL()) {
+  if (env.SSH_TTY || env.SSH_CONNECTION) return false;
+  if (platform !== 'linux' || wsl) return true;
+  return Boolean(env.DISPLAY || env.WAYLAND_DISPLAY);
+}
+
 /**
  * Open a URL in the user's default browser. Best-effort and non-blocking.
  * Callers also print the URL, so opener failure should never block OAuth.

package/src/runtime/shared/session-activity-signal.mjs

@@ -45,6 +45,20 @@ export function emitSessionApprovalCardChange(sessionId = '') {
   emit(approvalCardListeners, sessionId);
 }
 
+// The bots whose sends are in flight in a session changed (bot-owned-work.mjs):
+// the session catalog stamps them on each row (`handedBy`) and re-reads.
+const botWorkListeners = new Set();
+
+export function onSessionBotWorkChange(listener) {
+  if (typeof listener !== 'function') return () => {};
+  botWorkListeners.add(listener);
+  return () => botWorkListeners.delete(listener);
+}
+
+export function emitSessionBotWorkChange(sessionId = '') {
+  emit(botWorkListeners, sessionId);
+}
+
 function emit(targets, sessionId) {
   for (const listener of [...targets]) {
     try {