mixdog 0.9.145 → 0.9.147

package/src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs

@@ -23,7 +23,7 @@ eof_line: "*** End of File" LF
 // Lark custom tool. The tiny JSON schema remains only for function-only
 // compatibility paths; runtime knobs stay off the model surface.
 const APPLY_PATCH_FREEFORM_DESCRIPTION =
-  'Edit files with one raw V4A patch; do not wrap it in JSON. Use one Add/Delete/Update File block per target path and multiple @@ hunks within one Update File block. Add File atomically creates the file and missing parent directories, failing without changes if the target already exists; call it directly without a prior read, list, or mkdir. Use exact lines already in context; never re-open the file to build context or to verify a successful patch. Multi-file patches commit valid files and report rejected files separately.';
+  'Edit files with one raw V4A patch; do not wrap it in JSON. Use one Add/Delete/Update File block per target path and multiple @@ hunks within one Update File block. Add File atomically creates the file and missing parent directories, failing without changes if the target already exists; call it directly without a prior read, list, or mkdir. Use exact lines already in context; never re-open the file to build context or to verify a successful patch. Multi-file patches commit valid files and report rejected files separately. Replaces sed/awk and echo redirection.';
 
 const APPLY_PATCH_JSON_DESCRIPTION = 'Edit files with one complete V4A patch in `patch`.';
 

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -792,7 +792,7 @@ export function execShellCommand({
           jobId,
           backgroundTimeoutMs: adoptedTimeoutMs,
           backgroundMessage: jobId
-            ? `${_verb}; still running. Completion is automatic; do not poll with task read/monitor unless the user explicitly requests polling or periodic progress.`
+            ? `${_verb}; still running. Completion is automatic; do not call task read/monitor to wait or check progress. Continue independent work or end the turn. Use task read only when the user explicitly asks for current status, and task monitor only when they explicitly ask for periodic progress.`
             : `${_verb}; still running — judge from the partial output whether waiting can finish in budget, or diagnose and pursue an alternative.`,
         }),
       );

package/src/runtime/shared/edit-tool-dialect.mjs

@@ -13,6 +13,14 @@ export function modelEditToolName(modelName) {
   return isGptFamilyModel(modelName) ? 'apply_patch' : 'edit';
 }
 
+/**
+ * The edit dialect this model never receives. Rules that name a concrete edit
+ * tool are gated on it, so a session only reads the dialect it can call.
+ */
+export function unusedModelEditToolName(modelName) {
+  return modelEditToolName(modelName) === 'edit' ? 'apply_patch' : 'edit';
+}
+
 export function filterModelEditTools(tools, modelName) {
   const selected = modelEditToolName(modelName);
   return (Array.isArray(tools) ? tools : []).filter((tool) => {

package/src/runtime/shared/pristine-execution-contract.json

@@ -26,6 +26,9 @@
     "MIXDOG_STALL_FIRST_BYTE_ABORT_S",
     "MIXDOG_CACHE_MESSAGES_TTL",
     "MIXDOG_OAI_TRANSPORT",
+    "MIXDOG_OPENAI_OAUTH_WS_WARMUP",
+    "MIXDOG_OAI_CODEX_WIRE_PARITY",
+    "MIXDOG_OAI_WS_DUMP_DIR",
     "MIXDOG_SESSION_TRANSCRIPT_LOG",
     "MIXDOG_USAGE_LOG"
   ],

package/src/runtime/shared/task-notification-envelope.mjs

@@ -47,14 +47,28 @@ export function renderShellCompletionEnvelope({
   stderrPreview = null,
   mergeStderr = false,
 } = {}) {
+  // Verdict, not just liveness. `status` only says the task reached a terminal
+  // state, so a run that completed with a non-zero exit reads as "completed"
+  // and invites a success reading. Foreground shell results already separate
+  // the two; background completions state the same outcome explicitly.
+  const normalizedStatus = String(status || '').toLowerCase();
+  const outcome = normalizedStatus === 'completed'
+    ? (exitCode === 0 ? 'success' : (typeof exitCode === 'number' ? 'command-failed' : 'completed'))
+    : (normalizedStatus === 'failed'
+      ? 'not-completed'
+      : ((normalizedStatus === 'cancelled' || normalizedStatus === 'canceled') ? 'cancelled' : null));
   const header = [
     `[task_id: ${jobId}]`,
     `[status: ${status}]`,
     `[exit: ${exitCode === null ? 'n/a' : exitCode}]`,
+    outcome ? `[outcome: ${outcome}]` : null,
     elapsedMs !== null ? `[elapsed: ${elapsedMs} ms]` : null,
     command ? `[command: ${compactCommand(command)}]` : null,
   ].filter((l) => l !== null);
   const bodySections = [
+    outcome === 'command-failed'
+      ? '[completed: the shell ran this command; its non-zero exit code and output are command results, not a tool failure]'
+      : null,
     summary ? `Summary: ${summary}` : null,
     stdoutPreview ? `\n[stdout preview]\n${stdoutPreview}` : null,
     (mergeStderr !== true && stderrPreview) ? `\n[stderr preview]\n${stderrPreview}` : null,

package/src/session-runtime/lifecycle-api.mjs

@@ -32,6 +32,32 @@ function resolveResumeCwd(session, currentCwd) {
   return session?.cwd || currentCwd;
 }
 
+function contextNumber(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : null;
+}
+
+export function inheritanceContextFit(status) {
+  const context = status && typeof status === 'object' ? status : {};
+  const compaction = context.compaction && typeof context.compaction === 'object'
+    ? context.compaction
+    : {};
+  const used = contextNumber(
+    compaction.pressureTokens
+    ?? compaction.currentEstimatedTokens
+    ?? context.usedTokens
+    ?? context.currentEstimatedTokens,
+  );
+  const limit = contextNumber(compaction.triggerTokens ?? context.contextWindow);
+  const known = used !== null && limit !== null && limit > 0;
+  return {
+    known,
+    fits: !known || used < limit,
+    used: used ?? 0,
+    limit: limit ?? 0,
+  };
+}
+
 // Session lifecycle surface: teardown (close/abort), resume/new, and the
 // resumable-session listing. Extracted verbatim from the runtime API object;
 // stateless helpers are imported directly and the runtime injects live
@@ -51,7 +77,7 @@ export function createLifecycleApi(deps) {
     withTeardownDeadline, closePatchRuntimeIfLoaded, closeNativeToolTransports,
     stopSelfUpdateBootCheck,
     createCurrentSession, refreshRouteEffort,
-    invalidateContextStatusCache, invalidatePreSessionToolSurface,
+    computeContextStatus, invalidateContextStatusCache, invalidatePreSessionToolSurface,
     applyResolvedCwd, resolveRoute, applyDeferredToolSurface, getStandaloneTools,
     beginRoutePreparation, clearRoutePreparation,
     notificationListeners, clearRuntimeNotifications,
@@ -606,7 +632,24 @@ export function createLifecycleApi(deps) {
       if (!hasUserConversationMessage(carried)) {
         throw new Error('inheritFrom: the source session has no conversation to carry');
       }
+      const messageStart = target.messages.length;
       target.messages.push(...structuredClone(carried));
+      invalidateContextStatusCache();
+      try {
+        const fit = inheritanceContextFit(
+          typeof computeContextStatus === 'function' ? computeContextStatus() : null,
+        );
+        if (fit.known && !fit.fits) {
+          throw new Error(
+            `inheritFrom: the full conversation needs ${Math.ceil(fit.used)} tokens `
+            + `but the selected model allows ${Math.floor(fit.limit)} before compaction`,
+          );
+        }
+      } catch (error) {
+        target.messages.splice(messageStart);
+        invalidateContextStatusCache();
+        throw error;
+      }
       target.inheritedFromSessionId = source.id;
       target.updatedAt = Date.now();
       if (!clean(target.title) && clean(source.title)) target.title = source.title;

package/src/session-runtime/runtime-core.mjs

@@ -1458,6 +1458,7 @@ export async function createMixdogSessionRuntime({
     stopSelfUpdateBootCheck: () => selfUpdate.stopBootCheck(),
     createCurrentSession,
     refreshRouteEffort,
+    computeContextStatus,
     invalidateContextStatusCache,
     invalidatePreSessionToolSurface,
     applyResolvedCwd,

package/src/session-runtime/session-lifecycle.test.mjs

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import { test } from 'node:test';
 import { makeResolveRoute } from './config-helpers.mjs';
 import { resolveRouteContextState, resolveRouteEffortState } from './session-lifecycle.mjs';
+import { inheritanceContextFit } from './lifecycle-api.mjs';
 
 test('cold route metadata preserves persisted effort and enabled Fast mode', () => {
   assert.deepEqual(resolveRouteEffortState({
@@ -100,3 +101,25 @@ test('route config treats a cleared context percentage as model-default intent',
     model: 'gpt-5.4',
   }).contextPercent, undefined);
 });
+
+test('session inheritance uses the selected model compaction boundary as its fit guard', () => {
+  assert.deepEqual(inheritanceContextFit({
+    usedTokens: 80_000,
+    contextWindow: 200_000,
+    compaction: {
+      pressureTokens: 95_000,
+      triggerTokens: 100_000,
+    },
+  }), {
+    known: true,
+    fits: true,
+    used: 95_000,
+    limit: 100_000,
+  });
+  assert.equal(inheritanceContextFit({
+    compaction: {
+      pressureTokens: 100_000,
+      triggerTokens: 100_000,
+    },
+  }).fits, false);
+});

package/src/session-runtime/tool-policy-refresh.mjs

@@ -8,6 +8,7 @@ import { applyDeferredToolSurface, filterDisallowedTools } from './tool-catalog.
 import { deferredSurfaceModeForLead } from './effort.mjs';
 import { applyInitialDeferredToolManifestToBp2, composeSystemPrompt } from '../runtime/agent/orchestrator/context/collect.mjs';
 import { _buildSharedRules, _buildLeadRules } from '../runtime/agent/orchestrator/session/manager/rules-cache.mjs';
+import { unusedModelEditToolName } from '../runtime/shared/edit-tool-dialect.mjs';
 
 function toolNames(list) {
   return (Array.isArray(list) ? list : []).map((item) => (
@@ -103,7 +104,9 @@ export function createToolPolicyRefresh({
     applyInitialDeferredToolManifestToBp2(session, pool, { rebuild: true });
 
     const allowsAgents = workflow?.delegatesAgents !== false;
-    const baseRules = _buildSharedRules({ omitTools: denied });
+    const baseRules = _buildSharedRules({
+      omitTools: [...denied, unusedModelEditToolName(getRoute()?.model)],
+    });
     const roleRules = _buildLeadRules({ includeLeadBrief: allowsAgents });
     let coreMemoryContext = '';
     if (memoryToolsEnabled()) {

package/src/session-runtime/tool-policy-surface.test.mjs

@@ -103,6 +103,18 @@ test('shared tool rules omit disabled web search and memory routes', () => {
   assert.doesNotMatch(omitted, /# Research/);
   assert.doesNotMatch(omitted, /# Memory/);
   assert.match(omitted, /`find`/);
+
+  // Exactly one edit dialect ships per model, so the rules must never describe
+  // the tool that is absent from the surface.
+  const patchOnly = buildSharedToolContent({ PLUGIN_ROOT: pluginRoot, omitTools: ['edit'] });
+  assert.doesNotMatch(patchOnly, /`edit`/);
+  assert.match(patchOnly, /Placement: use exact unchanged context/i);
+  assert.match(patchOnly, /source-file edits stay with `apply_patch`/i);
+  const editOnly = buildSharedToolContent({ PLUGIN_ROOT: pluginRoot, omitTools: ['apply_patch'] });
+  assert.doesNotMatch(editOnly, /`apply_patch`/);
+  assert.doesNotMatch(editOnly, /Add File|Update File/);
+  assert.match(editOnly, /Placement: use an exact unique target string/i);
+  assert.match(editOnly, /source-file edits stay with `edit`\./i);
 });
 
 test('shared tool rules keep workflow and shell-boundary anchors', () => {
@@ -111,15 +123,15 @@ test('shared tool rules keep workflow and shell-boundary anchors', () => {
   const full = buildSharedToolContent({ PLUGIN_ROOT: join(process.cwd(), 'src') });
   assert.match(full, /Minimize tool turns through maximal useful parallelism/i);
   assert.match(full, /In each round, issue every necessary non-overlapping call whose inputs are\s+already known/i);
+  assert.match(full, /Determine the required outcome and its gaps/i);
+  assert.match(full, /gather only what is missing, act, then verify the affected facets/i);
   assert.match(full, /Investigate, build, and verify only what the requested outcome requires, at\s+the level it requires/i);
   assert.match(full, /A check runs at the strictness the task requires; never raise a tool's own\s+severity beyond it/i);
   assert.match(full, /Cost is counted in\s+rounds, not calls/i);
-  assert.match(full, /Plan the fewest evidence-complete dependent\s+rounds first/i);
   assert.match(full, /defer a call only when its target or arguments require an\s+earlier result/i);
-  assert.match(full, /Route each remaining evidence facet once to its primary owner, preferring the\s+operation that directly returns the evidence needed for the next decision/i);
-  assert.match(full, /summary, overview, or enumeration is not a prerequisite when that operation's\s+complete inputs are already known/i);
+  assert.match(full, /Route each evidence facet once to its primary owner/i);
+  assert.match(full, /enumeration is not a prerequisite when that operation's/i);
   assert.match(full, /apply\s+one analysis to many targets as one parameterized call/i);
-  assert.match(full, /use Execution when the information can only be produced by running a program\s+or observing runtime state/i);
   assert.match(full, /Evidence or artifacts available only through program execution, calculation,\s+data transformation, generated output, or unsupported-format decoding→`shell`/i);
   assert.match(full, /an already-open shell is never a routing reason/i);
   assert.match(full, /Route the missing evidence to its primary owner/i);
@@ -138,15 +150,18 @@ test('shared tool rules keep workflow and shell-boundary anchors', () => {
   assert.match(full, /If verification fails, collect all failures, leave Verification/i);
   assert.match(full, /A successful verification closes the task unless later changes affect it/i);
   assert.doesNotMatch(full, /affected failed checks once/i);
-  assert.match(full, /Every Git operation→`git`; source-file edits stay with `edit`\/`apply_patch`/i);
+  assert.match(full, /Every Git operation→`git`; source-file edits stay with `edit`\./i);
+  assert.match(full, /Every Git operation→`git`; source-file edits stay with `apply_patch`\./i);
   assert.doesNotMatch(full, /Every repository mutation→`git`/i);
   assert.doesNotMatch(full, /always batch safely in parallel/i);
   assert.match(full, /A required new file is created directly: Add File is itself the atomic\s+absence check/i);
   assert.match(full, /Source: use exact current target text from any visible evidence/i);
-  assert.match(full, /Placement: with `edit`, use an exact unique target string/i);
-  assert.match(full, /with `apply_patch`, use exact unchanged context/i);
+  assert.match(full, /Placement: use an exact unique target string/i);
+  assert.match(full, /Placement: use exact unchanged context/i);
   assert.match(full, /Apply all determined changes in the fewest safe calls the active tool\s+supports/i);
-  assert.match(full, /Batch scope: never split one file across concurrent edit calls/i);
+  assert.match(full, /One file, several changes: one Update File block carries every hunk/i);
+  assert.match(full, /One file, several changes: issue the calls together in one turn/i);
+  assert.match(full, /Defer only ambiguous or result-dependent changes/i);
   assert.match(full, /Commit, push, release, and deployment happen only on the user's explicit\s+request/i);
   assert.match(full, /past facts recorded in prior work or sessions→`recall`/i);
   assert.match(full, /Use judgment to decide whether a durable memory should be stored/i);

package/src/tui/session/context-state.mjs

@@ -90,7 +90,11 @@ export function createContextState({ runtime, getState, updateState, getPendingS
     if (Object.keys(patch).length > 0) updateState(patch);
   }
 
-  const syncContextStats = ({ allowEstimated = false, invalidateExact = false } = {}) => {
+  const syncContextStats = ({
+    allowEstimated = false,
+    invalidateExact = false,
+    compactedEstimateTokens = null,
+  } = {}) => {
     if (getPendingSessionReset()) return null;
     const ctx = runtime.contextStatus?.() || null;
     if (!ctx) return null;
@@ -113,14 +117,24 @@ export function createContextState({ runtime, getState, updateState, getPendingS
       updateState({ stats });
       return ctx;
     }
-    const estimatedTokens = Math.max(0, Number(ctx.currentEstimatedTokens ?? ctx.usedTokens ?? 0));
+    // A compact completion already carries the estimate measured from the
+    // replacement transcript. Prefer it for this publication instead of
+    // letting a lagging contextStatus/provider snapshot repaint the deleted
+    // pre-compact prefix until the next request lands.
+    const compactedEstimate = Number(compactedEstimateTokens);
+    const hasCompactedEstimate = compactedEstimateTokens != null
+      && Number.isFinite(compactedEstimate)
+      && compactedEstimate > 0;
+    const estimatedTokens = hasCompactedEstimate
+      ? compactedEstimate
+      : Math.max(0, Number(ctx.currentEstimatedTokens ?? ctx.usedTokens ?? 0));
     const usedTokens = Math.max(0, Number(ctx.usedTokens ?? estimatedTokens ?? 0));
     const usedSource = String(ctx.usedSource || '').toLowerCase();
     // A successful pre-send auto-compact rewrites the transcript before the
     // next provider request can publish fresh usage. Never keep painting the
     // exact token count measured against the deleted pre-compact prefix during
     // that gap; publish the compacted transcript estimate immediately.
-    const forceEstimated = invalidateExact && estimatedTokens > 0;
+    const forceEstimated = hasCompactedEstimate || (invalidateExact && estimatedTokens > 0);
     const shouldPublishEstimate = allowEstimated && (
       usedSource === 'estimated'
       || Number(ctx.currentEstimatedTokens) > 0

package/src/tui/session/session-api-ext.mjs

@@ -9,7 +9,7 @@ import { flushTuiSteeringPersist } from './tui-steering-persist.mjs';
 import { getVoiceStatus, toggleVoice } from '../lib/voice-setup.mjs';
 import { createSessionOAuthFlowRegistry } from './oauth-flows.mjs';
 import { aggregateToolCategoryEntries, aggregateDoneCategories, classifyToolCategory, formatAggregateDetail, summarizeToolResult, toolLoadingTargets } from '../../runtime/shared/tool-surface.mjs';
-import { aggregateBucketForCategory, aggregateRawResult, failureDetailText, toolCallOutcome } from './tool-result-status.mjs';
+import { aggregateBucketForCategory, aggregateRawResult, aggregateToolMembers, failureDetailText, toolCallOutcome } from './tool-result-status.mjs';
 import {
   isInternalTranscriptDisplayText,
   isTranscriptCancelledStatusText,
@@ -142,6 +142,7 @@ function buildRestoredAggregateItem(members) {
       toolName: item.name,
     }, resultText);
     calls.push({
+      callId: item.id,
       name: item.name,
       args: item.args,
       category,
@@ -150,7 +151,10 @@ function buildRestoredAggregateItem(members) {
       isExitError,
       exitCode,
       resultText,
+      rawResultText: String(item.rawResult ?? item.result ?? ''),
       resolved: true,
+      startedAt: item.startedAt,
+      completedAt: item.completedAt,
       summary: !isCallError && resultText.trim()
         ? summarizeToolResult(item.name, item.args, resultText, false)
         : null,
@@ -194,6 +198,7 @@ function buildRestoredAggregateItem(members) {
     result: displayDetail,
     text: displayDetail,
     rawResult: rawResult || null,
+    toolMembers: aggregateToolMembers(calls),
     ...(latestUiDiff ? { uiDiff: latestUiDiff.uiDiff } : {}),
     expanded: false,
     headerFinalized: true,

package/src/tui/session/session-api.mjs

@@ -690,7 +690,12 @@ export function createSessionApiA(bag) {
         // no spinner until the compact already finished).
         await new Promise((resolve) => setTimeout(resolve, 0));
         const result = await runtime.compact({ recoverAgent: true });
-        syncContextStats({ allowEstimated: true });
+        const compactChanged = Boolean(result && !result.error && result.changed !== false);
+        syncContextStats({
+          allowEstimated: true,
+          invalidateExact: compactChanged,
+          compactedEstimateTokens: compactChanged ? result.afterTokens : null,
+        });
         set({ ...routeState(), stats: { ...getState().stats } });
         if (result) {
           if (!result.error && result.changed !== false) {

package/src/tui/session/tool-card-results.mjs

@@ -19,6 +19,7 @@ import {
   groupedToolResultText,
   aggregateRawResult,
   aggregateSummaries,
+  aggregateToolMembers,
   assignAggregateSummaryOrder,
   failureDetailText,
   toolCallOutcome,
@@ -104,7 +105,9 @@ export function createToolCardResults({
       callRec.isExitError = isExitError;
       callRec.exitCode = exitCode;
       callRec.resultText = text;
+      callRec.rawResultText = rawText;
       callRec.resolved = true;
+      callRec.completedAt = callRec.completedAt || Date.now();
       const allCalls = [...aggregate.calls.values()];
       const completed = allCalls.filter((r) => r.resolved).length;
       const errors = allCalls.filter((r) => r.isError).length;
@@ -138,6 +141,7 @@ export function createToolCardResults({
         count: allCalls.length,
         completedCount: visualCompleted,
         doneCategories: aggregateDoneCategories(allCalls),
+        toolMembers: aggregateToolMembers(allCalls),
         completedAt: Number(currentItem?.completedAt) || Date.now(),
       });
       card.done = true;
@@ -247,9 +251,11 @@ export function createToolCardResults({
         for (const rec of allCalls) {
           if (rec.resolved) continue;
           rec.resolved = true;
+          rec.completedAt = rec.completedAt || Date.now();
           if (!rec.completedEarly) {
             rec.isError = false;
             rec.resultText = rec.resultText || '';
+            rec.rawResultText = rec.rawResultText ?? rec.resultText;
           }
         }
         const completed = allCalls.filter((r) => r.resolved).length;
@@ -283,6 +289,7 @@ export function createToolCardResults({
           count: allCalls.length,
           completedCount: totalCompleted,
           doneCategories: aggregateDoneCategories(allCalls),
+          toolMembers: aggregateToolMembers(allCalls),
           completedAt: Date.now(),
         });
         for (const sibling of toolCards || []) {

package/src/tui/session/tool-result-status.mjs

@@ -152,7 +152,7 @@ export function aggregateRawResult(calls) {
   const chunks = [];
   for (const rec of calls || []) {
     if (rec?.resolved !== true) continue;
-    let text = String(rec?.resultText || '').replace(/\s+$/, '');
+    let text = String(rec?.rawResultText ?? rec?.resultText ?? '').replace(/\s+$/, '');
     if (!text.trim()) continue;
     const label = String(rec?.name || rec?.category || 'tool').trim() || 'tool';
     chunks.push(`${chunks.length + 1}. ${label}\n${text}`);
@@ -160,6 +160,36 @@ export function aggregateRawResult(calls) {
   return chunks.join('\n\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,
+      ...(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

package/src/tui/session/tool-result-status.test.mjs

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 
 import {
+  aggregateToolMembers,
   failureDetailText,
   shellCommandExitCode,
   toolCallOutcome,
@@ -99,3 +100,32 @@ test('shared TUI/desktop tone keeps command failures warning and tool failures r
   assert.equal(deriveToolOutcomeTone({ terminalStatus: 'exit', exitFailedCount: 1 }), 'warning');
   assert.equal(deriveToolOutcomeTone({ terminalStatus: 'failed', callFailedCount: 1 }), 'error');
 });
+
+test('aggregate members preserve atomic tool identity, inputs, outputs, and order', () => {
+  const members = aggregateToolMembers([
+    {
+      callId: 'call-read',
+      name: 'read',
+      args: { file_path: 'a.ts' },
+      resultText: 'source',
+      resolved: true,
+      isError: false,
+    },
+    {
+      callId: 'call-shell',
+      name: 'shell',
+      args: { command: 'exit 2' },
+      resultText: 'boom',
+      rawResultText: '[exit code: 2]\nboom',
+      resolved: true,
+      isError: false,
+      isExitError: true,
+    },
+  ]);
+  assert.deepEqual(members.map(({ id, name, args, result, rawResult, exitErrorCount }) => ({
+    id, name, args, result, rawResult, exitErrorCount,
+  })), [
+    { id: 'call-read', name: 'read', args: { file_path: 'a.ts' }, result: 'source', rawResult: 'source', exitErrorCount: 0 },
+    { id: 'call-shell', name: 'shell', args: { command: 'exit 2' }, result: 'boom', rawResult: '[exit code: 2]\nboom', exitErrorCount: 1 },
+  ]);
+});

package/src/tui/session/turn.mjs

@@ -9,7 +9,7 @@ import { isCancelLikeError } from '../../runtime/shared/err-text.mjs';
 import { toolCallId, toolResultCallId, toolCallName, toolCallArgs } from './tool-call-fields.mjs';
 import { promptDisplayText, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { TUI_FRAME_MS, yieldToRenderer } from './render-timing.mjs';
-import { aggregateRawResult, aggregateBucketForCategory, aggregateSummaries, assignAggregateSummaryOrder, failureDetailText, toolCallOutcome } from './tool-result-status.mjs';
+import { aggregateRawResult, aggregateBucketForCategory, aggregateSummaries, aggregateToolMembers, assignAggregateSummaryOrder, failureDetailText, toolCallOutcome } from './tool-result-status.mjs';
 
 export const STREAM_BATCH_INTERVAL_MS = TUI_FRAME_MS;
 
@@ -327,6 +327,7 @@ export function createRunTurn(bag) {
           result: displayDetail,
           text: displayDetail,
           rawResult: rawResult || null,
+          toolMembers: aggregateToolMembers(allCalls),
           isError: errors > 0,
           errorCount: errors,
           callErrorCount: callErrors,
@@ -403,6 +404,7 @@ export function createRunTurn(bag) {
         count: aggregate.calls.size,
         completedCount: [...aggregate.calls.values()].filter((r) => r.resolved || r.completedEarly).length,
         categories: Object.fromEntries(aggregate.categories),
+        toolMembers: aggregateToolMembers(aggregate.calls),
       };
       if (aggregate.pushed) {
         patchItem(aggregate.itemId, patch);
@@ -678,7 +680,9 @@ export function createRunTurn(bag) {
         callRec.isExitError = isExitError;
         callRec.exitCode = exitCode;
         callRec.resultText = text;
+        callRec.rawResultText = rawText;
         callRec.completedEarly = true;
+        callRec.completedAt = callRec.completedAt || Date.now();
         const allCalls = [...aggregate.calls.values()];
         const completedCount = allCalls.filter((r) => r.resolved || r.completedEarly).length;
         const errors = allCalls.filter((r) => r.isError).length;
@@ -710,6 +714,7 @@ export function createRunTurn(bag) {
           exitErrorCount: exitErrors,
           count: allCalls.length,
           completedCount: visualCompleted,
+          toolMembers: aggregateToolMembers(allCalls),
         };
         if (visualCompleted >= allCalls.length) {
           patch.completedAt = Number(currentItem?.completedAt) || Date.now();
@@ -889,7 +894,7 @@ export function createRunTurn(bag) {
                 count: Number(prevCategory?.count || 0) + Number(categoryEntry.count || 1),
               });
             }
-            aggregateCard.calls.set(callKey, { name, args, category, summary: null, summarySeq: null, isError: false, isCallError: false, isExitError: false, exitCode: null, resultText: null, resolved: false, completedEarly: false });
+            aggregateCard.calls.set(callKey, { callId: callKey, name, args, category, summary: null, summarySeq: null, isError: false, isCallError: false, isExitError: false, exitCode: null, resultText: null, rawResultText: null, resolved: false, completedEarly: false, startedAt: Date.now(), completedAt: null });
             touchedAggregates.add(aggregateCard);
             const card = { itemId: aggregateCard.itemId, callId: callKey, done: false, aggregate: aggregateCard };
             if (callId) {
@@ -983,7 +988,11 @@ export function createRunTurn(bag) {
           // Compaction itself remains owned by the pre-provider-send pass.
           // This event only refreshes the gauge from the already-mutated
           // transcript before another render can show stale pressure.
-          syncContextStats({ allowEstimated: true, invalidateExact: compactChanged });
+          syncContextStats({
+            allowEstimated: true,
+            invalidateExact: compactChanged,
+            compactedEstimateTokens: compactChanged ? event?.afterTokens : null,
+          });
         },
         onStageChange: async (stage, detail = null) => {
           if (!markTurnProgress(`stage:${String(stage || '')}`)) return;