mixdog 1.4.1 → 1.4.3

package/src/runtime/shared/session-scratch.mjs

@@ -1,16 +1,25 @@
 // Per-session scratch directory under Mixdog's data directory. Processes the
 // `shell` tool starts see it as TEMP/TMP/TMPDIR, so scratch files never land in
 // the project, and it is removed with its session (session-delete.mjs).
+import { createHash } from 'node:crypto';
 import { mkdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { resolvePluginData } from './plugin-paths.mjs';
 
 const SESSION_ID = /^[A-Za-z0-9_-]+$/;
 
+// The folder is named by a short digest of the id, not the id itself: a desktop
+// session id is 77 characters, and a TEMP that long leaves too little of
+// Windows' 260-character path limit for what runs under it (Git refuses a
+// $GIT_DIR over 220 characters, LibreOffice crashes on a profile past ~150).
+// The "." is a character no session id has, so no id's legacy folder (named
+// after the id itself) can ever be another session's digest folder.
+const scratchName = (id) => `s.${createHash('sha256').update(id).digest('hex').slice(0, 16)}`;
+
 /** The session's scratch path (not created), or '' for an unusable id. */
 export function sessionScratchDir(sessionId) {
   const id = typeof sessionId === 'string' ? sessionId : '';
-  return SESSION_ID.test(id) ? join(resolvePluginData(), 'scratch', id) : '';
+  return SESSION_ID.test(id) ? join(resolvePluginData(), 'scratch', scratchName(id)) : '';
 }
 
 /** Create the session's scratch directory if absent; returns its path ('' without a session id). */
@@ -22,7 +31,10 @@ export function ensureSessionScratchDir(sessionId) {
 
 export function removeSessionScratchDir(sessionId) {
   const dir = sessionScratchDir(sessionId);
-  if (dir) rmSync(dir, { recursive: true, force: true });
+  if (!dir) return;
+  rmSync(dir, { recursive: true, force: true });
+  // Earlier versions named the folder after the full id.
+  rmSync(join(resolvePluginData(), 'scratch', sessionId), { recursive: true, force: true });
 }
 
 /** Point an env's temp variables at the session's scratch directory. */

package/src/runtime/shared/shipped-definitions.mjs

@@ -9,7 +9,13 @@ import { dirname, join, relative } from 'node:path';
 import { readMarkdownDocument } from './markdown-frontmatter.mjs';
 
 export const SHIPPED_HISTORY_FILE = ['defaults', 'shipped-history.json'];
-export const EMPTY_HISTORY = Object.freeze({ agents: {}, workflows: {}, outputStyles: {}, skills: {} });
+export const EMPTY_HISTORY = Object.freeze({
+  agents: {},
+  workflows: {},
+  outputStyles: {},
+  orchestration: {},
+  skills: {},
+});
 
 // Leftovers from hand edits or editors that never belong to a definition.
 const IGNORABLE_STRAY = /(\.(bak|orig|tmp)|~)$/i;

package/src/runtime/shared/staged-install-worker.mjs

@@ -6,8 +6,13 @@
  * quitting mid-install. Does its work and exits; the swap happens on a later
  * clean launch via performPendingSwap().
  */
+import { adoptSystemProxy } from './llm/system-proxy.mjs';
 import { runStagedInstall } from './staged-update.mjs';
 
+// Consume the system proxy handed over by the launcher (removing it from this
+// env); only the npm install below receives it, as npm settings.
+adoptSystemProxy();
+
 const version = process.argv[2] || process.env.MIXDOG_STAGE_VERSION || '';
 runStagedInstall(version)
   .then((r) => process.exit(r?.ok || r?.alreadyStaged || r?.inProgress ? 0 : 1))

package/src/runtime/shared/staged-update.mjs

@@ -46,6 +46,7 @@ import { dirname, basename, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from 'node:child_process';
 import { resolvePluginData } from './plugin-paths.mjs';
+import { systemProxyHandoffEnv, systemProxyNpmEnv } from './llm/system-proxy.mjs';
 // Same probe every discovery/lock reader uses; `process.pid` is trivially alive.
 import { isPidAlive as pidAlive } from './pid-liveness.mjs';
 import { sleepSync } from './sleep.mjs';
@@ -222,6 +223,38 @@ function releaseStagingLock(verDir) {
   }
 }
 
+const DEFAULT_NPM_REGISTRY = 'https://registry.npmjs.org/';
+
+/** The registry npm installs from (its .npmrc files included); npm's default when npm cannot say. */
+function npmRegistry(cliJs) {
+  return new Promise((resolve) => {
+    let out = '';
+    let child;
+    try {
+      child = spawn(process.execPath, [cliJs, 'config', 'get', 'registry'], {
+        stdio: ['ignore', 'pipe', 'ignore'],
+        shell: false,
+        timeout: 10_000,
+        ...hiddenSpawnOpts,
+      });
+    } catch {
+      resolve(DEFAULT_NPM_REGISTRY);
+      return;
+    }
+    child.stdout?.on('data', (chunk) => {
+      out += chunk;
+    });
+    child.once('error', () => resolve(DEFAULT_NPM_REGISTRY));
+    child.once('close', (code) => {
+      try {
+        resolve(code === 0 ? new URL(out.trim()).href : DEFAULT_NPM_REGISTRY);
+      } catch {
+        resolve(DEFAULT_NPM_REGISTRY);
+      }
+    });
+  });
+}
+
 /**
  * runStagedInstall(version) — perform the full staging install for one version
  * into ~/.mixdog/data/staging/<version>. Runs to completion (awaits the npm
@@ -259,10 +292,17 @@ export async function runStagedInstall(version) {
     // shell spawn (AV constraint — no shell spawns).
     const cliJs = npmCliJsPath();
     if (!cliJs) return { ok: false, error: 'npm-cli.js unresolved — staging skipped' };
+    // The system proxy of npm's registry, as npm's own settings for this one install.
+    const npmProxyEnv = await systemProxyNpmEnv(() => npmRegistry(cliJs));
     const code = await new Promise((res) => {
       let child;
       try {
-        child = spawn(process.execPath, [cliJs, ...installArgs], { stdio: 'ignore', shell: false, ...hiddenSpawnOpts });
+        child = spawn(process.execPath, [cliJs, ...installArgs], {
+          stdio: 'ignore',
+          shell: false,
+          env: { ...process.env, ...npmProxyEnv },
+          ...hiddenSpawnOpts,
+        });
       } catch {
         res(-1);
         return;
@@ -319,7 +359,12 @@ export function spawnStagedInstall(version) {
   if (isStagedComplete(v)) return false;
   try {
     const worker = join(_MODULE_DIR, 'staged-install-worker.mjs');
-    const child = spawn(process.execPath, [worker, v], { stdio: 'ignore', ...detachedSpawnOpts });
+    // The worker gets the system proxy decision privately (it consumes it).
+    const child = spawn(process.execPath, [worker, v], {
+      stdio: 'ignore',
+      env: { ...process.env, ...systemProxyHandoffEnv() },
+      ...detachedSpawnOpts,
+    });
     child.once?.('error', () => {});
     child.unref?.();
     return true;

package/src/runtime/shared/tool-card-model.golden.json

@@ -513,10 +513,7 @@
     "normalizedName": "load_tool",
     "label": "Load Tools",
     "parsedArgs": {
-      "names": [
-        "office",
-        "media"
-      ]
+      "names": ["office", "media"]
     },
     "isShellSurface": false,
     "isSkillSurface": false,
@@ -752,10 +749,7 @@
     "normalizedName": "",
     "label": "",
     "parsedArgs": {
-      "categoryOrder": [
-        "read",
-        "search"
-      ]
+      "categoryOrder": ["read", "search"]
     },
     "isShellSurface": false,
     "isSkillSurface": false,
@@ -825,10 +819,7 @@
     "normalizedName": "",
     "label": "",
     "parsedArgs": {
-      "loadingTargets": [
-        "office",
-        "media"
-      ]
+      "loadingTargets": ["office", "media"]
     },
     "isShellSurface": false,
     "isSkillSurface": false,

package/src/runtime/shared/tool-execution-contract.mjs

@@ -193,6 +193,8 @@ const TRANSCRIPT_HIDDEN_CONTROL_TOOL_NAMES = new Set([
   'get_goal',
   'set_goal_tasks',
   'update_goal',
+  // The step list shows in its own composer panel, not as transcript cards.
+  'todo',
   'load_tool',
   'tool_search',
   // A bot's reaction shows as its emoji under the user's message, not as a card.

package/src/runtime/shared/tool-surface.mjs

@@ -83,7 +83,7 @@ export function isTaskWaitToolCall(name, args = {}) {
   );
 }
 
-export function displayToolName(name, args = {}) {
+function displayToolName(name, args = {}) {
   if (isExternalMcpToolName(name)) {
     const mcp = parseMcpToolName(name);
     return `MCP ${titleCaseMcpServer(mcp.server)}`;
@@ -127,6 +127,8 @@ export function displayToolName(name, args = {}) {
     case 'web_fetch':
     case 'fetch':
       return 'Fetch';
+    case 'explore':
+      return 'Explore';
     case 'browser':
     case 'browser_devtools':
       return 'Browser';
@@ -213,18 +215,14 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
   }
   switch (normalized) {
     case 'read':
-      if (!a.path && !a.file_path) return '';
-      if (Array.isArray(a.path) || Array.isArray(a.file_path)) {
-        return formatCountedUnit(collectionCount(a.path, a.file_path), 'file');
-      }
-      return compactParts([
-        displayToolPath(a.path ?? a.file_path),
-        a.pages ? `pages ${a.pages}` : summarizeLineWindow(a),
-      ]);
     case 'view_image':
-      return displayToolPath(a.path || a.file_path || '');
     case 'apply_patch':
-      return summarizePatch(a.patch, a.base_path);
+    case 'list':
+    case 'ls':
+    case 'grep':
+    case 'glob':
+    case 'find':
+      return summarizeFileToolArgs(normalized, a, max);
     case 'shell':
     case 'bash':
     case 'bash_session':
@@ -250,6 +248,82 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
           .join(', '),
         max
       );
+    case 'search_query':
+    case 'image_query':
+    case 'web_search':
+    case 'web_search_call':
+    case 'load_tool':
+    case 'web_fetch':
+    case 'fetch':
+      return summarizeWebToolArgs(normalized, a, max);
+    case 'browser':
+    case 'browser_devtools':
+    case 'computer':
+    case 'terminal':
+    case 'visualize':
+    case 'office':
+    case 'media':
+    case 'tidy':
+      return summarizeInterfaceToolArgs(normalized, a, args, max);
+    case 'explore':
+      if (Array.isArray(a.query)) return formatCountedUnit(collectionCount(a.query), 'query', 'queries');
+      return truncateToolText(a.query || '', Math.min(max, 80));
+    case 'read_mcp_resource':
+      return truncateToolText(a.uri || '', max);
+    case 'list_mcp_resources':
+    case 'list_mcp_resource_templates':
+      return a.server ? `server "${truncateToolText(a.server, max)}"` : 'all servers';
+    case 'cwd':
+    case 'session':
+    case 'setup':
+    case 'memory':
+    case 'remember':
+    case 'save_memory':
+    case 'update_memory':
+    case 'recall_memory':
+    case 'recall':
+    case 'search_memories':
+      return summarizeStateToolArgs(normalized, a, max);
+    case 'bridge':
+    case 'agent': {
+      const agentModel = bridgeAgentModelSummary(a);
+      if (agentModel) return agentModel;
+      const bridgeAction = a.type || a.action || a.mode || '';
+      const showTarget = !/^(status|read)$/i.test(String(bridgeAction || ''));
+      return compactParts([bridgeAction, showTarget ? a.tag || a.sessionId || a.task_id || '' : '']);
+    }
+    case 'code_graph':
+      return codeGraphSummary(a, max);
+    case 'skill':
+    case 'skill_execute':
+    case 'skill_view':
+    case 'skills_list':
+    case 'use_skill':
+      return truncateToolText(
+        firstText(a.name, a.skill, a.skill_name, a.query, a.q, normalized === 'skills_list' ? 'all skills' : ''),
+        max
+      );
+    default:
+      return genericArgsSummary(a, max);
+  }
+}
+
+// Files, directories and patches.
+function summarizeFileToolArgs(normalized, a, max) {
+  switch (normalized) {
+    case 'read':
+      if (!a.path && !a.file_path) return '';
+      if (Array.isArray(a.path) || Array.isArray(a.file_path)) {
+        return formatCountedUnit(collectionCount(a.path, a.file_path), 'file');
+      }
+      return compactParts([
+        displayToolPath(a.path ?? a.file_path),
+        a.pages ? `pages ${a.pages}` : summarizeLineWindow(a),
+      ]);
+    case 'view_image':
+      return displayToolPath(a.path || a.file_path || '');
+    case 'apply_patch':
+      return summarizePatch(a.patch, a.base_path);
     case 'list':
     case 'ls':
       if (Array.isArray(a.path) || Array.isArray(a.dir) || Array.isArray(a.cwd)) {
@@ -284,6 +358,14 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
         return formatCountedUnit(collectionCount(a.query, a.fuzzy), 'query', 'queries');
       }
       return compactParts([quoted(a.query ?? a.fuzzy, max), a.path ? `path: ${displayToolPath(a.path)}` : '']);
+    default:
+      return '';
+  }
+}
+
+// Search, fetch and tool-search loading.
+function summarizeWebToolArgs(normalized, a, max) {
+  switch (normalized) {
     case 'search_query':
     case 'image_query':
     case 'web_search':
@@ -303,6 +385,14 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
         return formatCountedUnit(collectionCount(a.url, a.uri), 'URL', 'URLs');
       }
       return truncateToolText(a.url || a.uri || '', max);
+    default:
+      return '';
+  }
+}
+
+// Bridge and interface tools: browser, computer, terminal, visualize, office, media, tidy.
+function summarizeInterfaceToolArgs(normalized, a, args, max) {
+  switch (normalized) {
     case 'browser':
     case 'browser_devtools': {
       const call = bridgeToolCall(args);
@@ -342,11 +432,14 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
         Array.isArray(a.paths) && a.paths.length ? truncateToolText(a.paths.join(' '), max) : '',
         a.apply === true ? 'apply' : '',
       ]);
-    case 'read_mcp_resource':
-      return truncateToolText(a.uri || '', max);
-    case 'list_mcp_resources':
-    case 'list_mcp_resource_templates':
-      return a.server ? `server "${truncateToolText(a.server, max)}"` : 'all servers';
+    default:
+      return '';
+  }
+}
+
+// Sessions, setup and memory.
+function summarizeStateToolArgs(normalized, a, max) {
+  switch (normalized) {
     case 'cwd': // legacy: old transcripts
     case 'session':
       return compactParts([
@@ -396,27 +489,8 @@ export function summarizeToolArgs(name, args, { max = DEFAULT_SUMMARY_MAX } = {}
         a.limit || a.topK ? `top ${a.limit ?? a.topK}` : '',
       ]);
     }
-    case 'bridge':
-    case 'agent': {
-      const agentModel = bridgeAgentModelSummary(a);
-      if (agentModel) return agentModel;
-      const bridgeAction = a.type || a.action || a.mode || '';
-      const showTarget = !/^(status|read)$/i.test(String(bridgeAction || ''));
-      return compactParts([bridgeAction, showTarget ? a.tag || a.sessionId || a.task_id || '' : '']);
-    }
-    case 'code_graph':
-      return codeGraphSummary(a, max);
-    case 'skill':
-    case 'skill_execute':
-    case 'skill_view':
-    case 'skills_list':
-    case 'use_skill':
-      return truncateToolText(
-        firstText(a.name, a.skill, a.skill_name, a.query, a.q, normalized === 'skills_list' ? 'all skills' : ''),
-        max
-      );
     default:
-      return genericArgsSummary(a, max);
+      return '';
   }
 }
 

package/src/runtime/shared/tool-work-units.mjs

@@ -20,6 +20,7 @@ export const CATEGORY_ORDER = [
   'Skill',
   'Web Research',
   'Memory',
+  'Explore',
   'Patch',
   'Git',
   'Shell',
@@ -58,6 +59,7 @@ const TOOL_CATEGORY = new Map([
   ['save_memory', 'Memory'],
   ['update_memory', 'Memory'],
   ['memory', 'Memory'],
+  ['explore', 'Explore'],
   ['apply_patch', 'Patch'],
   ['edit', 'Patch'],
   ['strreplace', 'Patch'],
@@ -116,6 +118,7 @@ const CATEGORY_COPY = new Map([
   ['Skill', { active: 'Loading', done: 'Loaded', noun: 'skill' }],
   ['Web Research', { active: 'Researching', done: 'Researched', noun: 'query', pluralNoun: 'queries' }],
   ['Memory', { active: 'Checking', done: 'Checked', noun: 'memory item' }],
+  ['Explore', { active: 'Exploring', done: 'Explored', noun: 'query', pluralNoun: 'queries' }],
   ['Patch', { active: 'Editing', done: 'Edited', noun: 'file' }],
   ['Git', { active: 'Running', done: 'Ran', noun: 'Git command' }],
   ['Shell', { active: 'Running', done: 'Ran', noun: 'command' }],
@@ -417,13 +420,8 @@ function goalUnit(a) {
   const verbs = {
     status: ['Checking', 'Checked'],
     create: ['Creating', 'Created'],
-    pause: ['Pausing', 'Paused'],
-    resume: ['Resuming', 'Resumed'],
-    set_tasks: ['Planning', 'Planned'],
-    update_tasks: ['Updating', 'Updated'],
     complete: ['Completing', 'Completed'],
     block: ['Blocking', 'Blocked'],
-    abandon: ['Abandoning', 'Abandoned'],
   }[action] || ['Updating', 'Updated'];
   return unitDescriptor('Setup', {
     count: 1,
@@ -523,6 +521,14 @@ function agentUnit(a) {
   if (/^(?:status|read|list)$/.test(type)) {
     return unitDescriptor('Agent', { count, active: 'Checking', done: 'Checked', noun: 'agent' });
   }
+  // Stopping an agent is not calling it, and ending a finished agent's
+  // session (close) is not cancelling its work.
+  if (type === 'cancel') {
+    return unitDescriptor('Agent', { count, active: 'Cancelling', done: 'Cancelled', noun: 'agent', effect: true });
+  }
+  if (type === 'close') {
+    return unitDescriptor('Agent', { count, active: 'Ending', done: 'Ended', noun: 'agent', effect: true });
+  }
   return unitDescriptor('Agent', { count, noun: 'agent' });
 }
 
@@ -625,6 +631,28 @@ function cwdUnit(a) {
   });
 }
 
+/** The `session` tool: its session actions are about sessions, not the legacy
+ *  `cwd` tool's working directory (which cwdUnit's fallback names). */
+function sessionUnit(a) {
+  const action = String(a.action || a.type || '').toLowerCase();
+  if (action === 'create') {
+    return unitDescriptor('Setup', { active: 'Creating', done: 'Created', noun: 'session', effect: true });
+  }
+  if (action === 'send') {
+    return unitDescriptor('Setup', { active: 'Sending to', done: 'Sent to', noun: 'session', effect: true });
+  }
+  if (action === 'cancel') {
+    return unitDescriptor('Setup', { active: 'Cancelling', done: 'Cancelled', noun: 'session', effect: true });
+  }
+  if (action === 'delete') {
+    return unitDescriptor('Setup', { active: 'Deleting', done: 'Deleted', noun: 'session', effect: true });
+  }
+  if (/^(?:list|bots|read|suggest)$/.test(action)) {
+    return unitDescriptor('Setup', { active: 'Checking', done: 'Checked', noun: 'session' });
+  }
+  return cwdUnit(a);
+}
+
 const TOOL_UNITS = new Map([
   [
     'read',
@@ -689,6 +717,7 @@ const TOOL_UNITS = new Map([
         pluralNoun: 'URLs',
       }),
   ],
+  ['explore', (a) => unitDescriptor('Explore', { count: queryCount(a, 'query') || 1 })],
   ['browser', browserUnit],
   ['browser_devtools', browserUnit],
   ['computer', () => unitDescriptor('Computer', { count: 1, active: 'Operating', done: 'Operated', noun: 'action' })],
@@ -743,7 +772,7 @@ const TOOL_UNITS = new Map([
     () => unitDescriptor('Setup', { active: 'Listing', done: 'Listed', noun: 'MCP resource template' }),
   ],
   ['cwd', cwdUnit], // legacy: old transcripts
-  ['session', cwdUnit],
+  ['session', sessionUnit],
 ]);
 
 function mcpUnit(name, a) {

package/src/runtime/shared/turn-snapshot.mjs

@@ -98,6 +98,9 @@ let _writeSeq = 0;
 // `${sessionId}\0${checkpointId}` → seals in flight. A sealing turn's change
 // record is `pending` and its session refuses Undo/Reapply until it lands.
 const _pendingFreezes = new Map();
+// `${sessionId}\0${checkpointId}` → getTurnChanges reads in flight. A seal of
+// that checkpoint landing marks them: each may hold the record from before it.
+const _changeReads = new Map();
 // Per-session Undo/Reapply chain.
 const _changeMutations = new Map();
 // `${sessionId}\0${checkpointId}` → path keys whose worktree state is unknown
@@ -1241,6 +1244,7 @@ function sealTurn(ownerSessionId, tracker) {
     const count = (_pendingFreezes.get(key) || 1) - 1;
     if (count > 0) _pendingFreezes.set(key, count);
     else _pendingFreezes.delete(key);
+    for (const read of _changeReads.get(key) || []) read.sealLanded = true;
   });
   tracker.freezing = run;
   return run;
@@ -1788,9 +1792,26 @@ function requiredCheckpointId(value) {
 export async function getTurnChanges(sessionId, options = {}) {
   const ownerSessionId = clean(sessionId);
   const checkpointId = requiredCheckpointId(options?.checkpointId);
-  let record = ownerSessionId
-    ? withUnknownChangeStates(ownerSessionId, await loadTurnChangeRecord(ownerSessionId, checkpointId))
-    : null;
+  // Settled only when no seal of this checkpoint was in flight at any point of
+  // the record read: one in flight before or after it (a completion wake
+  // reopened the turn meanwhile), or one that landed during it, answers
+  // pending instead of the record from before that seal.
+  const inFlight = () => Boolean(ownerSessionId) && turnChangesPending(ownerSessionId, checkpointId);
+  const key = pendingFreezeKey(ownerSessionId, checkpointId);
+  const read = { sealLanded: false };
+  const reads = _changeReads.get(key) || new Set();
+  _changeReads.set(key, reads.add(read));
+  let pending = inFlight();
+  let record;
+  try {
+    record = ownerSessionId
+      ? withUnknownChangeStates(ownerSessionId, await loadTurnChangeRecord(ownerSessionId, checkpointId))
+      : null;
+  } finally {
+    reads.delete(read);
+    if (reads.size === 0 && _changeReads.get(key) === reads) _changeReads.delete(key);
+  }
+  pending ||= read.sealLanded || inFlight();
   // An old record's outside-root file kept no counts: measure it so the card
   // agrees with the session review and the island.
   if (record?.files?.length) {
@@ -1801,7 +1822,7 @@ export async function getTurnChanges(sessionId, options = {}) {
     };
   }
   let status = 'missing';
-  if (ownerSessionId && turnChangesPending(ownerSessionId, checkpointId)) status = 'pending';
+  if (pending) status = 'pending';
   else if (record) status = record.files?.length || record.outside?.length ? 'ready' : 'none';
   const reply = turnChangesReply({
     status,
@@ -2083,6 +2104,7 @@ export function _resetTurnSnapshotForTest() {
   _turnsBySession.clear();
   _diffTrackersBySession.clear();
   _pendingFreezes.clear();
+  _changeReads.clear();
   _changeMutations.clear();
   _unknownChangeStates.clear();
   _parkedWorkerReviews.clear();