mixdog 0.9.85 → 0.9.87

package/src/runtime/agent/orchestrator/session/manager.mjs

@@ -123,5 +123,8 @@ export {
     flushSessionMetrics,
 } from './manager/session-crud.mjs';
 export { deleteSession } from './store.mjs';
+// Read-only parsed-session access (desktop pane peek): no resume, no
+// ownership, no liveness side effects.
+export { loadSession } from './store.mjs';
 export { closeSession, abortSessionTurn } from './manager/session-close.mjs';
 export { sweepTombstones, startIdleCleanup, stopIdleCleanup } from './manager/idle-cleanup.mjs';

package/src/runtime/agent/orchestrator/session/store-summary-reader.mjs

@@ -173,6 +173,25 @@ function scanSessionFiles(heartbeatMtimes = sessionHeartbeatMtimes()) {
         (right.lastUsedAt || right.updatedAt || 0) - (left.lastUsedAt || left.updatedAt || 0));
 }
 
+function sessionFilesAreNewerThan(indexPath) {
+    const directory = join(dataDir(), 'sessions');
+    if (!existsSync(directory)) return false;
+    let indexMtime = 0;
+    try { indexMtime = statSync(indexPath).mtimeMs || 0; }
+    catch { return true; }
+    try {
+        for (const filename of readdirSync(directory)) {
+            if (!filename.endsWith('.json')) continue;
+            try {
+                if ((statSync(join(directory, filename)).mtimeMs || 0) > indexMtime) return true;
+            } catch { /* session disappeared after readdir */ }
+        }
+    } catch {
+        return true;
+    }
+    return false;
+}
+
 export function listStoredSessionSummaries(options = {}) {
     const heartbeatMtimes = sessionHeartbeatMtimes();
     if (options.refreshFromStorage === true) return scanSessionFiles(heartbeatMtimes);
@@ -185,6 +204,13 @@ export function listStoredSessionSummaries(options = {}) {
                 .filter((row) => row && isLeadVisibleRow(row))
                 .sort((left, right) =>
                     (right.lastUsedAt || right.updatedAt || 0) - (left.lastUsedAt || left.updatedAt || 0));
+            // A crashed/non-blocking sidecar writer can leave a valid but old,
+            // non-empty index indefinitely. Detect only newer session JSONs
+            // (heartbeat churn does not count), then recover read-only from the
+            // authoritative files without trying to rewrite the stuck index.
+            if (options.rebuildIfMissing !== false && sessionFilesAreNewerThan(indexPath)) {
+                return scanSessionFiles(heartbeatMtimes);
+            }
             if (rows.length > 0 || options.rebuildIfMissing === false) return rows;
         }
     } catch {

package/src/runtime/agent/orchestrator/session/token-bpe.mjs

@@ -0,0 +1,42 @@
+// Chunked o200k BPE encode-count, shared by the main thread (context-utils)
+// and the token-count worker. BPE merge cost is quadratic in WORD length, not
+// text length: a degenerate single-word run ('p'.repeat(250k), base64/minified
+// blobs) forms one giant pat_str word and encode() spins for minutes while the
+// event loop is blocked. Encoding fixed-size slices caps the worst-case word at
+// the chunk size, so cost stays linear. Chunk cuts snap back to the nearest
+// whitespace so the next slice starts at a natural ` word` boundary — o200k
+// tokenizes that identically to the unsliced text, keeping estimates EXACT for
+// prose. Only a whitespace-free degenerate run falls back to a hard cut
+// (±1 token per boundary). Hard cuts avoid splitting a surrogate pair so
+// sliced emoji/CJK-ext code points still encode cleanly.
+const BPE_ENCODE_CHUNK_CHARS = 4_096;
+const BPE_CHUNK_BOUNDARY_SCAN = 512;
+
+export function bpeEncodeCount(enc, s) {
+    if (s.length <= BPE_ENCODE_CHUNK_CHARS) return enc.encode(s, undefined, []).length;
+    let total = 0;
+    let i = 0;
+    while (i < s.length) {
+        let end = Math.min(s.length, i + BPE_ENCODE_CHUNK_CHARS);
+        if (end < s.length) {
+            // Prefer cutting BEFORE a whitespace run: the next chunk then
+            // starts with ` word`, which o200k merges exactly as it would
+            // mid-text. Scan a bounded window so degenerate inputs stay O(1).
+            let ws = -1;
+            const scanFloor = Math.max(i + 1, end - BPE_CHUNK_BOUNDARY_SCAN);
+            for (let j = end - 1; j >= scanFloor; j -= 1) {
+                const c = s.charCodeAt(j);
+                if (c === 0x20 || c === 0x0A || c === 0x0D || c === 0x09) { ws = j; break; }
+            }
+            if (ws > i) {
+                end = ws; // next chunk starts at the whitespace
+            } else {
+                const last = s.charCodeAt(end - 1);
+                if (last >= 0xD800 && last <= 0xDBFF) end += 1;
+            }
+        }
+        total += enc.encode(s.slice(i, end), undefined, []).length;
+        i = end;
+    }
+    return total;
+}

package/src/runtime/agent/orchestrator/session/token-native.mjs

@@ -0,0 +1,186 @@
+// Native mixdog-token client: persistent stdio server (transport lifecycle
+// modeled on tools/patch/native-server.mjs) that serves precise o200k BPE
+// counts ~5-12x faster than the in-process tiktoken WASM worker.
+//
+// Wire format: length-prefixed BINARY frames (raw utf8 payload, no JSON
+// escape/parse on either side — that overhead dominated once the encoder
+// went linear-time):
+//   request  : u8 op (1=ping, 2=count) | u32le id | u32le byteLen | payload
+//   response : u8 op                   | u32le id | u64le count
+// A stale JSON-only server never answers a binary ping, so the ready probe
+// times out and this module degrades to the WASM worker path.
+//
+// Strictly a best-effort accelerator behind context-utils' async count path:
+// unavailable binary / dead server / timeout all resolve `null`, and the
+// caller falls back to the JS worker thread. Kill switch:
+// MIXDOG_TOKEN_NATIVE=0 (mode `auto` is the default; MIXDOG_TOKEN_NATIVE_BIN
+// overrides binary resolution).
+import { existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { resolve as pathResolve, dirname as pathDirname, join as pathJoin } from 'node:path';
+import { startChildGuardian } from '../../../shared/child-guardian.mjs';
+import { getPluginData } from '../config.mjs';
+import { ensureTokenBinary, findCachedTokenBinary } from '../tools/token-binary-fetcher.mjs';
+
+const PLUGIN_ROOT = process.env.MIXDOG_ROOT
+    || pathResolve(pathDirname(fileURLToPath(import.meta.url)), '../../../../..');
+const BIN_NAME = process.platform === 'win32' ? 'mixdog-token.exe' : 'mixdog-token';
+const LOCAL_BIN = pathJoin(PLUGIN_ROOT, 'native/mixdog-token/target/release', BIN_NAME);
+const READY_TIMEOUT_MS = 10_000;
+const REQUEST_TIMEOUT_MS = 30_000;
+const OP_PING = 1;
+const OP_COUNT = 2;
+const RESPONSE_FRAME_BYTES = 13;
+const UNKNOWN_OP_SENTINEL = 0xFFFF_FFFF_FFFF_FFFFn;
+const EMPTY_PAYLOAD = Buffer.alloc(0);
+
+function nativeTokenMode() {
+    return String(process.env.MIXDOG_TOKEN_NATIVE || 'auto').toLowerCase();
+}
+
+function nativeTokenModeEnabled() {
+    return !/^(0|false|no|off|js)$/i.test(nativeTokenMode());
+}
+
+let _binPath; // undefined = not resolved, null = none found
+function _resolveBinary() {
+    if (_binPath !== undefined) return _binPath;
+    const candidates = [
+        String(process.env.MIXDOG_TOKEN_NATIVE_BIN || '').trim() || null,
+        LOCAL_BIN,
+    ].filter(Boolean);
+    _binPath = candidates.find((candidate) => {
+        try { return existsSync(candidate); } catch { return false; }
+    }) || null;
+    if (!_binPath) {
+        // Release-supply cache (sha256-verified against the bundled manifest).
+        try { _binPath = findCachedTokenBinary(getPluginData()) || null; } catch { _binPath = null; }
+    }
+    return _binPath;
+}
+
+let _server = null; // { child, pending: Map, seq, ready }  null after hard failure
+let _serverFailed = false;
+
+function _dropServer(error) {
+    const server = _server;
+    _server = null;
+    if (!server) return;
+    const reason = error instanceof Error ? error : new Error(String(error || 'mixdog-token server closed'));
+    for (const [, entry] of server.pending) {
+        clearTimeout(entry.timer);
+        entry.resolve(null);
+        void reason;
+    }
+    server.pending.clear();
+    try { server.child.kill(); } catch { /* already down */ }
+}
+
+function _ensureServer() {
+    if (_server || _serverFailed || !nativeTokenModeEnabled()) return _server;
+    const bin = _resolveBinary();
+    if (!bin) { _serverFailed = true; return null; }
+    let child;
+    try {
+        child = spawn(bin, [], { stdio: ['pipe', 'pipe', 'ignore'], windowsHide: true });
+    } catch {
+        _serverFailed = true;
+        return null;
+    }
+    const server = { child, pending: new Map(), seq: 0, ready: null };
+    let inbox = EMPTY_PAYLOAD;
+    child.stdout.on('data', (chunk) => {
+        inbox = inbox.length ? Buffer.concat([inbox, chunk]) : chunk;
+        while (inbox.length >= RESPONSE_FRAME_BYTES) {
+            const id = inbox.readUInt32LE(1);
+            const count = inbox.readBigUInt64LE(5);
+            inbox = inbox.subarray(RESPONSE_FRAME_BYTES);
+            const entry = server.pending.get(id);
+            if (!entry) continue;
+            server.pending.delete(id);
+            clearTimeout(entry.timer);
+            entry.resolve(count === UNKNOWN_OP_SENTINEL ? null : Number(count));
+        }
+    });
+    child.on('error', () => { _serverFailed = true; _dropServer('spawn error'); });
+    child.on('exit', () => { _dropServer('exited'); });
+    // Best-effort accelerator: never keeps the process alive. Unref the
+    // stdio PIPES too — child.unref() alone leaves the socket handles ref'd,
+    // which kept short-lived hosts (node --test suites) from ever exiting.
+    child.unref();
+    child.stdin?.unref?.();
+    child.stdout?.unref?.();
+    child.stdin?.on?.('error', () => { /* EPIPE on teardown */ });
+    try {
+        startChildGuardian({ childPid: child.pid, label: 'mixdog-token', orphanGraceMs: 8000, forceGraceMs: 3000 });
+    } catch { /* guardian best-effort */ }
+    server.ready = _request(server, OP_PING, null, READY_TIMEOUT_MS).then((count) => count !== null);
+    _server = server;
+    return server;
+}
+
+function _request(server, op, text, timeoutMs = REQUEST_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+        const id = ++server.seq;
+        const timer = setTimeout(() => {
+            server.pending.delete(id);
+            resolve(null);
+        }, timeoutMs);
+        timer.unref?.();
+        server.pending.set(id, { resolve, timer });
+        try {
+            const payload = text ? Buffer.from(text, 'utf8') : EMPTY_PAYLOAD;
+            const header = Buffer.allocUnsafe(9);
+            header[0] = op;
+            header.writeUInt32LE(id >>> 0, 1);
+            header.writeUInt32LE(payload.length >>> 0, 5);
+            const stdin = server.child.stdin;
+            stdin.cork();
+            stdin.write(header);
+            if (payload.length) stdin.write(payload);
+            stdin.uncork();
+        } catch {
+            server.pending.delete(id);
+            clearTimeout(timer);
+            resolve(null);
+        }
+    });
+}
+
+/** True when the native counter can be attempted (mode on + binary present). */
+export function nativeTokenCounterEnabled() {
+    return nativeTokenModeEnabled() && !_serverFailed && Boolean(_resolveBinary());
+}
+
+/** Precise o200k count via the native server; null on any unavailability. */
+export async function countTokensNative(text) {
+    const server = _ensureServer();
+    if (!server) return null;
+    const ready = await server.ready;
+    if (!ready) { _serverFailed = true; _dropServer('ready failed'); return null; }
+    const count = await _request(server, OP_COUNT, String(text ?? ''));
+    return Number.isFinite(count) && count >= 0 ? count : null;
+}
+
+let _fetchAttempted = false;
+
+/** Boot prewarm: spawn the server + build the encoder off the first estimate.
+ *  With no local/env/cached binary, kick ONE background manifest fetch; on
+ *  success the resolution cache resets so the next estimate adopts it. */
+export function prewarmNativeTokenCounter() {
+    const server = _ensureServer();
+    if (!server) {
+        if (!_fetchAttempted && nativeTokenModeEnabled() && !_resolveBinary()) {
+            _fetchAttempted = true;
+            void ensureTokenBinary(getPluginData()).then((path) => {
+                if (!path) return;
+                _binPath = undefined;
+                _serverFailed = false;
+            }).catch(() => { /* soft degrade — WASM worker path remains */ });
+        }
+        return false;
+    }
+    server.ready?.catch?.(() => {});
+    return true;
+}

package/src/runtime/agent/orchestrator/session/tool-batch.mjs

@@ -32,6 +32,7 @@ import { crossTurnSignature, crossTurnDedupStub, isEditProgressTool } from './lo
 import {
     getToolKind,
     isEagerDispatchable,
+    isParallelDispatchable,
     isToolCallDedupEligible,
     parseNativeToolSearchPayload,
 } from './loop/tool-helpers.mjs';
@@ -181,7 +182,11 @@ export async function processToolBatch(ctx) {
             // re-issue it cleanly in a new turn instead of copying back a
             // `[mixdog compacted …]` placeholder. Emits a matching is_error
             // tool_result so the assistant tool_use is not orphaned.
-            if (_orderedMutationFailed && _isOrderedGateSkippable(call.name)) {
+            // Full-parallel caveat: a call that ALREADY started (pending eager
+            // promise) cannot be "skipped" — its side effects are running, so
+            // its real result must be consumed below. The gate only skips
+            // calls that have not started (apply_patch never starts eagerly).
+            if (_orderedMutationFailed && _isOrderedGateSkippable(call.name) && !pending.has(call.id)) {
                 if (call?.id) restoreToolCallBodyForId(assistantTurnMsg, calls, call.id);
                 pushToolResultMessage({
                     role: 'tool',
@@ -252,13 +257,18 @@ export async function processToolBatch(ctx) {
                     _executeOk = true;
                 } else {
                 // Fallback for providers that don't stream tool calls early:
-                // execute a contiguous read-only run in parallel, but never
-                // cross a write/bash/MCP boundary that may change state.
-                if (isEagerDispatchable(call.name, tools)) {
+                // start the whole remaining batch in parallel (full-parallel
+                // policy; only apply_patch stays in this serial body).
+                if (isParallelDispatchable(call.name)) {
                     startEagerRun(calls, callIndex, _duplicateCallIds);
                 }
                 let eager = pending.get(call.id);
-                if (eager !== undefined && eager.mutationEpoch < epoch.mutation) {
+                // Post-mutation invalidation applies ONLY to read-only results:
+                // a read that raced an apply_patch re-executes for fresh
+                // content. Non-read-only parallel calls (shell/MCP/...) already
+                // ran — their side effects are real, so their results are
+                // consumed as-is and NEVER re-executed.
+                if (eager !== undefined && eager.mutationEpoch < epoch.mutation && isEagerDispatchable(call.name, tools)) {
                     pending.delete(call.id);
                     eager = undefined;
                 }

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -39,6 +39,7 @@ import {
     resolveExecutionMode,
 } from '../../../../shared/background-tasks.mjs';
 import { resolveShellFor } from './shell-runtime.mjs';
+import { prewarmPwshStandbyPool } from '../lib/pwsh-standby-pool.mjs';
 import { smartMiddleTruncate } from './shell-output.mjs';
 import { normalizeOutputPath } from './path-utils.mjs';
 import { normalizeErrorMessage } from './path-diagnostics.mjs';
@@ -58,6 +59,25 @@ import { resourceAdmission } from '../../../../shared/resource-admission.mjs';
 export function _captureTrackedMtimes(_scope) {
     return new Map();
 }
+
+/**
+ * Boot prewarm: build the EXACT spawn env/spec a real shell call uses and warm
+ * the pwsh standby pool with it, so the first shell call of a session skips
+ * the pwsh startup cost. No-op off Windows / non-pwsh. Best-effort.
+ */
+export function prewarmShellStandbys() {
+    try {
+        const spec = resolveShellFor('default');
+        if (!spec || spec.shellType !== 'powershell') return false;
+        const env = { ...process.env, LANG: 'C.UTF-8', LC_ALL: 'C.UTF-8' };
+        scrubProviderSecrets(env);
+        scrubLoaderVars(env);
+        scrubRuntimeRootVars(env);
+        return prewarmPwshStandbyPool({ shell: spec.shell, shellArgs: spec.shellArgs, env }) === true;
+    } catch {
+        return false;
+    }
+}
 export function _trackedDriftNoteAfter(_scope, _pre) {
     return '';
 }

package/src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs

@@ -74,13 +74,20 @@ export const BUILTIN_TOOLS = [
         name: 'shell',
         title: 'Mixdog Shell',
         annotations: { title: 'Mixdog Shell', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true, compressible: true },
-        description: `Run programs or change system state; not for reading, listing or searching. Shell/write calls are serial.${_shellSyntaxCheat} ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
+        description: 'Run programs/change state; not file inspection. Calls in one turn run parallel; '
+            + 'combine order-dependent commands. Use async for sleep/watch/dev loops.'
+            + `${_shellSyntaxCheat} ${TOOL_ASYNC_EXECUTION_CONTRACT}`,
         inputSchema: {
             type: 'object',
             properties: {
                 command: { type: 'string', description: 'Command.' },
                 cwd: { type: 'string', description: 'Working directory; persists across calls. Omit to reuse; absolute path changes it.' },
-                timeout: { type: 'number', description: `Timeout ms; default ${_shellDefaultTimeoutMs()}. On sync timeout the command is promoted to a background task_id and keeps running, with any explicit timeout enforced as a background deadline. Sleep-like commands skip promotion: they block the full timeout, then are killed with a [timeout] marker. async runs until done/cancelled unless a timeout is set.` },
+                timeout: {
+                    type: 'number',
+                    description: `Timeout ms; default ${_shellDefaultTimeoutMs()}. `
+                        + 'Sync timeout may return task_id; explicit timeout becomes its deadline. '
+                        + 'Sleeps are killed, not promoted.',
+                },
                 merge_stderr: { type: 'boolean', description: 'Merge stderr.' },
                 mode: { type: 'string', enum: ['sync', 'async'], description: executionModeSchemaDescription('sync') },
                 shell: { type: 'string', enum: ['bash', 'powershell'], description: 'Force shell. Windows defaults to PowerShell; bash = Git Bash/POSIX.' },

package/src/runtime/agent/orchestrator/tools/builtin/shell-job-process.mjs

@@ -117,6 +117,30 @@ function normalizeWindowsSnapshot(snapshot) {
     return rows;
 }
 
+// Standby-pool support: does `pid` currently own live descendant processes?
+// FRESH snapshot on purpose — the 750ms cache could miss a just-spawned
+// grandchild and wrongly certify a polluted standby shell as clean. Unknown
+// snapshots answer true (conservative: the pool discards instead of reusing).
+export async function windowsPidHasDescendants(pid, { spawnFn = spawn } = {}) {
+    if (!Number.isFinite(pid) || pid <= 0) return false;
+    if (process.platform !== 'win32') return false;
+    let rows = null;
+    try { rows = await windowsProcessSnapshot({ fresh: true, spawnFn }); } catch { rows = null; }
+    if (!rows) return true;
+    const owned = new Set([pid]);
+    let discovered = true;
+    while (discovered) {
+        discovered = false;
+        for (const row of rows.values()) {
+            if (!owned.has(row.pid) && owned.has(row.parentPid)) {
+                owned.add(row.pid);
+                discovered = true;
+            }
+        }
+    }
+    return owned.size > 1;
+}
+
 // Invoke onQuiescent exactly once, synchronously when already quiescent or
 // after positive liveness probes stop observing the owned tree/group.
 export function trackProcessTreeQuiescence(

package/src/runtime/agent/orchestrator/tools/env-scrub.mjs

@@ -110,5 +110,13 @@ export function scrubProviderSecrets(env) {
 export function scrubRuntimeRootVars(env) {
     if (!env || typeof env !== 'object') return env;
     delete env.MIXDOG_ROOT;
+    // Host-runtime leak: a packaged Electron/daemon host runs with
+    // NODE_ENV=production, and inheriting it silently corrupts model-spawned
+    // shells — `npm install` prunes devDependencies, React resolves its
+    // production build (no `act`), test suites flip red on developer machines
+    // while CI stays green. The value is OUR process's, not the user's OS
+    // env, so shells must not see it. A command that needs NODE_ENV sets it
+    // explicitly.
+    delete env.NODE_ENV;
     return env;
 }

package/src/runtime/agent/orchestrator/tools/graph-manifest.json

@@ -1,26 +1,26 @@
 {
-  "version": "0.1.1",
+  "version": "0.1.2",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.1/mixdog-graph-darwin-arm64",
-      "sha256": "3fb76a5e3064547b68e7bcab6ce2a855ce615a732157d836cb561c5d7c8d86b6"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.2/mixdog-graph-darwin-arm64",
+      "sha256": "e54f09013af2ae057eae89c629237af79caeb248e59c335c64c88fc7b720d662"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.1/mixdog-graph-darwin-x64",
-      "sha256": "64eeffc17984a76b0fbf7d85f9d84cb5e1bb949a251053feb260f70481235bb1"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.2/mixdog-graph-darwin-x64",
+      "sha256": "d4506109fab2a392157ee016d9dfd2524d74363925004f008795eab3fba3de23"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.1/mixdog-graph-linux-arm64",
-      "sha256": "15d5cbb7575b3e0671c6f5fbef3460c5c9353f17968a80faba737fcc15b49c33"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.2/mixdog-graph-linux-arm64",
+      "sha256": "ba5f3e52f95c6e0c976115fea9e60c1a1d4534565a15c2da7284ad9c59c1eeb5"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.1/mixdog-graph-linux-x64",
-      "sha256": "5079544c09ae2311295cef21978fda3c1c06f93beaaf666cfe1f68971d5b27ae"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.2/mixdog-graph-linux-x64",
+      "sha256": "3642d773317a468fe5ba5efc4544ae91a68117b78d577ee2aad37e2639fcc01a"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.1/mixdog-graph-win32-x64.exe",
-      "sha256": "acfbcd02b96154f4fb342a44dec1a4808752944c5941bbb7983d84ed64464830"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.2/mixdog-graph-win32-x64.exe",
+      "sha256": "3d86870fc6d3ce1151dd97b91fc634fd2755e3f3c74f10809aaea34ae3e2aa02"
     }
   }
 }