mixdog 0.9.75 → 0.9.78

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mixdog",
-  "version": "0.9.75",
+  "version": "0.9.78",
   "private": false,
   "type": "module",
   "description": "Standalone mixdog coding-agent CLI/TUI workspace.",
@@ -33,6 +33,7 @@
     "!scripts/smoke-loop*.mjs",
     "!scripts/*-bench.mjs",
     "!scripts/*bench-*.mjs",
+    "!scripts/verify-embedding-runtime.mjs",
     "!scripts/*.ps1",
     "!scripts/*.jsx",
     "src/",
@@ -40,6 +41,7 @@
     "vendor/"
   ],
   "scripts": {
+    "postinstall": "node scripts/prune-embedding-runtime.mjs",
     "prepack": "npm run build:tui",
     "prepublishOnly": "node -e \"if(!process.env.CI){console.error('local npm publish is disabled — run npm run release:patch');process.exit(1)}\"",
     "start": "node src/cli.mjs",
@@ -71,7 +73,10 @@
     "test:anthropic-oauth-race": "node --test scripts/anthropic-oauth-refresh-race-test.mjs",
     "test:grok-oauth-race": "node --test scripts/grok-oauth-refresh-race-test.mjs",
     "test:atomiclock": "node --test scripts/atomic-lock-tryonce-test.mjs",
-    "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/maintenance-default-routes-test.mjs scripts/embedding-worker-exit-test.mjs",
+    "test:memory-routing": "node --test scripts/memory-cycle-routing-test.mjs scripts/maintenance-default-routes-test.mjs scripts/embedding-worker-exit-test.mjs scripts/embedding-runtime-prune-test.mjs",
+    "test:embedding-runtime": "node --test scripts/embedding-runtime-prune-test.mjs && node scripts/verify-embedding-runtime.mjs",
+    "test:embedding-runtime:core": "node --test scripts/embedding-runtime-prune-test.mjs && node scripts/verify-embedding-runtime.mjs --core",
+    "test:embedding-runtime:warmup": "node scripts/verify-embedding-runtime.mjs --warmup",
     "test:code-graph-dispatch": "node --test scripts/code-graph-dispatch-test.mjs",
     "test:code-graph-clean-cache": "node --test scripts/code-graph-dispatch-test.mjs",
     "test:tui-queue": "node --test scripts/submit-commandbusy-race-test.mjs scripts/steering-drain-buckets-test.mjs scripts/abort-recovery-test.mjs scripts/execution-pending-resume-kick-test.mjs scripts/execution-resume-esc-integration-test.mjs",
@@ -79,7 +84,7 @@
     "test:tui-streaming-window": "node --test scripts/streaming-tail-window-test.mjs",
     "test:tui-ambiguous-width": "node --test scripts/tui-ambiguous-width-test.mjs",
     "test:release-assets": "node --check scripts/verify-release-assets.mjs && node --check scripts/verify-release-assets-test.mjs && node --test scripts/verify-release-assets-test.mjs",
-    "test:release-focused": "npm run test:release-assets && npm run test:tool-contracts && npm run test:placeholder && npm run smoke:patch && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test scripts/code-graph-root-federation-test.mjs scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && npm run test:session && npm run test:workflow-editor && node --test scripts/tui-transcript-perf-test.mjs",
+    "test:release-focused": "npm run test:release-assets && npm run test:tool-contracts && npm run test:placeholder && npm run smoke:patch && npm run test:patch-binary-cache && npm run test:providers && npm run test:deferred-tools && npm run smoke:compact && node --test scripts/code-graph-root-federation-test.mjs scripts/code-graph-aggregate-cwd-test.mjs && npm run test:code-graph-dispatch && node --test scripts/code-graph-disk-hit-test.mjs && npm run test:shellhardening && node --test scripts/windows-hide-spawn-options-test.mjs && npm run test:session && npm run test:workflow-editor && npm run test:embedding-runtime && node --test scripts/tui-transcript-perf-test.mjs",
     "test:native-edit-wire": "node --test scripts/native-edit-wire-test.mjs",
     "test:patch-binary-cache": "node --test scripts/patch-binary-cache-test.mjs",
     "test:session": "node --test scripts/session-orphan-sweep-test.mjs scripts/interrupted-turn-history-test.mjs scripts/session-heartbeat-lifecycle-test.mjs scripts/remote-transition-order-test.mjs",

package/scripts/prune-embedding-runtime.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+import { access, readdir, readFile, rm } from 'node:fs/promises'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const SUPPORTED_TARGETS = new Map([
+  ['win32', new Set(['x64', 'arm64'])],
+  ['darwin', new Set(['x64', 'arm64'])],
+  ['linux', new Set(['x64', 'arm64'])],
+])
+
+async function exists(path) {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function removeChildrenExcept(directory, keep) {
+  let entries
+  try {
+    entries = await readdir(directory, { withFileTypes: true })
+  } catch (error) {
+    if (error?.code === 'ENOENT') return
+    throw error
+  }
+  await Promise.all(entries
+    .filter((entry) => !keep.has(entry.name))
+    .map((entry) => rm(join(directory, entry.name), { recursive: true, force: true })))
+}
+
+async function packageName(directory) {
+  try {
+    return JSON.parse(await readFile(join(directory, 'package.json'), 'utf8')).name
+  } catch {
+    return ''
+  }
+}
+
+async function findPackageRoot(entry, expectedName) {
+  let current = dirname(entry)
+  for (;;) {
+    if (await packageName(current) === expectedName) return current
+    const parent = dirname(current)
+    if (parent === current) break
+    current = parent
+  }
+  throw new Error(`Unable to locate ${expectedName} from ${entry}`)
+}
+
+export function embeddingRuntimeTarget(options = {}) {
+  const platform = String(
+    options.platform
+      || process.env.MIXDOG_EMBED_TARGET_PLATFORM
+      || process.platform,
+  ).trim()
+  const arch = String(
+    options.arch
+      || process.env.MIXDOG_EMBED_TARGET_ARCH
+      || process.arch,
+  ).trim()
+  if (!SUPPORTED_TARGETS.get(platform)?.has(arch)) {
+    throw new Error(`Unsupported embedding runtime target: ${platform}-${arch}`)
+  }
+  return { platform, arch, key: `${platform}-${arch}` }
+}
+
+export async function pruneEmbeddingRuntime(packageRoot, options = {}) {
+  const root = resolve(packageRoot)
+  const target = embeddingRuntimeTarget(options)
+  const nodeModules = join(root, 'node_modules')
+  const transformerRoot = join(nodeModules, '@huggingface', 'transformers')
+  const transformerPackage = join(transformerRoot, 'package.json')
+  if (!(await exists(transformerPackage))) {
+    throw new Error(`Embedding runtime is incomplete: missing ${transformerPackage}`)
+  }
+
+  const transformerEntry = join(transformerRoot, 'dist', 'transformers.node.cjs')
+  const transformerImport = join(transformerRoot, 'dist', 'transformers.node.mjs')
+  for (const required of [transformerEntry, transformerImport]) {
+    if (!(await exists(required))) {
+      throw new Error(`Embedding runtime is incomplete: missing ${required}`)
+    }
+  }
+
+  const ortCandidates = [
+    join(transformerRoot, 'node_modules', 'onnxruntime-node'),
+    join(nodeModules, 'onnxruntime-node'),
+  ]
+  const ortRoot = (await Promise.all(ortCandidates.map(async (candidate) => (
+    await exists(join(candidate, 'package.json')) ? candidate : null
+  )))).find(Boolean)
+  if (!ortRoot) throw new Error('Embedding runtime is incomplete: onnxruntime-node is unavailable')
+
+  const targetBinaryDir = join(ortRoot, 'bin', 'napi-v3', target.platform, target.arch)
+  if (!(await exists(join(targetBinaryDir, 'onnxruntime_binding.node')))) {
+    throw new Error(`Embedding runtime is incomplete: missing ${target.key} ONNX binding`)
+  }
+
+  // Transformers' Node conditional export bundles all JS implementation code.
+  // Browser bundles, WASM, maps, source and types are not runtime inputs.
+  await removeChildrenExcept(transformerRoot, new Set([
+    'package.json',
+    'LICENSE',
+    'dist',
+    'node_modules',
+  ]))
+  await removeChildrenExcept(join(transformerRoot, 'dist'), new Set([
+    'transformers.node.cjs',
+    'transformers.node.mjs',
+  ]))
+
+  // onnxruntime-node resolves exactly:
+  // bin/napi-v3/${process.platform}/${process.arch}/onnxruntime_binding.node.
+  // Keep one native payload and remove every foreign OS/architecture.
+  const napiRoot = join(ortRoot, 'bin', 'napi-v3')
+  await removeChildrenExcept(napiRoot, new Set([target.platform]))
+  await removeChildrenExcept(join(napiRoot, target.platform), new Set([target.arch]))
+  await removeChildrenExcept(ortRoot, new Set([
+    'package.json',
+    'dist',
+    'bin',
+    'node_modules',
+  ]))
+
+  // The Node bundle marks onnxruntime-web as an ignored webpack external. Keep
+  // only its manifest so npm's dependency inventory remains coherent.
+  for (const webRoot of [
+    join(nodeModules, 'onnxruntime-web'),
+    join(transformerRoot, 'node_modules', 'onnxruntime-web'),
+  ]) {
+    if (await exists(join(webRoot, 'package.json'))) {
+      await removeChildrenExcept(webRoot, new Set(['package.json', 'LICENSE']))
+    }
+  }
+
+  return {
+    ...target,
+    transformerRoot,
+    ortRoot,
+    targetBinaryDir,
+  }
+}
+
+const invokedPath = process.argv[1] ? pathToFileURL(resolve(process.argv[1])).href : ''
+if (invokedPath === import.meta.url) {
+  const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+  pruneEmbeddingRuntime(packageRoot)
+    .then(({ key }) => {
+      process.stdout.write(`Embedding runtime pruned for ${key}.\n`)
+    })
+    .catch((error) => {
+      process.stderr.write(`Embedding runtime prune failed: ${error?.message || error}\n`)
+      process.exitCode = 1
+    })
+}

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

@@ -848,7 +848,17 @@ export async function askSession(sessionId, prompt, context, onToolCall, cwdOver
                         activeSession.messages = finalized.messages;
                         if (!finalized.responsePreserved) {
                             releasePendingMessages(sessionId, _turnPendingEntries);
-                            activeSession.sessionStartMetaInjected = _sessionStartMetaInjectedBeforeTurn;
+                            if (finalized.userTurnPreserved) {
+                                // Non-user abort (app quit / engine dispose /
+                                // watchdog): the just-sent user turn stays in
+                                // history, so the session-start meta it carries
+                                // remains consumed, and the opaque provider
+                                // continuation no longer matches — force full
+                                // transcript replay on the next send.
+                                activeSession.providerState = undefined;
+                            } else {
+                                activeSession.sessionStartMetaInjected = _sessionStartMetaInjectedBeforeTurn;
+                            }
                         } else {
                             recordPendingMessageDelivery(activeSession, _turnPendingEntries);
                             // The opaque provider continuation now points at a

package/src/runtime/agent/orchestrator/session/manager/turn-interruption.mjs

@@ -10,6 +10,16 @@ const INTERRUPT_MESSAGE_FOR_TOOL_USE = '[Request interrupted by user for tool us
 const STREAMING_INTERRUPTED_TOOL_RESULT = 'Interrupted by user';
 const TOOL_USE_REJECT_RESULT = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
 
+// Abort reasons that represent an EXPLICIT user cancellation of this turn.
+// Only these rewind a not-yet-answered user turn out of history — the TUI/
+// desktop restore the prompt into the input box on user cancel, so keeping
+// the message would duplicate it on resubmit. Any other closeReason (engine
+// shutdown `cli-react-exit`, watchdog, idle-sweep, runner-crash, …) must
+// PRESERVE the just-sent user turn: nothing restores the prompt there, and
+// rewinding erases the user's message from the persisted transcript (the
+// exact loss seen when the desktop app quits mid-turn).
+const USER_CANCEL_ABORT_REASONS = new Set(['cli-abort', 'user-cancel', 'turn-abort']);
+
 function assistantToolCallIds(message) {
     if (!message || message.role !== 'assistant') return [];
     const ids = [];
@@ -60,9 +70,21 @@ function finalizeInterruptedTurn({
     const preserveResponse = responseStarted
         && !isInternalRuntimeNotificationText(currentUserContent);
     if (!preserveResponse) {
+        // Null/unknown reasons keep the legacy rewind (status quo for wrapped
+        // aborts without a closeReason enum); named non-user reasons preserve.
+        const userCancelled = abortReason == null
+            || USER_CANCEL_ABORT_REASONS.has(abortReason);
+        if (!userCancelled) {
+            return {
+                messages,
+                responsePreserved: false,
+                userTurnPreserved: true,
+            };
+        }
         return {
             messages: rewindProvisionalUserTurn(messages, currentUserContent),
             responsePreserved: false,
+            userTurnPreserved: false,
         };
     }
 
@@ -132,7 +154,7 @@ function finalizeInterruptedTurn({
                 : INTERRUPT_MESSAGE,
         });
     }
-    return { messages: pairedMessages, responsePreserved: true };
+    return { messages: pairedMessages, responsePreserved: true, userTurnPreserved: true };
 }
 
 export function createTurnInterruptionTracker() {

package/src/runtime/agent/orchestrator/tools/bash-session.mjs

@@ -45,7 +45,7 @@ import { markCodeGraphDirtyPaths, drainCodeGraphCache } from './code-graph-state
 import { maybeRewriteWmicProcessCommand } from './shell-policy.mjs';
 import { _maybeEncodePowerShellCommand } from './shell-command.mjs';
 import { _captureTrackedMtimes, _trackedDriftNoteAfter, getDedupedDestructiveWarnings } from './builtin/bash-tool.mjs';
-import { scrubLoaderVars, scrubProviderSecrets } from './env-scrub.mjs';
+import { scrubLoaderVars, scrubProviderSecrets, scrubRuntimeRootVars } from './env-scrub.mjs';
 import { checkExecPolicyMessage } from './bash-policy-scan.mjs';
 import { startChildGuardian } from '../../../shared/child-guardian.mjs';
 import { resourceAdmission } from '../../../shared/resource-admission.mjs';
@@ -342,6 +342,8 @@ function buildBashEnv() {
     scrubProviderSecrets(env);
     // R11 loader/execution scrub (NODE_OPTIONS, LD_PRELOAD, DYLD_*, …).
     scrubLoaderVars(env);
+    // Runtime-root isolation — see env-scrub.mjs scrubRuntimeRootVars.
+    scrubRuntimeRootVars(env);
     return env;
 }
 

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

@@ -44,7 +44,7 @@ import { normalizeOutputPath } from './path-utils.mjs';
 import { normalizeErrorMessage } from './path-diagnostics.mjs';
 import { invalidateBuiltinResultCache } from './cache-layers.mjs';
 import { resolveOptionalCwd } from './cwd-utils.mjs';
-import { scrubLoaderVars, scrubProviderSecrets } from '../env-scrub.mjs';
+import { scrubLoaderVars, scrubProviderSecrets, scrubRuntimeRootVars } from '../env-scrub.mjs';
 import { resolveSessionCwd, stateFilePath, wrapPowerShellWithCwdProbe, wrapBashWithCwdProbe } from '../shell-state.mjs';
 import { resourceAdmission } from '../../../../shared/resource-admission.mjs';
 
@@ -407,6 +407,7 @@ export async function executeBashTool(args, workDir, options = {}) {
         // R5/R11: same scrub as background/persistent spawn sites (env-scrub.mjs).
         scrubProviderSecrets(spawnEnv);
         scrubLoaderVars(spawnEnv);
+        scrubRuntimeRootVars(spawnEnv);
         let wrappedCommand;
         // PowerShell UTF-8 prefix is PS-only: the Windows Git Bash path
         // (shellType==='posix') must NOT receive it. Snapshot wrapper stays

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

@@ -2,7 +2,7 @@
 import { spawn } from 'child_process';
 import { existsSync, readFileSync, statSync, unlinkSync, watch as fsWatch, writeFileSync } from 'fs';
 import { basename } from 'path';
-import { scrubLoaderVars, scrubProviderSecrets } from '../env-scrub.mjs';
+import { scrubLoaderVars, scrubProviderSecrets, scrubRuntimeRootVars } from '../env-scrub.mjs';
 import {
     normalizeToolNotifyContext,
     notifyToolCompletion,
@@ -169,7 +169,7 @@ export async function _startBackgroundShellJobImpl({
     try {
         child = spawnFn(shell, [wrappedTempPath], {
             cwd: workDir,
-            env: scrubLoaderVars(scrubProviderSecrets({ ...spawnEnv })),
+            env: scrubRuntimeRootVars(scrubLoaderVars(scrubProviderSecrets({ ...spawnEnv }))),
             stdio: 'ignore',
             ...detachedSpawnOpts,
         });
@@ -398,7 +398,7 @@ async function startBackgroundPowerShellJob({
     try {
         child = spawnFn(shell, wrapperArgs, {
             cwd: workDir,
-            env: scrubLoaderVars(scrubProviderSecrets({ ...spawnEnv })),
+            env: scrubRuntimeRootVars(scrubLoaderVars(scrubProviderSecrets({ ...spawnEnv }))),
             detached: false,
             stdio: 'ignore',
             windowsHide: true,

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

@@ -98,3 +98,17 @@ export function scrubProviderSecrets(env) {
     }
     return env;
 }
+
+// Runtime-root isolation: MIXDOG_ROOT is a runtime-internal alias for THIS
+// process's install/resource root (a packaged desktop host points it at
+// resources/runtime.asar/...). Model-spawned shells must never inherit it —
+// a dev-tree test run inside such a shell would resolve defaults/agents.json
+// and friends from the INSTALLED app instead of the repo under test (plain
+// node can't even read asar paths → ENOENT). Internal worker spawns that need
+// the root re-set it explicitly and are unaffected: only shell spawn sites
+// call this.
+export function scrubRuntimeRootVars(env) {
+    if (!env || typeof env !== 'object') return env;
+    delete env.MIXDOG_ROOT;
+    return env;
+}

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

@@ -18,7 +18,7 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { randomUUID } from 'node:crypto';
 import { getPluginData } from '../config.mjs';
-import { scrubLoaderVars, scrubProviderSecrets } from './env-scrub.mjs';
+import { scrubLoaderVars, scrubProviderSecrets, scrubRuntimeRootVars } from './env-scrub.mjs';
 
 const SNAPSHOT_TIMEOUT_MS = 10_000;
 
@@ -191,6 +191,8 @@ function _runSnapshot(shellPath, snapshotPath, configFileExists) {
         // provider/cloud tokens before exposing the env to that script.
         // Shared with bash-session and shell-jobs via env-scrub.mjs.
         scrubProviderSecrets(e);
+        // Runtime-root isolation — see env-scrub.mjs scrubRuntimeRootVars.
+        scrubRuntimeRootVars(e);
         return e;
       })(),
       windowsHide: true,

package/src/runtime/memory/lib/embedding-provider.mjs

@@ -306,3 +306,17 @@ export async function embedTexts(texts) {
     return cached ? [...cached] : []
   })
 }
+
+export async function shutdownEmbeddingProvider() {
+  const activeWorker = worker
+  worker = null
+  _warmupPromise = null
+  _modelReady = false
+  cachedDims = null
+  queryEmbeddingCache.clear()
+  if (!activeWorker) return
+  const shutdownError = new Error('embedding provider shut down')
+  for (const [, pending] of _pending) pending.reject(shutdownError)
+  _pending.clear()
+  await activeWorker.terminate()
+}