mixdog 1.2.3 → 1.2.5

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

@@ -22,12 +22,36 @@ import {
   waitNativeTask,
 } from '../lib/native-spawn-client.mjs';
 import { attachJobInsights, shellJobPublicTaskResult } from './lib/shell-job-insights.mjs';
+import { tryAdmitWorkspaceActivity } from '../../../../shared/worktrees/activity-gate.mjs';
+import { worktreeError } from '../../../../shared/worktrees/contract.mjs';
 import {
+  adoptShellWorkspaceAdmission,
+  clearTerminationHold,
   completeShellJobRecord,
   listShellJobRecords,
+  markShellJobTerminationUnconfirmed,
   publishShellJobRecord,
+  registerTerminationHold,
   retireShellJobRecord,
+  takeReleaseRequest,
 } from './lib/shell-job-records.mjs';
+import { createProcessTreeTracker, killAfterSnapshot, watchTermination } from '../lib/shell-descendants.mjs';
+import {
+  flushPendingOwnerCancels,
+  registerOwnedShellTree,
+  unregisterOwnedShellTree,
+} from '../lib/owned-shell-trees.mjs';
+
+// Pre-kill snapshot of a tracked background job: the promotion baseline, or a
+// fresh read when that did not complete. Marks the job killed, so its settle
+// relies on this snapshot instead of an after-exit observation.
+function prepareTrackedKill(entry) {
+  entry.killed = true;
+  if (entry.tracker.complete) return true;
+  return (entry.baseline || Promise.resolve(false)).then(
+    (complete) => complete || entry.tracker.capture().catch(() => false)
+  );
+}
 import { isPidAlive } from '../../../../shared/pid-liveness.mjs';
 import {
   renderShellCompletionEnvelope,
@@ -50,6 +74,8 @@ export function buildJobNotFoundMessage(jobId) {
 const promotedJobIds = new Set();
 const backgroundShellJobWatchers = new Map();
 const jobNotifyCtxByJobId = new Map();
+// jobId -> process-tree tracker of a published background job.
+const backgroundTrackers = new Map();
 
 function demoteBackgroundShellPriority(pid) {
   if (process.env.MIXDOG_BG_PRIORITY === '0') return;
@@ -63,18 +89,76 @@ function demoteBackgroundShellPriority(pid) {
 // also publishes a disk record for the out-of-process shell-count readers
 // (desktop pane chip, CLI statusline). The record is retired the moment the job
 // settles — completed, timed out, or killed.
+// The workspace admission a job record holds is released only once the job's
+// processes are confirmed gone — the same confirmation path a foreground run
+// uses, not the native terminal status alone.
 function trackShellJobRecord(task, options) {
   const jobId = String(task?.jobId || '').trim();
   if (!jobId) return;
   publishShellJobRecord(task, options);
+  if (task?.cwd) {
+    // The record's own reader is filed under the job's root pid, which the
+    // gate drops the moment that pid dies. Survivors must keep the folder
+    // reserved, so this runtime holds it under its own live pid as well.
+    const hold = tryAdmitWorkspaceActivity(options?.ownerSessionId || jobId, task.cwd, { kind: 'command' });
+    if (!hold) throw worktreeError('WORKTREE_BUSY_JOBS', 'The command folder is being managed.');
+    adoptShellWorkspaceAdmission(jobId, hold);
+  }
+  const tracker = task?.cwd ? createProcessTreeTracker({ pid: task.pid }) : null;
+  const entry = { tracker, killed: false, baseline: null };
+  if (tracker) {
+    backgroundTrackers.set(jobId, entry);
+    // Baseline identities while the promoted root is known to run, so a later
+    // kill (ours or the native timeout) has a pre-kill snapshot without
+    // waiting for one.
+    entry.baseline = tracker.capture().catch(() => false);
+    entry.owned = { ownerSessionId: options?.ownerSessionId || null, prepareKill: () => prepareTrackedKill(entry) };
+    registerOwnedShellTree(jobId, entry.owned);
+  }
   let unsubscribe = null;
+  let settled = false;
   const settle = (detail) => {
-    if (!detail || detail.status === 'running') return;
+    if (settled || !detail || detail.status === 'running') return;
+    settled = true;
     try {
       unsubscribe?.();
     } catch {}
     promotedJobIds.delete(jobId);
-    void completeShellJobRecord(jobId, normalizeShellJobDetail(detail));
+    if (entry.owned) unregisterOwnedShellTree(jobId, entry.owned);
+    const normalized = normalizeShellJobDetail(detail);
+    if (!tracker) {
+      void completeShellJobRecord(jobId, normalized);
+      return;
+    }
+    // A root that exited on its own is observed after exit, as a foreground
+    // settle does. A killed one relies on the snapshot taken before the kill.
+    const killed = entry.killed || detail.killed || detail.timedOut || String(detail.status) === 'cancelled';
+    if (!killed) tracker.acceptExitObservation();
+    // The completion notice is already on its way (watchBackgroundShellJob);
+    // the record — and with it the workspace admission — completes only once
+    // every process is confirmed gone, or the user releases it explicitly.
+    let finished = false;
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      stop();
+      clearTerminationHold(jobId);
+      if (backgroundTrackers.get(jobId) === entry) backgroundTrackers.delete(jobId);
+      return completeShellJobRecord(jobId, normalized);
+    };
+    const stop = watchTermination({
+      tracker,
+      onTerminated: finish,
+      releaseRequested: () => takeReleaseRequest(jobId),
+      onUnconfirmed: () => {
+        void markShellJobTerminationUnconfirmed(jobId);
+        registerTerminationHold(jobId, {
+          ownerSessionId: options?.ownerSessionId || null,
+          cwd: task.cwd,
+          release: finish,
+        });
+      },
+    });
   };
   unsubscribe = subscribeNativeTask(jobId, settle);
   settle(getNativeTask(jobId) || task);
@@ -243,6 +327,16 @@ export function refreshShellJob(jobId) {
 }
 
 export function killShellJob(jobId) {
+  const tracked = backgroundTrackers.get(String(jobId || ''));
+  const current = tracked ? getNativeTask(jobId) : null;
+  if (current?.status === 'running') {
+    // The pre-kill snapshot is the promotion baseline (or, when that did not
+    // complete, a fresh read). The kill waits for it at most the read bound
+    // and is sent regardless; without a snapshot the outcome stays unknown and
+    // the folder stays held under the observation loop.
+    void killAfterSnapshot(prepareTrackedKill(tracked), () => cancelNativeTask(jobId));
+    return { ...attachJobInsights(normalizeShellJobDetail(current)), killed: true };
+  }
   const detail = cancelNativeTask(jobId);
   if (!detail) return null;
   const wasRunning = detail.status === 'running';
@@ -409,6 +503,7 @@ export function publishForegroundShellRecord({
   startedAtMs = 0,
   ownerSessionId = null,
   clientHostPid = null,
+  terminationUnconfirmed = false,
 }) {
   if (!jobId || !Number.isFinite(Number(pid)) || Number(pid) <= 0) return;
   publishShellJobRecord(
@@ -418,6 +513,7 @@ export function publishForegroundShellRecord({
       clientHostPid,
       startedAtMs,
       foreground: true,
+      terminationUnconfirmed,
     }
   );
 }
@@ -486,6 +582,9 @@ export async function reconcileRecoveredShellJobCompletions() {
 
 export async function shutdownShellJobs(_reason = 'runtime-close', { scope = null } = {}) {
   const scoped = Boolean(scope);
+  // Runtime shutdown: a session-close cancel still waiting for its snapshot
+  // is sent now, before the process can go away with it.
+  if (!scoped) flushPendingOwnerCancels();
   const ownerSessionId = scoped ? String(scope.ownerSessionId || '') : '';
   if (scoped && !ownerSessionId) {
     return { killed: 0, cancelledJobs: 0, cancelledWatchers: 0 };

package/src/runtime/agent/orchestrator/tools/code-graph-prewarm-worker.mjs

@@ -1,6 +1,6 @@
 // Code-graph prewarm worker. Runs the heavy CPU/sync-fs traversal in a
 // dedicated worker thread so the main event loop (Claude stream readers,
-// MCP socket pumps, .hb writes, aiWrapped worker startup) is never starved
+// MCP socket pumps, aiWrapped worker startup) is never starved
 // by a cold build (~3s typical, 90s outlier observed in PG telemetry).
 //
 // Contract:

package/src/runtime/agent/orchestrator/tools/lib/owned-shell-trees.mjs

@@ -0,0 +1,67 @@
+// Owner-wide shell cancellation (session close) with the same pre-kill
+// identity snapshot every other kill takes. Each live shell tree — a
+// foreground run or a promoted background job — registers how to prepare its
+// kill; the owner cancel prepares them all, waits for their snapshots at most
+// PROCESS_TABLE_READ_BOUND_MS, and then sends the kill whether or not they
+// arrived. A missing snapshot leaves the outcome unknown, so the workspace
+// stays held under the observation loop instead of being released blind.
+import { cancelNativeTasks } from './native-spawn-client.mjs';
+import { killAfterSnapshot } from './shell-descendants.mjs';
+
+// jobId -> { ownerSessionId, prepareKill }. prepareKill() marks the tree as
+// killed by its owner and returns true when its snapshot is already complete,
+// otherwise a promise for it.
+const ownedTrees = new Map();
+// owner -> send(): cancels still waiting for their snapshots. Runtime
+// shutdown sends them at once — a kill is never lost to an exit.
+const pendingCancels = new Map();
+
+export function registerOwnedShellTree(jobId, entry) {
+  const key = String(jobId || '').trim();
+  if (key && typeof entry?.prepareKill === 'function') ownedTrees.set(key, entry);
+}
+
+/** Drops `entry` only while it is still the registered one for the job. */
+export function unregisterOwnedShellTree(jobId, entry) {
+  const key = String(jobId || '').trim();
+  if (ownedTrees.get(key) === entry) ownedTrees.delete(key);
+}
+
+/** Cancel every shell tree of one owner session. Synchronous (the native
+ *  cancel's own result) when every snapshot is already complete; otherwise a
+ *  promise that sends the cancel once the snapshots land or the bound passes. */
+export function cancelOwnedShellTrees(ownerSessionId) {
+  const owner = String(ownerSessionId || '').trim();
+  const pending = [];
+  for (const [jobId, entry] of [...ownedTrees]) {
+    if (String(entry.ownerSessionId || '') !== owner) continue;
+    let ready;
+    try {
+      ready = entry.prepareKill();
+    } catch {
+      ready = false;
+    }
+    if (ready !== true) pending.push(Promise.resolve(ready).catch(() => false));
+    unregisterOwnedShellTree(jobId, entry);
+  }
+  if (pending.length === 0) return cancelNativeTasks({ ownerSessionId: owner });
+  let result = null;
+  const send = () => {
+    if (pendingCancels.get(owner) === send) pendingCancels.delete(owner);
+    result = result ?? cancelNativeTasks({ ownerSessionId: owner });
+    return result;
+  };
+  pendingCancels.set(owner, send);
+  return killAfterSnapshot(Promise.all(pending), send);
+}
+
+/** Send every owner cancel still waiting for its snapshot, now (runtime
+ *  shutdown). A snapshot that has not landed leaves that outcome unknown. */
+export function flushPendingOwnerCancels() {
+  let sent = 0;
+  for (const send of [...pendingCancels.values()]) {
+    send();
+    sent += 1;
+  }
+  return sent;
+}

package/src/runtime/agent/orchestrator/tools/lib/process-table-fixture.mjs

@@ -0,0 +1,50 @@
+// Test support: a scripted process table standing in for mcp/child-tree.mjs.
+// Each row is one process identity; `state.next()` answers every table read
+// (throw from it to model a failed enumeration).
+
+export function processTable(rows = []) {
+  const table = { childrenOf: new Map(), tokenOf: new Map(), nameOf: new Map(), pgidOf: new Map() };
+  for (const { pid, ppid = 1, token = `created-${pid}`, name = 'node.exe', pgid } of rows) {
+    if (!table.childrenOf.has(ppid)) table.childrenOf.set(ppid, []);
+    table.childrenOf.get(ppid).push(pid);
+    table.tokenOf.set(pid, token);
+    table.nameOf.set(pid, name);
+    if (pgid) table.pgidOf.set(pid, pgid);
+  }
+  return table;
+}
+
+function descendantsOf(table, root) {
+  const out = [];
+  const stack = [root];
+  const seen = new Set(stack);
+  while (stack.length) {
+    for (const pid of table.childrenOf.get(stack.pop()) ?? []) {
+      if (seen.has(pid)) continue;
+      seen.add(pid);
+      stack.push(pid);
+      out.push({ pid, name: table.nameOf.get(pid), token: table.tokenOf.get(pid) });
+    }
+  }
+  return out;
+}
+
+export function scriptedChildTree() {
+  const state = { reads: 0, kills: [], next: () => processTable() };
+  const read = async () => {
+    state.reads += 1;
+    return state.next();
+  };
+  return {
+    state,
+    namedExports: {
+      readProcessTable: read,
+      collectDescendantProcesses: async (root) => descendantsOf(await read(), root),
+      killProcessTrees: async (pids) => {
+        state.kills.push(...pids);
+      },
+      killStdioChildTreeFast: () => false,
+      shutdownStdioChild: async () => false,
+    },
+  };
+}