mixdog 1.2.5 → 1.2.6

package/src/runtime/agent/orchestrator/tools/builtin.mjs

@@ -58,6 +58,7 @@ import {
   GREP_OUTPUT_MAX_BYTES,
   LOCATOR_OUTPUT_MAX_BYTES,
   capLineOrientedToolOutput,
+  capMarker,
 } from './builtin/tool-output-limit.mjs';
 import {
   isBlockedDevicePath,
@@ -340,6 +341,46 @@ function _locatorTargets(toolName, args) {
   return [toolName === 'find' ? '' : '.'];
 }
 
+const _GREP_MATCH_ROW_RE = /^(?:\d+|.+?:\d+):/;
+
+// Match rows the byte cap left visible, in the units grep's `offset` counts.
+function _grepShownEntries(keptLines, mode) {
+  // A context block counts only when its header and every source line survived.
+  let blocks = 0;
+  let sawHeader = false;
+  keptLines.forEach((line, index) => {
+    const header = /^# .+:\d+ \[lines (\d+)-(\d+)\]$/.exec(line);
+    if (!header) return;
+    sawHeader = true;
+    if (index + Number(header[2]) - Number(header[1]) + 1 < keptLines.length) blocks += 1;
+  });
+  if (sawHeader) return blocks;
+  const rows = keptLines.filter((line) => line && !/^(?:#|--$|\[|\.\.\.|…|\()/.test(line));
+  return mode === 'content' ? rows.filter((line) => _GREP_MATCH_ROW_RE.test(line)).length : rows.length;
+}
+
+// Byte-cap marker for grep: the continuation is the offset of the first match
+// row not shown. A pattern/path fan-out has per-target offsets, so it gets
+// narrowing advice instead of a misleading global offset.
+function _grepBudgetFooter(args, keptLines, capBytes) {
+  const fanout = keptLines.some((line) => line.startsWith('# grep '));
+  const baseOffset =
+    Number.isFinite(Number(args?.offset)) && Number(args.offset) > 0 ? Math.floor(Number(args.offset)) : 0;
+  const shown = _grepShownEntries(keptLines, args?.mode);
+  // Every mode orders the whole result set before `offset` slices it (files
+  // and count pages are sorted first, then cut), so the rows kept here are a
+  // prefix of the offset order and offset resumes right after them.
+  let narrow = '';
+  if (fanout) narrow = 'run one pattern/path per call, or add path/glob/type to cut the match set';
+  else if (shown === 0) narrow = 'one match row exceeds the cap; read that file window or use a tighter pattern';
+  return capMarker({
+    limit: capBytes,
+    shown: `${shown} match row(s) shown`,
+    nextOffset: fanout || shown === 0 ? null : baseOffset + shown,
+    narrow,
+  });
+}
+
 function _locatorBudgetFooter(toolName, args, keptLines, capBytes) {
   const targets = _locatorTargets(toolName, args);
   const header = new RegExp(`^# ${toolName} (.+)$`);
@@ -358,17 +399,24 @@ function _locatorBudgetFooter(toolName, args, keptLines, capBytes) {
   }
   const target = targets[targetIndex] || targets[0] || '';
   const remaining = targets.length - targetIndex - 1;
-  const capKb = Math.round((Number(capBytes) > 0 ? Number(capBytes) : LOCATOR_OUTPUT_MAX_BYTES) / 1024);
-  // Factual continuation only — no retry imperatives: the marker states
-  // what was cut, never instructs another call.
+  const limit = Number(capBytes) > 0 ? Number(capBytes) : LOCATOR_OUTPUT_MAX_BYTES;
   const nextTarget =
     remaining > 0 ? `; ${remaining} target(s) not shown, next=${JSON.stringify(targets[targetIndex + 1])}` : '';
   if (toolName === 'find') {
-    return `... [find output capped at ${capKb} KB; remaining matches for query=${JSON.stringify(target)} omitted${nextTarget}]`;
+    // find has no offset: the rest of the ranked matches needs a tighter query.
+    return capMarker({
+      limit,
+      shown: `matches for query=${JSON.stringify(target)} cut${nextTarget}`,
+      narrow: 'use a more specific query or add path',
+    });
   }
   const baseOffset =
     Number.isFinite(Number(args?.offset)) && Number(args.offset) > 0 ? Math.floor(Number(args.offset)) : 0;
-  return `... [${toolName} output capped at ${capKb} KB; rows above are complete; continue path=${JSON.stringify(target)} offset:${baseOffset + visibleEntries}${nextTarget}]`;
+  return capMarker({
+    limit,
+    shown: `${visibleEntries} complete row(s) shown for path=${JSON.stringify(target)}${nextTarget}`,
+    nextOffset: baseOffset + visibleEntries,
+  });
 }
 
 export async function executeBuiltinTool(name, args, cwd, options = {}) {
@@ -489,11 +537,7 @@ function _budgetBuiltinOutput(toolName, args, result, options) {
   const explicitCap = Number(options?.toolOutputMaxBytes) > 0 ? Math.trunc(Number(options.toolOutputMaxBytes)) : null;
   if (toolName === 'grep') {
     const grepCap = explicitCap ? Math.min(explicitCap, GREP_OUTPUT_MAX_BYTES) : GREP_OUTPUT_MAX_BYTES;
-    return capLineOrientedToolOutput(
-      result,
-      grepCap,
-      (kept) => `[grep output capped at ${grepCap} bytes; ${kept.length} line(s) shown, remainder omitted]`
-    );
+    return capLineOrientedToolOutput(result, grepCap, (kept) => _grepBudgetFooter(args, kept, grepCap));
   }
   if (_LOCATOR_BUDGET_TOOLS.has(toolName)) {
     const locatorCap = explicitCap ? Math.min(explicitCap, LOCATOR_OUTPUT_MAX_BYTES) : LOCATOR_OUTPUT_MAX_BYTES;

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

@@ -172,9 +172,10 @@ async function _validateDiskCodeGraphHit({
   return { graph, manifest, signature };
 }
 
-// Owns a pre-acquired slot until a validated miss hands it to spawnWorker.
-// Keeping this seam dependency-injectable makes slot/abort behavior testable
-// without spawning native processes or Worker threads.
+// Validates the disk graph under a read-only query slot; a miss releases it
+// and spawnWorker queues for a build slot, so queries never wait behind
+// builds. Keeping this seam dependency-injectable makes slot/abort behavior
+// testable without spawning native processes or Worker threads.
 export async function _runDiskCodeGraphFastPath({
   graphCwd,
   diskProbe,
@@ -182,36 +183,31 @@ export async function _runDiskCodeGraphFastPath({
   signal = null,
   loadDiskEntry,
   consumeDirty = () => {},
-  // Long-lived code-graph lane so a cold graph build never blocks short rg
-  // processes in the independent search lane.
-  acquireSlot = (signal) => acquireChildSpawnSlot(signal, 'code-graph'),
+  acquireSlot = (signal) => acquireChildSpawnSlot(signal, 'code-graph-query'),
   validateDiskHit = _validateDiskCodeGraphHit,
   spawnWorker,
   maxFiles = CODE_GRAPH_MAX_FILES,
 }) {
   if (!diskProbe?.isFastPathEligible || diskProbe.maxFiles !== maxFiles) {
-    return spawnWorker(null, null, null);
+    return spawnWorker(null, null);
   }
   const diskEntry = loadDiskEntry();
   if (!_isCompatibleDiskCodeGraphEntry(diskEntry, maxFiles)) {
-    return spawnWorker(null, null, null);
+    return spawnWorker(null, null);
   }
   consumeDirty();
   const release = await acquireSlot(signal || null);
-  let handedToWorker = false;
+  let hit;
   try {
     _throwIfAborted(signal);
-    const hit = await validateDiskHit({ graphCwd, diskEntry, genAtStart, signal });
-    _throwIfAborted(signal);
-    if (hit?.invalidated) throw codeGraphBuildInvalidatedError(hit.graph);
-    if (hit?.graph) return hit.graph;
-    _throwIfAborted(signal);
-    const workerPromise = spawnWorker(release, hit?.manifest || null, hit?.signature || null);
-    handedToWorker = true;
-    return workerPromise;
+    hit = await validateDiskHit({ graphCwd, diskEntry, genAtStart, signal });
   } finally {
-    if (!handedToWorker) release();
+    release();
   }
+  _throwIfAborted(signal);
+  if (hit?.invalidated) throw codeGraphBuildInvalidatedError(hit.graph);
+  if (hit?.graph) return hit.graph;
+  return spawnWorker(hit?.manifest || null, hit?.signature || null);
 }
 
 function _prepareDiskCodeGraphFastPath({
@@ -306,8 +302,10 @@ export async function buildCodeGraphAsync(
   const existing = _inflightAsyncBuilds.get(inflightKey);
   if (existing) return raceAbort(existing, signal);
   // Non-competing prewarm: the signature-validation manifest also needs a
-  // child-spawn slot, so warmers skip before either it or a Worker can queue.
-  if (bestEffort && !childSpawnHasSpareCapacity('code-graph')) return null;
+  // query slot and a miss a build slot, so warmers skip before either queues.
+  if (bestEffort && !(childSpawnHasSpareCapacity('code-graph-query') && childSpawnHasSpareCapacity('code-graph'))) {
+    return null;
+  }
   const promise = _retryCodeGraphBuildAfterInvalidation(
     async () => {
       const genAtStart = _getCodeGraphGen(graphCwd);
@@ -315,7 +313,7 @@ export async function buildCodeGraphAsync(
       // bounded I/O. Do not run a manifest at all when no disk candidate exists:
       // cold/dirty misses remain entirely on the existing Worker path.
       if (scoped) {
-        return _spawnCodeGraphWorker(cwd, graphCwd, genAtStart, signal, null, null, null, {
+        return _spawnCodeGraphWorker(cwd, graphCwd, genAtStart, signal, null, null, {
           buildOptions: scopeOptions,
           cacheResult: false,
         });
@@ -330,8 +328,8 @@ export async function buildCodeGraphAsync(
             signal,
             loadDiskEntry: () => getDiskCodeGraphEntry(graphCwd),
             consumeDirty: () => _consumeCodeGraphDirtyPaths(graphCwd),
-            spawnWorker: (preAcquiredRelease, manifest, signature) =>
-              _spawnCodeGraphWorker(cwd, graphCwd, genAtStart, signal, preAcquiredRelease, manifest, signature),
+            spawnWorker: (manifest, signature) =>
+              _spawnCodeGraphWorker(cwd, graphCwd, genAtStart, signal, manifest, signature),
           }),
       });
     },
@@ -350,7 +348,6 @@ export function _spawnCodeGraphWorker(
   graphCwd,
   genAtStart,
   signal,
-  preAcquiredRelease = null,
   manifest = null,
   signature = null,
   {
@@ -416,10 +413,7 @@ export function _spawnCodeGraphWorker(
         /* best-effort */
       }
     };
-    (preAcquiredRelease
-      ? Promise.resolve(preAcquiredRelease)
-      : acquireChildSpawnSlot(signal || null, 'code-graph')
-    ).then((release) => {
+    acquireChildSpawnSlot(signal || null, 'code-graph').then((release) => {
       _releaseSlot = release;
       if (settled) {
         release();

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

@@ -14,7 +14,7 @@ import { resolve as pathResolve, isAbsolute, relative as pathRelative, dirname a
 import { normalizeInputPath } from '../builtin/path-utils.mjs';
 import { markScopedCacheIncomplete, recordScopedCacheDependency } from '../../session/cache/scoped-cache-outcome.mjs';
 import { CODE_GRAPH_TOOL_DEFS } from '../code-graph-tool-defs.mjs';
-import { CODE_GRAPH_OUTPUT_MAX_BYTES, capLineOrientedToolOutput } from '../builtin/tool-output-limit.mjs';
+import { CODE_GRAPH_OUTPUT_MAX_BYTES, capLineOrientedToolOutput, capMarker } from '../builtin/tool-output-limit.mjs';
 import { _graphRel, _appendSameBasenameHint, _isExistingFile } from './source-access.mjs';
 import {
   _capGraphList,
@@ -375,7 +375,6 @@ async function executeCodeGraphToolRaw(name, rawArgs, cwd, signal = null, option
 
 function _codeGraphBudgetFooter(args, keptLines) {
   const rawMode = String(args?.mode || '').trim();
-  const capKb = Math.round(CODE_GRAPH_OUTPUT_MAX_BYTES / 1024);
   const targets = collectGraphSymbolList(args);
   const files = _collectGraphFileList(args);
   const batchTargets = targets.length ? targets : files;
@@ -389,13 +388,18 @@ function _codeGraphBudgetFooter(args, keptLines) {
       const index = batchTargets.indexOf(match[1]);
       if (index >= 0) currentIndex = index;
     }
-    return `... [code_graph output capped at ${capKb} KB; not fully shown: ${label}=${JSON.stringify(batchTargets.slice(currentIndex))}]`;
+    return capMarker({
+      limit: CODE_GRAPH_OUTPUT_MAX_BYTES,
+      shown: `${label} from index ${currentIndex} not fully shown`,
+      narrow: `re-query ${label}=${JSON.stringify(batchTargets.slice(currentIndex))} separately`,
+    });
   }
   const target = batchTargets[0];
-  const targetTail = target
-    ? `; remainder for ${label.slice(0, -1)}=${JSON.stringify(target)} omitted`
-    : '; remainder omitted';
-  return `... [code_graph output capped at ${capKb} KB${targetTail}]`;
+  return capMarker({
+    limit: CODE_GRAPH_OUTPUT_MAX_BYTES,
+    shown: target ? `remainder for ${label.slice(0, -1)}=${JSON.stringify(target)} omitted` : 'remainder omitted',
+    narrow: 'add file/path scope, a narrower mode, or a smaller depth/limit',
+  });
 }
 
 export async function executeCodeGraphTool(name, args, cwd, signal = null, options = {}) {

package/src/runtime/agent/orchestrator/tools/destructive-warning.mjs

@@ -9,12 +9,111 @@
 import { SHELL_NAMES as _SHELL_NAMES, WRAPPER_NAMES as _WRAPPER_NAMES } from './shell-policy.mjs';
 import { extractPowerShellCommandInner } from './shell-powershell.mjs';
 
+// A `#` (or PowerShell `<#`) starts a comment only at the start of a word:
+// line start, after whitespace, or after a command operator. Inside a word or
+// URL (`a#b`, `http://x/#y`, `$#`, `${#v}`) it is an ordinary character.
+function _isCommentStart(text, i) {
+  return i === 0 || /[\s;&|(]/.test(text[i - 1]);
+}
+
+const _PS_HERE_SQ = /@'[ \t]*\r?\n[\s\S]*?\r?\n'@/y;
+const _PS_HERE_DQ = /@"[ \t]*\r?\n[\s\S]*?\r?\n"@/y;
+const _HEREDOC_START = /<<-?\s*['"]?(\w+)['"]?/y;
+
+function _closingQuote(text, from, quote, escapes) {
+  let j = from;
+  while (j < text.length && text[j] !== quote) j += escapes && text[j] === '\\' ? 2 : 1;
+  return j < text.length ? j : -1;
+}
+
+// Single left-to-right scan so each construct is recognised by what the shell
+// would see at that position (a `'` inside a comment, a `#` inside a word or a
+// quote inside a here-string never mis-pair later delimiters). Any construct
+// that cannot be closed (unterminated quote, `<#` without `#>`, heredoc without
+// terminator) is left in the output verbatim, so uncertain text stays visible
+// to the policy checks instead of being dropped.
 export function stripQuotedAndHeredoc(s) {
-  return String(s || '')
-    .replace(/<<-?\s*['"]?(\w+)['"]?[\s\S]*?\n\1\b/g, '<<HEREDOC>>')
-    .replace(/'[^']*'/g, "''")
-    .replace(/"(?:[^"\\]|\\.)*"/g, '""')
-    .replace(/#[^\n]*/g, '');
+  const text = String(s || '');
+  const n = text.length;
+  const pendingHeredocs = [];
+  let out = '';
+  let i = 0;
+  while (i < n) {
+    const ch = text[i];
+    if (ch === '\\') {
+      out += text.slice(i, i + 2);
+      i += 2;
+      continue;
+    }
+    if (ch === '@' && (text[i + 1] === "'" || text[i + 1] === '"')) {
+      const re = text[i + 1] === "'" ? _PS_HERE_SQ : _PS_HERE_DQ;
+      re.lastIndex = i;
+      const m = re.exec(text);
+      if (m) {
+        out += text[i + 1] === "'" ? "''" : '""';
+        i += m[0].length;
+        continue;
+      }
+    }
+    if (ch === '<' && text[i + 1] === '<' && text[i - 1] !== '<') {
+      _HEREDOC_START.lastIndex = i;
+      const m = _HEREDOC_START.exec(text);
+      if (m && new RegExp(`\\n${m[1]}\\b`).test(text.slice(i + m[0].length))) {
+        // The rest of the opening line stays visible; the body is skipped at
+        // the next newline.
+        pendingHeredocs.push(m[1]);
+        out += '<<HEREDOC>>';
+        i += m[0].length;
+        continue;
+      }
+    }
+    if (ch === '<' && text[i + 1] === '#' && _isCommentStart(text, i)) {
+      const end = text.indexOf('#>', i + 2);
+      if (end >= 0) {
+        out += ' ';
+        i = end + 2;
+        continue;
+      }
+    }
+    if (ch === '#' && _isCommentStart(text, i)) {
+      const nl = text.indexOf('\n', i);
+      i = nl < 0 ? n : nl;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || (ch === '$' && text[i + 1] === "'")) {
+      const ansiC = ch === '$';
+      const quote = ansiC ? "'" : ch;
+      const open = ansiC ? i + 2 : i + 1;
+      const close = _closingQuote(text, open, quote, ch !== "'");
+      if (close >= 0) {
+        out += (ansiC ? '$' : '') + quote + quote;
+        i = close + 1;
+        continue;
+      }
+    }
+    if (ch === '\n' && pendingHeredocs.length) {
+      let at = i;
+      let found = true;
+      for (const delimiter of pendingHeredocs) {
+        const re = new RegExp(`\\n${delimiter}\\b`, 'g');
+        re.lastIndex = at;
+        const m = re.exec(text);
+        if (!m) {
+          found = false;
+          break;
+        }
+        at = m.index + m[0].length;
+      }
+      pendingHeredocs.length = 0;
+      if (found) {
+        i = at;
+        continue;
+      }
+    }
+    out += ch;
+    i++;
+  }
+  return out;
 }
 
 // Heredoc bodies (shell-exec contexts route the body through scanning).
@@ -37,8 +136,11 @@ function _tokenize(s) {
     if (c === "'") {
       const e = src.indexOf("'", i + 1);
       if (e === -1) {
-        cur += src.slice(i);
-        break;
+        // Unterminated: an apostrophe inside a PowerShell word is literal, so
+        // keep tokenizing instead of swallowing the rest of the command.
+        cur += c;
+        i++;
+        continue;
       }
       cur += src.slice(i, e + 1);
       i = e + 1;
@@ -55,8 +157,9 @@ function _tokenize(s) {
         j++;
       }
       if (j >= src.length) {
-        cur += src.slice(i);
-        break;
+        cur += c;
+        i++;
+        continue;
       }
       cur += src.slice(i, j + 1);
       i = j + 1;
@@ -67,6 +170,20 @@ function _tokenize(s) {
       i += 2;
       continue;
     }
+    // `cur` is empty exactly at a word start (after whitespace or an operator),
+    // the only place `#` / PowerShell `<#` begins a comment.
+    if (!cur && c === '#') {
+      const nl = src.indexOf('\n', i);
+      i = nl < 0 ? src.length : nl;
+      continue;
+    }
+    if (!cur && c === '<' && src[i + 1] === '#') {
+      const end = src.indexOf('#>', i + 2);
+      if (end >= 0) {
+        i = end + 2;
+        continue;
+      }
+    }
     if (c === ' ' || c === '\t') {
       if (cur) {
         t.push(cur);

package/src/runtime/agent/orchestrator/tools/graph-manifest.json

@@ -1,30 +1,30 @@
 {
-  "version": "0.1.32",
+  "version": "0.1.33",
   "_comment": "Synced from immutable graph-v release assets.",
   "assets": {
     "darwin-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.32/mixdog-graph-darwin-arm64",
-      "sha256": "e4efda42c8fac65f4ba7da894ad0679cbb541069470633ccf5e9752c9fac680e"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.33/mixdog-graph-darwin-arm64",
+      "sha256": "8637d61493eddca3eee80620a64e737f12eead44ea899ad19a18966a3843ff3a"
     },
     "darwin-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.32/mixdog-graph-darwin-x64",
-      "sha256": "9b6cc73185a0b3a59a1279727fc92b8674fc0f7b7519b28a5e75f26926802de8"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.33/mixdog-graph-darwin-x64",
+      "sha256": "49ce311687c3df7e7080ecb7694219c9b51bbbb272864aa43d2102a8baa83550"
     },
     "linux-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.32/mixdog-graph-linux-arm64",
-      "sha256": "373522940be2e261bf7f4de3ad226d1e68d73ef1efe95307525b2f867322e722"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.33/mixdog-graph-linux-arm64",
+      "sha256": "2e2a4ea6dccc5b33f583040b0ee6e8d47f93a1e879eb17343acd0b2f9838696f"
     },
     "linux-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.32/mixdog-graph-linux-x64",
-      "sha256": "ae8dce99b93c31f5e9f5c5f510dafdc035896fb7faf1e04b5fb603e182a21525"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.33/mixdog-graph-linux-x64",
+      "sha256": "2cd1caa7f39e183d6fb6f7764f49e9a0643863d137c2bfb5f40bb7ac616c8d73"
     },
     "win32-arm64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.32/mixdog-graph-win32-arm64.exe",
-      "sha256": "077012187e7a48c6cea8b7e5cdcfd567e518239078a247a6062c32562a76658c"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.33/mixdog-graph-win32-arm64.exe",
+      "sha256": "592dfa7e95e1e91424c7467e74f35d09758de502be403b7d229444b435600392"
     },
     "win32-x64": {
-      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.32/mixdog-graph-win32-x64.exe",
-      "sha256": "9a449f632ea6f5c6f08feb158a6bbf7f829a3d7731e36821d1dbc042ab69bf48"
+      "url": "https://github.com/tribgames/mixdog/releases/download/graph-v0.1.33/mixdog-graph-win32-x64.exe",
+      "sha256": "0ed17859a39f0160421865f3a3486ce53957b836ee164d606434519b85b90830"
     }
   }
 }

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

@@ -27,14 +27,14 @@ export function unregisterOwnedShellTree(jobId, entry) {
   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();
+/** Prepare the kill of every registered tree — of one owner, or of all when
+ *  `ownerSessionId` is null (runtime shutdown) — and unregister them. Returns
+ *  the snapshots still pending (empty when all were complete). */
+export function prepareOwnedShellTreeKills(ownerSessionId = null) {
+  const owner = ownerSessionId == null ? null : String(ownerSessionId).trim();
   const pending = [];
   for (const [jobId, entry] of [...ownedTrees]) {
-    if (String(entry.ownerSessionId || '') !== owner) continue;
+    if (owner !== null && String(entry.ownerSessionId || '') !== owner) continue;
     let ready;
     try {
       ready = entry.prepareKill();
@@ -44,6 +44,15 @@ export function cancelOwnedShellTrees(ownerSessionId) {
     if (ready !== true) pending.push(Promise.resolve(ready).catch(() => false));
     unregisterOwnedShellTree(jobId, entry);
   }
+  return pending;
+}
+
+/** 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 = prepareOwnedShellTreeKills(owner);
   if (pending.length === 0) return cancelNativeTasks({ ownerSessionId: owner });
   let result = null;
   const send = () => {

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

@@ -32,6 +32,9 @@ export const TERMINATION_RECHECK_MS = 5_000;
 // read is not abandoned — a snapshot that lands later is still absorbed.
 export const PROCESS_TABLE_READ_BOUND_MS = 2_000;
 
+// Kill-and-observe rounds of a survivor kill before it reports what is left.
+const KILL_ROUNDS = 3;
+
 /** Resolve `promise`'s value, or `onTimeout` once `ms` elapse first. The
  *  bound's timer is cleared whichever side wins. */
 export function withinBound(promise, ms, onTimeout) {
@@ -169,13 +172,30 @@ export function createProcessTreeTracker({ pid, members = [], exitObserved = fal
   };
 }
 
+/** Terminate every identity the last observation found alive (console hosts
+ *  excepted: they are witnesses, never workers). These are processes of a tree
+ *  that was KILLED — they escaped its process group (setsid, job control, a
+ *  double fork that kept its parent link) or outlived the root on Windows —
+ *  so the kill is not finished while they run. Windows: taskkill /T /F;
+ *  POSIX: SIGTERM, then SIGKILL after a short grace. */
+function sweepLiveIdentities(tracker) {
+  const targets = tracker.live
+    .filter((entry) => entry.token != null && !CONSOLE_HOST.test(entry.name))
+    .map((entry) => entry.pid);
+  return targets.length > 0 ? killProcessTrees(targets) : Promise.resolve();
+}
+
 /** One observation loop: observe now, then every `intervalMs` until the tree
  *  is confirmed gone, then run `onTerminated` once. 'running', 'unknown', a
  *  failed or unanswered (by the next cadence tick) observation and a failing
  *  `onTerminated` all re-check on the same cadence; the first pass that is not
  *  'gone' calls `onUnconfirmed` once. The returned stop() clears the pending
  *  timer; nothing else (listener, timer) outlives the loop. Nothing in it ever
- *  releases on time alone. */
+ *  releases on time alone.
+ *
+ *  `sweep` (a killed tree): a pass that finds captured identities alive
+ *  terminates them and observes again in the same pass, so a cancellation
+ *  ends with the tree gone instead of a held folder over live processes. */
 export function watchTermination({
   tracker,
   rootExited = () => true,
@@ -183,6 +203,7 @@ export function watchTermination({
   onUnconfirmed = null,
   releaseRequested = null,
   intervalMs = TERMINATION_RECHECK_MS,
+  sweep = false,
 }) {
   let timer = null;
   let stopped = false;
@@ -206,6 +227,17 @@ export function watchTermination({
         observation.catch(() => {});
         // A pass that has not answered by the next cadence tick is unknown.
         state = await withinBound(observation, intervalMs, 'unknown');
+        if (state === 'running' && sweep && !stopped) {
+          await withinBound(
+            sweepLiveIdentities(tracker).catch(() => {}),
+            intervalMs,
+            null
+          );
+          await observation.catch(() => {});
+          observation = tracker.observe({ rootExited: rootExited() });
+          observation.catch(() => {});
+          state = await withinBound(observation, intervalMs, 'unknown');
+        }
       } catch {
         state = 'unknown';
       }
@@ -365,7 +397,13 @@ export async function killShellDescendants(handle) {
       .map((entry) => entry.pid);
     await killProcessTrees(targets).catch(() => {});
     const tracker = trackerFor(handle);
-    const state = await tracker.observe({ rootExited: true });
+    let state = await tracker.observe({ rootExited: true });
+    // What the first kill missed (a child forked meanwhile, a slow exit) is
+    // found by the re-observation itself and killed in the next round.
+    for (let round = 1; state === 'running' && round < KILL_ROUNDS; round += 1) {
+      await sweepLiveIdentities(tracker).catch(() => {});
+      state = await tracker.observe({ rootExited: true });
+    }
     return { terminated: state === 'gone', survivors: tracker.live.map((entry) => entry.pid) };
   } catch {
     return { terminated: false, survivors: [...handle.watchPids] };

package/src/runtime/agent/orchestrator/tools/lib/shell-run-background/promote-job.mjs

@@ -75,8 +75,8 @@ export function killAfterFailedPromotion(run, reason, promotionFailure) {
 }
 
 /**
- * The promoted job leaves foreground admission: its lease is RELEASED, which
- * also restores the parent's high-load share. A long-lived server must never
+ * The promoted job leaves foreground admission: its lease is RELEASED. A
+ * long-lived server must never
  * hold a foreground slot for its whole life; background jobs are not counted
  * against any cap (session/runtime close stops them via shutdownShellJobs).
  */

package/src/runtime/agent/orchestrator/tools/lib/shell-run-background/promotion-results.mjs

@@ -13,7 +13,18 @@ import {
 } from '../shell-run-state.mjs';
 
 const BACKGROUND_GUIDANCE =
-  'Completion arrives automatically; call task wait (not task read polling) when the result is due.';
+  'Its result is delivered automatically when it finishes; use task wait only if you need it now.';
+
+function backgroundVerb(reason, secs) {
+  if (reason === 'timeout') return `moved to background at timeout after ${secs}s`;
+  if (reason === 'input') return `moved to background on new user input after ${secs}s`;
+  if (reason === 'notification') {
+    return `moved to background after ${secs}s because a notification arrived (delivered to you now)`;
+  }
+  if (reason === 'interrupt') return `moved to background on interrupt after ${secs}s`;
+  if (reason === 'background') return 'started in the background';
+  return `moved to background after the ${secs}s hold`;
+}
 
 export function promotedSpillPaths(taskOutput) {
   return {
@@ -89,8 +100,7 @@ export function resolveBackgrounded(run, { jobId, reason, remainingBackgroundTim
   // frame alive and could later kill an unrelated, already-returned job.
   detachAbortHandler(run);
   const secs = Math.max(0, Math.round(elapsedSinceStart(run) / 1000));
-  const verb =
-    reason === 'timeout' ? `moved to background at timeout after ${secs}s` : `auto-backgrounded after ${secs}s`;
+  const verb = backgroundVerb(reason, secs);
   run.resolveResult(
     new ExecResult({
       ...capturedFields(run, capture),

package/src/runtime/agent/orchestrator/tools/lib/shell-run-settle.mjs

@@ -56,6 +56,8 @@ export function releaseAdmissionOnConfirmedTermination(run, { markNow = true } =
   run.stopTerminationWatch = watchTermination({
     tracker: run.terminationTracker,
     rootExited: () => child.exitCode != null || child.signalCode != null,
+    // A killed run is not over while processes it started still run.
+    sweep: run.killed === true,
     onTerminated: release,
     onUnconfirmed: markNow ? null : () => keepTerminationUnconfirmedRecord(run),
     releaseRequested: () => takeReleaseRequest(run.foregroundRecordId),

package/src/runtime/agent/orchestrator/tools/lib/shell-run-state.mjs

@@ -30,7 +30,9 @@ export function registerForegroundOwnedTree(run, ownerSessionId) {
       run.killed = true;
       run.ownerCancelled = true;
       run.killCause = run.killCause || 'session-close';
-      return run.terminationTracker?.complete === true || capturePreKill(run);
+      // Always a fresh read: an earlier one predates what the run started
+      // since. Pending, the kill is sent at the snapshot bound regardless.
+      return capturePreKill(run);
     },
   };
   registerOwnedShellTree(run.foregroundRecordId, run.ownedTree);

package/src/runtime/agent/orchestrator/tools/patch/v4a-convert.mjs

@@ -829,7 +829,7 @@ function unifiedUpdateHunks(sourceLines, section, displayPath, { fuzzy, rejectPa
     const loc = resolveV4AHunkPosition(sourceLines, hunk, nextSearchLine, { fuzzy });
     if (loc.skip) continue;
     if (loc.error) {
-      const msg = `${loc.error.replace(/^V4A hunk /, `V4A hunk ${section.path}: `)}`;
+      const msg = `${loc.error.replace(/^V4A hunk /, () => `V4A hunk ${section.path}: `)}`;
       if (rejectPartial) throw new Error(msg);
       if (rejectedHunks) rejectedHunks.push({ file: section.path, hunk, reason: msg });
       continue;