mixdog 1.2.0 → 1.2.2

package/src/runtime/agent/orchestrator/tools/patch/read-redirects.mjs

@@ -6,7 +6,7 @@ import { resolve as pathResolve, relative as pathRelative, isAbsolute } from 'no
 import { findBySuffixStrip, findFileByBasename } from '../builtin/path-diagnostics.mjs';
 import { resolveEntryPath, resolveV4AEntryPath, classifyEntry, pathKey } from './paths.mjs';
 
-function uniqueExistingPatchTarget(basePath, requestedFullPath) {
+async function uniqueExistingPatchTarget(basePath, requestedFullPath) {
   // Auto-relocation is only valid for a missing target lexically inside the
   // patch root. An explicit outside-root path must never be pulled back into
   // the project merely because a basename happens to match.
@@ -23,14 +23,14 @@ function uniqueExistingPatchTarget(basePath, requestedFullPath) {
   };
   const suffix = asFile(findBySuffixStrip(basePath, requestedFullPath));
   if (suffix) return suffix;
-  const basenameHits = findFileByBasename(basePath, requestedFullPath, { limit: 2 });
+  const basenameHits = await findFileByBasename(basePath, requestedFullPath, { limit: 2 });
   return basenameHits.length === 1 ? asFile(basenameHits[0]) : null;
 }
 
-function redirectedPatchPath(requestedFullPath, basePath) {
+async function redirectedPatchPath(requestedFullPath, basePath) {
   // An existing requested path always wins over relocation.
   if (!requestedFullPath || existsSync(requestedFullPath)) return requestedFullPath;
-  return uniqueExistingPatchTarget(basePath, requestedFullPath) || requestedFullPath;
+  return (await uniqueExistingPatchTarget(basePath, requestedFullPath)) || requestedFullPath;
 }
 
 export function patchHeaderPathForResolved(basePath, fullPath) {
@@ -41,33 +41,37 @@ export function patchHeaderPathForResolved(basePath, fullPath) {
   return fullPath;
 }
 
-export function rewriteV4AReadRedirects(sections, basePath) {
-  return (sections || []).map((section) => {
-    if (!section || section.kind === 'add' || !section.path) return section;
-    const requested = resolveV4AEntryPath(basePath, section.path);
-    const redirected = redirectedPatchPath(requested, basePath);
-    if (pathKey(redirected) === pathKey(requested)) return section;
-    return { ...section, path: patchHeaderPathForResolved(basePath, redirected) };
-  });
+export async function rewriteV4AReadRedirects(sections, basePath) {
+  return Promise.all(
+    (sections || []).map(async (section) => {
+      if (!section || section.kind === 'add' || !section.path) return section;
+      const requested = resolveV4AEntryPath(basePath, section.path);
+      const redirected = await redirectedPatchPath(requested, basePath);
+      if (pathKey(redirected) === pathKey(requested)) return section;
+      return { ...section, path: patchHeaderPathForResolved(basePath, redirected) };
+    })
+  );
 }
 
-export function rewriteParsedReadRedirects(parsed, basePath) {
-  return (parsed || []).map((entry) => {
-    const kind = classifyEntry(entry);
-    if (kind === 'create' || !entry?.oldFileName) return entry;
-    const requested = resolveEntryPath(basePath, entry.oldFileName);
-    const redirected = redirectedPatchPath(requested, basePath);
-    if (pathKey(redirected) === pathKey(requested)) return entry;
-    const rewritten = {
-      ...entry,
-      oldFileName: patchHeaderPathForResolved(basePath, redirected),
-    };
-    if (kind === 'modify' && entry.newFileName) {
-      const newRequested = resolveEntryPath(basePath, entry.newFileName);
-      if (pathKey(newRequested) === pathKey(requested)) {
-        rewritten.newFileName = rewritten.oldFileName;
+export async function rewriteParsedReadRedirects(parsed, basePath) {
+  return Promise.all(
+    (parsed || []).map(async (entry) => {
+      const kind = classifyEntry(entry);
+      if (kind === 'create' || !entry?.oldFileName) return entry;
+      const requested = resolveEntryPath(basePath, entry.oldFileName);
+      const redirected = await redirectedPatchPath(requested, basePath);
+      if (pathKey(redirected) === pathKey(requested)) return entry;
+      const rewritten = {
+        ...entry,
+        oldFileName: patchHeaderPathForResolved(basePath, redirected),
+      };
+      if (kind === 'modify' && entry.newFileName) {
+        const newRequested = resolveEntryPath(basePath, entry.newFileName);
+        if (pathKey(newRequested) === pathKey(requested)) {
+          rewritten.newFileName = rewritten.oldFileName;
+        }
       }
-    }
-    return rewritten;
-  });
+      return rewritten;
+    })
+  );
 }

package/src/runtime/agent/orchestrator/tools/patch/sequence/units.mjs

@@ -84,10 +84,10 @@ function parsedEntryUnit(entry, basePath) {
 // Parse the patch body into V4A-style sections (V4A envelope, bare-@@ hunks,
 // or counted-unified salvaged as V4A), or into parsed unified entries for a
 // plain unified diff.
-function parsePatchSections(patchStr, requestedFormat, basePath, { coalesceByFile }) {
+async function parsePatchSections(patchStr, requestedFormat, basePath, { coalesceByFile }) {
   if (isV4APatchInput(patchStr, requestedFormat)) {
     try {
-      const parsedSections = rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
+      const parsedSections = await rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
       return { sections: coalesceByFile ? coalesceCompatibleV4ASections(parsedSections, basePath) : parsedSections };
     } catch (err) {
       throw new Error(`apply_patch: V4A parse failed — ${err?.message || String(err)}`);
@@ -98,7 +98,7 @@ function parsePatchSections(patchStr, requestedFormat, basePath, { coalesceByFil
     // section's conversion into its own unit (ordered-stop preserved) rather
     // than converting the whole patch up front.
     try {
-      return { sections: rewriteV4AReadRedirects(parseUnifiedBareV4APatch(patchStr), basePath) };
+      return { sections: await rewriteV4AReadRedirects(parseUnifiedBareV4APatch(patchStr), basePath) };
     } catch (err) {
       throw new Error(`apply_patch: bare @@ parse failed — ${err?.message || String(err)}`);
     }
@@ -116,18 +116,18 @@ function parsePatchSections(patchStr, requestedFormat, basePath, { coalesceByFil
     // V4A-style sections and defer per-section conversion — same ordered-stop
     // guarantee as the V4A path (no whole-patch up-front convert).
     try {
-      return { sections: rewriteV4AReadRedirects(parseUnifiedCountedAsV4APatch(patchStr), basePath) };
+      return { sections: await rewriteV4AReadRedirects(parseUnifiedCountedAsV4APatch(patchStr), basePath) };
     } catch (fallbackErr) {
       throw new Error(
         `apply_patch: parse failed — ${err?.message || String(err)}; V4A fallback failed — ${fallbackErr?.message || String(fallbackErr)}`
       );
     }
   }
-  return { parsed: rewriteParsedReadRedirects(parsed, basePath) };
+  return { parsed: await rewriteParsedReadRedirects(parsed, basePath) };
 }
 
-export function buildPatchUnits(patchStr, requestedFormat, basePath, ctx) {
-  const { sections, parsed } = parsePatchSections(patchStr, requestedFormat, basePath, ctx);
+export async function buildPatchUnits(patchStr, requestedFormat, basePath, ctx) {
+  const { sections, parsed } = await parsePatchSections(patchStr, requestedFormat, basePath, ctx);
   if (sections) return sections.map((section) => sectionUnit(section, basePath, ctx));
   return (parsed || []).map((entry) => parsedEntryUnit(entry, basePath));
 }

package/src/runtime/agent/orchestrator/tools/patch/sequence.mjs

@@ -30,7 +30,7 @@ export async function applyPatchSequence(patchStr, requestedFormat, basePath, ct
     coalesceByFile = false,
   } = ctx;
 
-  const units = buildPatchUnits(patchStr, requestedFormat, basePath, {
+  const units = await buildPatchUnits(patchStr, requestedFormat, basePath, {
     v4aConvertOpts,
     dryRun,
     readStateScope,

package/src/runtime/agent/orchestrator/tools/shell-snapshot.mjs

@@ -18,6 +18,7 @@ import { randomUUID } from 'node:crypto';
 import { getPluginData } from '../config.mjs';
 import { scrubLoaderVars, scrubProviderSecrets, scrubRuntimeRootVars } from './env-scrub.mjs';
 import { spawnShellWithRetry } from './lib/shell-spawn-retry.mjs';
+import { ensureSkillLauncherDir } from '../../../shared/skill-script-runtime.mjs';
 
 const SNAPSHOT_TIMEOUT_MS = 10_000;
 
@@ -146,6 +147,9 @@ echo "# Shell options" >> "$SNAPSHOT_FILE"
 ${optDump}
 echo "# Aliases" >> "$SNAPSHOT_FILE"
 ${aliasDump}
+# The sourced PATH replaces the model shell's own, so it carries the
+# skill-launcher entry buildShellSpawnEnv prepends (mixdog-skill-node).
+PATH=${_shellQuote(ensureSkillLauncherDir())}:"$PATH"
 # PATH may contain $, backticks, or quotes that would re-expand if we
 # emitted it inside double quotes. Emit a shell-safe single-quoted PATH
 # export line via printf %q-style escaping inside the dump shell.

package/src/runtime/attachments/store.d.mts

@@ -0,0 +1,3 @@
+export function readAttachmentBuffer(value: string | { attachmentRef?: string }): Buffer;
+export function isPermanentAttachmentError(error: unknown): boolean;
+export function isAttachmentReference(value: unknown): boolean;

package/src/runtime/channels/lib/owned-runtime/owned-start.mjs

@@ -97,7 +97,7 @@ export function createOwnedStarter({
     state.automationRunning = true;
   }
   // DEGRADED MODE: a messaging connect failure — packaged runtime without
-  // discord.js, bad token, gateway outage — must not take schedules/webhooks
+  // the provider library, bad token, gateway outage — must not take schedules/webhooks
   // down with it. Sends stay dead (connected=false) but session runs, the
   // webhook server and the relay tunnel keep working.
   async function degradeToAutomation() {

package/src/runtime/channels/lib/webhook/session-dispatch.mjs

@@ -27,6 +27,14 @@ ${payload}
 <<<${_UNTRUSTED}_END>>>`;
 }
 
+/** The run's model-visible prompt (endpoint instructions + fenced external
+ *  payload) and its trusted skill-selection input: the endpoint-authored
+ *  instructions alone, so nothing in the payload or headers selects a skill. */
+function webhookRunPrompt(instructions, body, headers) {
+  const trusted = String(instructions ?? '');
+  return { prompt: `${trusted}\n\n${buildFencedPayload(body, headers)}`, skillSelection: trusted };
+}
+
 function trackDispatch({ name, deliveryId, dispatchP, controller }) {
   let settled = false;
   const timeoutHandle = setTimeout(
@@ -89,6 +97,10 @@ function createWebhookSessionDispatcher({ getConfig, getBridgeDispatch }) {
         workflow: extra.workflow || null,
         attachments: extra.attachments || null,
         delivery: extra.delivery || null,
+        // Trusted skill-selection input: only the endpoint-authored
+        // instructions, never the fenced external body/headers that share
+        // the model-visible prompt.
+        skillSelection: String(extra.skillSelection ?? ''),
         context: {
           source: 'webhook',
           endpoint: name,
@@ -105,14 +117,14 @@ function createWebhookSessionDispatcher({ getConfig, getBridgeDispatch }) {
   async function dispatchEndpoint({ name, body, headers, res, deliveryId, endpoint }) {
     try {
       const { model, instructions, cwd, workflow, attachments, delivery } = endpoint;
-      const payloadContent = buildFencedPayload(body, headers);
+      const run = webhookRunPrompt(instructions, body, headers);
       if (!getBridgeDispatch()) throw new Error(`[webhook] session dispatch requires bridgeDispatch`);
-      const fullPrompt = `${instructions}\n\n${payloadContent}`;
-      await dispatchSessionRun(name, model || null, fullPrompt, headers, deliveryId, res, {
+      await dispatchSessionRun(name, model || null, run.prompt, headers, deliveryId, res, {
         cwd: cwd || null,
         workflow: workflow || null,
         attachments: attachments || null,
         delivery: delivery || null,
+        skillSelection: run.skillSelection,
       });
       return true;
     } catch (err) {
@@ -125,4 +137,4 @@ function createWebhookSessionDispatcher({ getConfig, getBridgeDispatch }) {
   return { dispatchEndpoint };
 }
 
-export { buildFencedPayload, createWebhookSessionDispatcher };
+export { buildFencedPayload, createWebhookSessionDispatcher, webhookRunPrompt };

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

@@ -218,20 +218,23 @@ function wireWebhookHandlers() {
   webhookServer.setEventPipeline(eventPipeline);
   // Webhook fires run as sessions (schedules parity); the Automations
   // session row is the only surface (channel relay retired).
-  webhookServer.setBridgeDispatch(async ({ prompt, model, cwd, workflow, attachments, context, signal }) => {
-    const { runWebhookSession } = await import('../../../session-runtime/webhook-session-run.mjs');
-    const run = await runWebhookSession({
-      name: context?.endpoint || 'webhook',
-      model: model || null,
-      cwd: cwd || null,
-      workflow: workflow || null,
-      attachments: attachments || null,
-      // Dispatch-timeout cancellation only works if the signal reaches the run.
-      signal: signal || null,
-      prompt,
-    });
-    return run;
-  });
+  webhookServer.setBridgeDispatch(
+    async ({ prompt, skillSelection, model, cwd, workflow, attachments, context, signal }) => {
+      const { runWebhookSession } = await import('../../../session-runtime/webhook-session-run.mjs');
+      const run = await runWebhookSession({
+        name: context?.endpoint || 'webhook',
+        model: model || null,
+        cwd: cwd || null,
+        workflow: workflow || null,
+        attachments: attachments || null,
+        // Dispatch-timeout cancellation only works if the signal reaches the run.
+        signal: signal || null,
+        prompt,
+        skillSelection,
+      });
+      return run;
+    }
+  );
 }
 function wireEventQueueHandlers(eventQueue) {
   if (!eventQueue) return;

package/src/runtime/computer-bridge/linux-readiness.mjs

@@ -17,8 +17,6 @@ export const INPUT_GROUP_SECURITY_NOTE =
 export const GNOME_EXTENSION_UUID = 'mixdog-windows@mixdog.io';
 /** The oldest helper interface this app can use (2 added Screenshot and StopRequested, 3 the in-shell indicator). */
 export const MIN_WINDOW_HELPER_VERSION = 3;
-export const WINDOW_CONTROL_HINT =
-  'wayland_window_control_unavailable: this compositor offers no window control to other programs; on GNOME the Mixdog Windows extension (mixdog-windows@mixdog.io) provides it and must be enabled and loaded';
 export const WINDOW_HELPER_RELOGIN_HINT =
   'wayland_window_control_unavailable: the Mixdog Windows GNOME extension is installed and enabled but GNOME Shell has not loaded it yet; the user must sign out and sign in again once';
 export const WINDOW_HELPER_ENABLE_HINT =

package/src/runtime/effort-judge/judge-client.mjs

@@ -20,12 +20,19 @@ const MODEL_FILES = ['model.onnx', 'tokenizer.json'];
 // The worker runs one judgment at a time, so requests are sent one by one:
 // each answer's deadline starts when it is sent, and the wait for earlier
 // requests is bounded separately so a burst of turns queues instead of
-// timing out behind each other.
+// timing out behind each other. The next request is sent only once the worker
+// has answered the previous one: an answer that missed its deadline still
+// occupies the worker, and sending into it would start the next deadline
+// while the worker is busy, failing it too.
+// 500 ms covers the 18-layer judge's tail while parallel agents share the CPU.
 // MIXDOG_EFFORT_JUDGE_TIMEOUT_MS raises it on a host whose CPUs are shared
 // with heavy work (parallel benchmark containers).
 const WARM_TIMEOUT_MS =
-  Number(process.env.MIXDOG_EFFORT_JUDGE_TIMEOUT_MS) > 0 ? Number(process.env.MIXDOG_EFFORT_JUDGE_TIMEOUT_MS) : 400;
+  Number(process.env.MIXDOG_EFFORT_JUDGE_TIMEOUT_MS) > 0 ? Number(process.env.MIXDOG_EFFORT_JUDGE_TIMEOUT_MS) : 500;
 const QUEUE_WAIT_MS = 1000;
+// A worker that has not answered for this long is stuck; it is replaced so
+// the queue does not stay blocked behind it.
+const STUCK_MS = 10_000;
 let queueTail = Promise.resolve();
 // A turn that arrives while the judge is still loading (its first use, or the
 // first turn after a model update) waits at most this long; loading takes about 2 s on a desktop CPU.
@@ -107,7 +114,7 @@ function settle(id, fn) {
   const entry = pending.get(id);
   if (!entry) return;
   pending.delete(id);
-  clearTimeout(entry.timer);
+  entry.done();
   fn(entry);
 }
 
@@ -151,11 +158,27 @@ function ensureWorker(dir) {
   return created;
 }
 
+// `answer` settles with the probabilities or fails at the deadline; `done`
+// resolves once the worker has answered (or exited), when it can take the next request.
 function request(target, { request: text, prev, prevRequest, step }) {
   const id = ++msgId;
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => settle(id, (entry) => entry.reject(new Error('timeout'))), WARM_TIMEOUT_MS);
-    pending.set(id, { resolve, reject, timer });
+  let finish;
+  const done = new Promise((resolve) => {
+    finish = resolve;
+  });
+  const answer = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('timeout')), WARM_TIMEOUT_MS);
+    const stuck = setTimeout(() => void target.terminate().catch(() => {}), STUCK_MS);
+    stuck.unref();
+    pending.set(id, {
+      resolve,
+      reject,
+      done: () => {
+        clearTimeout(timer);
+        clearTimeout(stuck);
+        finish();
+      },
+    });
     // The worker formats the text the way its model was trained.
     target.postMessage({
       action: 'judge',
@@ -169,6 +192,9 @@ function request(target, { request: text, prev, prevRequest, step }) {
       ...(step ? { step } : {}),
     });
   });
+  // A caller that gave up while queued never reads its answer.
+  answer.catch(() => {});
+  return { answer, done };
 }
 
 // One install at a time (the settings install and the boot refresh can overlap).
@@ -257,19 +283,31 @@ export async function judgeTurn(input) {
   if (!ready && !(await waitReady(COLD_WAIT_MS))) {
     return { skipped: lastLoadError ? `load-error: ${lastLoadError}` : 'warming' };
   }
-  const queuedAt = Date.now();
-  const run = queueTail.then(async () => {
-    if (worker !== target || !ready) return { skipped: 'effort judge exited' };
-    if (Date.now() - queuedAt > QUEUE_WAIT_MS) return { skipped: 'busy' };
-    const startedAt = Date.now();
-    try {
-      return { probs: await request(target, input), ms: Date.now() - startedAt };
-    } catch (error) {
-      return { skipped: String(error?.message || error) };
-    }
+  let abandoned = false;
+  const turn = queueTail.then(() => {
+    if (abandoned) return null;
+    if (worker !== target || !ready) return { exited: true };
+    return { startedAt: Date.now(), ...request(target, input) };
   });
-  queueTail = run;
-  return run;
+  queueTail = turn.then((sent) => sent?.done);
+  let timer;
+  const sent = await Promise.race([
+    turn,
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, QUEUE_WAIT_MS, null);
+    }),
+  ]);
+  clearTimeout(timer);
+  if (!sent) {
+    abandoned = true;
+    return { skipped: 'busy' };
+  }
+  if (sent.exited) return { skipped: 'effort judge exited' };
+  try {
+    return { probs: await sent.answer, ms: Date.now() - sent.startedAt };
+  } catch (error) {
+    return { skipped: String(error?.message || error) };
+  }
 }
 
 // MIXDOG_EFFORT_DECISIONS_LOG redirects the log, e.g. for benchmark runs whose

package/src/runtime/memory/lib/memory.mjs

@@ -161,7 +161,7 @@ async function _migrateRecallIndexesIfStale(db) {
 }
 
 // One-time cleanup: attachment-only placeholder rows ('(attachment)' user
-// content, e.g. Discord provider discord.mjs:724) predate the
+// content from the former channel provider) predate the
 // shouldExcludeIngestMessage() ingest-time filter (session-ingest.mjs).
 // Delete any already-persisted rows so they stop polluting recall/cycle1.
 // Idempotent (no-op once cleaned); best-effort so a failure never blocks boot.

package/src/runtime/memory/lib/pg/process.mjs

@@ -12,17 +12,16 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
-  readdirSync,
   readFileSync,
   rmdirSync,
   rmSync,
-  statSync,
   symlinkSync,
   unlinkSync,
   writeFileSync,
 } from 'node:fs';
+import { readdir, readFile, rm, stat } from 'node:fs/promises';
 import { join } from 'node:path';
-import { spawn, spawnSync } from 'node:child_process';
+import { execFile, spawn, spawnSync } from 'node:child_process';
 import { createConnection, createServer } from 'node:net';
 import { isPidAlive } from '../../../shared/pid-liveness.mjs';
 
@@ -607,22 +606,36 @@ export function classifyOrphanTempPostmaster({
   return Number(uptimeSec) >= Math.max(60, Number(minUptimeSec) || ORPHAN_TEMP_PG_MIN_UPTIME_SEC);
 }
 
-function tempPostmasterOwnerAlive(args) {
+async function tempPostmasterOwnerAlive(args) {
   const rawDataDir = pgDataDirFromArgs(args);
   if (!rawDataDir) return false;
   const dataRoot = join(rawDataDir, '..');
   for (const name of ['memory-runtime-owner.json', 'daemon-owner.json']) {
     try {
-      const owner = JSON.parse(readFileSync(join(dataRoot, name), 'utf8'));
+      const owner = JSON.parse(await readFile(join(dataRoot, name), 'utf8'));
       if (Number(owner?.pid) > 0 && isPidAlive(Number(owner.pid))) return true;
     } catch {}
   }
   return false;
 }
 
-function listPostmasterRows() {
+// Async child run: stdout on exit 0, null on any failure/timeout (the old
+// spawnSync `status !== 0` contract). Never blocks the event loop.
+function execFileText(file, args, options) {
+  return new Promise((resolve) => {
+    try {
+      execFile(file, args, { encoding: 'utf8', ...options }, (error, stdout) => {
+        resolve(error ? null : String(stdout || ''));
+      });
+    } catch {
+      resolve(null);
+    }
+  });
+}
+
+async function listPostmasterRows() {
   if (process.platform === 'win32') {
-    const result = spawnSync(
+    const stdout = await execFileText(
       'powershell',
       [
         '-NoProfile',
@@ -632,10 +645,10 @@ function listPostmasterRows() {
           'started = [int](New-TimeSpan -Start $_.CreationDate -End (Get-Date)).TotalSeconds; ' +
           'args = $_.CommandLine } }',
       ],
-      { encoding: 'utf8', timeout: 15_000, windowsHide: true }
+      { timeout: 15_000, windowsHide: true }
     );
-    if (result.status !== 0) return [];
-    return String(result.stdout || '')
+    if (stdout === null) return [];
+    return stdout
       .split(/\r?\n/)
       .filter(Boolean)
       .flatMap((line) => {
@@ -647,12 +660,9 @@ function listPostmasterRows() {
         }
       });
   }
-  const result = spawnSync('ps', ['-eo', 'pid=,etimes=,args='], {
-    encoding: 'utf8',
-    timeout: 15_000,
-  });
-  if (result.status !== 0) return [];
-  return String(result.stdout || '')
+  const stdout = await execFileText('ps', ['-eo', 'pid=,etimes=,args='], { timeout: 15_000 });
+  if (stdout === null) return [];
+  return stdout
     .split(/\r?\n/)
     .flatMap((line) => {
       const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.*postgres.*)$/);
@@ -679,11 +689,11 @@ function pristineRootForArgs(args, tempRoot) {
 // (observed: 87 roots, 6.1GB, alongside 57 live postmasters). Roots a live
 // postmaster still owns are kept, and the same uptime margin that protects a
 // running harness from the process sweep protects its directory here.
-function sweepAbandonedPristineRoots(tempRoot, liveRoots, minAgeMs) {
+async function sweepAbandonedPristineRoots(tempRoot, liveRoots, minAgeMs) {
   let removed = 0;
   let entries;
   try {
-    entries = readdirSync(tempRoot, { withFileTypes: true });
+    entries = await readdir(tempRoot, { withFileTypes: true });
   } catch {
     return 0;
   }
@@ -693,12 +703,12 @@ function sweepAbandonedPristineRoots(tempRoot, liveRoots, minAgeMs) {
     const full = join(tempRoot, entry.name);
     if (liveRoots.has(normalizePathForMatch(full))) continue;
     try {
-      if (statSync(full).mtimeMs > cutoff) continue;
+      if ((await stat(full)).mtimeMs > cutoff) continue;
     } catch {
       continue;
     }
     try {
-      rmSync(full, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+      await rm(full, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
       removed += 1;
     } catch {
       /* a process this sweep did not reap still holds it */
@@ -709,18 +719,18 @@ function sweepAbandonedPristineRoots(tempRoot, liveRoots, minAgeMs) {
 
 /** Best-effort machine hygiene: reap orphan temp postmasters, then drop the
  *  throwaway roots no live postmaster owns. Runs periodically, not once. */
-export function sweepOrphanTempPostmasters({ tempRoot, minUptimeSec } = {}) {
+export async function sweepOrphanTempPostmasters({ tempRoot, minUptimeSec } = {}) {
   let reaped = 0;
   try {
     const root = tempRoot || process.env.TMPDIR || process.env.TEMP || process.env.TMP || '/tmp';
     const liveRoots = new Set();
-    for (const row of listPostmasterRows()) {
+    for (const row of await listPostmasterRows()) {
       if (!row.pid || row.pid === process.pid) continue;
       if (
         !classifyOrphanTempPostmaster({
           ...row,
           tempRoot: root,
-          ownerAlive: tempPostmasterOwnerAlive(row.args),
+          ownerAlive: await tempPostmasterOwnerAlive(row.args),
           minUptimeSec,
         })
       ) {
@@ -737,7 +747,7 @@ export function sweepOrphanTempPostmasters({ tempRoot, minUptimeSec } = {}) {
       }
     }
     const minAgeMs = Math.max(60, Number(minUptimeSec) || ORPHAN_TEMP_PG_MIN_UPTIME_SEC) * 1000;
-    const removed = sweepAbandonedPristineRoots(root, liveRoots, minAgeMs);
+    const removed = await sweepAbandonedPristineRoots(root, liveRoots, minAgeMs);
     if (removed > 0) __mixdogMemoryLog(`[pg-process] removed ${removed} abandoned pristine root(s)\n`);
   } catch {
     /* hygiene is best-effort */

package/src/runtime/memory/lib/pg/supervisor.mjs

@@ -372,6 +372,16 @@ function readPostmasterInfo(pgdata) {
   }
 }
 
+// Async child run (never blocks the daemon loop): stdout on exit 0, else null.
+async function _execFileText(file, args) {
+  const { execFile } = await import('node:child_process');
+  return new Promise((resolveText) => {
+    execFile(file, args, { encoding: 'utf8', windowsHide: true, timeout: 15_000 }, (error, stdout) => {
+      resolveText(error ? null : String(stdout || ''));
+    });
+  });
+}
+
 /**
  * Best-effort process-name check: confirms the pid's comm name contains 'postgres'.
  * Falls back to true (alive) when the name cannot be determined.
@@ -383,19 +393,12 @@ async function isPostgresPid(pid) {
       return comm.includes('postgres');
     }
     if (process.platform === 'darwin') {
-      const { spawnSync } = await import('node:child_process');
-      const r = spawnSync('ps', ['-o', 'comm=', '-p', String(pid)], { encoding: 'utf8', windowsHide: true });
-      if (r.status === 0) return (r.stdout || '').trim().includes('postgres');
-      return true;
+      const out = await _execFileText('ps', ['-o', 'comm=', '-p', String(pid)]);
+      return out === null ? true : out.trim().includes('postgres');
     }
     if (process.platform === 'win32') {
-      const { spawnSync } = await import('node:child_process');
-      const r = spawnSync('tasklist', ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH'], {
-        encoding: 'utf8',
-        windowsHide: true,
-      });
-      if (r.status === 0) return (r.stdout || '').toLowerCase().includes('postgres');
-      return true;
+      const out = await _execFileText('tasklist', ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH']);
+      return out === null ? true : out.toLowerCase().includes('postgres');
     }
   } catch {
     /* cannot read — fall back to alive */
@@ -463,8 +466,8 @@ function scheduleOrphanTempPostmasterSweep() {
   _orphanSweepStarted = true;
   const runSweep = () => {
     void _getPgProc()
-      .then(({ sweepOrphanTempPostmasters }) => {
-        const reaped = sweepOrphanTempPostmasters?.() || 0;
+      .then(async ({ sweepOrphanTempPostmasters }) => {
+        const reaped = (await sweepOrphanTempPostmasters?.()) || 0;
         if (reaped > 0) __mixdogMemoryLog(`[supervisor-pg] orphan sweep reaped ${reaped} temp postmaster(s)\n`);
       })
       .catch(() => {

package/src/runtime/memory/lib/session-ingest.mjs

@@ -201,8 +201,8 @@ function isExcludedUserIngestText(m, text) {
   if (metaSource === 'task-notification') return true;
   // `Reference files:` synthetic user rows (manager.mjs isReferenceFilesMessage).
   if (/^Reference files:\s*/i.test(trimmedStart)) return true;
-  // Attachment-only placeholder rows (e.g. Discord provider discord.mjs:724
-  // `"(attachment)"` fallback when a message carries no text, only files).
+  // Attachment-only placeholder rows (`"(attachment)"` fallback written by the
+  // former channel provider when a message carried no text, only files).
   if (text.trim() === '(attachment)') return true;
   // Compaction summary user rows (compact.mjs isSummaryMessage / SUMMARY_PREFIX).
   if (metaSource === 'compact-summary') return true;

package/src/runtime/office/README.md

@@ -17,7 +17,7 @@ Microsoft Office installed.
 | `design/` | Design tokens, content model, composition, creative direction for the Word and Excel composers (`compose_document`, `compose_sheet`); `design-discipline.mjs` owns the safe typeface list, palette repair (tinted dark fields, WCAG contrast, paired accent tints), and the brief rules; `docx/`, `xlsx/` format compilers; `library/` template library with the bundled `templates/`. Decks are never composed here — a slide is authored by the model as a script (`authoring/`), and `compose_slide` is refused with that route. |
 | `quality/` | Reviews and gates: `assurance-*.mjs` (trust, structure, rendered pages, checklist), aesthetics, design review, scoring, visual diff. |
 | `bench/` | Benchmarks behind `npm run bench:office*`; `bench-support.mjs` holds the shared tool-call helpers. |
-| `shared/` | Tiny helpers used across folders: `values.mjs` (`plainObject`, `clone`, `stableValue`, `sha256`, `clamp`, `compact`, `imageBuffer`), `page-sizes.mjs` (the paper sizes PDF create and Word `set_page` share), `column-widths.mjs` (the widths a Word or PDF table given none takes from its text), and `asar-path.mjs`. |
+| `shared/` | Tiny helpers used across folders: `values.mjs` (`plainObject`, `clone`, `stableValue`, `sha256`, `clamp`, `compact`), `page-sizes.mjs` (the paper sizes PDF create and Word `set_page` share), `column-widths.mjs` (the widths a Word or PDF table given none takes from its text), and `asar-path.mjs`. |
 
 ## Dependency direction
 

package/src/runtime/office/shared/values.mjs

@@ -32,8 +32,3 @@ export function compact(value, maximum = 120) {
     .replace(/\s+/g, ' ')
     .slice(0, maximum);
 }
-
-export function imageBuffer(image) {
-  if (Buffer.isBuffer(image?.data)) return image.data;
-  return Buffer.from(String(image?.data || ''), 'base64');
-}