mixdog 1.1.1 → 1.2.0

package/src/runtime/attachments/store.mjs

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

package/src/runtime/channels/index.mjs

@@ -1,13 +1,9 @@
 // Thin facade for the channels worker runtime. The implementation was split
 // out into ./lib/worker-main.mjs plus focused lib/ modules; this file preserves
-// the exact public API and boot side-effects by re-exporting from worker-main.
+// the current worker API and boot side-effects by re-exporting from worker-main.
 // Kept as the channels worker entrypoint the daemon loads.
 export {
-  TOOL_DEFS,
   handleToolCall,
-  handleToolCallWithBridgeRetry,
-  init,
-  instructions,
   isChannelBridgeActive,
   isChannelsDegraded,
   start,

package/src/runtime/channels/lib/runtime-paths.mjs

@@ -114,8 +114,7 @@ function getControlResponsePath(instanceId) {
 function getStopFlagPath(instanceId) {
   return join(RUNTIME_ROOT, `stop-${sanitize(instanceId)}.flag`);
 }
-// Pure metadata-advert read: ownership is the OS seat lock, so a leftover
-// advert is never evicted here. A transient read during an atomic rename may
+// Pure metadata-advert read. A transient read during an atomic rename may
 // yield empty/partial content: retry once after 50 ms before reporting the
 // advert as unreadable.
 function readActiveInstance() {
@@ -141,8 +140,6 @@ function buildActiveInstanceState(instanceId, meta) {
     supervisor_started_at: Date.now(),
     server_started_at: Date.now(),
     updatedAt: Date.now(),
-    turnEndFile: getTurnEndPath(instanceId),
-    statusFile: getStatusPath(instanceId),
     ...metaFields(meta),
   };
 }
@@ -193,26 +190,14 @@ function refreshActiveInstance(instanceId, meta, options) {
     (curRaw) => {
       const prevForPreserve = curRaw;
       const prev = activeInstanceStaleReason(curRaw) ? null : curRaw;
-      // CAS guard (opt-in via options.onlyIfOwned): heartbeat/refresh ticks
-      // check ownership OUTSIDE this lock, so a newer session can claim the
-      // seat between that check and this locked update. Without this re-read,
-      // the tick would overwrite the newer owner's instanceId (TOCTOU
-      // re-steal -> ownership ping-pong / double provider connections).
-      // Returning undefined aborts the update with no write. Explicit claims
-      // (boot, claimBridgeOwnership) omit the option and stay last-wins.
-      if (options?.onlyIfOwned && (!prev?.instanceId || prev.instanceId !== instanceId)) {
-        return undefined;
-      }
-      // CAS guard (opt-in via options.onlyIfVacant): auto-start claim-if-vacant.
-      // Abort the write when a live (non-stale) owner OTHER than us already holds
-      // the seat — an auto-start must never steal from a live owner. A stale/dead
-      // prior owner leaves prev=null above, so it does NOT block the claim; an
-      // absent seat (prev=null) is claimable too.
-      if (options?.onlyIfVacant && prev?.instanceId && prev.instanceId !== instanceId) {
-        return undefined;
-      }
       // Drop stale fields (pid/startedAt) written by older server versions.
-      const { pid: _legacyPid, startedAt: _legacyStartedAt, ...prevRest } = prev ?? {};
+      const {
+        pid: _legacyPid,
+        startedAt: _legacyStartedAt,
+        turnEndFile: _turnEndFile,
+        statusFile: _statusFile,
+        ...prevRest
+      } = prev ?? {};
       const identity = buildRuntimeIdentity();
       // server_started_at tracks the CURRENT server_pid's start time so the
       // dev-sync barrier can verify the CHILD's freshness (the supervisor's

package/src/runtime/channels/lib/tool-dispatch.mjs

@@ -82,12 +82,6 @@ function createToolDispatch({ isChannelsDegraded, lifecycle }) {
           };
           break;
         }
-        case 'rebind_current_transcript': {
-          // Transcript forwarding is retired with channel messaging: accept
-          // and no-op so legacy lead-side pushes never surface an error.
-          result = { content: [{ type: 'text', text: 'transcript rebind retired' }] };
-          break;
-        }
         // memory — handled by memory-service.mjs MCP
         default:
           result = {
@@ -105,13 +99,7 @@ function createToolDispatch({ isChannelsDegraded, lifecycle }) {
     return result;
   }
 
-  // IPC/HTTP wrapper: with channel messaging retired there is no transcript
-  // pre-flush or tool-log relay — plain dispatch.
-  async function handleToolCallWithBridgeRetry(toolName, args, signal) {
-    return handleToolCall(toolName, args, signal);
-  }
-
-  return { handleToolCall, handleToolCallWithBridgeRetry };
+  return { handleToolCall };
 }
 
 export { createToolDispatch };

package/src/runtime/channels/lib/worker-ipc.mjs

@@ -14,7 +14,7 @@ export function runWorkerIpc({
   getProvider: _getProvider,
   getConfig: _getConfig,
   handleMemoryCallResponse,
-  handleToolCallWithBridgeRetry,
+  handleToolCall,
   bootProfile,
 }) {
   const sendToParent = (message) =>
@@ -94,7 +94,7 @@ export function runWorkerIpc({
       _inFlightChannelCalls.set(msg.callId, ac);
       let result;
       try {
-        result = await handleToolCallWithBridgeRetry(msg.name, msg.args || {}, ac.signal);
+        result = await handleToolCall(msg.name, msg.args || {}, ac.signal);
       } finally {
         _inFlightChannelCalls.delete(msg.callId);
       }

package/src/runtime/channels/lib/worker-main.mjs

@@ -4,7 +4,6 @@ import { createRequire } from 'node:module';
 import { loadConfig, createProvider, DATA_DIR } from './config.mjs';
 import { resolveVoiceRuntime } from './voice-runtime-fetcher.mjs';
 import { whisperThreadCount } from './voice-transcription.mjs';
-import { TOOL_DEFS } from '../tool-defs.mjs';
 import { ensureReady, stopVoiceWhisperServer } from './whisper-server.mjs';
 import { ensurePrivateRuntimeRoot, resolveRuntimeRoot } from '../../shared/runtime-root.mjs';
 import { Scheduler } from './scheduler.mjs';
@@ -102,7 +101,6 @@ runWorkerBootstrap({
   pruneStalePluginDataLogSiblings,
   DEFAULT_STALE_LOG_SIBLING_MAX,
 });
-const INSTRUCTIONS = '';
 
 // ── Parent notification helper ───────────────────────────────────────
 // This worker has no MCP transport of its own. All notifications flow
@@ -129,10 +127,7 @@ let _reloadDebounce = null;
 const STATUS_FILE = getStatusPath(INSTANCE_ID);
 const statusState = new JsonStateFile(STATUS_FILE, {});
 statusState.ensure();
-const scheduler = new Scheduler(
-  config.nonInteractive ?? [],
-  config.interactive ?? []
-);
+const scheduler = new Scheduler(config.nonInteractive ?? [], config.interactive ?? []);
 // Schedules fire as visible sessions; the session runner belongs to the
 // session-runtime layer, so this worker entry injects it (lazy, like webhooks).
 scheduler.setScheduleRunner(async (schedule, opts) => {
@@ -250,19 +245,12 @@ function wireEventQueueHandlers(eventQueue) {
   // re-read at probe time so a stale-connected flag cannot mask a lost seat.
   eventQueue.setOwnerGetter(() => bridgeRuntimeConnected && currentOwnerState().owned);
 }
-// Inbound messaging, provider interaction handlers, and channel voice-message
-// transcription are DELETED with Discord/Telegram (user decision: PWA replaces
-// channels). The headless provider emits no events, so nothing wires here.
-// Tool dispatch in worker mode goes through the IPC `call` handler at the
-// bottom of this file (parent's `callWorker` → `handleToolCall`). There is no
-// orphan worker-level MCP Server: the parent (server.mjs) owns the single
-// connected transport and routes CallTool through the IPC `call` path.
 // ── Worker/HTTP tool-call dispatch ──────────────────────────────────────────
 // Runtime lifecycle dispatch only (activate_channel_bridge / reload_config):
 // threaded as a lifecycle bag of lazy getters so the module reads live
 // file-level references at call time. Used by the HTTP MCP CallTool path and
 // the worker IPC `call` handler at the bottom of this file.
-const { handleToolCall, handleToolCallWithBridgeRetry } = createToolDispatch({
+const { handleToolCall } = createToolDispatch({
   isChannelsDegraded,
   lifecycle: {
     getChannelBridgeActive: () => channelBridgeActive,
@@ -277,14 +265,6 @@ const { handleToolCall, handleToolCallWithBridgeRetry } = createToolDispatch({
     reloadRuntimeConfig,
   },
 });
-async function init(_sharedMcp) {
-  // _sharedMcp is no longer used. Notifications now flow via IPC to the parent
-  // (sendNotifyToParent above). The parameter is retained for backward
-  // compatibility with any caller that still passes a Server reference.
-  scheduler.setInjectHandler((channelId, name, content, options) => {
-    injectAndRecord(channelId, name, content, options);
-  });
-}
 function ensureConfigWatcher() {
   if (_configWatcher) return;
   try {
@@ -374,19 +354,9 @@ if (_isWorkerMode && process.send && process.env.MIXDOG_DAEMON_HOST !== '1') {
     getProvider: () => provider,
     getConfig: () => config,
     handleMemoryCallResponse,
-    handleToolCallWithBridgeRetry,
+    handleToolCall,
     bootProfile,
   });
 }
 
-export {
-  TOOL_DEFS,
-  handleToolCall,
-  handleToolCallWithBridgeRetry,
-  init,
-  INSTRUCTIONS as instructions,
-  isChannelBridgeActive,
-  isChannelsDegraded,
-  start,
-  stop,
-};
+export { handleToolCall, isChannelBridgeActive, isChannelsDegraded, start, stop };

package/src/runtime/shared/atomic-file.mjs

@@ -240,6 +240,12 @@ export function writeJsonAtomicSync(filePath, value, opts = {}) {
   return writeFileAtomicSync(filePath, `${JSON.stringify(value, null, opts.compact ? 0 : 2)}\n`, opts);
 }
 
+// Windows editors and PowerShell 5 save UTF-8 with a leading byte order mark,
+// which JSON.parse rejects; a hand-edited state file must still load.
+export function parseJsonText(text) {
+  return JSON.parse(text.charCodeAt(0) === 0xfeff ? text.slice(1) : text);
+}
+
 function recoverJsonMutationRead(error) {
   // Missing/malformed JSON retains the existing initializer contract. An I/O
   // or permission failure is not an empty document and must never authorize
@@ -255,7 +261,7 @@ export function updateJsonAtomicSync(filePath, mutator, opts = {}) {
     () => {
       let cur = null;
       try {
-        cur = JSON.parse(readFileSync(filePath, 'utf8'));
+        cur = parseJsonText(readFileSync(filePath, 'utf8'));
       } catch (error) {
         cur = recoverJsonMutationRead(error);
       }
@@ -336,7 +342,7 @@ export async function updateJsonAtomic(filePath, mutator, opts = {}) {
     async () => {
       let cur = null;
       try {
-        cur = JSON.parse(await readFileAsync(filePath, 'utf8'));
+        cur = parseJsonText(await readFileAsync(filePath, 'utf8'));
       } catch (error) {
         cur = recoverJsonMutationRead(error);
       }

package/src/runtime/shared/best-effort-stderr.mjs

@@ -0,0 +1,8 @@
+// stderr diagnostics that must never throw (closed or broken stderr).
+export function writeStderrBestEffort(line) {
+  try {
+    process.stderr.write(line);
+  } catch {
+    /* diagnostics only */
+  }
+}

package/src/runtime/shared/code-graph-state.mjs

@@ -74,6 +74,18 @@ export function markCodeGraphDirtyPaths(paths) {
   }
 }
 
+/** Drop the resident graph, pending dirty paths and dirty generation of one
+ *  root (exact canonical match; nested roots are other roots). Returns the
+ *  names of the state that was actually dropped. */
+export function forgetCodeGraphStateRoot(root) {
+  const key = canonicalGraphCwd(root);
+  const removed = [];
+  if (codeGraphCache.delete(key)) removed.push('resident-graph');
+  if (codeGraphDirtyPaths.delete(key)) removed.push('dirty-paths');
+  if (codeGraphDirtyGen.delete(key)) removed.push('dirty-generation');
+  return removed;
+}
+
 export function registerCodeGraphDrain(fn) {
   drainCodeGraphCacheFn = typeof fn === 'function' ? fn : null;
 }

package/src/runtime/shared/defaults-separation.mjs

@@ -21,6 +21,7 @@ import { DEFAULTS_VERSION, DEFAULTS_VERSION_KEY, configPath, readConfig, updateC
 import { DEFAULT_DISABLED_AGENT_ROSTER, disabledAgentDelta, disabledAgentIds } from './agent-route-config.mjs';
 import { withGrandfatheredBuiltins } from './builtin-grandfathering.mjs';
 import { DEFAULT_ORCHESTRATION_MODE, legacyWorkflowOrchestrationMode } from './orchestration.mjs';
+import { WORKTREE_SETTINGS_DEFAULTS } from './worktrees/settings.mjs';
 
 export { DEFAULTS_VERSION, DEFAULTS_VERSION_KEY };
 
@@ -33,6 +34,7 @@ const AGENT_SECTION_DEFAULTS = Object.freeze({
   update: Object.freeze({ auto: true }),
   recap: Object.freeze({ enabled: true }),
   memoryTools: Object.freeze({ enabled: true }),
+  worktree: WORKTREE_SETTINGS_DEFAULTS,
 });
 const MODULE_DEFAULTS = Object.freeze({ enabled: true });
 

package/src/runtime/shared/git-runner-worker.mjs

@@ -6,7 +6,7 @@
 import { spawn } from 'node:child_process';
 import { serveWorkerRequests } from './worker-requests.mjs';
 
-function runGit({ args, cwd, input, env, timeoutMs, maxBytes }) {
+function runGit({ args, cwd, input, env, timeoutMs, maxBytes, stdoutEncoding = 'utf8' }) {
   return new Promise((resolvePromise, rejectPromise) => {
     const hasInput = (typeof input === 'string' || ArrayBuffer.isView(input)) && input.length > 0;
     const child = spawn('git', args, {
@@ -55,7 +55,8 @@ function runGit({ args, cwd, input, env, timeoutMs, maxBytes }) {
     child.once('close', (code) => {
       const result = {
         code: Number(code ?? 1),
-        stdout: Buffer.concat(stdout).toString('utf8'),
+        // 'base64' keeps non-UTF-8 bytes (a replayable patch) intact across the thread hop.
+        stdout: Buffer.concat(stdout).toString(stdoutEncoding === 'base64' ? 'base64' : 'utf8'),
         stderr: Buffer.concat(stderr).toString('utf8'),
       };
       // A failed stdin write only matters when git otherwise reported success.

package/src/runtime/shared/git-runner.mjs

@@ -13,8 +13,9 @@ const requestGit = createWorkerRequestClient(new URL('./git-runner-worker.mjs',
 /**
  * Resolves to { code, stdout, stderr }. Rejects with code ETIMEDOUT after
  * timeoutMs (the child is killed), EMAXBUFFER once stdout+stderr exceed
- * maxBytes, or the spawn error itself.
+ * maxBytes, or the spawn error itself. `stdoutEncoding: 'base64'` returns the
+ * exact stdout bytes base64-encoded instead of decoded as UTF-8.
  */
-export function runGitOffThread(args, { cwd, input = '', env = null, timeoutMs, maxBytes }) {
-  return requestGit({ args, cwd, input, env, timeoutMs, maxBytes });
+export function runGitOffThread(args, { cwd, input = '', env = null, timeoutMs, maxBytes, stdoutEncoding = 'utf8' }) {
+  return requestGit({ args, cwd, input, env, timeoutMs, maxBytes, stdoutEncoding });
 }

package/src/runtime/shared/llm/default-context-window.mjs

@@ -24,6 +24,12 @@ function positiveTokens(value) {
   return Number.isFinite(tokens) && tokens > 0 ? Math.floor(tokens) : 0;
 }
 
+/** An exact context-window selection in tokens (`contextTokens`); undefined when unset or invalid. */
+export function normalizeContextTokens(value) {
+  const tokens = Math.round(Number(value));
+  return Number.isFinite(tokens) && tokens > 0 ? tokens : undefined;
+}
+
 /**
  * The default and the largest selectable window of one model row, in tokens.
  * `defaultWindow` is 0 when the row states no window to start from.

package/src/runtime/shared/llm/model-catalog-projection.mjs

@@ -69,7 +69,8 @@ function projectModelsDevRow(row) {
   if (limit) out.limit = limit;
   const modalities = pickArrays(row.modalities, MODELSDEV_MODALITY_FIELDS);
   if (modalities) out.modalities = modalities;
-  if (row.reasoning === true) out.reasoning = true;
+  // A declared `reasoning: false` must stay distinct from absent (capabilityFlag).
+  if (typeof row.reasoning === 'boolean') out.reasoning = row.reasoning;
   if (Array.isArray(row.reasoning_options) && row.reasoning_options.length > 0) {
     out.reasoning_options = row.reasoning_options;
   }
@@ -129,8 +130,8 @@ const LITELLM_NUMBER_FIELDS = [
   'output_cost_per_video_token',
   'output_cost_per_second',
 ];
-// _normalize tests each of these with `=== true`, so only a true value carries
-// information; anything else is indistinguishable from absent.
+// _normalize keeps each declared boolean (an explicit false outranks a lower
+// layer's true); any other value is indistinguishable from absent.
 const LITELLM_FLAG_FIELDS = [
   'supports_vision',
   'supports_function_calling',
@@ -164,7 +165,7 @@ function projectLitellmRow(row) {
       out[field] = value;
   }
   for (const field of LITELLM_FLAG_FIELDS) {
-    if (row[field] === true) out[field] = true;
+    if (typeof row[field] === 'boolean') out[field] = row[field];
   }
   for (const field of LITELLM_STRING_FIELDS) {
     const value = row[field];