mixdog 1.1.2 → 1.2.1

package/src/runtime/agent/orchestrator/tools/patch/apply-patch/codex-batch.mjs

@@ -47,7 +47,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
   let v4aRenamePlan = null;
   if (isV4APatchInput(patchStr, requestedFormat)) {
     try {
-      const parsedSections = preParsedV4ASections || rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
+      const parsedSections = preParsedV4ASections || (await rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath));
       const allSections = coalesceCompatibleV4ASections(parsedSections, basePath);
       v4aRenamePlan = await planV4ARenameSections(allSections, basePath);
       inputPatchStr = await convertV4ASectionsToUnifiedPatch(v4aRenamePlan.remainingSections, basePath, v4aConvertOpts);
@@ -56,7 +56,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
     }
   } else if (requestedFormat !== 'unified' && hasUnifiedBareV4AHunk(patchStr)) {
     try {
-      const sections = rewriteV4AReadRedirects(parseUnifiedBareV4APatch(patchStr), basePath);
+      const sections = await rewriteV4AReadRedirects(parseUnifiedBareV4APatch(patchStr), basePath);
       inputPatchStr = await convertV4ASectionsToUnifiedPatch(sections, basePath, v4aConvertOpts);
     } catch (err) {
       throw new Error(`apply_patch: bare @@ parse failed — ${err?.message || String(err)}`);
@@ -82,7 +82,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
       );
     }
     try {
-      const sections = rewriteV4AReadRedirects(parseUnifiedCountedAsV4APatch(patchStr), basePath);
+      const sections = await rewriteV4AReadRedirects(parseUnifiedCountedAsV4APatch(patchStr), basePath);
       inputPatchStr = await convertV4ASectionsToUnifiedPatch(sections, basePath, v4aConvertOpts);
       parsed = parsePatch(prepareInput(inputPatchStr));
     } catch (fallbackErr) {
@@ -91,7 +91,7 @@ export async function prepareCodexBatch({ patchStr, requestedFormat, basePath, p
       );
     }
   }
-  parsed = rewriteParsedReadRedirects(parsed, basePath);
+  parsed = await rewriteParsedReadRedirects(parsed, basePath);
   if (!Array.isArray(parsed) || parsed.length === 0) {
     return { error: 'Error: patch contained no file sections' };
   }

package/src/runtime/agent/orchestrator/tools/patch/apply-patch/route.mjs

@@ -7,11 +7,11 @@ import { pathKey, resolveV4AEntryPath } from '../paths.mjs';
 import { rewriteV4AReadRedirects } from '../read-redirects.mjs';
 import { isV4ARenameSection } from '../v4a-convert.mjs';
 
-export function selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath }) {
+export async function selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath }) {
   let preParsedV4ASections = null;
   if (isV4APatchInput(patchStr, requestedFormat)) {
     try {
-      preParsedV4ASections = rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
+      preParsedV4ASections = await rewriteV4AReadRedirects(parseV4APatch(patchStr), basePath);
     } catch {
       // The selected execution path reports the authoritative parse error.
     }

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

@@ -34,7 +34,7 @@ async function apply_patch(rawArgs, cwd, options = {}) {
   }
   const rejectedV4AHunks = [];
   const v4aConvertOpts = { rejectPartial, rejectedHunks: rejectedV4AHunks, fuzzy, dryRun, readStateScope };
-  const route = selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath });
+  const route = await selectApplyPatchRoute({ args, patchStr, requestedFormat, basePath });
   if (route.useSequence) {
     const seqOut = await applyPatchSequence(patchStr, requestedFormat, basePath, {
       v4aConvertOpts,

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/patch/ui-diff.mjs

@@ -1,6 +1,7 @@
 // UI-diff side channel: a committed apply_patch (or edit-tool write) records
 // a turn-review change entry and a per-call diff the desktop/TUI tool cards
 // pick up. Display only — never affects edit semantics.
+import { createTwoFilesPatch } from 'diff';
 import { boundReviewPatch } from '../../../../shared/review-diff.mjs';
 import { recordTurnDiffChanges } from '../../../../shared/turn-snapshot.mjs';
 import { pathKey, resolveV4AEntryPath } from './paths.mjs';
@@ -29,6 +30,77 @@ export function takeApplyPatchUiDiff(callId) {
   return value;
 }
 
+// A display path is a plain relative or absolute path; the patch header only
+// needs forward slashes. Its own leading "a/" is part of the name.
+function headerPath(value) {
+  return String(value || '')
+    .trim()
+    .replace(/\\/g, '/');
+}
+
+const DIFF_TIMEOUT_MS = 100;
+
+const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+
+function isOmitted(value) {
+  return Boolean(value) && typeof value === 'object' && !(value instanceof Uint8Array) && value.omitted === true;
+}
+
+// Text of one side: '' for an absent file, null when it is not UTF-8 text.
+function sideText(value) {
+  if (value == null) return '';
+  if (typeof value === 'string') return value;
+  if (value instanceof Uint8Array) {
+    try {
+      return utf8.decode(value);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// One file's change, from the call's own before and after states: absent
+// (null), bytes or text, or an omitted marker when the bytes were not kept.
+function renderCallChange({ displayPath, newDisplayPath, before, after }) {
+  const oldName = headerPath(displayPath) || 'unknown file';
+  const newName = headerPath(newDisplayPath) || oldName;
+  const oldHeader = before == null ? '/dev/null' : `a/${oldName}`;
+  const newHeader = after == null ? '/dev/null' : `b/${newName}`;
+  let head = `diff --git a/${oldName} b/${newName}\n`;
+  if (before == null && after != null) head += 'new file mode 100644\n';
+  else if (before != null && after == null) head += 'deleted file mode 100644\n';
+  if (isOmitted(before) || isOmitted(after)) {
+    return `${head}Binary files ${oldHeader} and ${newHeader} differ\n`;
+  }
+  const oldText = sideText(before);
+  const newText = sideText(after);
+  if (oldText === null || newText === null) return `${head}Binary files ${oldHeader} and ${newHeader} differ\n`;
+  if (oldText === newText) {
+    // An empty file created or deleted still changed: git writes the mode line alone.
+    if ((before == null) !== (after == null)) return head;
+    return oldName === newName ? '' : `${head}similarity index 100%\nrename from ${oldName}\nrename to ${newName}\n`;
+  }
+  const rename = oldName === newName ? '' : `rename from ${oldName}\nrename to ${newName}\n`;
+  try {
+    const generated = createTwoFilesPatch(oldHeader, newHeader, oldText, newText, '', '', {
+      context: 3,
+      timeout: DIFF_TIMEOUT_MS,
+    });
+    const start = generated.search(/^--- /m);
+    if (start >= 0) return `${head}${rename}${generated.slice(start).replace(/\n*$/, '\n')}`;
+  } catch {
+    // A pathological diff timing out must not stall tool completion.
+  }
+  return `${head}${rename}Binary files ${oldHeader} and ${newHeader} differ\n`;
+}
+
+// A call's card shows the change that call made — its own before against its
+// own after — never the turn's running total for the same files.
+export function callUiDiff(changes) {
+  return (changes || []).map(renderCallChange).join('');
+}
+
 // Edit-tool UI diff: a successful single-file str-replace edit records the
 // same turn-review change entry and per-call UI diff side channel that a
 // committed apply_patch gets, so desktop/TUI tool cards render both edit
@@ -36,15 +108,16 @@ export function takeApplyPatchUiDiff(callId) {
 export function registerEditToolUiDiff({ callId, sessionId, basePath, fullPath, before, after }) {
   if (!callId || !sessionId || typeof fullPath !== 'string') return;
   try {
-    const turnDiff = recordTurnDiffChanges(sessionId, [
+    const changes = [
       {
         path: fullPath,
         displayPath: patchHeaderPathForResolved(basePath || '', fullPath),
         before: before ?? null,
         after: after ?? null,
       },
-    ]);
-    registerApplyPatchUiDiff(callId, turnDiff);
+    ];
+    recordTurnDiffChanges(sessionId, changes);
+    registerApplyPatchUiDiff(callId, callUiDiff(changes));
   } catch {
     // best-effort display channel
   }
@@ -111,8 +184,8 @@ export function registerCommittedPatchUiDiff({
         after: snapshotContent(after),
       });
     }
-    const turnDiff = recordTurnDiffChanges(sessionId, changes);
-    registerApplyPatchUiDiff(callId, turnDiff);
+    recordTurnDiffChanges(sessionId, changes);
+    registerApplyPatchUiDiff(callId, callUiDiff(changes));
   } catch {
     // Review collection is a side channel and must never affect committed
     // apply_patch success/failure semantics.

package/src/runtime/agent/orchestrator/tools/progress-message.mjs

@@ -75,6 +75,8 @@ export function formatToolStartProgress(name, args = {}) {
     }
     case 'terminal':
       return a.action === 'read' ? `reading terminal${a.tab ? ` ${_t(a.tab)}` : ''}` : 'listing terminals';
+    case 'visualize':
+      return `visualize ${_t(a.action || 'command')}`;
     case 'office':
       return a.path ? `office ${_t(a.action || 'command')} ${_t(a.path)}` : `office ${_t(a.action || 'command')}`;
     case 'media': {

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/attachments/store.mjs

@@ -8,9 +8,13 @@
  */
 import { createHash, randomBytes } from 'node:crypto';
 import {
+  closeSync,
   existsSync,
+  fstatSync,
   mkdirSync,
+  openSync,
   readFileSync,
+  readSync,
   renameSync,
   statSync,
   unlinkSync,
@@ -303,6 +307,40 @@ function readAttachmentText(value) {
   return readAttachmentBuffer(value).toString('utf8');
 }
 
+/**
+ * A referenced blob's UTF-8 text when the blob on disk holds at most
+ * `maxBytes`, else null. The size comes from the opened file, never from the
+ * reference's claimed sizeBytes, and at most `maxBytes + 1` bytes are read, so
+ * a blob that grows between the check and the read is rejected too. Missing,
+ * invalid or tampered blobs throw like readAttachmentBuffer.
+ */
+export function readAttachmentTextWithin(value, maxBytes) {
+  const ref = typeof value === 'string' ? value : value?.attachmentRef;
+  const fd = openSync(attachmentPath(ref), 'r');
+  try {
+    const info = fstatSync(fd);
+    if (!info.isFile() || info.size <= 0) {
+      throw Object.assign(new Error('prompt attachment blob is invalid'), { code: ATTACHMENT_INVALID });
+    }
+    if (info.size > maxBytes) return null;
+    const buffer = Buffer.alloc(info.size + 1);
+    let length = 0;
+    while (length < buffer.length) {
+      const read = readSync(fd, buffer, length, buffer.length - length, length);
+      if (read === 0) break;
+      length += read;
+    }
+    if (length > maxBytes) return null;
+    const bytes = buffer.subarray(0, length);
+    if (attachmentRefForBuffer(bytes) !== ref) {
+      throw Object.assign(new Error('prompt attachment integrity check failed'), { code: ATTACHMENT_INTEGRITY });
+    }
+    return bytes.toString('utf8');
+  } finally {
+    closeSync(fd);
+  }
+}
+
 export function attachmentTextForPart(part) {
   if (!isAttachmentReference(part)) return typeof part?.text === 'string' ? part.text : '';
   const text = readAttachmentText(part);

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.