mixdog 0.9.157 → 0.9.158

package/README.md

@@ -45,31 +45,35 @@ workflow setup.
 
 Terminal-Bench 2.1 — same model, same 89 tasks, same official verifier, with
 only the harness changed. Against the native CLI of each model family, Mixdog
-scores higher while spending less to get there.
+delivers the same results at the same speed — on a fraction of the context,
+for far less cost.
 
 ### GPT-5.6 Sol xhigh — Mixdog vs Codex CLI
 
 ![Terminal-Bench 2.1: Mixdog with GPT-5.6 Sol xhigh versus Codex CLI](https://raw.githubusercontent.com/tribgames/mixdog/main/benchmarks/terminal-bench-2.1/tb21-sol-vs-codex.svg)
 
-- **86.5%** (385/445) vs Codex CLI's **84.3%** (75/89)
-- **42%** lower priced cost — $0.641 vs $1.096 per trial
-- **45%** smaller median final context — 18.5k vs 33.5k tokens
-- **1.11×** faster — 339s vs 378s per trial
+- **39%** lower priced cost — $0.476 vs $0.782 per trial
+- **46%** smaller median final context — 18.5k vs 34.3k tokens
+- **86.5%** (385/445) vs Codex CLI's **86.1%** (383/445) — full `k=5` on both
+  sides, pass@5 **96.6%** vs 95.5%
+- Matched speed — 415s vs 437s wall time per trial
 
 ### Claude Opus 5 — Mixdog vs Claude Code
 
 ![Terminal-Bench 2.1: Mixdog with Claude Opus 5 versus Claude Code](https://raw.githubusercontent.com/tribgames/mixdog/main/benchmarks/terminal-bench-2.1/tb21-opus-vs-claude-code.svg)
 
-- **79/89** vs Claude Code's **77/89**
 - **19%** lower priced cost — $104.29 vs $129.21 per run
 - **28%** smaller median final context — 27.6k vs 38.2k tokens
-- **1.15×** faster
+- **79/89** vs Claude Code's **77/89**
+- **1.16×** faster — 610s vs 708s wall time per trial
 
-Every run uses the official Harbor verifier, fast mode off, a 272k context
-window, and zero retries. The Mixdog Sol run follows the protocol the official
-Terminal-Bench leaderboard requires — all 89 tasks repeated five times (`k=5`,
-445 trials); the Codex CLI baseline and both Opus-side runs are single passes
-(`k=1`, 89 trials each).
+Every run uses the official Harbor verifier, fast mode off, and a 272k context
+window; task failures and agent timeouts are never retried. The Sol comparison
+follows the protocol the official Terminal-Bench leaderboard requires on both
+sides — all 89 tasks repeated five times (`k=5`, 445 trials each); the
+Opus-side runs are single passes (`k=1`, 89 trials each). Speed is the full
+trial wall clock, and cost values both sides at the same current API list
+rates.
 
 The leaderboard is not accepting community submissions, so every run here ships
 its raw artifacts instead — Harbor verdicts, official verifier output, pinned
@@ -88,6 +92,13 @@ the harness, presets, and metric scripts that recompute each number above:
   MCP, skills, hooks, and plugins.
 - **Local memory** — semantic and lexical recall with project-scoped context
   and multilingual retrieval.
+- **Browser Use** — a logged-in Chromium pane the agent can drive: tabs,
+  forms, downloads, and snapshots, with one-time Chrome profile import
+  including cookies and passwords.
+- **Computer Use** — agent control of the Windows desktop through screen
+  capture, accessibility, OCR, and a strict guarded input contract.
+- **Office documents** — author and edit Word, Excel, and PowerPoint files
+  with model-authored design plans, charts, and assurance-checked output.
 - **Encrypted remote access** — pair the installable web app with Desktop and
   use Mixdog from a browser or phone over authenticated E2EE.
 - **Desktop coding app** — agent panes, Monaco editor, Git, terminals, file
@@ -202,14 +213,20 @@ Mixdog Desktop runs the same agent runtime as the CLI:
 - Git staging, commits, branches, and generated commit messages
 - File explorer with previews, thumbnails, search, and drag-and-drop
 - Integrated terminal tabs using the local system shell
+- Browser Use pane with agent control and Chromium profile import
+- Computer Use on Windows with guarded native input
+- Office document authoring with rendered previews
 - Image and video generation Studio with a persistent local gallery
 - Visual workflow, agent, schedule, and webhook editors
 - Voice dictation with an optional local transcription runtime
+- Extensions hub with guided setup for Git, Memory, Browser Use, Computer
+  Use, Office, and voice
 - Provider setup, usage, git identity, and remote pairing settings
 
 The paired remote web app is installable on desktop and mobile browsers. It
 uses an authenticated end-to-end encrypted connection before session state,
-terminal data, files, or operation requests cross the relay.
+terminal data, files, or operation requests cross the relay, and adds mobile
+share-target intake, push notifications, and remote Browser Use.
 
 For desktop development:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.157",
+  "version": "0.9.158",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -72,7 +72,7 @@
     "test:session-transport": "node --test scripts/session-transport-test.mjs scripts/daemon-bootstrap-test.mjs src/runtime/shared/child-spawn-remote.test.mjs src/standalone/session-runtime-agent-control-client.test.mjs src/standalone/session-runtime-dispatch-cancel.test.mjs src/standalone/session-runtime-host-factory.test.mjs src/standalone/session-runtime-inline-host.test.mjs src/standalone/session-runtime-provider-cooldown.test.mjs src/standalone/session-runtime-shard-host.test.mjs src/standalone/session-runtime-shard-router.test.mjs",
     "test:session": "node --test scripts/runtime-turn-contract-test.mjs scripts/session-save-fault-store-test.mjs scripts/turn-review-revert-test.mjs src/runtime/shared/tool-surface.test.mjs src/runtime/bridge-clients.test.mjs",
     "test:quick": "npm run test:session && npm run test:session-transport && npm run test:desktop-main --prefix apps/desktop",
-    "test:office": "node --test scripts/run-office-live-tests.test.mjs src/runtime/office/office-runtime.test.mjs src/runtime/office/office-assurance.test.mjs src/runtime/office/portable-authoring.test.mjs && npm run test:office-approval --prefix apps/desktop",
+    "test:office": "node --test scripts/run-office-live-tests.test.mjs src/runtime/office/office-runtime.test.mjs src/runtime/office/office-assurance.test.mjs src/runtime/office/portable-authoring.test.mjs src/runtime/office/slide-quality.test.mjs && npm run test:office-approval --prefix apps/desktop",
     "test:office:live": "node scripts/run-office-live-tests.mjs",
     "test:media": "node --test src/runtime/media/store.test.mjs src/runtime/media/renditions.test.mjs src/runtime/media/adapters/codex-image.test.mjs",
     "failures": "node scripts/tool-failures.mjs",

package/scripts/build-runtime-linux.sh

@@ -78,6 +78,7 @@ else
   make -j"$(nproc)"
   make install
   make -C contrib/pgcrypto install
+  make -C contrib/pg_trgm install
 fi
 
 PG_CONFIG="$STAGE_DIR/bin/pg_config"
@@ -255,6 +256,10 @@ for attempt in 1 2 3; do
     echo "  vector extension version: $EXTV"
     echo "  distance query result:    $DIST"
     [[ "$EXTV" == "$PGVECTOR_VERSION" ]] || { echo "FAIL: extversion=$EXTV expected=$PGVECTOR_VERSION"; exit 1; }
+    "${RUN_AS[@]}" "$RUNTIME_DIR/bin/psql" -h 127.0.0.1 -p "$SMOKE_PORT" -U postgres -d postgres -c "CREATE EXTENSION pg_trgm;" > /dev/null
+    SIM="$("${RUN_AS[@]}" "$RUNTIME_DIR/bin/psql" -h 127.0.0.1 -p "$SMOKE_PORT" -U postgres -d postgres -tAc "SELECT similarity('mixdog','mixdig') > 0;")"
+    echo "  pg_trgm similarity probe: $SIM"
+    [[ "$SIM" == "t" ]] || { echo "FAIL: pg_trgm similarity=$SIM"; exit 1; }
     "${RUN_AS[@]}" "$RUNTIME_DIR/bin/pg_ctl" -D "$SMOKE_DATA" -m fast stop > /dev/null
   )
   attempt_rc=$?
@@ -323,6 +328,8 @@ for attempt in 1 2 3; do
       "$EXTRACT_DIR/bin/psql" -h 127.0.0.1 -p "$EXTRACT_PORT" -U postgres -d postgres -tAc \
       "SELECT extversion FROM pg_extension WHERE extname='vector';")"
     [[ "$EXTV2" == "$PGVECTOR_VERSION" ]] || { echo "FAIL: extracted-smoke extversion=$EXTV2"; exit 1; }
+    "${RUN_AS[@]}" env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
+      "$EXTRACT_DIR/bin/psql" -h 127.0.0.1 -p "$EXTRACT_PORT" -U postgres -d postgres -c "CREATE EXTENSION pg_trgm;" > /dev/null
     "${RUN_AS[@]}" env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
       "$EXTRACT_DIR/bin/pg_ctl" -D "$EXTRACT_DATA" -m fast stop > /dev/null
   )

package/scripts/build-runtime-macos.sh

@@ -73,6 +73,7 @@ else
   make -j"$(sysctl -n hw.logicalcpu)"
   make install
   make -C contrib/pgcrypto install
+  make -C contrib/pg_trgm install
 fi
 
 PG_CONFIG="$STAGE_DIR/bin/pg_config"
@@ -165,6 +166,10 @@ DIST="$("$RUNTIME_DIR/bin/psql" -h 127.0.0.1 -p "$SMOKE_PORT" -U postgres -d pos
 echo "  vector extension version: $EXTV"
 echo "  distance query result:    $DIST"
 [[ "$EXTV" == "$PGVECTOR_VERSION" ]] || { echo "FAIL: extversion=$EXTV expected=$PGVECTOR_VERSION"; exit 1; }
+"$RUNTIME_DIR/bin/psql" -h 127.0.0.1 -p "$SMOKE_PORT" -U postgres -d postgres -c "CREATE EXTENSION pg_trgm;" > /dev/null
+SIM="$("$RUNTIME_DIR/bin/psql" -h 127.0.0.1 -p "$SMOKE_PORT" -U postgres -d postgres -tAc "SELECT similarity('mixdog','mixdig') > 0;")"
+echo "  pg_trgm similarity probe: $SIM"
+[[ "$SIM" == "t" ]] || { echo "FAIL: pg_trgm similarity=$SIM"; exit 1; }
 "$RUNTIME_DIR/bin/pg_ctl" -D "$SMOKE_DATA" -m fast stop > /dev/null
 trap - EXIT
 rm -rf "$SMOKE_DATA"
@@ -207,6 +212,8 @@ env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
   "$EXTRACT_DIR/bin/psql" -h 127.0.0.1 -p "$EXTRACT_PORT" -U postgres -d postgres -c "CREATE EXTENSION vector;" > /dev/null
 EXTV2="$(env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" "$EXTRACT_DIR/bin/psql" -h 127.0.0.1 -p "$EXTRACT_PORT" -U postgres -d postgres -tAc "SELECT extversion FROM pg_extension WHERE extname='vector';")"
 [[ "$EXTV2" == "$PGVECTOR_VERSION" ]] || { echo "FAIL: extracted-smoke extversion=$EXTV2"; exit 1; }
+env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
+  "$EXTRACT_DIR/bin/psql" -h 127.0.0.1 -p "$EXTRACT_PORT" -U postgres -d postgres -c "CREATE EXTENSION pg_trgm;" > /dev/null
 env -i HOME="$EXTRACT_DIR" PATH="/usr/bin:/bin" \
   "$EXTRACT_DIR/bin/pg_ctl" -D "$EXTRACT_DATA" -m fast stop > /dev/null
 trap - EXIT

package/scripts/lib/stage-postgres-runtime-windows.ps1

@@ -64,6 +64,7 @@ function Stage-MixdogWindowsPgRuntime {
     )
     $ModuleSources = [ordered]@{
         'dict_snowball.dll' = Join-Path $PgRoot 'lib\dict_snowball.dll'
+        'pg_trgm.dll'       = Join-Path $PgRoot 'lib\pg_trgm.dll'
         'plpgsql.dll'       = Join-Path $PgRoot 'lib\plpgsql.dll'
         'vector.dll'        = $VectorDll
     }
@@ -137,6 +138,15 @@ function Stage-MixdogWindowsPgRuntime {
     }
     $PlpgsqlAssets | Copy-Item -Destination $RuntimeExtensionDir -Force
 
+    # pg_trgm ships with the runtime: memory recall's hybrid trigram CTEs and
+    # transcript inserts depend on it (runtime-v0.4.0 omitted it and every
+    # memory write/recall failed with 'could not access file "$libdir/pg_trgm"').
+    $PgTrgmAssets = @(Get-ChildItem -Path "$SourceShare\extension\pg_trgm*" -File)
+    if ($PgTrgmAssets.Count -eq 0) {
+        throw "Required pg_trgm extension assets not found under $SourceShare\extension"
+    }
+    $PgTrgmAssets | Copy-Item -Destination $RuntimeExtensionDir -Force
+
     $RuntimeBytes = (
         Get-ChildItem -LiteralPath $RuntimeDir -File -Recurse |
             Measure-Object -Property Length -Sum
@@ -174,7 +184,7 @@ function Assert-MixdogWindowsPgRuntime {
         throw "Unexpected PostgreSQL executable set: $($ActualExecutables -join ', ')"
     }
 
-    $ExpectedModules = @('dict_snowball.dll', 'plpgsql.dll', 'vector.dll')
+    $ExpectedModules = @('dict_snowball.dll', 'pg_trgm.dll', 'plpgsql.dll', 'vector.dll')
     $ActualModules = @(
         Get-ChildItem -LiteralPath "$RuntimeDir\lib" -File -Filter '*.dll' |
             ForEach-Object Name |
@@ -195,7 +205,7 @@ function Assert-MixdogWindowsPgRuntime {
 
     $UnexpectedExtensionAssets = @(
         Get-ChildItem -LiteralPath "$RuntimeDir\share\extension" -Force |
-            Where-Object { $_.Name -notlike 'plpgsql*' -and $_.Name -notlike 'vector*' }
+            Where-Object { $_.Name -notlike 'pg_trgm*' -and $_.Name -notlike 'plpgsql*' -and $_.Name -notlike 'vector*' }
     )
     if ($UnexpectedExtensionAssets.Count -gt 0) {
         throw "Unexpected extension assets leaked into runtime: $($UnexpectedExtensionAssets.Count)"
@@ -205,6 +215,7 @@ function Assert-MixdogWindowsPgRuntime {
         "$RuntimeDir\share\extension\vector.control",
         "$RuntimeDir\share\extension\vector--$PgVectorVersion.sql",
         "$RuntimeDir\share\extension\plpgsql.control",
+        "$RuntimeDir\share\extension\pg_trgm.control",
         "$RuntimeDir\share\postgres.bki"
     )
     foreach ($Path in $RequiredPaths) {

package/scripts/smoke-runtime-negative.sh

@@ -9,7 +9,7 @@
 
 set -euo pipefail
 
-TAG="${TAG:-runtime-v0.4.0}"
+TAG="${TAG:-runtime-v0.4.1}"
 OS="${OS:-$(uname -s | tr '[:upper:]' '[:lower:]')}"
 ARCH="${ARCH:-$(uname -m | sed 's/x86_64/x64/')}"
 PG_VER="16.4"
@@ -76,7 +76,8 @@ echo "==> ldd vector.so (under env -i):"
 "${RUN_AS[@]}" env -i HOME="$WORK/fresh" PATH=/usr/bin:/bin "$PG_BIN/psql" -h 127.0.0.1 -p "$PORT" -U postgres -d postgres -c "CREATE EXTENSION vector;" > /dev/null
 EXTV="$("${RUN_AS[@]}" env -i HOME="$WORK/fresh" PATH=/usr/bin:/bin "$PG_BIN/psql" -h 127.0.0.1 -p "$PORT" -U postgres -d postgres -tAc "SELECT extversion FROM pg_extension WHERE extname='vector';")"
 [[ "$EXTV" == "$PGVECTOR_VER" ]] || { echo "FAIL: extversion=$EXTV"; exit 1; }
-echo "  PASS: fresh-extract boot + vector extension"
+"${RUN_AS[@]}" env -i HOME="$WORK/fresh" PATH=/usr/bin:/bin "$PG_BIN/psql" -h 127.0.0.1 -p "$PORT" -U postgres -d postgres -c "CREATE EXTENSION pg_trgm;" > /dev/null
+echo "  PASS: fresh-extract boot + vector + pg_trgm extensions"
 
 echo "==> Test 5: same tarball extracted twice → second initdb refuses (data-dir already initialized)"
 mkdir -p "$WORK/twice"

package/src/runtime/agent/orchestrator/providers/cursor-wire-guards.mjs

@@ -0,0 +1,234 @@
+const SCHEMA_ANNOTATIONS = new Set([
+    '$comment',
+    '$id',
+    '$schema',
+    'default',
+    'deprecated',
+    'description',
+    'examples',
+    'readOnly',
+    'title',
+    'writeOnly',
+]);
+
+export const MAX_CONNECT_FRAME_BYTES = 64 * 1024 * 1024;
+export const MAX_CHECKPOINT_BYTES = 48 * 1024 * 1024;
+export const MAX_TOOL_TEXT_BYTES = 512 * 1024;
+export const MAX_TOOL_MEDIA_BYTES = 16 * 1024 * 1024;
+export const MAX_USER_IMAGE_BYTES = 5 * 1024 * 1024;
+export const MAX_CONVERSATION_BLOB_BYTES = 128 * 1024 * 1024;
+export const MAX_CONVERSATION_BLOB_ENTRIES = 512;
+export const MAX_INDIVIDUAL_BLOB_BYTES = 32 * 1024 * 1024;
+
+function boundedInteger(value, fallback, { min = 0, max = Number.MAX_SAFE_INTEGER } = {}) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < min) return fallback;
+    return Math.min(max, Math.floor(parsed));
+}
+
+export function resolveCursorStreamTuning(env = process.env) {
+    return {
+        idleTimeoutMs: boundedInteger(env.MIXDOG_CURSOR_STREAM_IDLE_TIMEOUT_MS, 180_000),
+        parkTimeoutMs: boundedInteger(env.MIXDOG_CURSOR_STREAM_PARK_TIMEOUT_MS, 45_000, { min: 1_000 }),
+        maxRetries: boundedInteger(env.MIXDOG_CURSOR_STREAM_IDLE_MAX_RETRIES, 5, { max: 10 }),
+    };
+}
+
+function slimSchema(value, depth = 0) {
+    if (value == null || depth > 12) return value;
+    if (Array.isArray(value)) return value.map((entry) => slimSchema(entry, depth + 1));
+    if (typeof value !== 'object') return value;
+    const output = {};
+    for (const [key, child] of Object.entries(value)) {
+        if (SCHEMA_ANNOTATIONS.has(key) || child === undefined) continue;
+        if (key === 'additionalProperties' && child === true) continue;
+        if (key === 'required' && Array.isArray(child) && child.length === 0) continue;
+        output[key] = slimSchema(child, depth + 1);
+    }
+    return output;
+}
+
+function conciseDescription(value) {
+    const normalized = String(value || '').replace(/\s+/g, ' ').trim();
+    if (normalized.length <= 120) return normalized;
+    const sentence = normalized.match(/^.{24,117}?[.!?](?:\s|$)/)?.[0]?.trim();
+    return sentence || `${normalized.slice(0, 117)}...`;
+}
+
+export function prepareCursorToolDefinition(tool) {
+    const fn = tool?.function || tool || {};
+    const inputSchema = fn.parameters && typeof fn.parameters === 'object'
+        ? slimSchema(fn.parameters)
+        : { type: 'object', properties: {} };
+    return {
+        name: fn.name,
+        description: conciseDescription(fn.description),
+        inputSchema,
+    };
+}
+
+function truncateUtf8(value, maxBytes) {
+    const text = String(value ?? '');
+    const encoded = Buffer.from(text, 'utf8');
+    if (encoded.length <= maxBytes) return text;
+    const notice = Buffer.from('\n\n[Mixdog truncated this Cursor tool result to stay within the wire limit.]');
+    const end = Math.max(0, maxBytes - notice.length);
+    const clipped = encoded.subarray(0, end).toString('utf8').replace(/\uFFFD$/u, '');
+    return `${clipped}${notice.toString('utf8')}`;
+}
+
+export function capCursorToolResult(result) {
+    const media = [];
+    let mediaBytes = 0;
+    for (const image of Array.isArray(result?.media) ? result.media : []) {
+        const bytes = image?.data instanceof Uint8Array ? image.data : null;
+        if (!bytes || bytes.byteLength > MAX_TOOL_MEDIA_BYTES) continue;
+        if (mediaBytes + bytes.byteLength > MAX_TOOL_MEDIA_BYTES) break;
+        media.push(image);
+        mediaBytes += bytes.byteLength;
+    }
+    return {
+        ...result,
+        content: truncateUtf8(result?.content, MAX_TOOL_TEXT_BYTES),
+        media,
+    };
+}
+
+export function assertCursorUserImages(images) {
+    for (const image of images || []) {
+        const size = image?.data?.byteLength || 0;
+        if (size > MAX_USER_IMAGE_BYTES) {
+            const error = new Error(`Cursor image exceeds ${MAX_USER_IMAGE_BYTES} bytes`);
+            error.code = 'cursor_payload_too_large';
+            throw error;
+        }
+    }
+}
+
+function blobBytes(blobs) {
+    let total = 0;
+    for (const value of blobs.values()) total += value?.byteLength || 0;
+    return total;
+}
+
+export function storeCursorBlob(blobs, key, value) {
+    const data = value instanceof Uint8Array ? value : new Uint8Array(value);
+    if (data.byteLength > MAX_INDIVIDUAL_BLOB_BYTES) {
+        const error = new Error(`Cursor blob exceeds ${MAX_INDIVIDUAL_BLOB_BYTES} bytes`);
+        error.code = 'cursor_payload_too_large';
+        throw error;
+    }
+    if (blobs.has(key)) blobs.delete(key);
+    blobs.set(key, data);
+    while (
+        blobs.size > MAX_CONVERSATION_BLOB_ENTRIES
+        || blobBytes(blobs) > MAX_CONVERSATION_BLOB_BYTES
+    ) {
+        const oldest = blobs.keys().next().value;
+        if (oldest === undefined || (oldest === key && blobs.size === 1)) break;
+        blobs.delete(oldest);
+    }
+    return data;
+}
+
+export function createCursorByteQueue() {
+    let chunks = [];
+    let chunkIndex = 0;
+    let chunkOffset = 0;
+    let byteLength = 0;
+
+    const compact = () => {
+        if (chunkIndex < 64) return;
+        chunks = chunks.slice(chunkIndex);
+        chunkIndex = 0;
+    };
+    const copy = (count, consume) => {
+        if (count > byteLength) throw new Error('Cursor byte queue underflow');
+        const output = Buffer.allocUnsafe(count);
+        let written = 0;
+        let index = chunkIndex;
+        let offset = chunkOffset;
+        while (written < count) {
+            const chunk = chunks[index];
+            const take = Math.min(count - written, chunk.length - offset);
+            chunk.copy(output, written, offset, offset + take);
+            written += take;
+            offset += take;
+            if (offset === chunk.length) {
+                index += 1;
+                offset = 0;
+            }
+        }
+        if (consume) {
+            chunkIndex = index;
+            chunkOffset = offset;
+            byteLength -= count;
+            compact();
+        }
+        return output;
+    };
+
+    return {
+        get byteLength() { return byteLength; },
+        append(value) {
+            const chunk = Buffer.from(value);
+            if (!chunk.length) return;
+            chunks.push(chunk);
+            byteLength += chunk.length;
+        },
+        peek(count) { return copy(count, false); },
+        read(count) { return copy(count, true); },
+    };
+}
+
+export function createCursorStreamWatchdog({ idleTimeoutMs, parkTimeoutMs, onTimeout }) {
+    let timer = null;
+    let stopped = false;
+    const arm = (timeoutMs, kind) => {
+        if (timer) clearTimeout(timer);
+        timer = null;
+        if (stopped || timeoutMs <= 0) return;
+        timer = setTimeout(() => onTimeout(kind), timeoutMs);
+        timer.unref?.();
+    };
+    return {
+        start() { arm(idleTimeoutMs, 'idle'); },
+        progress(kind) {
+            if (kind === 'work') arm(idleTimeoutMs, 'idle');
+            else if (kind === 'park') arm(parkTimeoutMs, 'park');
+        },
+        stop() {
+            stopped = true;
+            if (timer) clearTimeout(timer);
+            timer = null;
+        },
+    };
+}
+
+export function cursorInteractionProgress(update) {
+    if (!update) return 'none';
+    if (update.heartbeat) return 'liveness';
+    if (update.textDelta?.text || update.thinkingDelta?.text) return 'work';
+    if (
+        update.tokenDelta
+        || update.toolCallStarted
+        || update.toolCallCompleted
+        || update.partialToolCall
+        || update.toolCallDelta
+        || update.thinkingCompleted
+        || update.summary
+        || update.summaryStarted
+        || update.summaryCompleted
+        || update.stepStarted
+        || update.stepCompleted
+        || update.turnEnded
+    ) return 'work';
+    return 'none';
+}
+
+export function isRetryableCursorStreamError(error) {
+    const status = Number(error?.httpStatus || error?.status || 0);
+    if ([400, 401, 403, 404, 429].includes(status)) return false;
+    if (error?.name === 'AbortError') return false;
+    return status === 0 || status >= 500;
+}

package/src/runtime/agent/orchestrator/providers/cursor-wire-interactions.mjs

@@ -0,0 +1,80 @@
+const REJECT_REASON = 'This Cursor-side interaction is unavailable. Use the Mixdog tools instead.';
+
+function response(name, value) {
+    return {
+        handled: true,
+        action: `${name}_rejected`,
+        message: { interactionResponse: value },
+    };
+}
+
+export function buildCursorInteractionResponse(query = {}) {
+    const id = Number(query.id) || 0;
+    if (query.webSearchRequestQuery) {
+        return response('web_search', {
+            id,
+            webSearchRequestResponse: { rejected: { reason: REJECT_REASON } },
+        });
+    }
+    if (query.exaSearchRequestQuery) {
+        return response('exa_search', {
+            id,
+            exaSearchRequestResponse: { rejected: { reason: REJECT_REASON } },
+        });
+    }
+    if (query.exaFetchRequestQuery) {
+        return response('exa_fetch', {
+            id,
+            exaFetchRequestResponse: { rejected: { reason: REJECT_REASON } },
+        });
+    }
+    if (query.switchModeRequestQuery) {
+        return response('switch_mode', {
+            id,
+            switchModeRequestResponse: { rejected: { reason: REJECT_REASON } },
+        });
+    }
+    if (query.askQuestionInteractionQuery) {
+        return response('ask_question', {
+            id,
+            askQuestionInteractionResponse: { result: { rejected: { reason: REJECT_REASON } } },
+        });
+    }
+    if (query.createPlanRequestQuery) {
+        return response('create_plan', {
+            id,
+            createPlanRequestResponse: { result: { error: { error: REJECT_REASON } } },
+        });
+    }
+    if (query.setupVmEnvironmentArgs) {
+        return {
+            handled: true,
+            action: 'setup_vm_acknowledged',
+            message: { interactionResponse: { id, setupVmEnvironmentResult: { success: {} } } },
+        };
+    }
+    if (query.$unknown?.some((field) => field.no === 9)) {
+        return response('web_fetch', {
+            id,
+            webFetchRequestResponse: { rejected: { reason: REJECT_REASON } },
+        });
+    }
+    const field = query.$unknown?.[0]?.no;
+    return {
+        handled: false,
+        action: 'unsupported',
+        queryCase: field ? `field_${field}` : 'unknown',
+        message: null,
+    };
+}
+
+export function buildCursorExecThrow(exec = {}, detail = 'Unsupported Cursor exec') {
+    return {
+        execClientControlMessage: {
+            throw: {
+                id: Number(exec.id) || 0,
+                error: `${detail}. Use a Mixdog tool instead.`,
+            },
+        },
+    };
+}