mixdog 1.0.8 → 1.0.9

package/src/runtime/office/portable/font-provisioner.mjs

@@ -217,7 +217,35 @@ async function installFont(fontDef) {
   return { installed: true, skipped: false, path: targetPath };
 }
 
+// Office for Mac keeps its faces (Calibri, Cambria, Aptos, Malgun Gothic, Yu
+// Gothic, ...) inside each app bundle and never registers them with the system,
+// so a Mac with Excel installed measured Calibri in a fallback face — its digit
+// read 9 px where Excel lays out 7, and every fitted column came out wide. The
+// apps share one copy; the first bundle found is the one Excel draws with.
+const MAC_OFFICE_FONT_DIRECTORIES = Object.freeze(
+  ['Microsoft Excel', 'Microsoft Word', 'Microsoft PowerPoint', 'Microsoft Outlook'].map(
+    (app) => `/Applications/${app}.app/Contents/Resources/DFonts`
+  )
+);
+
+/** The font folder of the installed Office for Mac, or '' elsewhere or without Office. */
+export function macOfficeFontDirectory() {
+  if (platform() !== 'darwin') return '';
+  return MAC_OFFICE_FONT_DIRECTORIES.find((candidate) => existsSync(candidate)) || '';
+}
+
+function registerMacOfficeFonts() {
+  const directory = macOfficeFontDirectory();
+  if (!directory) return;
+  try {
+    GlobalFonts.loadFontsFromDir(directory);
+  } catch {
+    // non-fatal: measurement falls back to the installed faces
+  }
+}
+
 export function warmupInstalledOfficeFonts() {
+  registerMacOfficeFonts();
   for (const fontDef of NOTO_FONT_DEFINITIONS) {
     const status = isFontInstalled(fontDef);
     if (status.installed) {

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

@@ -14,9 +14,11 @@ import { appendDocxBlock, docxBodyModel } from './portable-snapshot.mjs';
 import {
   OFFICE_RELATIONSHIP_BASE,
   XML_HEADER,
+  containerInner,
   paragraphTexts,
   replaceAcrossRuns,
   textNodes,
+  topLevelElements,
   upsertOrderedChild,
   xmlEncode,
 } from './portable-xml.mjs';
@@ -110,8 +112,33 @@ function bodyParagraphAt(model, ordinal) {
   return paragraph;
 }
 
+// The paragraphs inside the body's tables, with offsets into the body like a
+// top-level paragraph's, so one can be spliced back the same way.
+function tableCellParagraphs(model) {
+  const paragraphs = [];
+  const inside = (xml, tag, base, accepted, visit) => {
+    const container = containerInner(xml, tag);
+    if (!container) return;
+    for (const child of topLevelElements(container.inner, accepted)) visit(child, base + container.start + child.start);
+  };
+  for (const block of model.blocks.filter((entry) => entry.name === 'w:tbl')) {
+    inside(block.xml, 'w:tbl', block.start, ['w:tr'], (row, rowStart) =>
+      inside(row.xml, 'w:tr', rowStart, ['w:tc'], (cell, cellStart) =>
+        inside(cell.xml, 'w:tc', cellStart, ['w:p'], (paragraph, start) =>
+          paragraphs.push({ ...paragraph, start, end: start + paragraph.xml.length })
+        )
+      )
+    );
+  }
+  return paragraphs;
+}
+
+// A phrase the body does not hold may sit in a table cell, where Word anchors
+// a comment, hyperlink, or bookmark just as well; without Office this was the
+// only backend, and a Mac could not comment on any table text.
 function paragraphContaining(model, find) {
-  return bodyParagraphs(model).find((entry) => paragraphTexts(entry.xml, 'w:t').join('').includes(find));
+  const holds = (entry) => paragraphTexts(entry.xml, 'w:t').join('').includes(find);
+  return bodyParagraphs(model).find(holds) || tableCellParagraphs(model).find(holds);
 }
 
 // Splice one rewritten paragraph back into the document body.

package/src/runtime/office/portable/portable-soffice.mjs

@@ -14,8 +14,9 @@ import {
   workbookSheets,
   writeCachedValues,
 } from './portable-cells.mjs';
-import { xmlDecode } from './portable-xml.mjs';
+import { xmlDecode, xmlEncode } from './portable-xml.mjs';
 import { refreshChartCaches } from './portable-xlsx-charts.mjs';
+import { macOfficeFontDirectory } from './font-provisioner.mjs';
 
 const SOFFICE_PROBE_TIMEOUT_MS = 20_000;
 const SOFFICE_RENDER_TIMEOUT_MS = 120_000;
@@ -38,7 +39,9 @@ const SOFFICE_QUIET_ARGS = [
 function killQuietly(child) {
   try {
     child.kill();
-  } catch {}
+  } catch {
+    // Already exited: nothing left to stop.
+  }
 }
 
 // A detection probe must always answer. soffice.exe is a GUI launcher that can
@@ -141,7 +144,9 @@ function sharedProfileDir() {
         for (const profile of createdProfiles) {
           try {
             rmSync(profile, { recursive: true, force: true });
-          } catch {}
+          } catch {
+            // The process is exiting; a profile left behind lives in the temp directory.
+          }
         }
       });
     }
@@ -168,12 +173,16 @@ function queueConversion(work) {
 // stderr is kept up to this many characters, which is plenty to say why it failed.
 export const MAX_SOFFICE_STDERR_CHARS = 64 * 1024;
 
-export function runSoffice(program, args, { signal, timeoutMs, timeoutMessage, cancelMessage }) {
+export function runSoffice(program, args, { signal, timeoutMs, timeoutMessage, cancelMessage, env }) {
   return new Promise((resolve) => {
     let settled = false;
     let timer = null;
     let stderr = '';
-    const child = spawn(program, args, { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    const child = spawn(program, args, {
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      ...(env ? { env: { ...process.env, ...env } } : {}),
+    });
     const finish = (value) => {
       if (settled) return;
       settled = true;
@@ -218,6 +227,7 @@ function convertWithLibreOffice(program, input, { to, outDir, signal = null, tim
   // one discards it, and the path it used is gone by the time this one runs.
   return queueConversion(async () => {
     const profile = await sharedProfileDir();
+    const env = await headlessFontEnvironment(profile);
     const result = await runSoffice(
       program,
       [
@@ -229,13 +239,40 @@ function convertWithLibreOffice(program, input, { to, outDir, signal = null, tim
         outDir,
         input,
       ],
-      { signal, timeoutMs, timeoutMessage: messages.timeout, cancelMessage: messages.cancelled }
+      { signal, timeoutMs, timeoutMessage: messages.timeout, cancelMessage: messages.cancelled, env }
     );
     if (!result.ok) await discardProfileDir();
     return result;
   });
 }
 
+// Headless LibreOffice on macOS finds fonts through its bundled fontconfig,
+// which names none of the Mac's font folders: every face but the few it ships
+// was missing, and a Hangul, CJK, or Thai run rendered as nothing at all — a
+// Korean header came out of the preview as "( )". The config names the system,
+// local, and user folders, and the Office for Mac bundle where Excel keeps
+// Calibri and Malgun Gothic, so the preview draws a workbook in Excel's faces.
+export function macFontConfig(cacheDir, officeFontDir = macOfficeFontDirectory()) {
+  const directories = ['/System/Library/Fonts', '/Library/Fonts', join(homedir(), 'Library', 'Fonts')];
+  if (officeFontDir) directories.push(officeFontDir);
+  return [
+    '<?xml version="1.0"?>',
+    '<!DOCTYPE fontconfig SYSTEM "fonts.dtd">',
+    '<fontconfig>',
+    ...directories.map((directory) => `  <dir>${xmlEncode(directory)}</dir>`),
+    `  <cachedir>${xmlEncode(cacheDir)}</cachedir>`,
+    '</fontconfig>',
+    '',
+  ].join('\n');
+}
+
+async function headlessFontEnvironment(profile) {
+  if (process.platform !== 'darwin') return undefined;
+  const file = join(profile, 'mixdog-fonts.conf');
+  await writeFile(file, macFontConfig(join(profile, 'fontconfig-cache')));
+  return { FONTCONFIG_FILE: file };
+}
+
 // LibreOffice names what it writes after the source it read, minus the
 // source's own extension: `report.v2.docx` converted to pdf lands in the out
 // directory as `report.v2.pdf`. Every caller finds its output by that rule.
@@ -396,7 +433,7 @@ export async function recalculateLibreOfficeWorkbook(path, { force = false, sign
   // reopened answered with the numbers from before the edit — and an error a
   // guard had swallowed stayed swallowed. The edit path marks the workbook for
   // a full calculation, and that mark is what staleness looks like on disk.
-  const stale = workbookCalculation(await zipText(zip, 'xl/workbook.xml')).fullCalcOnLoad === true;
+  const stale = workbookCalculation(await zipText(zip, 'xl/workbook.xml')).fullCalcOnLoad;
   const needed = counts.formulaCount > 0 && (force || stale || counts.missingCachedValues > 0);
   if (!needed) return { needed: false, recalculated: false, ...counts };
   const unavailable = (reason) => ({

package/src/runtime/shared/llm/anthropic-betas.mjs

@@ -1,5 +1,6 @@
 import { EFFORT_BETA_HEADER } from './anthropic-effort.mjs';
 import { normalizeClaudeModelId } from './anthropic-thinking-contract.mjs';
+import { getModelMetadataSync } from './model-catalog.mjs';
 
 const EXTENDED_CACHE_TTL_BETA_HEADER = 'extended-cache-ttl-2025-04-11';
 const INTERLEAVED_THINKING_BETA_HEADER = 'interleaved-thinking-2025-05-14';
@@ -10,9 +11,14 @@ export const SERVER_SIDE_FALLBACK_BETA_HEADER = 'server-side-fallback-2026-07-01
 
 // Fast mode ships on Opus 5.5, Opus 5 and Opus 4.8 only. Opus 4.7 rejects
 // `speed: "fast"` and Opus 4.6 silently runs at standard speed.
+const KNOWN_FAST_MODE_MODELS = /^claude-opus-(?:4-8|5)(?:$|[-@])/;
+
+// The id pattern is the offline floor. A model the pricing catalog declares
+// Fast-capable is accepted too, so a later release needs no edit here.
 export function supportsAnthropicFastMode(model) {
   const id = normalizeClaudeModelId(model);
-  return /^claude-opus-(?:4-8|5)(?:$|[-@])/.test(id);
+  if (!id) return false;
+  return KNOWN_FAST_MODE_MODELS.test(id) || getModelMetadataSync(id, 'anthropic')?.supportsFastMode === true;
 }
 
 export function buildAnthropicBetaHeaders({

package/src/runtime/shared/llm/anthropic-thinking-contract.mjs

@@ -19,7 +19,7 @@ export function isAnthropicAdaptiveOnlyModel(model) {
 // preambles) as progress-update thinking blocks instead of text blocks.
 export function emitsAnthropicProgressUpdates(model) {
   const id = normalizeClaudeModelId(model);
-  return /^claude-(?:opus-5-5|fable-5-1|mythos-5-1|fable-5)(?:-\d{8})?$/.test(id);
+  return /^claude-(?:opus-5-5|sonnet-5-5|fable-5-1|mythos-5-1|fable-5)(?:-\d{8})?$/.test(id);
 }
 
 export function assertAnthropicManualBudgetSupported(model) {

package/src/runtime/shared/llm/default-context-window.mjs

@@ -0,0 +1,42 @@
+// The context window a model starts with when the user has not picked one.
+//
+// A provider row states the window it serves by default (`contextWindow`) and,
+// when it can serve more, the largest one (`maxContextWindow`). The picker's
+// 10% stops and the session's compaction boundary both follow that pair. A row
+// that serves its whole window by default makes the largest window the
+// starting point, and every request then re-sends whatever the session has
+// accumulated up to it: on stored sessions of 1M rows left at 100%
+// (2026-09-25..10-05) the average lead request carried 225K tokens and 62% of
+// the token volume was spent above 300K. Replaying those sessions against a
+// 500K boundary cut that volume by 19% (lead) and 14% (agents).
+//
+// The default is therefore set by range: a window up to the ceiling is used
+// whole, a larger one starts at the ceiling and keeps the rest selectable — the
+// shape provider rows with a smaller default of their own (272K of 872K)
+// already have. An explicit selection is never touched.
+export const DEFAULT_CONTEXT_WINDOW_CEILING = 500_000;
+
+// A local model's window is the memory its runtime allocated, not a budget.
+const LOCAL_PROVIDERS = new Set(['mixdog-local', 'local']);
+
+function positiveTokens(value) {
+  const tokens = Number(value);
+  return Number.isFinite(tokens) && tokens > 0 ? Math.floor(tokens) : 0;
+}
+
+/**
+ * The default and the largest selectable window of one model row, in tokens.
+ * `defaultWindow` is 0 when the row states no window to start from.
+ */
+export function contextWindowRange({ provider = '', contextWindow, maxContextWindow } = {}) {
+  const served = positiveTokens(contextWindow);
+  const maxWindow = Math.max(served, positiveTokens(maxContextWindow));
+  const whole = { defaultWindow: served, maxWindow };
+  if (served <= DEFAULT_CONTEXT_WINDOW_CEILING) return whole;
+  if (LOCAL_PROVIDERS.has(String(provider || '').toLowerCase())) return whole;
+  // The picker moves in 10% stops of the largest window. A window so close to
+  // the ceiling that both round to the last stop keeps its whole size: that
+  // stop would otherwise name the ceiling and leave the full window unreachable.
+  if (Math.round((DEFAULT_CONTEXT_WINDOW_CEILING / maxWindow) * 10) >= 10) return whole;
+  return { defaultWindow: DEFAULT_CONTEXT_WINDOW_CEILING, maxWindow };
+}

package/src/runtime/shared/llm/model-catalog-projection.mjs

@@ -138,6 +138,8 @@ const LITELLM_FLAG_FIELDS = [
   'supports_websearch',
   'supports_prompt_caching',
   'supports_reasoning',
+  // Reader: supportsAnthropicFastMode (anthropic-betas.mjs).
+  'supports_fast_mode',
 ];
 const LITELLM_STRING_FIELDS = ['mode', 'litellm_provider', 'reasoning_content_field'];
 

package/src/runtime/shared/llm/model-catalog.mjs

@@ -604,6 +604,7 @@ function _normalize(entry) {
     supportsFunctionCalling: entry.supports_function_calling === true,
     supportsWebSearch: entry.supports_web_search === true || entry.supports_websearch === true,
     supportsPromptCaching: entry.supports_prompt_caching === true,
+    supportsFastMode: entry.supports_fast_mode === true,
     supportsReasoning: entry.supports_reasoning === true,
     reasoningOptions: Array.isArray(entry.reasoning_options) ? entry.reasoning_options : [],
     reasoningContentField: entry.reasoning_content_field || null,
@@ -648,6 +649,7 @@ function mergeModelMetadata(base, overlay, opts = {}) {
     supportsFunctionCalling: base.supportsFunctionCalling || overlay.supportsFunctionCalling,
     supportsWebSearch: base.supportsWebSearch || overlay.supportsWebSearch,
     supportsPromptCaching: base.supportsPromptCaching || overlay.supportsPromptCaching,
+    supportsFastMode: base.supportsFastMode || overlay.supportsFastMode,
     supportsReasoning: base.supportsReasoning || overlay.supportsReasoning,
     reasoningOptions: overlay.reasoningOptions?.length ? overlay.reasoningOptions : base.reasoningOptions || [],
     reasoningContentField: overlay.reasoningContentField || base.reasoningContentField || null,

package/src/runtime/shared/plugin-paths.mjs

@@ -10,7 +10,14 @@ import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-const DEFAULT_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+// Resolved on first use, not at load: the desktop service bundle (CJS) carries
+// this module through the model catalog, and import.meta is empty there, so
+// computing it at load crashed the whole bundle before any caller needed it.
+let defaultRoot = null;
+function packagedRoot() {
+  defaultRoot ??= join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+  return defaultRoot;
+}
 
 // The defaults are joins over values that almost never change; they are hot
 // (every session path resolves the data dir), so each default join is reused
@@ -32,7 +39,7 @@ export function mixdogHome() {
 }
 
 export function mixdogRoot() {
-  return process.env.MIXDOG_ROOT || DEFAULT_ROOT;
+  return process.env.MIXDOG_ROOT || packagedRoot();
 }
 
 export function resolvePluginData() {

package/src/runtime/shared/worker-exec-argv.mjs

@@ -0,0 +1,25 @@
+// The parent's flags a worker thread may inherit. A worker rejects any flag that
+// governs the process itself (heap sizes, inspector, TLS, test-runner settings)
+// with ERR_WORKER_INVALID_EXEC_ARGV, and Node 24's test runner hands a child its
+// whole option table in execArgv (--use-system-ca, --tls-cipher-list, ...), so a
+// list of known-bad flags kept failing. Only what loads and resolves modules,
+// and what governs warnings, carries over.
+const INHERITED_FLAG =
+  /^--(?:import|require|loader|experimental-loader|conditions|enable-source-maps|preserve-symlinks(?:-main)?|no-warnings|disable-warning|trace-warnings|no-deprecation|(?:no-)?experimental-[a-z0-9-]+)(?:=|$)/;
+const SHORT_WITH_VALUE = new Set(['-r', '-C']);
+
+export function workerExecArgv(execArgv = process.execArgv) {
+  const source = Array.isArray(execArgv) ? execArgv.map(String) : [];
+  const kept = [];
+  for (let index = 0; index < source.length; index += 1) {
+    const argument = source[index];
+    const short = SHORT_WITH_VALUE.has(argument);
+    if (!short && !INHERITED_FLAG.test(argument)) continue;
+    kept.push(argument);
+    // A flag written apart from its value (`--import tsx`) keeps the value too.
+    const takesValue =
+      short || /^--(?:import|require|loader|experimental-loader|conditions|disable-warning)$/.test(argument);
+    if (takesValue && index + 1 < source.length) kept.push(source[++index]);
+  }
+  return kept;
+}

package/src/runtime/web-search/lib/formatter.mjs

@@ -2,6 +2,16 @@
  * Response formatter — strips metadata, returns human-readable text.
  */
 
+// Whether `text` names exactly this URL: an occurrence that runs on into a
+// longer URL (`…/docs` inside `…/docs/guide`) is a different page.
+function textCitesUrl(text, url) {
+  for (let at = text.indexOf(url); at !== -1; at = text.indexOf(url, at + 1)) {
+    const rest = text.slice(at + url.length, at + url.length + 2);
+    if (!/^(?:[A-Za-z0-9/?#&=%_~-]|\.[A-Za-z0-9])/.test(rest)) return true;
+  }
+  return false;
+}
+
 function formatWebSearchResults(data) {
   // data may be the full jsonText payload: { tool, providers, response, cache, ... }
   const response = data.response || data;
@@ -20,25 +30,40 @@ function formatWebSearchResults(data) {
   const SNIPPET_CAP = 600;
   const ANSWER_CAP = 4000;
   const clip = (text, cap) => (text.length > cap ? `${text.slice(0, cap)}…` : text);
-  if (answer) blocks.push(clip(answer, ANSWER_CAP));
+  const shownAnswer = answer ? clip(answer, ANSWER_CAP) : '';
+  if (shownAnswer) blocks.push(shownAnswer);
   if (!results.length) return blocks.join('\n\n');
-  blocks.push(
-    results
-      .map((r, i) => {
-        const num = i + 1;
-        const title = clip(r.title || '(no title)', TITLE_CAP);
-        const url = r.url || '';
-        const date = r.publishedDate || '';
-        const snippet = clip((r.snippet || '').trim(), SNIPPET_CAP);
-
-        const urlPart = [url, date].filter(Boolean).join(' — ');
-        const lines = [`${num}. ${title}`];
-        if (urlPart) lines.push(`   ${urlPart}`);
-        if (snippet && snippet !== title && snippet !== url) lines.push(`   ${snippet}`);
-        return lines.join('\n');
-      })
-      .join('\n\n')
-  );
+  // A native search route reports the pages a query reached without their
+  // titles, and the adapters label each one with that query. A label shared by
+  // several URLs names the search, not a page, so such a source prints as its
+  // URL alone — and not at all when the answer above already cites that URL.
+  // Measured on stored results: every source had this shape and 66% of their
+  // URLs were already in the answer.
+  const urlsByTitle = new Map();
+  for (const r of results) {
+    if (!r.title || !r.url) continue;
+    if (!urlsByTitle.has(r.title)) urlsByTitle.set(r.title, new Set());
+    urlsByTitle.get(r.title).add(r.url);
+  }
+  const entries = [];
+  for (const r of results) {
+    const url = r.url || '';
+    const date = r.publishedDate || '';
+    const snippet = clip((r.snippet || '').trim(), SNIPPET_CAP);
+    const urlPart = [url, date].filter(Boolean).join(' — ');
+    const queryLabelled =
+      !r.title || r.title === url || r.source === 'web_search_call' || urlsByTitle.get(r.title)?.size > 1;
+    if (url && !snippet && queryLabelled) {
+      if (!textCitesUrl(shownAnswer, url)) entries.push(`${entries.length + 1}. ${urlPart}`);
+      continue;
+    }
+    const title = clip(r.title || '(no title)', TITLE_CAP);
+    const lines = [`${entries.length + 1}. ${title}`];
+    if (urlPart) lines.push(`   ${urlPart}`);
+    if (snippet && snippet !== title && snippet !== url) lines.push(`   ${snippet}`);
+    entries.push(lines.join('\n'));
+  }
+  if (entries.length) blocks.push(entries.join('\n\n'));
   return blocks.join('\n\n');
 }
 

package/src/session-runtime/automation-agents.mjs

@@ -0,0 +1,88 @@
+/**
+ * Agent delegation for automation sessions (schedules, webhooks). They run
+ * headless in the daemon, so no session runtime registers tools for them or
+ * receives their agents' completions. The daemon's canonical agent control is
+ * exposed under a dedicated internal-tool scope instead, and the completions of
+ * the agents a run starts come back here, where the run turns them into the
+ * conversation's next turn — what a Lead in a window does when one arrives.
+ */
+import { setInternalToolsProvider } from '../runtime/agent/orchestrator/internal-tools.mjs';
+import { AGENT_TOOL } from './services/agent-tool/tool-def.mjs';
+
+export const AUTOMATION_TOOL_SCOPE = 'automation';
+// How long a run waits for the next result of an agent it started; past it the
+// run ends with the conversation as it stands.
+const AGENT_RESULT_WAIT_MS = 60 * 60_000;
+
+const runs = new Map(); // sessionId → { pending: Set<taskId>, ready: string[], wake }
+
+function resultText(result) {
+  return typeof result === 'string' ? result : JSON.stringify(result ?? '');
+}
+
+/** Registers the agent tool for automation sessions; returns its disposer. */
+export function registerAutomationAgentTool(executeAgentControl) {
+  return setInternalToolsProvider({
+    scopeId: AUTOMATION_TOOL_SCOPE,
+    tools: [AGENT_TOOL],
+    async executor(_name, args, callerCtx = {}) {
+      const result = await executeAgentControl(args, {
+        callerCwd: callerCtx.callerCwd,
+        invocationSource: 'model-tool',
+        callerSessionId: callerCtx.callerSessionId || null,
+        clientHostPid: process.pid,
+        signal: callerCtx.signal,
+      });
+      // A spawn/send acknowledgement ("agent task: <id>", "status: running")
+      // is a result still to come for this run.
+      const text = resultText(result);
+      const taskId = /agent task: ([\w.:-]+)/.exec(text)?.[1];
+      const run = runs.get(String(callerCtx.callerSessionId || ''));
+      if (run && taskId && /status: running/.test(text)) run.pending.add(taskId);
+      return result;
+    },
+  });
+}
+
+/** Hands an agent completion to the automation run that started the task; false when none did. */
+export function deliverAutomationCompletion(sessionId, text, meta = {}) {
+  const run = runs.get(String(sessionId || ''));
+  const taskId = String(meta?.execution_id || '');
+  if (!run?.pending.has(taskId)) return false;
+  // The header-only preview precedes the body-carrying completion.
+  if (meta?.model_visible === false) return true;
+  run.pending.delete(taskId);
+  run.ready.push(String(text || ''));
+  run.wake?.();
+  return true;
+}
+
+/**
+ * Runs an automation conversation to its end: the first turn, then one more
+ * turn per batch of agent results while agents it started are still out.
+ * Resolves with the last turn's result.
+ */
+export async function runAutomationTurns(sessionId, firstTurn, nextTurn, { waitMs = AGENT_RESULT_WAIT_MS } = {}) {
+  const run = { pending: new Set(), ready: [], wake: null };
+  runs.set(sessionId, run);
+  try {
+    let result = await firstTurn();
+    while (run.pending.size > 0 || run.ready.length > 0) {
+      if (run.ready.length === 0) {
+        const arrived = await new Promise((resolve) => {
+          const timer = setTimeout(() => resolve(false), waitMs);
+          run.wake = () => {
+            clearTimeout(timer);
+            resolve(true);
+          };
+        });
+        run.wake = null;
+        if (!arrived) break;
+      }
+      result = await nextTurn(run.ready.splice(0).join('\n\n'));
+    }
+    return result;
+  } finally {
+    runs.delete(sessionId);
+  }
+}

package/src/session-runtime/automation-workflow.mjs

@@ -10,6 +10,9 @@ import { createWorkflowHelpers } from '../runtime/agent/orchestrator/runtime-cor
 import { STANDALONE_ROOT, STANDALONE_DATA_DIR } from './runtime-paths.mjs';
 import { readMarkdownDocument, normalizeAgentPermissionOrNone } from '../runtime/shared/markdown-frontmatter.mjs';
 import { IMPLICIT_APPROVAL_MODE } from '../runtime/agent/orchestrator/session/approval-mode.mjs';
+import { loadConfig } from '../runtime/agent/orchestrator/config.mjs';
+import { configuredOrchestrationMode } from '../runtime/shared/orchestration.mjs';
+import { AUTOMATION_TOOL_SCOPE } from './automation-agents.mjs';
 
 let _helpers = null;
 function helpers() {
@@ -26,21 +29,31 @@ function helpers() {
 
 /** Non-interactive createSession opts, plus workflow context when the id resolves. */
 export function automationWorkflowOpts(workflowId) {
-  const approvalOpts = { approvalMode: IMPLICIT_APPROVAL_MODE };
+  const config = loadConfig({ secrets: false });
+  // The user's orchestration setting governs an automation exactly as it does a
+  // New task: a workflow id alone never turns delegation on, and the agent
+  // tool reaches the run through the automation tool scope.
+  const baseOpts = {
+    approvalMode: IMPLICIT_APPROVAL_MODE,
+    orchestrationMode: configuredOrchestrationMode(config),
+    mcpScopeId: AUTOMATION_TOOL_SCOPE,
+  };
   const id = String(workflowId || '').trim();
-  if (!id) return approvalOpts;
+  if (!id) return baseOpts;
   try {
     const h = helpers();
     const pack = h.loadWorkflowPack(undefined, id);
-    if (!pack) return approvalOpts;
-    const resolved = h.activeWorkflowContext({ workflow: { active: id } }, undefined);
+    if (!pack) return baseOpts;
+    // The whole config, so disabled agents and the orchestration mode are the
+    // user's, with only the active workflow swapped for the automation's own.
+    const resolved = h.activeWorkflowContext({ ...config, workflow: { ...config.workflow, active: id } }, undefined);
     return {
-      ...approvalOpts,
+      ...baseOpts,
       workflow: resolved.summary,
       workflowContext: resolved.context,
       orchestrationMode: resolved.orchestrationMode,
     };
   } catch {
-    return approvalOpts;
+    return baseOpts;
   }
 }

package/src/session-runtime/boot/apis.mjs

@@ -107,7 +107,6 @@ function wireToolPolicyRefresh(boot) {
     getDataDir: () => dataDirOf(cfgMod),
     modelStandaloneTools: boot.modelStandaloneTools,
     featureDisallowedTools: boot.featureDisallowedTools,
-    memoryToolsEnabled: boot.memoryToolsEnabledFn,
     loadCoreMemoryContext: boot.loadCoreMemoryContext,
     activeWorkflowContext: workflowHelpers.activeWorkflowContext,
     invalidatePreSessionToolSurface: boot.invalidatePreSessionToolSurface,

package/src/session-runtime/cwd-plugins/core-memory-context.mjs

@@ -1,9 +1,14 @@
 // cwd-plugins/core-memory-context.mjs — the user-curated core-memory block
 // injected into new sessions, read from the memory runtime's atomic snapshot.
-import { featureEnvOverride, memoryToolsEnabled } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
+import { featureEnvOverride } from '../../runtime/agent/orchestrator/runtime-core/config-helpers.mjs';
 import { readSessionCoreMemoryPayload } from '../../runtime/memory/lib/core-memory-file.mjs';
 
-export function createCoreMemoryContext({ getCurrentCwd, getConfig, bootProfile, clean, cfgMod, STANDALONE_DATA_DIR }) {
+// Budget for the whole injected block in UTF-8 bytes: bytes track token cost
+// more evenly across scripts than characters do.
+const CORE_MEMORY_MAX_BYTES = 32 * 1024;
+const TRUNCATED_MARK = '\n- ...';
+
+export function createCoreMemoryContext({ getCurrentCwd, bootProfile, clean, cfgMod, STANDALONE_DATA_DIR }) {
   function formatCoreMemoryLines(payload = {}) {
     const seen = new Set();
     const lines = [];
@@ -14,21 +19,18 @@ export function createCoreMemoryContext({ getCurrentCwd, getConfig, bootProfile,
       if (seen.has(key)) continue;
       seen.add(key);
       lines.push(`- ${text}`);
-      if (lines.length >= 40) break;
     }
     const out = lines.join('\n');
-    const maxChars = 6000;
-    return out.length > maxChars ? `${out.slice(0, maxChars).replace(/\s+\S*$/, '')}\n- ...` : out;
+    if (Buffer.byteLength(out, 'utf8') <= CORE_MEMORY_MAX_BYTES) return out;
+    const budget = CORE_MEMORY_MAX_BYTES - Buffer.byteLength(TRUNCATED_MARK, 'utf8');
+    // A byte cut can split a multi-byte character; drop its replacement chars.
+    const head = Buffer.from(out, 'utf8').subarray(0, budget).toString('utf8').replace(/\uFFFD+$/, '');
+    return `${head.replace(/\s+\S*$/, '')}${TRUNCATED_MARK}`;
   }
 
   async function loadCoreMemoryContext() {
-    // User-curated core memory injects into new sessions by default. The
-    // Memory toggle (settings → General) OFF skips ONLY this accumulated
-    // core-memory block — the profile injects regardless.
-    if (!(featureEnvOverride('MIXDOG_FEATURE_MEMORY') ?? memoryToolsEnabled(getConfig(), true))) {
-      bootProfile('core-memory:disabled');
-      return '';
-    }
+    // User-curated core memory always injects into new sessions: the Memory
+    // install marker and toggle gate only the model-facing memory/recall tools.
     // Explicit opt-out (MIXDOG_BOOT_CORE_MEMORY=0/false/no/off) skips this
     // file-backed prompt block. Recall and memory tools remain available.
     if (featureEnvOverride('MIXDOG_BOOT_CORE_MEMORY') === false) {