mixdog 0.9.174 → 1.0.0

package/src/runtime/agent/orchestrator/session/transcript-restore/tool-result-status.mjs

@@ -0,0 +1,358 @@
+/**
+ * Tool-result status, display text, and aggregate-record helpers for the
+ * session runtime.
+ */
+import { stripShellExitHeader, toolErrorDisplay } from './tool-result-text.mjs';
+import {
+  hasBenignExitOutcome,
+  normalizeToolTerminalStatus,
+  toolResultTerminalStatus,
+} from '../../../../shared/tool-status.mjs';
+import { isReadOnlyNavigationMiss } from '../result-classification.mjs';
+import { formatAggregateDetail, summarizeToolResult, toolLoadingTargets } from '../../../../shared/tool-surface.mjs';
+import { normalizeToolName } from '../../../../shared/tool-primitives.mjs';
+import { gitResultError, gitResultExitCode } from '../../../../shared/tool-card-model/git-result.mjs';
+import { readRowsForDisplay } from '../../../../shared/read-row-numbers.mjs';
+
+const CANCELLED_RESULT_STATUS_LINE = '[status: cancelled]';
+
+// Detect a shell command that RAN but exited non-zero (a process exit code)
+// as opposed to a real tool-call failure (`[shell-tool-failed]`) or a
+// timeout/abort. New results use bare `[exit code: N]`; legacy transcripts may
+// use `Error: [shell-run-failed] [exit code: N]`. Persistent shell results can
+// prefix `[session: …]`. Returns the numeric exit code, or null otherwise.
+export function shellCommandExitCode(text) {
+  const body = String(text || '');
+  const lines = body.split('\n');
+  if (/^\[tool output offloaded:\s*shell\b/i.test(String(lines[0] || '').trim())) {
+    lines.shift();
+    while (lines.length > 0 && !String(lines[0] || '').trim()) lines.shift();
+  }
+  const header = lines.slice(0, 6).join('\n');
+  // Timeout / signal / abort are NOT a plain command exit — keep them "Failed".
+  if (/\[timeout:|\[signal:|timed out|aborted|interrupted/i.test(header)) return null;
+  const m = header.match(
+    /^\s*(?:\[session:[^\n]*\]\s*\n)?(?:Error:\s*)?(?:\[shell-run-failed\]\s*)?\[exit code:\s*(\d+)\]/i
+  );
+  if (!m) return null;
+  const code = Number(m[1]);
+  return Number.isFinite(code) ? code : null;
+}
+
+// Only provider envelope metadata establishes a failed invocation. Result
+// bodies can contain "Error:"/HTTP/domain/task status text without making the
+// call itself fail. A recognized plain shell exit wins over provider envelope
+// error flags: adapters commonly label non-zero process exits as tool errors
+// even though the shell tool itself ran successfully.
+export function toolCallOutcome(message, rawText) {
+  if (normalizeToolName(message?.toolName || message?.name) === 'git') {
+    const exitCode = gitResultExitCode(rawText);
+    if (exitCode !== null) return { isCallError: false, isExitError: !hasBenignExitOutcome(rawText), exitCode };
+    if (gitResultError(rawText)) return { isCallError: true, isExitError: false, exitCode: null };
+  }
+  const exitCode = shellCommandExitCode(rawText);
+  if (exitCode != null) {
+    // Every completed shell result carries `[exit code: N]` — including 0.
+    // A non-zero code is a command failure unless execution marked a known
+    // successful no-match/no-change outcome.
+    const benignExit = exitCode !== 0 && hasBenignExitOutcome(rawText);
+    return { isCallError: false, isExitError: exitCode !== 0 && !benignExit, exitCode };
+  }
+  if (isReadOnlyNavigationMiss(message?.toolName || message?.name, rawText)) {
+    return { isCallError: false, isExitError: false, exitCode };
+  }
+  const isCallError = message?.isError === true || message?.toolKind === 'error';
+  return {
+    isCallError,
+    isExitError: false,
+    exitCode,
+  };
+}
+
+// Build the collapsed failure/exit detail string. Real tool-call/result
+// failures keep the red "Failed" wording; completed non-zero commands render
+// as the distinct warning "Exited" state. A mixed group surfaces both.
+export function failureDetailText({ succeeded = 0, realErrors = 0, exitErrors = 0, exitCode } = {}) {
+  const parts = [];
+  if (succeeded > 0) parts.push(`${succeeded} Ok`);
+  if (realErrors > 0) parts.push(`${realErrors} Failed`);
+  if (exitErrors > 0) {
+    const solo = exitErrors === 1 && realErrors === 0 && succeeded === 0;
+    parts.push(solo && Number.isFinite(exitCode) ? `Exited ${exitCode}` : `${exitErrors} Exited non-zero`);
+  }
+  return parts.join(' · ');
+}
+
+function itemHasKnownTerminalStatus(item, texts = []) {
+  const settled = (token) => token === 'completed' || token === 'failed' || token === 'cancelled';
+  if (settled(normalizeToolTerminalStatus(item?.args?.status))) return true;
+  for (const text of texts) {
+    if (settled(toolResultTerminalStatus(text))) return true;
+  }
+  return false;
+}
+
+export function withCancelledResultMarker(text, item) {
+  const body = String(text || '');
+  // Do NOT inspect item.rawResult here: aggregate rawResult is child tool
+  // output (`1. grep\n<result>…`) that can incidentally contain a `status:`
+  // line, which would false-positive as an already-terminal status and skip
+  // the cancelled marker. Only result/text/body are session runtime-controlled
+  // collapsed detail (empty / status word / an existing marker), so they are
+  // the trustworthy terminal-status sources.
+  const sources = [item?.result, item?.text, body];
+  if (itemHasKnownTerminalStatus(item, sources)) return body;
+  if (!body.trim()) return `${CANCELLED_RESULT_STATUS_LINE}\n`;
+  return `${CANCELLED_RESULT_STATUS_LINE}\n${body}`;
+}
+
+export function groupedToolResultText(group) {
+  const completed = Math.min(group.count, group.completed);
+  if (group.count <= 1) return group.results.at(-1)?.text ?? '';
+  const exitErrors = Number(group.exitErrors || 0);
+  if (group.errors > 0 || exitErrors > 0) {
+    const realErrors = Math.max(0, Number(group.callErrors || group.errors || 0));
+    const succeeded = Math.max(0, completed - group.errors - exitErrors);
+    const exitCode = group.results.find((result) => result?.isExitError)?.exitCode;
+    // Command-exits carry no failure reason line; only real failures do.
+    const reasons = group.results
+      .filter((result) => result?.isError && !result?.isExitError)
+      .map((result) => firstErrorLine(result?.text))
+      .filter(Boolean);
+    const uniqueReasons = [...new Set(reasons)].slice(0, 2);
+    const base = failureDetailText({ succeeded, realErrors, exitErrors, exitCode });
+    return [`${base}${uniqueReasons[0] ? ` · ${uniqueReasons[0]}` : ''}`, ...uniqueReasons.slice(1)].join('\n');
+  }
+  for (const result of group.results || []) {
+    const line = String(result?.text || '').trim();
+    if (line) return result.text;
+  }
+  return '';
+}
+
+function firstErrorLine(text) {
+  const clean = toolErrorDisplay(text, 'tool');
+  if (clean) return clean;
+  for (const line of String(text || '').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (/^(Error|\[?error|FAIL\b)/i.test(trimmed)) return trimmed;
+  }
+  return (
+    String(text || '')
+      .split('\n')
+      .map((line) => line.trim())
+      .find(Boolean) || ''
+  );
+}
+
+/** The members' raw outputs as one numbered text (`1. grep\n…\n\n2. read\n…`).
+ *
+ *  Built by `+`, never `join`: V8 keeps a concatenation as a rope that points
+ *  at the member strings the aggregate already holds (toolMembers[].rawResult,
+ *  the calls' raw text) and copies it flat only when something reads its
+ *  characters. A resumed session restores hundreds of aggregates it never
+ *  displays; a joined string gave each of them a second, flat copy of every
+ *  tool output (~1 MB per idle session in a 30-session measurement). */
+export function aggregateRawResult(calls) {
+  let joined = '';
+  let index = 0;
+  for (const rec of calls || []) {
+    if (rec?.resolved !== true) continue;
+    const text = String(rec?.rawResultText ?? rec?.resultText ?? '').replace(/\s+$/, '');
+    if (!text.trim()) continue;
+    const label = String(rec?.name || rec?.category || 'tool').trim() || 'tool';
+    index += 1;
+    joined = joined + (index > 1 ? `\n\n${index}. ${label}\n` : `${index}. ${label}\n`) + text;
+  }
+  return joined;
+}
+
+/** Expanded aggregate text with read members' numbered rows rebuilt (the
+ *  model-facing rows carry no numbers and would otherwise lose their gutter).
+ *  Runs at display time so restored, never-expanded aggregates keep their rope. */
+export function aggregateRawResultForDisplay(text) {
+  if (typeof text !== 'string' || !/^\[lines \d+-\d+\]$/m.test(text)) return text;
+  const lines = text.split('\n');
+  const out = [];
+  let member = [];
+  let inRead = false;
+  const flush = () => {
+    if (member.length) out.push(inRead ? readRowsForDisplay(member.join('\n')) : member.join('\n'));
+    member = [];
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const header = (i === 0 || lines[i - 1] === '') && /^\d+\. (.+)$/.exec(lines[i]);
+    if (!header) {
+      member.push(lines[i]);
+      continue;
+    }
+    flush();
+    out.push(lines[i]);
+    inRead = normalizeToolName(header[1]) === 'read';
+  }
+  flush();
+  return out.join('\n');
+}
+
+/** Preserve the atomic calls behind a visual aggregate. Renderers can keep the
+ * aggregate as one quiet summary row while revealing the original tool names,
+ * arguments, and outputs in provider order. */
+export function aggregateToolMembers(calls) {
+  const source = calls?.values?.() || calls || [];
+  const members = [];
+  for (const rec of source) {
+    if (!rec || typeof rec !== 'object') continue;
+    const completed = rec.resolved === true || rec.completedEarly === true;
+    members.push({
+      kind: 'tool',
+      ...(rec.callId != null ? { id: rec.callId } : {}),
+      name: String(rec.name || 'tool'),
+      args: rec.args ?? {},
+      result: rec.resultText ?? null,
+      rawResult: rec.rawResultText ?? rec.resultText ?? null,
+      isError: rec.isError === true,
+      errorCount: rec.isError === true ? 1 : 0,
+      callErrorCount: rec.isCallError === true ? 1 : 0,
+      exitErrorCount: rec.isExitError === true ? 1 : 0,
+      count: 1,
+      completedCount: completed ? 1 : 0,
+      headerFinalized: completed,
+      ...stringUiDiffPatch(rec.uiDiff),
+      ...(Number(rec.startedAt) > 0 ? { startedAt: Number(rec.startedAt) } : {}),
+      ...(Number(rec.completedAt) > 0 ? { completedAt: Number(rec.completedAt) } : {}),
+    });
+  }
+  return members;
+}
+
+export function aggregateBucketForCategory(category, { agentBatch = '' } = {}) {
+  // Merge consecutive tool calls of the SAME category into one aggregate card;
+  // a different category opens a fresh card (no cross-category merge). The
+  // bucket key is the category itself, so a run of Search calls collapses into
+  // one Search card while an adjacent Read/Patch stays separate. Falls back to
+  // 'default' when a call has no resolved category. Hook/approval denials keep
+  // their dedicated ToolHookDenialCard path in App.jsx.
+  const key = String(category || '').trim();
+  // Exception: Read and Search share one lookup bucket so a batched turn of
+  // read+grep renders as ONE card ("Reading 3 files · Searching 2 patterns")
+  // instead of two adjacent cards. The per-category entries in
+  // aggregateCard.categories keep their own verbs/counts, so the merged
+  // header still spells out both. State-changing categories (Patch/Shell/…)
+  // stay separate.
+  if (key === 'Read' || key === 'Search') return 'category:Read+Search';
+  // Agent actions are grouped only inside the provider callback that emitted
+  // them. This keeps a later provider batch from changing an older outbound
+  // card above an intervening result/transcript boundary.
+  if (key === 'Agent') return agentBatch ? `category:Agent:${agentBatch}` : 'category:Agent';
+  return key ? `category:${key}` : 'default';
+}
+
+// Fold one call's category entries into an aggregate's header counts
+// (`categories` Map + first-seen `categoryOrder`), shared by the live card
+// and the restored transcript card.
+export function mergeAggregateCategoryEntries(aggregate, categoryEntries) {
+  for (const entry of categoryEntries) {
+    if (!aggregate.categories.has(entry.key)) aggregate.categoryOrder.push(entry.key);
+    const prev = aggregate.categories.get(entry.key);
+    aggregate.categories.set(entry.key, { ...entry, count: Number(prev?.count || 0) + Number(entry.count || 1) });
+  }
+}
+
+function aggregateSummaries(aggregate) {
+  return [...(aggregate?.calls?.values?.() || [])]
+    .filter((r) => r.summary)
+    .sort((a, b) => Number(a.summarySeq ?? 0) - Number(b.summarySeq ?? 0))
+    .map((r) => r.summary);
+}
+
+function assignAggregateSummaryOrder(aggregate, callRec) {
+  if (!aggregate || !callRec?.summary || callRec.summarySeq != null) return;
+  const next = Math.max(0, Number(aggregate.nextSummarySeq || 0));
+  callRec.summarySeq = next;
+  aggregate.nextSummarySeq = next + 1;
+}
+
+/** Live tool messages: a present uiDiff is always a string (empty if malformed). */
+export function uiDiffFromMessage(source) {
+  if (!source || typeof source !== 'object' || !Object.hasOwn(source, 'uiDiff')) return undefined;
+  return typeof source.uiDiff === 'string' ? source.uiDiff : '';
+}
+
+export function uiDiffPatchFromMessage(source) {
+  const value = uiDiffFromMessage(source);
+  return value === undefined ? {} : { uiDiff: value };
+}
+
+export function assignUiDiffFromMessage(target, source) {
+  const value = uiDiffFromMessage(source);
+  if (value === undefined || !target) return target;
+  target.uiDiff = value;
+  return target;
+}
+
+/** Stored/member records only copy a string uiDiff; other types stay omitted. */
+export function stringUiDiffPatch(value) {
+  return typeof value === 'string' ? { uiDiff: value } : {};
+}
+
+export function toolResultDisplay(message, rawText, toolName) {
+  const outcome = toolCallOutcome({ ...message, toolName }, rawText);
+  const isError = outcome.isCallError;
+  let text = rawText;
+  if (isError) text = toolErrorDisplay(rawText, toolName || 'tool');
+  else if (outcome.exitCode != null) text = stripShellExitHeader(rawText);
+  return { ...outcome, isError, text };
+}
+
+export function applyAggregateCallFields(
+  callRec,
+  aggregate,
+  { isError, isCallError, isExitError, exitCode, text, rawText, message } = {}
+) {
+  if (!callRec) return callRec;
+  callRec.summary = !isError ? summarizeToolResult(callRec.name, callRec.args, rawText, isError) : null;
+  assignAggregateSummaryOrder(aggregate, callRec);
+  callRec.isError = isError;
+  callRec.isCallError = isCallError;
+  callRec.isExitError = isExitError;
+  callRec.exitCode = exitCode;
+  callRec.resultText = text;
+  callRec.rawResultText = rawText;
+  assignUiDiffFromMessage(callRec, message);
+  callRec.completedAt = callRec.completedAt || Date.now();
+  return callRec;
+}
+
+export function aggregateLoadingTargets(calls) {
+  const records = calls?.values ? [...calls.values()] : [...(calls || [])];
+  const groups = records.map((call) => toolLoadingTargets(call.name, call.args));
+  if (groups.length === 0 || !groups.every((targets) => targets.length > 0)) return [];
+  return [...new Set(groups.flat())];
+}
+
+export function aggregateResultPatch(aggregate, allCalls, completedCount) {
+  const errors = allCalls.filter((r) => r.isError).length;
+  const callErrors = allCalls.filter((r) => r.isCallError).length;
+  const exitErrors = allCalls.filter((r) => r.isExitError).length;
+  const succeeded = Math.max(0, completedCount - errors - exitErrors);
+  const displayDetail =
+    errors > 0 || exitErrors > 0
+      ? failureDetailText({
+          succeeded,
+          realErrors: callErrors,
+          exitErrors,
+          exitCode: allCalls.find((r) => r.isExitError)?.exitCode,
+        })
+      : formatAggregateDetail(aggregateSummaries(aggregate));
+  return {
+    result: displayDetail,
+    text: displayDetail,
+    isError: errors > 0,
+    errorCount: errors,
+    callErrorCount: callErrors,
+    exitErrorCount: exitErrors,
+    count: allCalls.length,
+    toolMembers: aggregateToolMembers(allCalls),
+  };
+}

package/src/runtime/agent/orchestrator/session/transcript-restore/tool-result-text.mjs

@@ -0,0 +1,157 @@
+/**
+ * src/tui/session/tool-result-text.mjs - flatten tool-result content shapes into
+ * display text, plus collapsed-detail/grouped fallbacks and error framing.
+ */
+import { presentErrorText } from '../../../../shared/err-text.mjs';
+
+// Every shape that carries a list of parts flattens the same way: render each
+// part at the given depth, drop the empties, join with newlines.
+function joinPartTexts(parts, depth) {
+  return parts
+    .map((c) => toolResultPartText(c, depth))
+    .filter((t) => t !== '')
+    .join('\n');
+}
+
+export function toolResultText(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return joinPartTexts(content, 0);
+  }
+  if (typeof content === 'object') {
+    if (Array.isArray(content.content)) {
+      const nested = joinPartTexts(content.content, 0);
+      if (nested) return nested;
+    } else if (content.content != null && typeof content.content === 'object') {
+      const nested = toolResultPartText(content.content);
+      if (nested) return nested;
+    }
+    if (Array.isArray(content.parts)) {
+      const nested = joinPartTexts(content.parts, 0);
+      if (nested) return nested;
+    }
+    const fromPart = toolResultPartText(content);
+    if (fromPart) return fromPart;
+    if (content?.type === 'tool_result') return '';
+    if (typeof content.text === 'string') return content.text;
+    if (typeof content.content === 'string') return content.content;
+  }
+  try {
+    return JSON.stringify(content);
+  } catch {
+    return String(content);
+  }
+}
+
+const TOOL_RESULT_PART_MAX_DEPTH = 12;
+const TOOL_RESULT_JSON_FALLBACK_MAX = 480;
+// Absolute cap for a collapsed tool detail line (the second row under the ⎿
+// gutter). Terminal-width independent so a wide terminal never lets a long line
+// stretch the row; lockstep with ToolExecution RESULT_LINE_HARD_MAX (80).
+const TOOL_DETAIL_LINE_MAX = 80;
+
+function compactToolResultObjectFallback(obj) {
+  if (obj?.type === 'tool_result') return '';
+  try {
+    const json = JSON.stringify(obj);
+    if (!json || json === '{}') return '';
+    if (json.length <= TOOL_RESULT_JSON_FALLBACK_MAX) return json;
+    return `${json.slice(0, TOOL_RESULT_JSON_FALLBACK_MAX - 1)}…`;
+  } catch {
+    return String(obj);
+  }
+}
+
+function toolResultPartText(part, depth = 0) {
+  if (part == null) return '';
+  if (depth > TOOL_RESULT_PART_MAX_DEPTH) return '';
+  if (typeof part === 'string') return part;
+  if (part?.type === 'image' || part?.type === 'input_image') {
+    return `[image: ${part.mimeType || part.mediaType || part.source?.media_type || 'image'}]`;
+  }
+  if (part?.type === 'tool_result') {
+    const inner = part.content;
+    if (typeof inner === 'string') return inner;
+    if (Array.isArray(inner)) {
+      return joinPartTexts(inner, depth + 1);
+    }
+    if (inner != null && typeof inner === 'object') {
+      return toolResultPartText(inner, depth + 1);
+    }
+    return '';
+  }
+  if (part?.type === 'text' || part?.type === 'output_text' || part?.type === 'input_text') {
+    return part.text ?? '';
+  }
+  if (Array.isArray(part)) {
+    return joinPartTexts(part, depth + 1);
+  }
+  if (typeof part === 'object') {
+    if (Array.isArray(part.content)) {
+      const nested = joinPartTexts(part.content, depth + 1);
+      if (nested) return nested;
+    }
+    if (part.content != null && typeof part.content === 'object') {
+      const nested = toolResultPartText(part.content, depth + 1);
+      if (nested) return nested;
+    }
+    if (Array.isArray(part.parts)) {
+      const nested = joinPartTexts(part.parts, depth + 1);
+      if (nested) return nested;
+    }
+    if (typeof part.text === 'string' && part.text) return part.text;
+    if (typeof part.output === 'string' && part.output) return part.output;
+    if (typeof part.message === 'string' && part.message) return part.message;
+    if (typeof part.content === 'string') return part.content;
+    if (part.source?.type === 'base64' && part.source?.data) {
+      return `[image: ${part.source.media_type || part.source.mediaType || 'base64'}]`;
+    }
+    return compactToolResultObjectFallback(part);
+  }
+  return '';
+}
+
+export function toolAggregateDetailFallback(detailText, rawResult) {
+  if (String(detailText || '').trim()) return detailText;
+  const raw = String(rawResult || '').trim();
+  if (!raw) return detailText;
+  const line =
+    raw
+      .split('\n')
+      .map((l) => l.trim())
+      .find(Boolean) || '';
+  if (!line) return detailText;
+  return line.length > TOOL_DETAIL_LINE_MAX ? `${line.slice(0, TOOL_DETAIL_LINE_MAX - 3)}…` : line;
+}
+
+export function toolGroupedDisplayFallback(resultText, text, rawText) {
+  if (String(resultText || '').trim()) return resultText;
+  const body = String(text || rawText || '').trim();
+  if (body) return text || rawText;
+  return resultText;
+}
+
+export function toolErrorDisplay(value, surface = 'tool') {
+  const text = presentErrorText(value, { surface });
+  if (
+    /^(?:Search failed|Fetch failed|No first response|No progress|Cancelled|The .+ went stale|(?:Web search agent|Agent|Tool|Request) (?:stopped|was cancelled))/i.test(
+      text
+    )
+  ) {
+    return text;
+  }
+  return /^error\s*:/i.test(text) ? text : `Error: ${text}`;
+}
+
+// Display-only: a command-failure card already renders its exit state, so
+// the machine header (`[exit code: N]`, or its legacy shell-run-failed form) is
+// redundant in the body. The model-facing result keeps it; only display drops
+// the header and explanatory completion note.
+export function stripShellExitHeader(text) {
+  const body = String(text ?? '');
+  return body.replace(
+    /(^|\n)(?:(?:Error:\s*)?\[shell-run-failed\]\s*)?\[exit code:\s*\d+\][^\n]*\n{0,2}(?:\[outcome:\s*(?:no-match|no-change)\]\n{0,2})?(?:\[completed:[^\n]*\]\n{0,2})?/i,
+    '$1'
+  );
+}

package/src/runtime/agent/orchestrator/tools/bash-policy-scan.mjs

@@ -1,6 +1,6 @@
 import { stripQuotedAndHeredoc, extractShellCInner } from './destructive-warning.mjs';
 import { decodePowerShellEncodedCommand } from './shell-policy.mjs';
-import { extractPowerShellCommandInner } from './shell-command.mjs';
+import { extractPowerShellCommandInner } from './shell-powershell.mjs';
 import { evaluateExecPolicyFromTargets, formatExecPolicyBlockMessage } from './shell-exec-policy.mjs';
 
 function _decodeAnsiCQuotes(s) {
@@ -24,8 +24,7 @@ function _extractSubstitutionBodies(s) {
   if (typeof s !== 'string') return [];
   const out = [];
   const re = /\$\(([^()]*(?:\([^()]*\)[^()]*)*)\)|`([^`]*)`/g;
-  let m;
-  while ((m = re.exec(s)) !== null) {
+  for (const m of s.matchAll(re)) {
     const body = m[1] != null ? m[1] : m[2];
     if (body?.trim()) out.push(body);
   }

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

@@ -16,6 +16,10 @@ import { CODE_GRAPH_FILE_MODES, CODE_GRAPH_MODES } from '../code-graph-tool-defs
 const MAX_INT = 100000;
 export const PUBLIC_PATH_BATCH_LIMIT = 10;
 export const PUBLIC_READ_WINDOW_MAX = MAX_INT;
+// A start line only positions the window (streaming reads seek through byte
+// anchors), so it is not capped like the output-sized limit.
+const READ_OFFSET_MAX = Number.MAX_SAFE_INTEGER;
+const READ_WINDOW_RANGE_TEXT = `offset must be an integer >= 1 and limit an integer from 1 to ${MAX_INT}`;
 // Explicit grep context should be large enough to frame a function/block without
 // letting one match explode into a huge tool result. `content_with_context` still
 // defaults to 25 lines; this is only the upper bound for caller-supplied -A/-B/-C.
@@ -596,15 +600,16 @@ function normalizePublicReadTargets(a) {
     return 'Error: read arg "file_path" must be a path string or an array of targets';
   }
   const targets = batch ? a.file_path : [a.file_path];
-  if (targets.length === 0 || targets.length > PUBLIC_PATH_BATCH_LIMIT) {
-    return `Error: read arg "file_path" must contain 1-${PUBLIC_PATH_BATCH_LIMIT} targets`;
+  if (targets.length === 0) {
+    return 'Error: read arg "file_path" must contain at least 1 target';
   }
   const windowValue = (value, fallback) => (value === undefined ? fallback : value);
-  const validWindow = (value) => Number.isInteger(value) && value >= 1 && value <= MAX_INT;
+  const validOffset = (value) => Number.isSafeInteger(value) && value >= 1;
+  const validLimit = (value) => Number.isInteger(value) && value >= 1 && value <= MAX_INT;
   const defaultOffset = windowValue(a.offset, 1);
   const defaultLimit = windowValue(a.limit, READ_GUARD_DEFAULT_LIMIT);
-  if (!validWindow(defaultOffset) || !validWindow(defaultLimit)) {
-    return `Error: read offset and limit must be integers from 1 to ${MAX_INT}`;
+  if (!validOffset(defaultOffset) || !validLimit(defaultLimit)) {
+    return `Error: read ${READ_WINDOW_RANGE_TEXT}`;
   }
   const entries = [];
   for (let index = 0; index < targets.length; index++) {
@@ -621,11 +626,24 @@ function normalizePublicReadTargets(a) {
     }
     const offset = windowValue(record.offset, defaultOffset);
     const limit = windowValue(record.limit, defaultLimit);
-    if (!validWindow(offset) || !validWindow(limit)) {
-      return `Error: read target ${index + 1} offset and limit must be integers from 1 to ${MAX_INT}`;
+    if (!validOffset(offset) || !validLimit(limit)) {
+      return `Error: read target ${index + 1} ${READ_WINDOW_RANGE_TEXT}`;
     }
     entries.push({ path: record.file_path, offset: offset - 1, limit });
   }
+  // The batch cap counts distinct files, not windows (several windows of one
+  // file coalesce into one read). Files past the cap are dropped from this
+  // call and named to the caller by the read tool.
+  const keptPaths = new Set();
+  const skippedPaths = new Set();
+  for (const entry of entries) {
+    if (keptPaths.size < PUBLIC_PATH_BATCH_LIMIT || keptPaths.has(entry.path)) keptPaths.add(entry.path);
+    else skippedPaths.add(entry.path);
+  }
+  if (skippedPaths.size > 0) {
+    entries.splice(0, entries.length, ...entries.filter((entry) => keptPaths.has(entry.path)));
+    a.skipped_files = [...skippedPaths];
+  }
   // Canonical public windows are one-based. Legacy executor windows are
   // zero-based; convert once here before any legacy shape handling.
   if (batch) {
@@ -695,7 +713,7 @@ function guardRead(a) {
       const err = applyLineContextWindow(entry, `path[${i}].`);
       if (err) return err;
       for (const ek of ['offset', 'limit']) {
-        const eErr = checkIntInRange(entry, ek, 0, MAX_INT);
+        const eErr = checkIntInRange(entry, ek, 0, ek === 'offset' ? READ_OFFSET_MAX : MAX_INT);
         if (eErr) return eErr.replace(`"${ek}"`, `"path[${i}].${ek}"`);
       }
     }
@@ -713,7 +731,7 @@ function guardRead(a) {
   }
   // offset >=0
   {
-    const err = checkIntInRange(a, 'offset', 0, MAX_INT);
+    const err = checkIntInRange(a, 'offset', 0, READ_OFFSET_MAX);
     if (err) return err;
   }
   // limit: >=1 = explicit cap; 0 = unlimited sentinel (read-formatting maps 0 to
@@ -738,10 +756,13 @@ function guardRead(a) {
 }
 
 function guardShell(a) {
-  const allowed = new Set(['command', 'timeout_ms']);
+  const allowed = new Set(['command', 'timeout_ms', 'wait_ms']);
   const unsupported = Object.keys(a).find((key) => !allowed.has(key));
   if (unsupported) {
-    return `Error: shell arg "${unsupported}" is unsupported; use only command and timeout_ms`;
+    return `Error: shell arg "${unsupported}" is unsupported; use only command, timeout_ms, and wait_ms`;
+  }
+  if (hasOwn(a, 'wait_ms') && (!Number.isInteger(a.wait_ms) || a.wait_ms < 1000 || a.wait_ms > 120000)) {
+    return `Error: shell arg "wait_ms" must be an integer from 1000 to 120000 (got ${describeType(a.wait_ms)})`;
   }
   if (!hasOwn(a, 'command')) {
     return 'Error: shell requires "command"';

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

@@ -1,14 +1,13 @@
 import { statSync, lstatSync, realpathSync, createWriteStream } from 'node:fs';
 import * as fsPromises from 'node:fs/promises';
 import { basename, dirname, join } from 'node:path';
-import { performance } from 'node:perf_hooks';
 import { randomBytes } from 'node:crypto';
 import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { getAbortSignalForSession } from '../../session/abort-lookup.mjs';
 import { hashText } from './hash-utils.mjs';
 import { sleep } from '../../../../shared/sleep.mjs';
-import { envFlag } from '../../../../shared/env.mjs';
+import { ioTraceDone, ioTraceStart } from '../io-trace.mjs';
 
 const STREAMING_THRESHOLD_BYTES = 1024 * 1024;
 
@@ -30,35 +29,6 @@ function expectedTargetSnapshotChanged(currentStat, expected) {
   return false;
 }
 
-function ioTraceEnabled() {
-  return envFlag('MIXDOG_IO_TRACE');
-}
-
-function ioTraceStart() {
-  return ioTraceEnabled() ? performance.now() : 0;
-}
-
-function ioTrace(event, fields = {}) {
-  if (!ioTraceEnabled()) return;
-  try {
-    process.stderr.write(
-      `[io-trace] ${JSON.stringify({
-        event,
-        ts: Date.now(),
-        ...fields,
-      })}\n`
-    );
-  } catch {}
-}
-
-function ioTraceDone(event, started, fields = {}) {
-  if (!started || !ioTraceEnabled()) return;
-  ioTrace(event, {
-    ...fields,
-    ms: Number((performance.now() - started).toFixed(3)),
-  });
-}
-
 function atomicWriteShouldFsync(value) {
   if (value === true || value === false) return value;
   return /^(1|true|yes|on|sync)$/i.test(String(process.env.MIXDOG_ATOMIC_FSYNC || ''));