mixdog 1.2.2 → 1.2.4

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

@@ -1,3 +1,12 @@
 export function readAttachmentBuffer(value: string | { attachmentRef?: string }): Buffer;
 export function isPermanentAttachmentError(error: unknown): boolean;
 export function isAttachmentReference(value: unknown): boolean;
+export interface MessageAttachment {
+  id: string;
+  attachmentRef: string;
+  kind: 'image' | 'file' | 'text';
+  name: string;
+  mimeType: string;
+  size: number;
+}
+export function attachmentsForIntake(prompt: unknown, options?: unknown): MessageAttachment[];

package/src/runtime/attachments/store.mjs

@@ -2,8 +2,8 @@
  * Content-addressed prompt attachment store.
  *
  * Renderer/TUI inputs carry the bytes exactly once to the daemon intake. From
- * that boundary onward queues, checkpoints, session JSON, live-share frames,
- * and desktop snapshots carry only a sha256 reference plus byte-free metadata.
+ * that boundary onward queues, checkpoints, session JSON and desktop
+ * snapshots carry only a sha256 reference plus byte-free metadata.
  * Provider lowering resolves the reference at the last possible boundary.
  */
 import { createHash, randomBytes } from 'node:crypto';
@@ -214,11 +214,13 @@ export function storeInlineDocumentPart(part) {
     if (source?.type !== 'base64' || typeof source.data !== 'string') return null;
     data = source.data;
     const { source: _source, type: _type, mimeType: _mimeType, mediaType: _mediaType, ...rest } = part;
-    const mimeType = String(source.media_type || source.mediaType || part.mimeType || part.mediaType || 'application/pdf')
-      .trim()
-      .toLowerCase() || 'application/pdf';
+    const mimeType =
+      String(source.media_type || source.mediaType || part.mimeType || part.mediaType || 'application/pdf')
+        .trim()
+        .toLowerCase() || 'application/pdf';
     metadata = { ...rest, type: 'file', mimeType };
-    const filename = (typeof part.title === 'string' && part.title) || (typeof part.filename === 'string' && part.filename) || '';
+    const filename =
+      (typeof part.title === 'string' && part.title) || (typeof part.filename === 'string' && part.filename) || '';
     if (filename) metadata.filename = filename;
   } else if (part.type === 'file' && typeof part.data === 'string') {
     const { data: inline, ...rest } = part;
@@ -282,9 +284,7 @@ export function isMissingAttachmentError(error) {
 // never become readable. EBUSY/EPERM/EACCES/EMFILE and friends are transient:
 // callers must let them propagate rather than rewrite history around them.
 export function isPermanentAttachmentError(error) {
-  return (
-    isMissingAttachmentError(error) || error?.code === ATTACHMENT_INVALID || error?.code === ATTACHMENT_INTEGRITY
-  );
+  return isMissingAttachmentError(error) || error?.code === ATTACHMENT_INVALID || error?.code === ATTACHMENT_INTEGRITY;
 }
 
 export function readAttachmentBase64(value) {
@@ -534,6 +534,77 @@ export function materializePromptSubmission(prompt, options = {}) {
   };
 }
 
+const MAX_MESSAGE_ATTACHMENTS = 64;
+
+/**
+ * The user-attachment records of one materialized submission, for the message
+ * metadata (`meta.transcript.attachments`): every image, file and
+ * pasted/attached text that lives in the store, by its content hash. The id IS
+ * the `attachmentRef`; the record repeats it under that key so the store's
+ * mark-and-sweep census (which scans persisted sessions for `"attachmentRef"`)
+ * keeps the blob for as long as the message exists, even after compaction
+ * dropped the content part. Plain long prompt text (no `textKind`) is not an
+ * attachment.
+ */
+export function attachmentsForIntake(prompt, options = {}) {
+  const found = new Map();
+  const add = (ref, info) => {
+    if (!ATTACHMENT_REF_RE.test(String(ref || '')) || found.has(ref) || found.size >= MAX_MESSAGE_ATTACHMENTS) return;
+    found.set(ref, info);
+  };
+  const named = (raw, fallback) => String(raw?.filename || raw?.name || fallback).slice(0, 200);
+  const pastedImages = Object.values(options?.pastedImages || {}).filter((raw) => raw && typeof raw === 'object');
+  const pastedTexts = Object.values(options?.pastedTexts || {}).filter((raw) => raw && typeof raw === 'object');
+  const parts = Array.isArray(prompt) ? prompt : [];
+  for (const part of parts) {
+    if (!isAttachmentReference(part)) continue;
+    const mimeType = String(part.mimeType || part.mediaType || '').slice(0, 100);
+    if (part.type === 'image') {
+      const meta = pastedImages.find((raw) => raw.attachmentRef === part.attachmentRef);
+      add(part.attachmentRef, {
+        kind: 'image',
+        name: named(meta || part, 'image'),
+        mimeType: mimeType || String(meta?.mediaType || 'image/png'),
+        size: attachmentBlobSize(part, part.sizeBytes),
+      });
+    } else if (part.type === 'file') {
+      add(part.attachmentRef, {
+        kind: 'file',
+        name: named(part, 'attachment'),
+        mimeType: mimeType || 'application/octet-stream',
+        size: attachmentBlobSize(part, part.sizeBytes),
+      });
+    } else if (part.type === 'text' && (part.textKind === 'paste' || part.textKind === 'file')) {
+      add(part.attachmentRef, {
+        kind: 'text',
+        name: named(part, part.textKind === 'paste' ? 'pasted-text.txt' : 'attachment.txt'),
+        mimeType: mimeType || 'text/plain',
+        size: attachmentBlobSize(part, part.sizeBytes),
+      });
+    }
+  }
+  // Images the prompt carries only by side table (no matching content part).
+  for (const raw of pastedImages) {
+    if (!isAttachmentReference(raw)) continue;
+    add(raw.attachmentRef, {
+      kind: 'image',
+      name: named(raw, 'image'),
+      mimeType: String(raw.mediaType || 'image/png').slice(0, 100),
+      size: attachmentBlobSize(raw, raw.sizeBytes),
+    });
+  }
+  for (const raw of pastedTexts) {
+    if (!isAttachmentReference(raw)) continue;
+    add(raw.attachmentRef, {
+      kind: 'text',
+      name: named(raw, raw.source === 'file' ? 'attachment.txt' : 'pasted-text.txt'),
+      mimeType: String(raw.mimeType || 'text/plain').slice(0, 100),
+      size: attachmentBlobSize(raw, raw.sizeBytes),
+    });
+  }
+  return [...found].map(([ref, info]) => ({ id: ref, attachmentRef: ref, ...info }));
+}
+
 /**
  * Whether a provider takes a PDF as a native document block. Decided by the
  * provider's wire protocol: each adapter class declares `nativePdf`; a provider

package/src/runtime/browser-bridge/browser-action-contract.d.mts

@@ -1,7 +1,6 @@
 export const BROWSER_ACTIONS: readonly string[];
 export const BROWSER_DEVTOOLS_ACTIONS: readonly string[];
 export const BROWSER_PAGE_ACTIONS: readonly string[];
-export const BROWSER_TOOL_NAMES: readonly string[];
 export function browserToolForAction(action: string): string;
 export const BROWSER_OBSERVATION_ACTIONS: readonly string[];
 export const BROWSER_POSTCONDITION_ACTIONS: readonly string[];

package/src/runtime/browser-bridge/browser-action-contract.mjs

@@ -57,8 +57,6 @@ export const BROWSER_PAGE_ACTIONS = Object.freeze(
 
 const BROWSER_TOOL_NAME = 'browser';
 const BROWSER_DEVTOOLS_TOOL_NAME = 'browser_devtools';
-/** Both tools drive the same bridge, pages, and sign-in. */
-export const BROWSER_TOOL_NAMES = Object.freeze([BROWSER_TOOL_NAME, BROWSER_DEVTOOLS_TOOL_NAME]);
 
 export function browserToolForAction(action) {
   return BROWSER_DEVTOOLS_ACTIONS.includes(action) ? BROWSER_DEVTOOLS_TOOL_NAME : BROWSER_TOOL_NAME;

package/src/runtime/computer-bridge/action-schema.mjs

@@ -1,6 +1,7 @@
 import { splitBridgeToolArgs } from '../shared/bridge-tool-args.mjs';
 import { hasOwn } from '../shared/object.mjs';
 import { schemaValueError } from '../shared/schema-value-error.mjs';
+import { advertiseActionInputUnion } from '../agent/orchestrator/providers/lib/action-input-contract.mjs';
 import {
   COMPUTER_CORE_ACTION_SCHEMA,
   COMPUTER_DEFAULT_DELIVERY,
@@ -149,7 +150,213 @@ const captureProperties = {
   },
 };
 
-export const COMPUTER_INPUT_SCHEMA = {
+// The strict per-action contract: which `input` each action accepts. The host
+// validates every call against it (validateComputerToolArgs), and the model-facing
+// schema below derives its `input` from it. It is not part of the advertised
+// root: provider tool schemas must be an object root without anyOf/oneOf/allOf.
+export const COMPUTER_ACTION_CONTRACTS = [
+  branch(
+    'wait_for_user',
+    input({
+      timeout_ms: {
+        type: 'integer',
+        minimum: 0,
+        maximum: 120000,
+        description: 'Wait for manual or host-configured idle resume; default 60000.',
+      },
+    }),
+    false
+  ),
+  branch(
+    'list',
+    input(
+      {
+        kind: {
+          type: 'string',
+          enum: ['windows', 'apps', 'history'],
+          description:
+            "history returns this session's own executed commands with their verdicts, for reviewing what a run already did.",
+        },
+        query: {
+          type: 'string',
+          minLength: 1,
+          maxLength: MAX_TARGET_TOKEN_LENGTH,
+          description:
+            'With kind="apps", also lists installed apps whose name or id matches, including apps that are not running.',
+        },
+        limit: {
+          type: 'integer',
+          minimum: 1,
+          maximum: 60,
+          description: 'kind="history" only: how many of the most recent records to return; default 60.',
+        },
+      },
+      ['kind']
+    )
+  ),
+  branch(
+    'diagnose',
+    input({
+      ...windowTarget,
+      ocr_language: {
+        ...ocrLanguage,
+        description: 'Optional OS OCR language tag to verify, e.g. ko or en-US.',
+      },
+    }),
+    false
+  ),
+  branch('capture', input(captureProperties), false),
+  branch(
+    'act',
+    input(
+      {
+        ...windowTarget,
+        ...appTarget,
+        frame_id: {
+          type: 'string',
+          minLength: 1,
+          maxLength: MAX_TARGET_TOKEN_LENGTH,
+          description: 'Latest unexpired frame id shared by coordinate actions in this act call.',
+        },
+        actions: {
+          type: 'array',
+          items: COMPUTER_CORE_ACTION_SCHEMA,
+          minItems: 1,
+          maxItems: 6,
+          description:
+            'First: an input action. Then type/key/wait reusing focus, or click/double_click/triple_click/scroll/set_value/type/key on a ref from the same observation (no marks or coordinates). Waits total ≤10s; transition/failure or a changed, disabled, or off-screen ref stops the rest.',
+        },
+        observe: {
+          type: 'string',
+          enum: ['state', 'ax'],
+          description:
+            'Returned observation. Default: ax when the first action targets a ref (full state if the tree is unusable), otherwise state. state includes the frame for coordinates or visual checks; ax skips the screenshot.',
+        },
+        ...delivery,
+      },
+      ['actions']
+    )
+  ),
+  branch(
+    'window',
+    input(
+      {
+        ...windowTarget,
+        ...appTarget,
+        operation: {
+          type: 'string',
+          enum: ['focus', 'move', 'minimize', 'maximize', 'restore', 'close', 'terminate'],
+        },
+        confirm: {
+          type: 'string',
+          enum: ['terminate'],
+          description:
+            'terminate only, and required for it: kills the process behind the window, losing unsaved work. Ask the user first.',
+        },
+        x: {
+          type: 'integer',
+          description: 'move only: new left edge; y the top; width/height an optional new size.',
+        },
+        y: { type: 'integer' },
+        width: { type: 'integer', minimum: 1 },
+        height: { type: 'integer', minimum: 1 },
+      },
+      ['operation']
+    )
+  ),
+  branch(
+    'menu',
+    input(
+      {
+        ...windowTarget,
+        ...appTarget,
+        path: {
+          type: 'array',
+          items: { type: 'string', minLength: 1, maxLength: 512 },
+          minItems: 1,
+          maxItems: 8,
+          description:
+            'Exact labels from the bar down, e.g. ["File","Save As"]. Missing, ambiguous, or disabled entries fail closed.',
+        },
+      },
+      ['path']
+    )
+  ),
+  branch(
+    'verify',
+    input(
+      {
+        ...windowTarget,
+        ...appTarget,
+        expect: {
+          type: 'array',
+          minItems: 1,
+          maxItems: 8,
+          description: 'AND-combined predicates. Reads state only: no pixels, and prior refs stay valid.',
+          items: {
+            type: 'object',
+            properties: {
+              present: {
+                type: 'string',
+                maxLength: MAX_TARGET_TOKEN_LENGTH,
+                description: 'Text an element name or value must contain.',
+              },
+              absent: { type: 'string', maxLength: MAX_TARGET_TOKEN_LENGTH },
+              title_contains: { type: 'string', maxLength: MAX_TARGET_TOKEN_LENGTH },
+              window_exists: { type: 'boolean' },
+            },
+            additionalProperties: false,
+          },
+        },
+        timeout_ms: { type: 'integer', minimum: 0, maximum: 30000 },
+        stable_samples: {
+          type: 'integer',
+          minimum: 1,
+          maximum: 5,
+          description: 'Consecutive satisfied samples required. Default 2.',
+        },
+      },
+      ['expect']
+    )
+  ),
+  branch(
+    'clipboard',
+    input(
+      {
+        operation: { type: 'string', enum: ['read', 'write'] },
+        text: {
+          type: 'string',
+          maxLength: MAX_CLIPBOARD_TEXT_LENGTH,
+          description: 'Required for operation="write".',
+        },
+      },
+      ['operation']
+    )
+  ),
+  branch(
+    'launch',
+    input(
+      {
+        app: {
+          type: 'string',
+          minLength: 1,
+          maxLength: MAX_TARGET_TOKEN_LENGTH,
+          description: 'Executable name, exact path, file, or URL.',
+        },
+      },
+      ['app']
+    )
+  ),
+];
+
+// A JSON Schema 2020-12 object root with no root combinator (Anthropic
+// input_schema rule) whose `input` offers each action's own input as an anyOf
+// alternative titled with that action. The tool advertises its flat projection
+// (flattenActionInputUnion); only provider paths verified to accept the nested
+// alternatives (first-party Anthropic, Claude via Antigravity) send this form
+// (actionInputUnionFor). validateComputerToolArgs enforces the strict
+// per-action contract.
+const COMPUTER_ACTION_INPUT_UNION = {
   type: 'object',
   description:
     'One compact Computer Use operation. Use act.actions to execute 1-6 simple actions and receive one fresh observation.',
@@ -163,208 +370,24 @@ export const COMPUTER_INPUT_SCHEMA = {
     input: {
       type: 'object',
       description: 'Fields for the selected action.',
+      anyOf: COMPUTER_ACTION_CONTRACTS.map(({ properties }) => {
+        const [action] = properties.action.enum;
+        return {
+          title: action,
+          description: `Input when action="${action}".`,
+          ...structuredClone(properties.input),
+        };
+      }),
     },
   },
   required: ['action'],
   additionalProperties: false,
-  oneOf: [
-    branch(
-      'wait_for_user',
-      input({
-        timeout_ms: {
-          type: 'integer',
-          minimum: 0,
-          maximum: 120000,
-          description: 'Wait for manual or host-configured idle resume; default 60000.',
-        },
-      }),
-      false
-    ),
-    branch(
-      'list',
-      input(
-        {
-          kind: {
-            type: 'string',
-            enum: ['windows', 'apps', 'history'],
-            description:
-              "history returns this session's own executed commands with their verdicts, for reviewing what a run already did.",
-          },
-          query: {
-            type: 'string',
-            minLength: 1,
-            maxLength: MAX_TARGET_TOKEN_LENGTH,
-            description:
-              'With kind="apps", also lists installed apps whose name or id matches, including apps that are not running.',
-          },
-          limit: {
-            type: 'integer',
-            minimum: 1,
-            maximum: 60,
-            description: 'kind="history" only: how many of the most recent records to return; default 60.',
-          },
-        },
-        ['kind']
-      )
-    ),
-    branch(
-      'diagnose',
-      input({
-        ...windowTarget,
-        ocr_language: {
-          ...ocrLanguage,
-          description: 'Optional OS OCR language tag to verify, e.g. ko or en-US.',
-        },
-      }),
-      false
-    ),
-    branch('capture', input(captureProperties), false),
-    branch(
-      'act',
-      input(
-        {
-          ...windowTarget,
-          ...appTarget,
-          frame_id: {
-            type: 'string',
-            minLength: 1,
-            maxLength: MAX_TARGET_TOKEN_LENGTH,
-            description: 'Latest unexpired frame id shared by coordinate actions in this act call.',
-          },
-          actions: {
-            type: 'array',
-            items: COMPUTER_CORE_ACTION_SCHEMA,
-            minItems: 1,
-            maxItems: 6,
-            description:
-              'First: an input action. Then type/key/wait reusing focus, or click/double_click/triple_click/scroll/set_value/type/key on a ref from the same observation (no marks or coordinates). Waits total ≤10s; transition/failure or a changed, disabled, or off-screen ref stops the rest.',
-          },
-          observe: {
-            type: 'string',
-            enum: ['state', 'ax'],
-            description:
-              'Returned observation. Default: ax when the first action targets a ref (full state if the tree is unusable), otherwise state. state includes the frame for coordinates or visual checks; ax skips the screenshot.',
-          },
-          ...delivery,
-        },
-        ['actions']
-      )
-    ),
-    branch(
-      'window',
-      input(
-        {
-          ...windowTarget,
-          ...appTarget,
-          operation: {
-            type: 'string',
-            enum: ['focus', 'move', 'minimize', 'maximize', 'restore', 'close', 'terminate'],
-          },
-          confirm: {
-            type: 'string',
-            enum: ['terminate'],
-            description:
-              'terminate only, and required for it: kills the process behind the window, losing unsaved work. Ask the user first.',
-          },
-          x: {
-            type: 'integer',
-            description: 'move only: new left edge; y the top; width/height an optional new size.',
-          },
-          y: { type: 'integer' },
-          width: { type: 'integer', minimum: 1 },
-          height: { type: 'integer', minimum: 1 },
-        },
-        ['operation']
-      )
-    ),
-    branch(
-      'menu',
-      input(
-        {
-          ...windowTarget,
-          ...appTarget,
-          path: {
-            type: 'array',
-            items: { type: 'string', minLength: 1, maxLength: 512 },
-            minItems: 1,
-            maxItems: 8,
-            description:
-              'Exact labels from the bar down, e.g. ["File","Save As"]. Missing, ambiguous, or disabled entries fail closed.',
-          },
-        },
-        ['path']
-      )
-    ),
-    branch(
-      'verify',
-      input(
-        {
-          ...windowTarget,
-          ...appTarget,
-          expect: {
-            type: 'array',
-            minItems: 1,
-            maxItems: 8,
-            description: 'AND-combined predicates. Reads state only: no pixels, and prior refs stay valid.',
-            items: {
-              type: 'object',
-              properties: {
-                present: {
-                  type: 'string',
-                  maxLength: MAX_TARGET_TOKEN_LENGTH,
-                  description: 'Text an element name or value must contain.',
-                },
-                absent: { type: 'string', maxLength: MAX_TARGET_TOKEN_LENGTH },
-                title_contains: { type: 'string', maxLength: MAX_TARGET_TOKEN_LENGTH },
-                window_exists: { type: 'boolean' },
-              },
-              additionalProperties: false,
-            },
-          },
-          timeout_ms: { type: 'integer', minimum: 0, maximum: 30000 },
-          stable_samples: {
-            type: 'integer',
-            minimum: 1,
-            maximum: 5,
-            description: 'Consecutive satisfied samples required. Default 2.',
-          },
-        },
-        ['expect']
-      )
-    ),
-    branch(
-      'clipboard',
-      input(
-        {
-          operation: { type: 'string', enum: ['read', 'write'] },
-          text: {
-            type: 'string',
-            maxLength: MAX_CLIPBOARD_TEXT_LENGTH,
-            description: 'Required for operation="write".',
-          },
-        },
-        ['operation']
-      )
-    ),
-    branch(
-      'launch',
-      input(
-        {
-          app: {
-            type: 'string',
-            minLength: 1,
-            maxLength: MAX_TARGET_TOKEN_LENGTH,
-            description: 'Executable name, exact path, file, or URL.',
-          },
-        },
-        ['app']
-      )
-    ),
-  ],
 };
 
+export const COMPUTER_INPUT_SCHEMA = advertiseActionInputUnion(COMPUTER_ACTION_INPUT_UNION);
+
 const COMPUTER_ACTION_BRANCHES = new Map();
-for (const actionBranch of COMPUTER_INPUT_SCHEMA.oneOf) {
+for (const actionBranch of COMPUTER_ACTION_CONTRACTS) {
   for (const action of actionBranch.properties?.action?.enum || []) {
     COMPUTER_ACTION_BRANCHES.set(action, actionBranch);
   }

package/src/runtime/computer-bridge/linux-readiness.d.mts

@@ -46,7 +46,5 @@ export function linuxComputerPreflight(options?: Record<string, unknown>): Promi
 export function resetLinuxComputerPreflightCache(): void;
 export const GNOME_EXTENSION_UUID: 'mixdog-windows@mixdog.io';
 export function gnomeExtensionDirs(env?: Record<string, string | undefined>): string[];
-export const FIX_MESSAGES: Readonly<Record<'allow_input' | 'relogin' | 'enable_window_helper' | 'install_package', string>>;
-export const REFUSAL_MESSAGE: string;
 export const CAPTURE_FALLBACK_NOTE: string;
 export function linuxCaptureFallback(options?: Record<string, unknown>): Promise<{ command: Record<string, unknown>; note: string } | null>;

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

@@ -32,22 +32,6 @@ export const CLIPBOARD_HINT =
 export const DISPLAY_HINT =
   'display_unavailable: no graphical session to drive; run inside a desktop session with DISPLAY (X11) or WAYLAND_DISPLAY set';
 
-/**
- * User-facing English phrases, one per fix a capability can ask for. They are
- * the keys of the UI catalogs (apps/desktop/src/renderer/locales), so a UI that
- * renders a capability's `fix` looks the phrase up there; `{{package}}` is the
- * capability's `package`. The tool result text for the model stays English.
- */
-export const FIX_MESSAGES = Object.freeze({
-  allow_input:
-    'Allow Mixdog to send keyboard and mouse input: grant access to /dev/uinput (add your user to the input group), then sign in again.',
-  relogin: 'Sign out and sign in again to finish setting up window control for Mixdog.',
-  enable_window_helper:
-    'Enable the Mixdog Windows extension so Mixdog can list and control windows (gnome-extensions enable mixdog-windows@mixdog.io).',
-  install_package: 'Install {{package}} to enable this Computer Use feature.',
-});
-export const REFUSAL_MESSAGE = 'Computer Use cannot run this action because a required capability is not ready.';
-
 /** Stable code of the whole refusal; the per-capability codes are the native ones. */
 export const CAPABILITY_UNAVAILABLE_CODE = 'computer_capability_unavailable';
 

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

@@ -1,7 +1,8 @@
-// Effort-judge client. The judge loads on the first turn that uses it (a model
-// with Auto effort support) and then stays resident until the feature is
-// turned off or a model update replaces its files, so users who never send
-// such a turn never hold it in memory. A turn waits for a still-loading judge
+// Effort-judge client. The judge loads when a session that uses it (a model
+// with Auto effort support) is created or opened, or on the first judged turn,
+// and then stays resident until the feature is turned off or a model update
+// replaces its files, so users who never open such a session never hold it in
+// memory. A turn waits for a still-loading judge
 // only briefly; when the model is missing, still loading, slow, or failing,
 // `judgeTurn` returns a `skipped` reason and the turn keeps its default
 // effort. Decisions are logged locally (lengths and probabilities only, never
@@ -237,6 +238,22 @@ export function refreshEffortJudge() {
   });
 }
 
+/**
+ * Starts the judge worker ahead of the first judged turn so its cold load
+ * (about 2.3 s) is over by then. Fire-and-forget: it spawns nothing when the
+ * platform is unsupported, the model is missing or being installed, or a
+ * failed load is still inside LOAD_RETRY_MS. Returns whether a worker is
+ * running or loading.
+ */
+export function prewarmEffortJudge() {
+  if (!onnxRuntimeSupported() || installing) return false;
+  const dir = effortJudgeModelDir();
+  if (!effortJudgeAvailable(dir)) return false;
+  if (!worker && lastLoadError && Date.now() - lastLoadErrorAt < LOAD_RETRY_MS) return false;
+  ensureWorker(dir);
+  return true;
+}
+
 export function effortJudgeReady() {
   return ready;
 }

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

@@ -94,7 +94,10 @@ async function load() {
     executionProviders: ['cpu'],
     graphOptimizationLevel: 'all',
     // One judgment runs at a time; 4 threads halve the long-input tail
-    // (p95 ~280 -> ~110 ms measured) for a ~0.1 s burst per turn.
+    // (p95 ~280 -> ~110 ms measured) for a ~0.1 s burst per turn. More threads
+    // did not help where agents share the CPU: with 3-4 agent-like loads on
+    // 20 logical cores, 6 threads timed out 8-16% (3 loads) and 78-87% (4 loads) of judgments against
+    // 0-5% for 4, so the count stays fixed.
     intraOpNumThreads: 4,
   });
   const settings = calibration();