elanous 0.2.41 → 0.2.43

package/src/task-orchestrator/surfaces/self-implement.ts

@@ -31,6 +31,7 @@ import { isAbandonedClassification, type AbandonedClassificationResult } from '.
 import { createExecution, type Task, type TaskExecution } from '../types.js';
 import type { DispatchContext, DispatchResult } from '../surface-registry.js';
 import { nestedPodResult } from './pod-failure-reason.js';
+import { isTddRecordTag, TDD_RECORD_TAGS, type TddRecordTag } from '../../self-implement/tdd-evidence-tags.js';
 import { SCOPE_EXPANSION_CAP, SCOPE_STOP_REASONS, isProtectedScopePath, type ScopeStopReason } from '../../self-implement/scope-adjacency.js';
 
 /** Result of one self-implement subprocess. */
@@ -145,6 +146,8 @@ export interface PodChildEvidence {
   supervisorVerdict?: unknown;
   goalCauseObserved?: true;
   terminationReason?: unknown;
+  /** TDD report-deficit facts carried as named fields, independent of clipped detail text. */
+  tddEvidenceFailure?: { reason: 'tdd-evidence-missing'; round: number; missing: TddRecordTag[] };
   accountAvailability?: Record<string, unknown>;
   prFailure?: {
     stage: 'pr-open-failed';
@@ -217,6 +220,20 @@ export function podChildEvidenceFromResult(o: Record<string, unknown>): PodChild
     if (o.ok !== false || typeof value !== 'string' || !value.trim()) return undefined;
     return redactSecretText(value).slice(0, 4_000);
   };
+  const rawTddEvidenceFailure = object(o.tddEvidenceFailure);
+  const rawTddMissing = rawTddEvidenceFailure?.missing;
+  const tddEvidenceFailure = o.ok === false && o.terminationReason === 'tdd-evidence-missing'
+    && rawTddEvidenceFailure?.reason === 'tdd-evidence-missing'
+    && typeof rawTddEvidenceFailure.round === 'number' && Number.isSafeInteger(rawTddEvidenceFailure.round) && rawTddEvidenceFailure.round >= 1
+    && Array.isArray(rawTddMissing) && rawTddMissing.length > 0 && rawTddMissing.length <= TDD_RECORD_TAGS.length
+    && rawTddMissing.every(isTddRecordTag)
+    && new Set(rawTddMissing).size === rawTddMissing.length
+    ? {
+        reason: 'tdd-evidence-missing' as const,
+        round: rawTddEvidenceFailure.round,
+        missing: rawTddMissing as TddRecordTag[],
+      }
+    : undefined;
   const failureExitCode = o.ok === false && typeof o.exitCode === 'number'
     && Number.isInteger(o.exitCode) && o.exitCode >= 0 && o.exitCode <= 255 ? o.exitCode : undefined;
   const outOfScopeEdits = scrubValue(o.outOfScopeEdits);
@@ -248,7 +265,10 @@ export function podChildEvidenceFromResult(o: Record<string, unknown>): PodChild
     ...(abandoned ? { abandonedClassification: abandoned } : {}),
     ...(o.supervisorVerdict !== undefined ? { supervisorVerdict: scrubValue(o.supervisorVerdict) } : {}),
     ...(o.goalCauseObserved === true ? { goalCauseObserved: true } : {}),
-    ...(o.terminationReason !== undefined ? { terminationReason: scrubValue(o.terminationReason) } : {}),
+    ...(o.terminationReason === 'tdd-evidence-missing'
+      ? (tddEvidenceFailure ? { terminationReason: 'tdd-evidence-missing' } : {})
+      : o.terminationReason !== undefined ? { terminationReason: scrubValue(o.terminationReason) } : {}),
+    ...(tddEvidenceFailure ? { tddEvidenceFailure } : {}),
     ...(accountAvailability ? { accountAvailability } : {}),
     ...(o.harvestable === true && typeof o.branch === 'string' && o.branch.trim() ? { harvestable: true } : {}),
     ...(typeof o.prNumber === 'number' && Number.isSafeInteger(o.prNumber) && o.prNumber > 0 ? { prNumber: o.prNumber } : {}),
@@ -294,6 +314,8 @@ export interface SelfImplementJobSpawn {
     draft?: boolean;
     /** Distinct-per-job harness-space id → own screen/log buffer. */
     spaceId: string;
+    /** Orchestrator task identity, preserved with terminal Pod failure evidence. */
+    taskId?: string;
     signal?: AbortSignal;
     /** Optional TC-owned warm-worker command. The warm request is advisory; this feature Job remains authoritative. */
     warmWorkerCommand?: WarmWorkerCommand;
@@ -394,6 +416,7 @@ export function createSelfImplementAdapter(opts: SelfImplementAdapterOptions) {
         ...(surface.openPr !== undefined ? { openPr: surface.openPr } : {}),
         ...(surface.draft !== undefined ? { draft: surface.draft } : {}),
         spaceId,
+        taskId: task.id,
         ...(ctx.signal ? { signal: ctx.signal } : {}),
       });
       address = res.address;
@@ -606,8 +629,9 @@ export function reviewGateFields(o: Record<string, unknown>): Pick<SelfImplement
 export function reportUnmappedDispositionFields(
   raw: Record<string, unknown>,
   mapped: SelfImplementDisposition,
+  knownRawFields: readonly string[] = [],
 ): readonly string[] {
-  const known = new Set(Object.keys(mapped));
+  const known = new Set([...Object.keys(mapped), ...knownRawFields]);
   const unmapped = Object.keys(raw).filter((key) => !known.has(key) && raw[key] !== undefined);
   if (unmapped.length > 0) {
     try {
@@ -716,7 +740,7 @@ export function parseSelfImplementJson(stdout: string): SelfImplementDisposition
             && ((o.review as { mustFix: unknown[] }).mustFix).every((item) => typeof item === 'string')
             ? { mustFix: (o.review as { mustFix: string[] }).mustFix } : {}),
       };
-      reportUnmappedDispositionFields(o, mapped);
+      reportUnmappedDispositionFields(o, mapped, ['terminationReason', 'tddEvidenceFailure']);
       return mapped;
     } catch { /* not this line */ }
   }

package/src/task-orchestrator/surfaces/warm-reuse-evidence.ts

@@ -0,0 +1,169 @@
+/** Durable, fail-closed evidence written only from an observed warm-worker lease. */
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, rmdirSync, statSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { dirname, join } from 'node:path';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { debug } from '../../debug/log.js';
+import type { WarmReuseEvidence, WarmReuseEvidenceByConsumer, WarmReuseConsumer } from './pod-warm-switch.js';
+
+const SHA = /^[0-9a-f]{40}$/i;
+const LOCK_HASH = /^[0-9a-f]{64}$/i;
+const MAX_BYTES = 4 * 1024 * 1024;
+const MAX_ROWS = 256;
+export const WARM_REUSE_EVIDENCE_MAX_AGE_MS = 60 * 60_000;
+
+export interface WarmReuseEvidenceRow {
+  schema: 1;
+  consumer: WarmReuseEvidenceConsumer;
+  pr?: number;
+  head: string;
+  main: string;
+  recordedAt: string;
+  /** Actual warm provider lease identity. Omitted on cold/fallback/timeout. */
+  leaseId?: string;
+  workerId?: string;
+  generation?: number;
+  expectedLockHash?: string;
+  workerLockHash?: string;
+  leaseValid?: boolean;
+  canaryPassed?: boolean;
+  agree?: boolean;
+  reason?: string;
+}
+
+export type WarmReuseEvidenceConsumer = 'gate-recheck' | 'land' | 'ta';
+
+export interface ActualWarmLeaseEvidence {
+  workerId: string;
+  leaseId: string;
+  generation: number;
+  expectedLockHash: string;
+  workerLockHash: string;
+  leaseValid: boolean;
+  canaryPassed: boolean;
+  agree: boolean;
+}
+
+export function warmReuseEvidencePath(root = effectiveInstanceRoot()): string {
+  return join(root, 'warm-reuse-evidence.jsonl');
+}
+
+function validRow(value: unknown): value is WarmReuseEvidenceRow {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const row = value as Partial<WarmReuseEvidenceRow>;
+  return row.schema === 1 && ['gate-recheck', 'land', 'ta'].includes(row.consumer ?? '')
+    && (row.pr === undefined || typeof row.pr === 'number' && Number.isSafeInteger(row.pr) && row.pr > 0)
+    && typeof row.head === 'string' && SHA.test(row.head) && typeof row.main === 'string' && SHA.test(row.main)
+    && typeof row.recordedAt === 'string' && Number.isFinite(Date.parse(row.recordedAt))
+    && (row.leaseId === undefined || typeof row.leaseId === 'string' && row.leaseId.length > 0)
+    && (row.workerId === undefined || typeof row.workerId === 'string' && row.workerId.length > 0)
+    && (row.generation === undefined || typeof row.generation === 'number' && Number.isSafeInteger(row.generation) && row.generation > 0)
+    && (row.expectedLockHash === undefined || typeof row.expectedLockHash === 'string' && LOCK_HASH.test(row.expectedLockHash))
+    && (row.workerLockHash === undefined || typeof row.workerLockHash === 'string' && LOCK_HASH.test(row.workerLockHash))
+    && (row.leaseValid === undefined || typeof row.leaseValid === 'boolean')
+    && (row.canaryPassed === undefined || typeof row.canaryPassed === 'boolean')
+    && (row.agree === undefined || typeof row.agree === 'boolean')
+    && (row.reason === undefined || typeof row.reason === 'string');
+}
+
+/** Append a bounded JSONL observation. A missing/invalid warm lease is recorded as unmeasured, never green. */
+export function recordWarmReuseEvidence(path: string, row: WarmReuseEvidenceRow): void {
+  if (!validRow(row)) throw new Error('invalid warm reuse evidence row');
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const lock = `${path}.lock`;
+  const deadline = Date.now() + 10_000;
+  for (;;) {
+    try { mkdirSync(lock); break; }
+    catch {
+      try { if (Date.now() - statSync(lock).mtimeMs > 30_000) { rmdirSync(lock); continue; } } catch { continue; }
+      if (Date.now() >= deadline) throw new Error('timed out locking warm reuse evidence');
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  }
+  try {
+    let rows: string[] = [];
+    try {
+      const contents = readFileSync(path, 'utf8');
+      if (Buffer.byteLength(contents) <= MAX_BYTES) rows = contents.split(/\r?\n/).filter(Boolean).slice(-(MAX_ROWS - 1));
+    } catch { /* first write */ }
+    const safe = typeof row.leaseValid === 'boolean' && row.leaseId && row.workerId && row.generation && row.expectedLockHash
+      && row.workerLockHash && row.canaryPassed !== undefined && row.agree !== undefined
+      ? row
+      : { schema: 1 as const, consumer: row.consumer, ...(row.pr ? { pr: row.pr } : {}), head: row.head, main: row.main,
+          recordedAt: row.recordedAt, reason: row.reason ?? 'warm-lease-unmeasured' };
+    const body = [...rows, JSON.stringify(safe)].join('\n') + '\n';
+    const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try { writeFileSync(tempPath, body, { mode: 0o600, flag: 'wx' }); renameSync(tempPath, path); }
+    catch (error) { rmSync(tempPath, { force: true }); throw error; }
+  } finally { try { rmdirSync(lock); } catch { /* best-effort release */ } }
+}
+
+/** Read only exact head/main rows. Invalid, oversized, or absent files produce no evidence. */
+export function readWarmReuseEvidence(path: string, identity: { consumer: WarmReuseEvidenceConsumer; pr?: number; head: string; main: string }, limit = 32, now = Date.now()): WarmReuseEvidenceRow[] | undefined {
+  if (!['gate-recheck', 'land', 'ta'].includes(identity.consumer) || (identity.pr !== undefined && (!Number.isSafeInteger(identity.pr) || identity.pr <= 0)) || !SHA.test(identity.head) || !SHA.test(identity.main)
+    || !Number.isSafeInteger(limit) || limit < 1 || !Number.isFinite(now)) return undefined;
+  try {
+    if (!existsSync(path)) return undefined;
+    const contents = readFileSync(path, 'utf8');
+    if (Buffer.byteLength(contents) > MAX_BYTES) return undefined;
+    const lines = contents.split(/\r?\n/).filter(Boolean);
+    if (lines.length > MAX_ROWS) return undefined;
+    const rows: WarmReuseEvidenceRow[] = [];
+    for (const line of lines) {
+      let row: unknown;
+      try { row = JSON.parse(line); } catch { return undefined; }
+      if (!validRow(row)) return undefined;
+      if (row.consumer === identity.consumer && (identity.pr === undefined || row.pr === identity.pr)
+        && row.head === identity.head && row.main === identity.main) {
+        const recordedAt = Date.parse(row.recordedAt);
+        if (recordedAt > now) return undefined;
+        if (now - recordedAt <= WARM_REUSE_EVIDENCE_MAX_AGE_MS) rows.push(row);
+      }
+    }
+    rows.splice(0, Math.max(0, rows.length - limit));
+    return rows.length ? rows : undefined;
+  } catch { return undefined; }
+}
+
+/** Read exact source-pair evidence for each consumer and summarize only observed rows. */
+export function loadWarmReuseEvidenceByConsumer(
+  identity: { head: string; main: string } | undefined, path = warmReuseEvidencePath(),
+): WarmReuseEvidenceByConsumer | undefined {
+  const result: WarmReuseEvidenceByConsumer = {};
+  const consumers: readonly WarmReuseEvidenceConsumer[] = ['gate-recheck', 'land', 'ta'];
+  const exactIdentity = identity && SHA.test(identity.head) && SHA.test(identity.main) ? identity : undefined;
+  for (const consumer of consumers) {
+    const rows = exactIdentity ? readWarmReuseEvidence(path, { consumer, ...exactIdentity }) : undefined;
+    const latest = rows?.[rows.length - 1];
+    if (!rows?.length || !latest) {
+      try { debug.log('pod.warm', 'evidence-supplied', { consumer, measured: false }); } catch { /* observation only */ }
+      continue;
+    }
+    const lock = latest.expectedLockHash ?? '';
+    let consecutiveMatchSamples = 0;
+    for (let index = rows.length - 1; index >= 0; index--) {
+      const row = rows[index]!;
+      const identityComplete = !!row.leaseId && !!row.workerId && Number.isSafeInteger(row.generation)
+        && !!row.expectedLockHash && !!row.workerLockHash;
+      if (!identityComplete || row.workerId !== latest.workerId || row.expectedLockHash !== lock || row.workerLockHash !== lock
+        || row.leaseValid !== true || row.canaryPassed !== true || row.agree !== true) break;
+      consecutiveMatchSamples++;
+    }
+    const evidence: WarmReuseEvidence = {
+      consecutiveMatchSamples,
+      recentMismatchCount: rows.filter((row) => row.agree === false).length,
+      ...(typeof latest.leaseValid === 'boolean'
+        ? { leaseValid: latest.leaseValid && !!latest.leaseId && !!latest.workerId && Number.isSafeInteger(latest.generation) }
+        : {}),
+      ...(typeof latest.canaryPassed === 'boolean' ? { canaryPassed: latest.canaryPassed } : {}),
+      expected: { head: exactIdentity!.head, main: exactIdentity!.main, lock },
+      worker: { head: exactIdentity!.head, main: exactIdentity!.main, lock: latest.workerLockHash ?? '' },
+    };
+    result[consumer as WarmReuseConsumer] = evidence;
+    const measured = typeof latest.leaseValid === 'boolean' && !!latest.leaseId && !!latest.workerId
+      && Number.isSafeInteger(latest.generation) && typeof latest.canaryPassed === 'boolean'
+      && !!latest.expectedLockHash && !!latest.workerLockHash && typeof latest.agree === 'boolean';
+    try { debug.log('pod.warm', 'evidence-supplied', { consumer, measured }); } catch { /* observation only */ }
+  }
+  return Object.keys(result).length ? result : undefined;
+}

package/src/task-orchestrator/types.ts

@@ -531,6 +531,17 @@ export type TaskExecutionStatus =
   | 'timeout'
   | 'cancelled';
 
+/** Explicit browser capture provenance forwarded from the run-scoped harness event. */
+export interface TaskCaptureArtifact {
+  path: string;
+  mimeType: string;
+  runId: string;
+  linearIssueId: string;
+  externalShare: boolean;
+  sensitivity: string;
+  createdAt: number;
+}
+
 export interface TaskExecution {
   readonly id: string;             // 'exec:<hex>'
   readonly taskId: string;
@@ -548,6 +559,9 @@ export interface TaskExecution {
   /** The agent ran, but its reported outcome needs human review rather than automatic completion. */
   reviewRequired?: boolean;
   outputPath?: string;
+  /** Harness run identity and approved captures observed during this exact execution window. */
+  runId?: string;
+  captureArtifacts?: TaskCaptureArtifact[];
   error?: { code: string; message: string; stack?: string };
   tokenUsage?: { input: number; output: number };
   costUsd?: number;

package/src/telegram.ts

@@ -1820,23 +1820,21 @@ export class TelegramBot {
     if (!fromVoice && ctx.text && !ctx.text.startsWith('/')) {
       try {
         const ambientMode = this.slashContext?.userConfig.intake.telegram.ambientCapture ?? 'off';
-        if (ambientMode !== 'off') {
-          const { maybeHandleTelegramAmbientMessage } = await import('./intake-plane/adapters/telegram-ambient.js');
-          const ambientReply = await maybeHandleTelegramAmbientMessage({
-            text: ctx.text,
-            chatId: ctx.chatId,
-            userId: ctx.userId,
-            ...(ctx.userName ? { userName: ctx.userName } : {}),
-            ...(ctx.threadId != null ? { threadId: ctx.threadId } : {}),
-            ambientCapture: ambientMode,
+        const { maybeHandleTelegramAmbientMessage } = await import('./intake-plane/adapters/telegram-ambient.js');
+        const ambientReply = await maybeHandleTelegramAmbientMessage({
+          text: ctx.text,
+          chatId: ctx.chatId,
+          userId: ctx.userId,
+          ...(ctx.userName ? { userName: ctx.userName } : {}),
+          ...(ctx.threadId != null ? { threadId: ctx.threadId } : {}),
+          ambientCapture: ambientMode,
+        });
+        if (ambientReply) {
+          await this.sendMessage(ctx.chatId, ambientReply, {
+            replyTo: ctx.messageId,
+            threadId: ctx.threadId,
           });
-          if (ambientReply) {
-            await this.sendMessage(ctx.chatId, ambientReply, {
-              replyTo: ctx.messageId,
-              threadId: ctx.threadId,
-            });
-            return;
-          }
+          return;
         }
       } catch (err) {
         this.log(`telegram ambient-intake failed: ${err instanceof Error ? err.message : String(err)}`);

package/src/terminal/coding-agent.ts

@@ -1,7 +1,7 @@
 // Coding-agent terminal preset.
 //
 // Thin wrapper over TerminalSessionRegistry that knows how to spawn
-// a "live agent host" session (claude-code / codex) with:
+// a "live agent host" session (claude-code / codex / grok) with:
 //
 //   • ELANOUS_SESSION_ID env so the child can self-identify in any
 //     scripts/hooks it runs
@@ -22,6 +22,8 @@ import type { ChromeControlResult } from '../ui/modal-adapter.js';
 export interface SpawnCodingAgentOpts {
   brand: CodingAgentBrand;
   cwd: string;
+  /** Optional stable UUID used to bind scoped mission-line authority to this PTY. */
+  id?: string;
   /** Extra CLI args to pass through after the binary name. */
   extraArgs?: string[];
   /** Override title. Defaults to `<brand> [<basename(cwd)>]`. */
@@ -74,8 +76,9 @@ export function spawnCodingAgent(
 
   const cwdName = basenameSafe(opts.cwd);
   const title = opts.title ?? `${opts.brand} [${cwdName}]`;
-  const rawCommand = opts.extraArgs && opts.extraArgs.length > 0
-    ? `${binary} ${opts.extraArgs.join(' ')}`
+  const extraArgs = opts.extraArgs ?? (opts.brand === 'grok' ? ['--always-approve'] : undefined);
+  const rawCommand = extraArgs && extraArgs.length > 0
+    ? `${binary} ${extraArgs.join(' ')}`
     : binary;
   // Only `claude` reads the macOS keychain — codex does not. Gate
   // the SSH unlock preamble on brand to avoid spawning a `sh -c`
@@ -92,8 +95,12 @@ export function spawnCodingAgent(
   // SSH keychain wrap and any other path-relative lookup. The
   // captured env mirrors what a fresh Terminal.app login would see
   // (see shell-env-bootstrap.ts), so it's the right baseline.
+  const callerEnv = { ...(opts.env ?? {}) };
+  const grokAuthEnvKeys = ['XAI_API_KEY', 'GROK_API_KEY', 'GROK_CODE_XAI_API_KEY'] as const;
+  if (opts.brand === 'grok') for (const key of grokAuthEnvKeys) delete callerEnv[key];
   const env: Record<string, string> = buildPtyEnv({
-    ...(opts.env ?? {}),
+    ...callerEnv,
+    ...(opts.brand === 'grok' ? { GROK_DISABLE_API_KEY_AUTH: '1' } : {}),
     ELANOUS_AGENT_BRAND: opts.brand,
     // Session id is filled in below once we know it.
     TERM: 'xterm-ghostty',
@@ -104,10 +111,11 @@ export function spawnCodingAgent(
     COLORTERM: 'truecolor',
     CLICOLOR: '1',
     CLICOLOR_FORCE: '1',
-  });
+  }, process.env, { unset: opts.brand === 'grok' ? grokAuthEnvKeys : [] });
 
   const session = deps.registry.spawn(
     {
+      id: opts.id,
       title,
       cwd: opts.cwd,
       command,
@@ -138,6 +146,7 @@ function binaryForBrand(brand: CodingAgentBrand): string {
     case 'claude-code': return 'claude';
     case 'codex':       return 'codex';
     case 'gemini':      return 'gemini';
+    case 'grok':        return 'grok';
   }
 }
 

package/src/terminal/session-registry.ts

@@ -33,7 +33,7 @@ import { defaultControlSignalBus, type ControlSignalBus } from '../input/control
 
 export type SessionState = 'foreground' | 'background' | 'exited';
 export type SessionKind = 'shell' | 'coding-agent';
-export type CodingAgentBrand = 'claude-code' | 'codex' | 'gemini';
+export type CodingAgentBrand = 'claude-code' | 'codex' | 'gemini' | 'grok';
 
 export interface TerminalSession {
   readonly id: string;

package/src/tokens.ts

@@ -33,7 +33,32 @@ export function estimateTokens(text: string): number {
   return Math.ceil(ascii / 4 + wide / 2);
 }
 
-export interface MessageLike { role: string; content: string | unknown[] }
+export interface MessageLike {
+  role: string;
+  content: string | unknown[];
+  /** Opaque reasoning replayed by the Codex Responses adapter. */
+  codexReasoningItems?: unknown[];
+}
+
+function estimateStructuredTokens(value: unknown, ancestors = new Set<object>()): number {
+  if (typeof value === 'string') return estimateTokens(value);
+  if (value === null || typeof value !== 'object') return 1;
+  if (ancestors.has(value)) return 200; // malformed cyclic extension: conservative block floor
+  ancestors.add(value);
+  let total = 2; // JSON brackets/braces
+  if (Array.isArray(value)) {
+    total += Math.ceil(value.length / 4); // commas
+    for (const item of value) total += estimateStructuredTokens(item, ancestors);
+  } else {
+    const entries = Object.entries(value);
+    total += Math.ceil(entries.length / 4); // commas
+    for (const [key, item] of entries) {
+      total += estimateTokens(key) + 1 + estimateStructuredTokens(item, ancestors);
+    }
+  }
+  ancestors.delete(value);
+  return total;
+}
 
 export function estimateMessagesTokens(messages: MessageLike[]): number {
   let total = 0;
@@ -44,7 +69,12 @@ export function estimateMessagesTokens(messages: MessageLike[]): number {
       for (const block of m.content) {
         if (!block || typeof block !== 'object') continue;
         const obj = block as Record<string, unknown>;
-        if (typeof obj.text === 'string') {
+        if (obj.type === 'tool_use' || obj.type === 'tool_result') {
+          // These payloads are replayed as structured JSON; fixed block cost
+          // misses large args/results. Retain the old 200-token floor for
+          // tiny blocks so many small calls cannot under-trigger compaction.
+          total += Math.max(200, estimateStructuredTokens(obj));
+        } else if (typeof obj.text === 'string') {
           total += estimateTokens(obj.text);
         } else if (typeof obj.content === 'string') {
           // Wave 2 (2026-05-04) · tool_result block content matters
@@ -58,6 +88,9 @@ export function estimateMessagesTokens(messages: MessageLike[]): number {
         }
       }
     }
+    if (m.role === 'assistant' && m.codexReasoningItems?.length) {
+      total += estimateStructuredTokens(m.codexReasoningItems);
+    }
   }
   return total;
 }

package/src/tool-hints/gate.ts

@@ -144,6 +144,7 @@ export function evaluateGate(
   if (signals.intentResearch) {
     bumpIfEnabled(enabled, boost, 'web_search', 2);
     bumpIfEnabled(enabled, boost, 'omni_search', 2);
+    bumpIfEnabled(enabled, boost, 'web_fetch', 2);
   }
   if (signals.intentDiagram) {
     bumpIfEnabled(enabled, boost, 'mermaid_render', 2);

package/src/tool-runtime/agent-runtime.ts

@@ -10,10 +10,12 @@ export const agentRuntime: ToolRuntime<Record<string, unknown>, AgentToolResult>
   spec: buildAgentTool(),
   async run(req, ctx) {
     return await dispatchAgent(req, {
+      ...(ctx.parentSessionId ? { parentSessionId: ctx.parentSessionId } : {}),
       ...(ctx.agentCwd ? { cwd: ctx.agentCwd } : {}),
       hostTools: ctx.agentHostTools,
       dispatchTool: ctx.agentDispatchTool,
       buildChildToolCatalog: ctx.buildChildToolCatalog,
+      inheritGeneralPurposeToolCatalog: ctx.inheritGeneralPurposeToolCatalog,
       signal: ctx.signal,
     });
   },