mixdog 1.4.2 → 1.4.3

package/src/runtime/shared/run-child.mjs

@@ -7,34 +7,56 @@
 // timeoutMs (the child is killed), EMAXBUFFER once stdout+stderr exceed
 // maxBytes, or the spawn error itself.
 import { spawn } from 'node:child_process';
+import { spawnTreeKill } from '../agent/orchestrator/mcp/child-tree.mjs';
 
 /** Kills `child` with everything it started. On Windows a plain kill ends only
  *  the child itself: `git` there is a launcher whose git.exe (and the alias,
- *  hook or filter it runs) would live on, still holding the output pipes. */
+ *  hook or filter it runs) would live on, still holding the output pipes.
+ *  Settles once the kill was attempted (on Windows: once the tree kill finished). */
 export function killChildTree(child) {
   if (process.platform === 'win32' && child.pid && child.exitCode === null) {
-    const taskkill = `${process.env.SystemRoot || 'C:\\Windows'}\\System32\\taskkill.exe`;
-    const fallback = () => {
-      try {
-        child.kill();
-      } catch {}
-    };
-    spawn(taskkill, ['/PID', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true })
-      .once('error', fallback)
-      .once('exit', (code) => {
-        if (code !== 0) fallback();
-      });
-    return;
+    // The shared pass kills `child` itself once it ends or runs out of time.
+    const pass = spawnTreeKill([child.pid], { root: child });
+    if (!pass) return Promise.resolve();
+    return new Promise((resolve) => {
+      pass.once('error', resolve).once('exit', resolve);
+    });
   }
   try {
     child.kill();
   } catch {}
+  return Promise.resolve();
 }
 
-export function runChild({ command, args, cwd, input, env, timeoutMs, maxBytes, stdoutEncoding = 'utf8' }) {
+/** The child has exited (an exit code or the signal that ended it). */
+const childEnded = (child) => child.exitCode !== null || child.signalCode !== null;
+
+/**
+ * `waitForExitMs` (> 0): a timeout rejects only once the killed child has
+ * exited, or after that many more ms; the error then carries `pid` and
+ * `childExited` (false: it outlived the wait). 0 (default): the timeout
+ * rejects as soon as the kill was sent.
+ * `killTree` (default true): a timeout kills the child's whole tree. false:
+ * only the child, directly — for the process-table and tree-kill helpers,
+ * whose own tree kill would be one more pass on the same stuck table read.
+ */
+export function runChild({
+  command,
+  args,
+  cwd,
+  input,
+  env,
+  timeoutMs,
+  maxBytes,
+  stdoutEncoding = 'utf8',
+  waitForExitMs = 0,
+  killTree = true,
+  // Tests only: a stand-in for child_process.spawn (in-process callers; not serializable).
+  spawnChild = spawn,
+}) {
   return new Promise((resolvePromise, rejectPromise) => {
     const hasInput = (typeof input === 'string' || ArrayBuffer.isView(input)) && input.length > 0;
-    const child = spawn(command, args, {
+    const child = spawnChild(command, args, {
       cwd,
       ...(env ? { env } : {}),
       windowsHide: true,
@@ -45,6 +67,7 @@ export function runChild({ command, args, cwd, input, env, timeoutMs, maxBytes,
     let outputBytes = 0;
     let stdinError = null;
     let settled = false;
+    let timedOut = false;
     const finish = (error, result) => {
       if (settled) return;
       settled = true;
@@ -52,17 +75,41 @@ export function runChild({ command, args, cwd, input, env, timeoutMs, maxBytes,
       if (error) rejectPromise(error);
       else resolvePromise(result);
     };
+    const exited = new Promise((resolve) => child.once('exit', resolve));
     // timeoutMs 0: no deadline (the caller's own work bounds the child).
     const timer =
       timeoutMs > 0
         ? setTimeout(() => {
             const error = new Error(`${command} ${args.join(' ')} timed out after ${timeoutMs}ms`);
             error.code = 'ETIMEDOUT';
-            killChildTree(child);
-            finish(error);
+            timedOut = true;
+            let killed = Promise.resolve();
+            if (killTree) killed = killChildTree(child);
+            else {
+              try {
+                child.kill();
+              } catch {}
+            }
+            if (!(waitForExitMs > 0)) {
+              finish(error);
+              return;
+            }
+            let bound;
+            const wait = new Promise((resolve) => {
+              bound = setTimeout(resolve, waitForExitMs);
+            });
+            void Promise.race([Promise.all([exited, killed]), wait]).then(() => {
+              clearTimeout(bound);
+              error.pid = child.pid ?? null;
+              error.childExited = childEnded(child);
+              finish(error);
+            });
           }, timeoutMs)
         : null;
     const collect = (chunks, chunk) => {
+      // Once a timeout terminates the child, it alone settles: later output
+      // (or an overflow) neither settles early nor grows the buffers.
+      if (timedOut) return;
       const next = Buffer.from(chunk);
       outputBytes += next.length;
       if (outputBytes > maxBytes) {
@@ -78,8 +125,13 @@ export function runChild({ command, args, cwd, input, env, timeoutMs, maxBytes,
     };
     child.stdout.on('data', (chunk) => collect(stdout, chunk));
     child.stderr.on('data', (chunk) => collect(stderr, chunk));
-    child.once('error', (error) => finish(error));
+    child.on('error', (error) => {
+      // An error while a timeout terminates the child (a failed kill) is the timeout's.
+      if (!timedOut) finish(error);
+    });
     child.once('close', (code) => {
+      // A timed-out child's close is the timeout's to report.
+      if (timedOut) return;
       const result = {
         code: Number(code ?? 1),
         // 'base64' keeps non-UTF-8 bytes (a replayable patch) intact across the thread hop.

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/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-work-units.mjs

@@ -420,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,
@@ -526,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' });
 }
 
@@ -628,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',
@@ -747,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();

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

@@ -268,15 +268,7 @@ async function sourceGitPath(root, suffix) {
 async function sourceGitPaths(state) {
   if (state.sourcePaths) return state.sourcePaths;
   const result = await runGit(
-    [
-      'rev-parse',
-      '--path-format=absolute',
-      '--git-path',
-      'info/exclude',
-      '--git-path',
-      'index',
-      '--git-common-dir',
-    ],
+    ['rev-parse', '--path-format=absolute', '--git-path', 'info/exclude', '--git-path', 'index', '--git-common-dir'],
     { cwd: state.root, allowFailure: true }
   );
   const lines = String(result.stdout || '')
@@ -695,7 +687,8 @@ async function hashBlobs(state, items, env) {
         // git ignores a symbolic-link .gitattributes, so only a regular file is carried over.
         ...[...directories].map(async (dir) => {
           const source = join(state.root, dir, '.gitattributes');
-          if ((await lstat(source).catch(() => null))?.isFile()) await copyFile(source, join(scratch, dir, '.gitattributes'));
+          if ((await lstat(source).catch(() => null))?.isFile())
+            await copyFile(source, join(scratch, dir, '.gitattributes'));
         }),
       ]);
       const options = { cwd: scratch, env };
@@ -720,7 +713,9 @@ async function hashBlobs(state, items, env) {
         });
         const oids = hashed.stdout.split('\n').filter(Boolean);
         if (oids.length !== plain.length) throw new Error('hash-object answered a different number of blobs');
-        plain.forEach((item, index) => ids.set(item, oids[index].trim()));
+        plain.forEach((item, index) => {
+          ids.set(item, oids[index].trim());
+        });
       }
     } finally {
       await rm(scratch, { recursive: true, force: true }).catch(() => {});

package/src/runtime/shared/worker-requests.mjs

@@ -67,8 +67,15 @@ export function createWorkerRequestClient(url, { idleExitMs = 0, onEvent = null,
         created.unref();
         if (worker === created) armIdleTimer(created);
       }
-      if (error) entry.reject(Object.assign(new Error(error.message), { code: error.code }));
-      else entry.resolve(result);
+      if (error) {
+        entry.reject(
+          Object.assign(
+            new Error(error.message),
+            { code: error.code },
+            typeof error.childExited === 'boolean' ? { childExited: error.childExited, pid: error.pid } : {}
+          )
+        );
+      } else entry.resolve(result);
     });
     created.on('error', (error) => {
       if (worker === created) {
@@ -132,7 +139,14 @@ export function serveWorkerRequests(handler) {
         (error) =>
           parentPort.postMessage({
             id,
-            error: { message: String(error?.message || error), code: error?.code ?? null },
+            error: {
+              message: String(error?.message || error),
+              code: error?.code ?? null,
+              // A timed-out child's fate (run-child.mjs waitForExitMs).
+              ...(typeof error?.childExited === 'boolean'
+                ? { childExited: error.childExited, pid: error.pid ?? null }
+                : {}),
+            },
           })
       );
   });

package/src/runtime/shared/worktrees/branch-management.mjs

@@ -48,11 +48,7 @@ async function inspect(projectPath, branch) {
     branch,
     commit,
     target: repo.currentBranch,
-    targetCommit: pair
-      ? pair[1]
-      : repo.currentBranch
-        ? await branchCommit(repo.projectPath, repo.currentBranch)
-        : null,
+    targetCommit: pair ? pair[1] : repo.currentBranch ? await branchCommit(repo.projectPath, repo.currentBranch) : null,
     path: holder?.path ?? null,
     worktreeId: entry?.id ?? null,
     kind: holder ? (samePath(holder.path, repo.topLevel) ? 'project' : entry ? 'managed' : 'external') : 'free',

package/src/runtime/shared/worktrees/contract.mjs

@@ -14,8 +14,10 @@ import { resolvePluginData } from '../plugin-paths.mjs';
 
 /** Versioned directory under the data dir that holds every managed worktree. */
 export const WORKTREE_STORE_DIR = 'worktrees-v1';
-/** Default ref prefix for branches created for managed worktrees. */
-export const DEFAULT_WORKTREE_BRANCH_PREFIX = 'mixdog/';
+/** Default ref prefix for branches created for managed worktrees: none, the
+ *  branch is the task's name. Which branches Mixdog owns is the registry's
+ *  record, never this prefix. */
+export const DEFAULT_WORKTREE_BRANCH_PREFIX = '';
 
 export const WORKSPACE_TRANSITION_STATES = Object.freeze(['idle', 'provisioning', 'switching', 'removing', 'recovery']);
 const WORKTREE_ENTRY_STATES = Object.freeze(['creating', 'ready', 'deleting', 'recovery']);
@@ -347,13 +349,21 @@ export function normalizeWorktreeOwner(input) {
  * The branch menu's rows (the desktop DesktopGitBranch shape) for the local
  * branch names the manager lists: `current` marks the branch checked out in
  * the project folder; managed lists hold local branches only.
+ * `committedAt` (branch → ISO time of its tip) becomes `lastCommitAt`.
  * @param {string[]} names
  * @param {BranchOccupancy[]} occupancy
- * @returns {Array<{ name: string, current: boolean, remote: false, upstream: string }>}
+ * @param {Record<string, string>} [committedAt]
+ * @returns {Array<{ name: string, current: boolean, remote: false, upstream: string, lastCommitAt?: string }>}
  */
-export function branchMenuEntries(names, occupancy) {
+export function branchMenuEntries(names, occupancy, committedAt = {}) {
   const current = new Set(occupancy.filter((row) => row.kind === 'current').map((row) => row.branch));
-  return names.map((name) => ({ name, current: current.has(name), remote: false, upstream: '' }));
+  return names.map((name) => ({
+    name,
+    current: current.has(name),
+    remote: false,
+    upstream: '',
+    ...(committedAt[name] ? { lastCommitAt: committedAt[name] } : {}),
+  }));
 }
 
 // ---------------------------------------------------------------------------
@@ -416,7 +426,7 @@ export function managedWorktreePath(repoCommonDir, slug, options) {
 /**
  * @param {string} slug
  * @param {string} [prefix]
- * @returns {string} e.g. "mixdog/fix-login"
+ * @returns {string} e.g. "fix-login", or "mixdog/fix-login" with prefix "mixdog/"
  */
 export function worktreeBranchName(slug, prefix = DEFAULT_WORKTREE_BRANCH_PREFIX) {
   const error = worktreeNameError(slug);