mixdog 1.2.5 → 1.2.6

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/backgrounded-result.mjs

@@ -7,7 +7,7 @@ import { cleanupArtifactOnTaskSettled, consumeTeeArtifact } from './transport-ar
 import { _backgroundResultLines, _prependDestructiveWarning } from './result-format.mjs';
 
 const DEFAULT_BACKGROUND_MESSAGE =
-  'auto-backgrounded; still running — judge from the partial output whether waiting can finish in budget, or diagnose and pursue an alternative.';
+  'moved to background; still running. Its result is delivered automatically when it finishes.';
 
 // The label and owner context every task registered for a shell command
 // carries, whether promoted or tracking survivors.
@@ -73,13 +73,19 @@ export function renderBackgroundedResult({ result, command, cwd, options, starte
   let taskBlock = null;
   if (task) taskBlock = renderBackgroundTask(task, { ownerTool: true });
   else if (result.jobId) taskBlock = `[task_id: ${result.jobId}]`;
+  // The output so far in the shared delivery shape, with the progress digest;
+  // the task cursor then starts after it, so nothing here is sent again.
   const partialOutput = task
-    ? readShellTaskOutput(task, {
-        stdout_path: result.stdoutPath,
-        stderr_path: result.stderrPath,
-        stdout_preview: stdout,
-        stderr_preview: stderr,
-      })
+    ? readShellTaskOutput(
+        task,
+        {
+          stdout_path: result.stdoutPath,
+          stderr_path: result.stderrPath,
+          stdout_preview: stdout,
+          stderr_preview: stderr,
+        },
+        { digest: true }
+      )
     : renderBackgroundPartialOutput(stdout, stderr);
   const lines = _backgroundResultLines({
     taskBlock,

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/bashism-rewrite.mjs

@@ -23,7 +23,7 @@ const HEREDOC_OPENER = /^<<-?[ \t]*(?:'([A-Za-z_]\w*)'|"([A-Za-z_]\w*)"|([A-Za-z
 /** Marks each character 1 when it is live PowerShell code and 0 when it sits in a
  *  string, here-string, comment or after a backtick. null when the text cannot be
  *  tokenised with confidence (unterminated string, `$(` inside a double quote). */
-function codeMask(text) {
+export function codeMask(text) {
   const mask = new Uint8Array(text.length);
   // Bash heredoc bodies start on the line after their `<<DELIM` opener and are
   // opaque text (quotes inside them must not be tokenised).

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/benign-exit.mjs

@@ -45,7 +45,13 @@ function _stripShellComment(text) {
       out += ch;
       continue;
     }
-    if (ch === '#' && (i === 0 || /\s/.test(text[i - 1]))) break;
+    if (ch === '#' && (i === 0 || /[\s;&|(]/.test(text[i - 1]))) {
+      // A comment ends at the newline; later lines are still live commands.
+      const nl = text.indexOf('\n', i);
+      if (nl < 0) break;
+      i = nl - 1;
+      continue;
+    }
     out += ch;
   }
   return out;

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/completed-result.mjs

@@ -4,6 +4,8 @@ import { releaseShellJobWorkspace } from '../lib/shell-job-records.mjs';
 import { consumeFilterTeeCapture } from '../shell-analysis.mjs';
 import { compactShellOutputLosslessly, renderShellOutputBody } from '../shell-lossless-compact.mjs';
 import { removeTransportFileNow } from './transport-artifacts.mjs';
+import { DELIVERY_FULL_CHARS, EMPTY_PIECE, fitPieces, shellTextPiece } from '../lib/shell-delivery.mjs';
+import { shellLogPiece } from '../lib/shell-task-output.mjs';
 import { shellTaskIdentity } from './backgrounded-result.mjs';
 import { _isBenignSearchExitOne } from './benign-exit.mjs';
 import {
@@ -24,7 +26,7 @@ import {
 function trackSurvivingDescendants(handle, { command, cwd, options, startedAtMs } = {}) {
   if (!handle?.taskId) return null;
   try {
-    return startBackgroundTask({
+    const task = startBackgroundTask({
       taskId: handle.taskId,
       startedAtMs: startedAtMs || Date.now(),
       surface: 'shell',
@@ -44,10 +46,15 @@ function trackSurvivingDescendants(handle, { command, cwd, options, startedAtMs
           detail: 'every process the command left running has exited',
         };
       },
+      // The kill's own re-observation is what `task cancel` reports.
       cancel: () => {
-        void killShellDescendants(handle);
+        task.cancelOutcome = killShellDescendants(handle);
       },
     });
+    // The command already returned its result; these processes are a side
+    // effect it left running, not work the agent is waiting on.
+    task.detached = true;
+    return task;
   } catch {
     return null;
   }
@@ -110,6 +117,20 @@ function classifyCompletion(result, timeout, analysisCommand) {
   };
 }
 
+// A spilled capture is rendered from its log (the in-memory string is already
+// a head+tail cut); an inline one from the captured text.
+function foregroundPiece(text, path, label) {
+  if (!text) return EMPTY_PIECE;
+  if (path) {
+    try {
+      return shellLogPiece(path);
+    } catch {
+      /* unreadable log: deliver the captured text */
+    }
+  }
+  return shellTextPiece(text, { label });
+}
+
 export function renderCompletedResult({
   result,
   command,
@@ -151,11 +172,23 @@ export function renderCompletedResult({
   // Without a boundary a stdout tail with no trailing newline glued itself
   // onto the first stderr line and corrupted both. No spill-path block: a
   // truncated stream already carries its own "full output at <path>" marker.
-  const payload = `${renderShellOutputBody(
-    losslessCompaction?.stdout ?? stdout,
-    losslessCompaction?.stderr ?? stderr,
-    losslessCompaction
-  )}${rescueNote}`;
+  // Each stream in the shared delivery shape: whole when short, else head,
+  // marker and tail, the marker naming the spill log (or a saved copy).
+  // A compacted stream goes through the same cap, its marker naming the
+  // stream's preserved full capture.
+  const streamPiece = (stream, text, logPath) => {
+    const compacted = losslessCompaction?.[stream];
+    if (compacted == null) return foregroundPiece(text, logPath, stream);
+    const archived = losslessCompaction.recovery?.find((item) => item.stream === stream)?.path;
+    return compacted ? shellTextPiece(compacted, { path: archived || null, label: stream }) : EMPTY_PIECE;
+  };
+  // Both streams share one delivery budget; the line break between them is
+  // taken off it.
+  const [outBody, errBody] = fitPieces(
+    [streamPiece('stdout', stdout, result.stdoutPath), streamPiece('stderr', stderr, result.stderrPath)],
+    DELIVERY_FULL_CHARS - 1
+  );
+  const payload = `${renderShellOutputBody(outBody, errBody, losslessCompaction)}${rescueNote}`;
   if (outcome.statusMarker) {
     const bashismHint = commandExitedNonzero || isReallyErrored ? _powershellBashismHint(analysisCommand, stderr) : '';
     const failure = _composeShellFailure(

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/deadline-plan.mjs

@@ -1,12 +1,14 @@
-// Commands start in the foreground. Only work still running after the
-// 10 s coordination budget is promoted to a tracked background task.
-// Short commands therefore complete in the original tool turn, while longer
-// work returns partial output plus task_id and finishes by notification.
-// A per-call wait_ms may stretch the window for a command whose result should
-// return in the same call, never past 30 s, so the conversation is never held
-// open long; anything longer finishes by notification.
-export const DEFAULT_SHELL_AUTO_BACKGROUND_MS = 10_000;
-export const MAX_SHELL_WAIT_MS = 30_000;
+// Commands start in the foreground and hold the call for the shell hold
+// (wait-budgets.mjs). Only work still running when the hold ends — or when new
+// user input ends it early — moves to a tracked background task, returning
+// partial output plus task_id and finishing by notification. A per-call
+// wait_ms picks a different hold, clamped to the published range.
+import { SHELL_HOLD_DEFAULT_MS, SHELL_HOLD_MAX_MS, SHELL_HOLD_MIN_MS } from '../wait-budgets.mjs';
+
+export const DEFAULT_SHELL_AUTO_BACKGROUND_MS = SHELL_HOLD_DEFAULT_MS;
+// The hold of an explicit background start: long enough for the child to be
+// spawned and promoted, short enough to return at once.
+const BACKGROUND_START_HOLD_MS = 1;
 
 // JS timers (setTimeout) and PS WaitForExit(ms) are 32-bit: a delay above
 // 2^31-1 wraps to a tiny/negative value and fires immediately. Clamp the
@@ -15,26 +17,25 @@ export const MAX_SHELL_WAIT_MS = 30_000;
 // per-site guards.
 const TIMER_MAX_MS = 2_147_483_647;
 
-// Main-agent blocking budget. A timeout is the command's total deadline, not
-// permission to hold the conversation open for that whole duration: after
-// 10 s a still-running command becomes a tracked background task and
-// completion is pushed to the owner. MIXDOG_SHELL_AUTO_BACKGROUND_MS
-// overrides; an explicit 0 disables. Gated on backgroundOnTimeout so
-// disabled background tasks remain foreground.
-// A per-call wait_ms extends that default for the call, capped by
-// MAX_SHELL_WAIT_MS and the foreground maximum; it never shortens it. A
-// shorter window promotes a command that would have returned its result in
-// the starting call and spends a whole follow-up request on `task wait`.
-function autoBackgroundBudget(backgroundOnTimeout, timeout, waitMs, maxForegroundMs) {
+// The shell hold. A timeout is the command's total deadline, not permission to
+// hold the conversation open for that whole duration: when the hold ends a
+// still-running command becomes a tracked background task and completion is
+// pushed to the owner. MIXDOG_SHELL_AUTO_BACKGROUND_MS overrides the default;
+// an explicit 0 disables it. A per-call wait_ms replaces the hold for that
+// call, clamped to SHELL_HOLD_MIN_MS..SHELL_HOLD_MAX_MS. Gated on
+// backgroundOnTimeout so disabled background tasks remain foreground.
+function shellHoldMs(waitMs) {
+  if (waitMs > 0) return Math.min(SHELL_HOLD_MAX_MS, Math.max(SHELL_HOLD_MIN_MS, Math.floor(waitMs)));
   const raw = process.env.MIXDOG_SHELL_AUTO_BACKGROUND_MS;
   const parsed = Number(raw);
-  let defaultMs =
-    raw != null && String(raw).trim() !== '' && Number.isFinite(parsed) && parsed >= 0
-      ? Math.floor(parsed)
-      : DEFAULT_SHELL_AUTO_BACKGROUND_MS;
-  if (waitMs > 0) defaultMs = Math.max(defaultMs, Math.min(waitMs, MAX_SHELL_WAIT_MS, maxForegroundMs));
-  if (!backgroundOnTimeout || defaultMs <= 0) return 0;
-  return timeout > 0 ? Math.min(defaultMs, timeout) : defaultMs;
+  return raw != null && String(raw).trim() !== '' && Number.isFinite(parsed) && parsed >= 0
+    ? Math.floor(parsed)
+    : SHELL_HOLD_DEFAULT_MS;
+}
+
+function autoBackgroundBudget(backgroundOnTimeout, timeout, holdMs) {
+  if (!backgroundOnTimeout || holdMs <= 0) return 0;
+  return timeout > 0 ? Math.min(holdMs, timeout) : holdMs;
 }
 
 // Background safety net. An omitted timeout_ms means "no caller deadline",
@@ -55,7 +56,14 @@ function backgroundMaxBudget() {
 // timeout becomes the background deadline.
 export function planShellDeadlines({ args, wmicRewrite, backgroundOnTimeout }) {
   const envMaxTimeout = parseInt(process.env.BASH_MAX_TIMEOUT_MS ?? '', 10);
-  const maxForegroundMs = envMaxTimeout > 0 ? envMaxTimeout : 120_000;
+  // background:true (servers, watchers) skips the hold: the command moves to
+  // the background as soon as it is running.
+  const holdMs =
+    args.background === true
+      ? BACKGROUND_START_HOLD_MS
+      : shellHoldMs(typeof args.wait_ms === 'number' ? args.wait_ms : 0);
+  // The foreground cap never cuts the requested hold short.
+  const maxForegroundMs = Math.max(envMaxTimeout > 0 ? envMaxTimeout : 120_000, holdMs);
   const hasExplicitTimeout = typeof args.timeout_ms === 'number' && args.timeout_ms > 0;
   const timeoutMs = hasExplicitTimeout ? args.timeout_ms : 0;
   // A rewrite-supplied cap (wmic → Get-CimInstance, 30 s) is a HARD deadline
@@ -79,11 +87,6 @@ export function planShellDeadlines({ args, wmicRewrite, backgroundOnTimeout }) {
     // Soft/interrupt promotion happens before the foreground cap; an explicit
     // total deadline is preserved separately.
     backgroundDeadlineMs: hasHardDeadline ? totalTimeout : backgroundMaxBudget(),
-    autoBackgroundMs: autoBackgroundBudget(
-      backgroundOnTimeout,
-      timeout,
-      typeof args.wait_ms === 'number' ? args.wait_ms : 0,
-      maxForegroundMs
-    ),
+    autoBackgroundMs: autoBackgroundBudget(backgroundOnTimeout, timeout, holdMs),
   };
 }

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/inline-hoist.mjs

@@ -19,7 +19,7 @@ import {
 export function hoistInlineScript(command, shellType) {
   const transport = { platform: process.platform, shellType };
   const hoist =
-    planInlineScriptHoist(command) ||
+    planInlineScriptHoist(command, { shellType }) ||
     planLongInlineScriptFileTransport(command, transport) ||
     planLongShellScriptFileTransport(command, transport);
   if (!hoist) return { command, hoistPath: null };

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool/spawn-env.mjs

@@ -1,4 +1,3 @@
-import { resourceAdmission } from '../../../../../shared/resource-admission.mjs';
 import { withSkillLauncherPath } from '../../../../../shared/skill-script-runtime.mjs';
 import {
   applyShellEgressPolicy,
@@ -10,9 +9,6 @@ import {
 export function buildShellSpawnEnv(cwd, baseEnv = process.env) {
   const spawnEnv = {
     ...baseEnv,
-    // Lets fan-out-heavy children (the test runner) size themselves to their
-    // share of the machine: up to this many shells run concurrently.
-    MIXDOG_SHELL_CONCURRENCY_CAP: String(resourceAdmission.limits.maxShells),
     LANG: 'C.UTF-8',
     LC_ALL: 'C.UTF-8',
     MIXDOG_SESSION_CWD: String(cwd || ''),

package/src/runtime/agent/orchestrator/tools/builtin/bash-tool.mjs

@@ -14,6 +14,7 @@ import { invalidateBuiltinResultCache } from './cache-layers.mjs';
 import { formatShellToolFailure } from './bash-tool/result-format.mjs';
 import { cleanupArtifactOnTaskSettled, removeTransportFileNow } from './bash-tool/transport-artifacts.mjs';
 import { combineAbortSignals, sessionAbortSignal } from './bash-tool/abort-signals.mjs';
+import { beginInterruptibleTaskWait } from '../../session/task-wait-control.mjs';
 import { prepareShellCommand } from './bash-tool/command-preflight.mjs';
 import { hoistInlineScript } from './bash-tool/inline-hoist.mjs';
 import { planShellDeadlines } from './bash-tool/deadline-plan.mjs';
@@ -84,6 +85,8 @@ export async function executeBashTool(args, workDir, options = {}) {
   const deadlines = planShellDeadlines({ args, wmicRewrite, backgroundOnTimeout });
 
   let combinedAbort = null;
+  // New user input ends the hold early, the same wake `task wait` uses.
+  const inputWake = backgroundOnTimeout ? beginInterruptibleTaskWait(options?.sessionId) : null;
   let backgrounded = false;
   let backgroundJobId = null;
   let queuedSettled = null;
@@ -104,6 +107,8 @@ export async function executeBashTool(args, workDir, options = {}) {
       cwd: bashWorkDir,
       timeoutMs: deadlines.timeout,
       abortSignal: combinedAbort.signal,
+      wakeSignal: inputWake?.signal || null,
+      autoBackgroundReason: args.background === true ? 'background' : 'threshold',
       autoBackgroundMs: deadlines.autoBackgroundMs,
       // On a foreground timeout, promote the still-running child to a tracked
       // background job (task_id + notify) instead of tree-killing it.
@@ -144,6 +149,7 @@ export async function executeBashTool(args, workDir, options = {}) {
       rewriteNote: [wmicRewrite?.note, bashismRewrite?.note].filter(Boolean).join('\n'),
     });
   } finally {
+    inputWake?.dispose();
     combinedAbort?.cleanup?.();
     if (hoisted.hoistPath) {
       // A promoted or queued command still runs from the hoisted file; a

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

@@ -9,25 +9,24 @@ import { GIT_TOOL_DEF } from './git-command-tool.mjs';
 import { PUBLIC_PATH_BATCH_LIMIT, PUBLIC_READ_WINDOW_MAX } from './arg-guard.mjs';
 import { GITHUB_TOOL_DEF } from '../../../../github/tool.mjs';
 import { envFlag } from '../../../../shared/env.mjs';
-// action=wait ceiling, colocated with the schema that publishes it so the
-// documented bounds and the runtime clamp cannot drift. The wait returns the
-// instant the task settles, so the ceiling only bounds how long a STILL-running
-// task may hold the call. The floor is the load-bearing part: measured runs
-// show a caller with no wait primitive re-reading the same task every 2-3 s
-// (177 reads in one trial), and a caller that can pass a timeout occasionally
-// asks for 1 s. Both collapse into a busy loop without a floor.
-//
-// The ceiling is bounded at 10 min for the mirror-image failure: a single wait
-// holding the ONLY decision point for longer than the caller's whole remaining
-// budget. Measured run: one `wait` with timeout_ms 2_400_000 blocked 1_611 s of
-// an 1_800 s budget and the caller never got another turn — no partial result,
-// no alternative path. A still-running task returns its current output at the
-// ceiling, so the caller re-decides and may wait again; nothing is lost except
-// the unbounded block. 10 min also matches the reference agent's equivalent
-// wait primitive, which caps at 600_000 ms.
-export const TASK_WAIT_TIMEOUT_DEFAULT_MS = 60_000;
-export const TASK_WAIT_TIMEOUT_MIN_MS = 10_000;
-export const TASK_WAIT_TIMEOUT_MAX_MS = 600_000;
+import {
+  SHELL_HOLD_DEFAULT_MS,
+  SHELL_HOLD_MAX_MS,
+  SHELL_HOLD_MIN_MS,
+  AGENT_TASK_WAIT_DEFAULT_MS,
+  TASK_WAIT_DEFAULT_MS,
+  TASK_WAIT_MAX_MS,
+  TASK_WAIT_MIN_MS,
+  budgetSeconds,
+} from './wait-budgets.mjs';
+// action=wait bounds, published by the schema below and clamped by the task
+// tool; the values live in wait-budgets.mjs. The wait returns the instant the
+// task settles or new user input or a task notification arrives, so the ceiling only bounds a
+// still-running task; the floor keeps wait from collapsing into a busy poll.
+export const TASK_WAIT_TIMEOUT_DEFAULT_MS = TASK_WAIT_DEFAULT_MS;
+export const TASK_WAIT_TIMEOUT_MIN_MS = TASK_WAIT_MIN_MS;
+export const TASK_WAIT_TIMEOUT_MAX_MS = TASK_WAIT_MAX_MS;
+const _holdS = budgetSeconds(SHELL_HOLD_DEFAULT_MS);
 const _shellSyntaxCheat =
   process.platform === 'win32'
     ? " PowerShell: ; between independent commands, if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } between dependent ones; no heredoc, </dev/null or | head/tail/wc (Select-Object -First/-Last); multiline python/node via @'…'@ | python - (node -); 2>$null; /c/→C:\\; $PID is reserved."
@@ -146,7 +145,7 @@ export const BUILTIN_TOOLS = [
       openWorldHint: true,
       compressible: true,
     },
-    description: `Run programs, builds, tests and computation. Never use shell commands or scripts for work covered by dedicated tools: cat/head/tail→read, ls→list, find→glob, filename lookup→find, grep/rg→grep, code structure→code_graph, file edits/writes (sed/awk/redirection)→edit/apply_patch, Git→git when that tool is on the surface. Tool names are not shell commands. ${_shellBackgroundDisabled ? 'Commands run in the foreground until completion.' : 'After a 10s foreground window (not a timeout; omit wait_ms by default, set it up to 30s only for a command you expect to finish in 10–30s, e.g. one test file), unfinished work continues under task_id; use task wait, not read polling. If no execution slot frees within the admission wait, the command is queued as a background task with a task_id. Dev servers/watchers: pass timeout_ms or stop them with task cancel when done.'}`,
+    description: `Run programs, builds, tests and computation. Never use shell commands or scripts for work covered by dedicated tools: cat/head/tail→read, ls→list, find→glob, filename lookup→find, grep/rg→grep, code structure→code_graph, file edits/writes (sed/awk/redirection)→edit/apply_patch, Git→git when that tool is on the surface. Tool names are not shell commands. ${_shellBackgroundDisabled ? 'Commands run in the foreground until completion.' : `Holds up to ${_holdS}s for the result. Still running at ${_holdS}s, or new user input or a task notification arrives: it moves to the background (never killed) and returns task_id plus output so far. Completion is delivered automatically; task wait only when you need the result now. If no execution slot frees, the command is queued as a background task. Dev servers/watchers: background:true, and stop them with task cancel when done.`}`,
     inputSchema: {
       type: 'object',
       properties: {
@@ -154,15 +153,18 @@ export const BUILTIN_TOOLS = [
         timeout_ms: {
           type: 'integer',
           minimum: 0,
-          description:
-            'Hard kill deadline in ms (omit or 0 = none), separate from the 10s foreground window; set one for throwaway probes so a slow check fails fast.',
+          description: `Hard kill deadline in ms (omit or 0 = none), separate from the ${_holdS}s hold; set one for throwaway probes so a slow check fails fast.`,
         },
         wait_ms: {
           type: 'integer',
-          minimum: 10000,
-          maximum: 30000,
+          minimum: SHELL_HOLD_MIN_MS,
+          maximum: SHELL_HOLD_MAX_MS,
+          description: `Hold in ms before a still-running command moves to the background (default ${SHELL_HOLD_DEFAULT_MS}). Usually omit.`,
+        },
+        background: {
+          type: 'boolean',
           description:
-            'Foreground wait in ms before unfinished work continues as a background task (default 10000). Omit it by default. Set it only when you expect the command to finish within 10–30s (e.g. one test file or a small build step); never for work expected to take longer, which finishes by notification.',
+            'Start in the background at once (servers, watchers, `npm run dev`); returns task_id right away.',
         },
       },
       required: ['command'],
@@ -188,7 +190,7 @@ export const BUILTIN_TOOLS = [
       openWorldHint: false,
     },
     description:
-      'Manage shell tasks. read/wait return new output, prioritizing the tail on completion. output:tail re-reads recent output without advancing the cursor; use read on the log path for omitted content. Wait instead of polling; completion notifications are automatic.',
+      'Manage shell tasks. Completion is delivered automatically; wait only when you need the result now, never poll with read. wait returns when the task finishes, or when new user input or any task notification arrives (the task keeps running). read/wait return new output, prioritizing the tail on completion. output:tail re-reads recent output without advancing the cursor; use read on the log path for omitted content.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -201,7 +203,7 @@ export const BUILTIN_TOOLS = [
         timeout_ms: {
           type: 'integer',
           minimum: 0,
-          description: `Wait ceiling in ms; returns on completion, else current output at the ceiling. Default ${TASK_WAIT_TIMEOUT_DEFAULT_MS}; clamped to ${TASK_WAIT_TIMEOUT_MIN_MS}-${TASK_WAIT_TIMEOUT_MAX_MS}.`,
+          description: `Wait ceiling in ms; returns on completion, new user input or a task notification, else current output at the ceiling. Default ${TASK_WAIT_TIMEOUT_DEFAULT_MS} (agents ${AGENT_TASK_WAIT_DEFAULT_MS}); clamped to ${TASK_WAIT_TIMEOUT_MIN_MS}-${TASK_WAIT_TIMEOUT_MAX_MS}.`,
         },
         output: {
           type: 'string',

package/src/runtime/agent/orchestrator/tools/builtin/external-tool-adapters.mjs

@@ -708,7 +708,7 @@ async function applyEditNative(edit, oldStr, newStr, editPlan, replaceAll) {
     if (/old_string (?:not found|found \d+ times)/i.test(message)) {
       const latest = readEditTextForDisplay(fullPath, fileEnc) ?? content;
       const hinted = /found \d+ times/i.test(message)
-        ? message.replace(/(found \d+ times)/i, `$1${matchLineHint(latest, oldStr)}`)
+        ? message.replace(/(found \d+ times)/i, (__m, __1) => `${__1}${matchLineHint(latest, oldStr)}`)
         : message;
       return `Error: edit failed (${hinted})${formatEditFailureExcerpt(latest, oldStr, message)}`;
     }

package/src/runtime/agent/orchestrator/tools/builtin/find-files-tool.mjs

@@ -15,7 +15,7 @@ import { markScopedCacheIncomplete } from '../../session/cache/scoped-cache-outc
 import { cacheGet, cacheSet, statPathsForMtime } from './cache-layers.mjs';
 import { formatListSize, formatMtime } from './list-formatting.mjs';
 import { compileSimpleGlob } from './glob-walk.mjs';
-import { capLineOrientedToolOutput, LOCATOR_OUTPUT_MAX_BYTES } from './tool-output-limit.mjs';
+import { capLineOrientedToolOutput, capMarker, LOCATOR_OUTPUT_MAX_BYTES } from './tool-output-limit.mjs';
 import { runRg } from './native-search-runner.mjs';
 import { tryServeFuzzySearch } from './native-search-client.mjs';
 import {
@@ -23,7 +23,12 @@ import {
   recordLocalSearchCacheHit,
   recordNativeSearchTiming,
 } from './local-search-telemetry.mjs';
-import { guardedWalkRoot, normalizeListHeadLimit, pageContinuationLine } from './lib/list-helpers.mjs';
+import {
+  comparePathsStable,
+  guardedWalkRoot,
+  normalizeListHeadLimit,
+  pageContinuationLine,
+} from './lib/list-helpers.mjs';
 import { reportToolProgress } from './lib/tool-progress.mjs';
 import { displayRelPath, statWalkRoot, toolErrorText } from './list-tool-shared.mjs';
 
@@ -198,11 +203,16 @@ export async function executeFuzzyFindTool(args, workDir, options = {}) {
   const { query, fullPath, headLimit } = request;
   const cacheKey = fuzzyFindCacheKey(request);
   const capFindResult = (value) =>
-    capLineOrientedToolOutput(
-      value,
-      _findOutputBudgetBytes(options),
-      () => `... [find result budget reached for query=${JSON.stringify(query)}; narrow path/limit]`
-    );
+    capLineOrientedToolOutput(value, _findOutputBudgetBytes(options), (kept) => {
+      const rows = kept.filter((line) => line && !/^(?:#|\.\.\.|\[|\()/.test(line)).length;
+      return capMarker({
+        limit: _findOutputBudgetBytes(options),
+        shown: `${rows} match row(s) shown for query=${JSON.stringify(query)}`,
+        // Fuzzy find ranks by score and has no offset: a continuation offset
+        // would be ignored, so the cut gets narrowing advice instead.
+        narrow: rows > 0 ? 'use a more specific query or add path' : 'narrow path/limit',
+      });
+    });
   const cached = cacheGet(cacheKey);
   if (cached !== null) {
     recordLocalSearchCacheHit('result');
@@ -444,9 +454,12 @@ async function collectFindMatches(request, relPaths, nameMatches, workDir) {
 }
 
 function findComparator(sortMode) {
-  if (sortMode === 'name') return (a, b) => normalizeOutputPath(a.path).localeCompare(normalizeOutputPath(b.path));
-  if (sortMode === 'size') return (a, b) => b.size - a.size;
-  return (a, b) => b.mtimeMs - a.mtimeMs;
+  const byPath = (a, b) => comparePathsStable(normalizeOutputPath(a.path), normalizeOutputPath(b.path));
+  if (sortMode === 'name') {
+    return (a, b) => normalizeOutputPath(a.path).localeCompare(normalizeOutputPath(b.path)) || byPath(a, b);
+  }
+  if (sortMode === 'size') return (a, b) => b.size - a.size || byPath(a, b);
+  return (a, b) => b.mtimeMs - a.mtimeMs || byPath(a, b);
 }
 
 function findResultLine(match, fullPath) {
@@ -467,7 +480,11 @@ function renderFindResult(
   if (paged) lines.push(pageContinuationLine(offset, sliced.length, matches.length));
   if (truncatedByCap) {
     lines.push(
-      `... walk truncated at ${FIND_ABSOLUTE_CAP} matches; narrow the scope (path/name/modified_after) for accurate global sort`
+      capMarker({
+        limit: `${FIND_ABSOLUTE_CAP} matches`,
+        shown: 'walk cut, global sort inexact',
+        narrow: 'narrow the scope (path/name/modified_after)',
+      })
     );
   }
   if (walkIncomplete) {

package/src/runtime/agent/orchestrator/tools/builtin/git-command-policy.mjs

@@ -108,6 +108,11 @@ function gitActionOf(operation, args) {
   return first || DEFAULT_GIT_ACTIONS.get(operation) || 'list';
 }
 
+const GIT_BRANCH_WRITE_FLAGS =
+  /^(?:-[dDmMcCfu]|--(?:delete|move|copy|force|set-upstream-to(?:=.*)?|unset-upstream|edit-description|track|no-track|create-reflog))$/;
+const GIT_TAG_WRITE_FLAGS =
+  /^(?:-[adfsumFe]|--(?:annotate|delete|force|sign|local-user(?:=.*)?|message(?:=.*)?|file(?:=.*)?|edit))$/;
+
 const GIT_CONFIG_MUTATION_FLAGS = new Set([
   '--add',
   '--edit',
@@ -140,9 +145,13 @@ export function gitPlanIsReadOnly(plan) {
   }
   if (operation === 'hash-object') return !args.includes('-w') && !args.includes('--stdin-paths');
   if (operation === 'branch' || operation === 'tag') {
-    return (
-      args.length === 0 || args.some((value) => ['--list', '-l', '-a', '--all', '-r', '--remotes'].includes(value))
-    );
+    // A listing flag does not make the call read-only when another flag writes:
+    // `branch -a -D x` deletes and `tag -a v1` creates (there `-a` is
+    // --annotate, not --all).
+    const writes = operation === 'tag' ? GIT_TAG_WRITE_FLAGS : GIT_BRANCH_WRITE_FLAGS;
+    if (args.some((value) => writes.test(value))) return false;
+    const listFlags = operation === 'tag' ? ['--list', '-l'] : ['--list', '-l', '-a', '--all', '-r', '--remotes'];
+    return args.length === 0 || args.some((value) => listFlags.includes(value));
   }
   if (operation === 'config') {
     if (args.some((value) => GIT_CONFIG_MUTATION_FLAGS.has(value))) return false;