mixdog 0.9.47 → 0.9.50

package/scripts/tool-smoke.mjs

@@ -30,6 +30,7 @@ import {
   shouldRecordObservedForProvider,
 } from '../src/runtime/agent/orchestrator/agent-runtime/cache-strategy.mjs';
 import { executeBuiltinTool } from '../src/runtime/agent/orchestrator/tools/builtin.mjs';
+import { executeFuzzyFindTool } from '../src/runtime/agent/orchestrator/tools/builtin/list-tool.mjs';
 import { applyGrepContextLeadPolicy, GREP_CONTEXT_MAX, validateBuiltinArgs } from '../src/runtime/agent/orchestrator/tools/builtin/arg-guard.mjs';
 import { normaliseReadLineWindowArgs } from '../src/runtime/agent/orchestrator/tools/builtin/read-args.mjs';
 import { BUILTIN_TOOLS } from '../src/runtime/agent/orchestrator/tools/builtin/builtin-tools.mjs';
@@ -44,10 +45,16 @@ import { TOOL_DEFS as SEARCH_TOOL_DEFS } from '../src/runtime/search/tool-defs.m
 import { TOOL_DEFS as CHANNEL_TOOL_DEFS } from '../src/runtime/channels/tool-defs.mjs';
 import { AGENT_OWNER } from '../src/runtime/agent/orchestrator/agent-owner.mjs';
 import { recursiveWrapperToolNameForPublicAgent } from '../src/runtime/agent/orchestrator/session/manager/tool-resolution.mjs';
+import {
+  applyDeferredToolSurface,
+  reconcileDeferredMcpToolCatalog,
+} from '../src/session-runtime/tool-catalog.mjs';
+import { prepareDeferredToolCallThrough } from '../src/runtime/agent/orchestrator/session/loop/deferred-call-through.mjs';
 import { composeSystemPrompt } from '../src/runtime/agent/orchestrator/context/collect.mjs';
 import { setInternalToolsProvider } from '../src/runtime/agent/orchestrator/internal-tools.mjs';
 import { prepareAgentSession } from '../src/runtime/agent/orchestrator/agent-runtime/session-builder.mjs';
 import { resolveHiddenRoleSchemaAllowedTools } from '../src/runtime/agent/orchestrator/agent-runtime/agent-dispatch.mjs';
+import { assertCodeGraphDescriptionContract } from './code-graph-description-contract.mjs';
 import { getHiddenAgent, resolveAgentSessionPermission } from '../src/runtime/agent/orchestrator/internal-agents.mjs';
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
@@ -492,8 +499,8 @@ const findOut = await executeBuiltinTool('find', {
 }, root);
 assertOk('find', findOut, /scripts[\\/]tool-smoke\.mjs/i);
 
-// find query[] batch: fan-out must emit one section per query in caller order
-// and share the broad enumeration sweep across queries (single-flight dedup).
+// End-to-end find query[] batch: fan-out must emit one section per query in
+// caller order.
 const findBatchOut = await executeBuiltinTool('find', {
   query: ['tool smoke', 'smoke'],
   path: '.',
@@ -514,6 +521,48 @@ const findBatchOut = await executeBuiltinTool('find', {
   }
 }
 
+// Exercise the test-only rg seam directly so this verifies the in-flight
+// single-flight rather than merely observing cached output from the real tree.
+// TTL=0 rules out persistent broad-enumeration cache reuse; the delayed listing
+// keeps both exact-name workers concurrent while the first sweep is in flight.
+{
+  const previousFindEnumCacheTtl = process.env.MIXDOG_FIND_ENUM_CACHE_TTL_MS;
+  const firstQuery = 'tool-smoke-single-flight-first.mjs';
+  const secondQuery = 'tool-smoke-single-flight-second.mjs';
+  const firstPath = `fixtures/${firstQuery}`;
+  const secondPath = `fixtures/${secondQuery}`;
+  let broadEnumerationCalls = 0;
+  process.env.MIXDOG_FIND_ENUM_CACHE_TTL_MS = '0';
+  try {
+    const singleFlightOut = await executeFuzzyFindTool({
+      query: [firstQuery, secondQuery],
+      path: '.',
+      head_limit: 5,
+    }, root, {
+      __runRg: async () => {
+        broadEnumerationCalls += 1;
+        await new Promise((resolve) => setTimeout(resolve, 20));
+        return `${firstPath}\n${secondPath}\n`;
+      },
+    });
+    const s = String(singleFlightOut);
+    const iA = s.indexOf(`# find ${firstQuery}`);
+    const iB = s.indexOf(`# find ${secondQuery}`);
+    if (broadEnumerationCalls !== 1) {
+      throw new Error(`find query[] must share exactly one broad enumeration, got ${broadEnumerationCalls}`);
+    }
+    if (iA < 0 || iB < 0 || !(iA < iB)) {
+      throw new Error(`find query[] seam must preserve section order:\n${s}`);
+    }
+    if (!s.slice(iA, iB).includes(firstPath) || !s.slice(iB).includes(secondPath)) {
+      throw new Error(`find query[] seam must retain both exact-name bodies:\n${s}`);
+    }
+  } finally {
+    if (previousFindEnumCacheTtl === undefined) delete process.env.MIXDOG_FIND_ENUM_CACHE_TTL_MS;
+    else process.env.MIXDOG_FIND_ENUM_CACHE_TTL_MS = previousFindEnumCacheTtl;
+  }
+}
+
 const readOut = await executeBuiltinTool('read', {
   path: 'scripts/smoke.mjs',
   offset: 0,
@@ -1922,6 +1971,9 @@ const memoryProps = memoryTool?.inputSchema?.properties || {};
 if (!/mutation/i.test(memoryTool?.description || '') || !/Exact confirmation phrase/i.test(memoryProps.confirm?.description || '')) {
   throw new Error('memory schema must preserve mutation/destructive confirmation guidance');
 }
+if (memoryProps.category || /category/i.test(memoryTool?.description || '')) {
+  throw new Error('memory mutation schema must not expose category');
+}
 const searchTool = SEARCH_TOOL_DEFS.find((tool) => tool.name === 'search');
 const searchProps = searchTool?.inputSchema?.properties || {};
 if (!/Runs synchronously/i.test(searchTool?.description || '') || searchProps.mode || searchProps.action || searchProps.task_id || !searchProps.query?.anyOf || !/array for fan-out/i.test(searchProps.query?.description || '')) {
@@ -1940,7 +1992,8 @@ if (!/offset/i.test(webFetchProps.startIndex?.description || '') || !/Maximum ch
 }
 if (!/deferred tools/i.test(TOOL_SEARCH_TOOL.description || '')
   || !TOOL_SEARCH_TOOL.inputSchema?.properties?.names
-  || !TOOL_SEARCH_TOOL.inputSchema?.properties?.select) {
+  || !TOOL_SEARCH_TOOL.inputSchema?.properties?.select
+  || TOOL_SEARCH_TOOL.inputSchema?.additionalProperties !== false) {
   throw new Error('load_tool schema must preserve loader guidance plus names + legacy select fields');
 }
 const toolSearchSession = {
@@ -1994,6 +2047,7 @@ if (!Array.isArray(toolSearchSession.deferredDiscoveredTools) || !toolSearchSess
   throw new Error('tool_search must persist discovered tool state on the session');
 }
 const nativeToolSearchSession = {
+  provider: 'openai-oauth',
   tools: smokeCatalog.filter((tool) => fullDefaults.has(tool?.name)),
   deferredToolCatalog: smokeCatalog.slice(),
   deferredSelectedTools: [...fullDefaults],
@@ -2001,21 +2055,111 @@ const nativeToolSearchSession = {
   deferredProviderMode: 'native',
   deferredNativeTools: true,
 };
+nativeToolSearchSession.deferredCallableTools = nativeToolSearchSession.tools.map((tool) => tool.name);
+const nativeBaseToolsJson = JSON.stringify(nativeToolSearchSession.tools);
+const nativeBaseRequest = buildRequestBody(
+  [{ role: 'user', content: 'load shell' }],
+  'gpt-5.4',
+  nativeToolSearchSession.tools,
+  { sessionId: 'deferred-stability', session: nativeToolSearchSession },
+);
 const nativeSelectResult = JSON.parse(__renderToolSearchForTest({ select: 'shell,recall' }, nativeToolSearchSession, 'full'));
-if (nativeSelectResult.activeTools.includes('shell') || nativeSelectResult.activeTools.includes('recall')) {
-  throw new Error(`native tool_search must not mutate active tool schemas: ${JSON.stringify(nativeSelectResult)}`);
-}
 for (const name of ['shell', 'task', 'recall']) {
-  if (!nativeSelectResult.discoveredTools.includes(name)) {
-    throw new Error(`native tool_search missing discovered ${name}: ${JSON.stringify(nativeSelectResult)}`);
+  if (!nativeSelectResult.activeTools.includes(name)) {
+    throw new Error(`native load_tool must register ${name} as callable: ${JSON.stringify(nativeSelectResult)}`);
   }
 }
+if (JSON.stringify(nativeToolSearchSession.tools) !== nativeBaseToolsJson
+  || nativeToolSearchSession.tools.some((tool) => tool?.name === 'shell')) {
+  throw new Error(`native load_tool must keep the base tools array byte-stable: ${JSON.stringify(nativeToolSearchSession.tools)}`);
+}
 if (!nativeSelectResult.nativeToolSearch?.openaiTools?.some((tool) => tool?.name === 'shell' && tool?.defer_loading === true)) {
   throw new Error(`native tool_search must return OpenAI loadable deferred tools: ${JSON.stringify(nativeSelectResult.nativeToolSearch)}`);
 }
 if (!nativeSelectResult.nativeToolSearch?.toolReferences?.includes('shell')) {
   throw new Error(`native tool_search must return Anthropic tool references: ${JSON.stringify(nativeSelectResult.nativeToolSearch)}`);
 }
+const nativeToolCountAfterFirstLoad = nativeToolSearchSession.tools.length;
+const nativeRepeatResult = JSON.parse(__renderToolSearchForTest({ select: 'shell,recall' }, nativeToolSearchSession, 'full'));
+if (nativeRepeatResult.loaded.length
+  || !['shell', 'task', 'recall'].every((name) => nativeRepeatResult.alreadyActive.includes(name))
+  || nativeRepeatResult.nativeToolSearch?.toolReferences?.length
+  || nativeRepeatResult.nativeToolSearch?.openaiTools?.length
+  || nativeToolSearchSession.tools.length !== nativeToolCountAfterFirstLoad) {
+  throw new Error(`repeated native load_tool must report already-active without reinjection: ${JSON.stringify(nativeRepeatResult)}`);
+}
+const nativeHistory = [
+  { role: 'user', content: 'load shell' },
+  {
+    role: 'assistant',
+    content: '',
+    toolCalls: [{ id: 'search-1', name: 'load_tool', arguments: { names: ['shell'] }, nativeType: 'tool_search_call' }],
+  },
+  {
+    role: 'tool',
+    toolCallId: 'search-1',
+    content: nativeSelectResult.nativeToolSearch.summary,
+    nativeToolSearch: nativeSelectResult.nativeToolSearch,
+  },
+];
+const nativeFollowupRequest = buildRequestBody(
+  nativeHistory,
+  'gpt-5.4',
+  nativeToolSearchSession.tools,
+  { sessionId: 'deferred-stability', session: nativeToolSearchSession },
+);
+if (JSON.stringify(nativeFollowupRequest.tools) !== JSON.stringify(nativeBaseRequest.tools)
+  || nativeFollowupRequest.prompt_cache_key !== nativeBaseRequest.prompt_cache_key) {
+  throw new Error('OpenAI native loading must not change tools or prompt_cache_key');
+}
+const nativeOutput = nativeFollowupRequest.input.find((item) => item?.type === 'tool_search_output');
+if (!nativeOutput?.tools?.some((tool) => tool?.name === 'shell')
+  || nativeFollowupRequest.tools.some((tool) => tool?.name === 'shell')) {
+  throw new Error(`OpenAI loaded schemas must exist only in tool_search_output history: ${JSON.stringify(nativeFollowupRequest)}`);
+}
+const directMcpSession = {
+  provider: 'openai-oauth',
+  toolSpec: 'full',
+  tools: [{ name: 'load_tool', inputSchema: { type: 'object', properties: {} } }],
+  deferredToolCatalog: [
+    { name: 'load_tool', inputSchema: { type: 'object', properties: {} } },
+    { name: 'mcp__demo__ping', annotations: { readOnlyHint: true }, inputSchema: { type: 'object', properties: {} } },
+  ],
+  deferredCallableTools: ['load_tool', 'mcp__demo__ping'],
+  deferredProviderMode: 'native',
+  deferredNativeTools: true,
+};
+prepareDeferredToolCallThrough(directMcpSession, 'mcp__demo__ping', {});
+if (directMcpSession.tools.some((tool) => tool?.name === 'mcp__demo__ping')
+  || !directMcpSession.deferredCallableTools.includes('mcp__demo__ping')) {
+  throw new Error('subsequent native MCP calls must use the callable registry without session.tools promotion');
+}
+const readonlyReportingSession = {
+  tools: [TOOL_SEARCH_TOOL],
+  deferredToolCatalog: smokeCatalog.slice(),
+  deferredSelectedTools: ['load_tool'],
+};
+const readonlyReportingResult = JSON.parse(__renderToolSearchForTest(
+  { names: ['shell', 'definitely_missing_tool'] },
+  readonlyReportingSession,
+  'readonly',
+  {
+    mcpStatus: () => ({
+      servers: [
+        { name: 'connecting-mcp', status: 'disconnected' },
+        { name: 'failed-mcp', status: 'failed' },
+      ],
+    }),
+  },
+));
+if (!readonlyReportingResult.blocked?.some((entry) => entry?.name === 'shell' && entry?.reason === 'readonly mode')
+  || !readonlyReportingResult.missing.includes('definitely_missing_tool')
+  || !readonlyReportingResult.pendingMcpServers?.includes('connecting-mcp')
+  || !readonlyReportingResult.failedMcpServers?.includes('failed-mcp')
+  || !/retry next turn/i.test(readonlyReportingResult.note || '')
+  || !/unavailable/i.test(readonlyReportingResult.note || '')) {
+  throw new Error(`load_tool must preserve readonly and MCP status reporting: ${JSON.stringify(readonlyReportingResult)}`);
+}
 const nativePatchSearchSession = {
   provider: 'openai-oauth',
   tools: smokeCatalog.filter((tool) => fullDefaults.has(tool?.name) && tool?.name !== 'apply_patch'),
@@ -2033,24 +2177,17 @@ if (nativePatchTool?.type !== 'custom' || nativePatchTool?.format?.syntax !== 'l
 if (nativePatchTool.defer_loading === true || nativePatchTool.parameters) {
   throw new Error(`native tool_search custom apply_patch must not be downgraded to deferred function schema: ${JSON.stringify(nativePatchTool)}`);
 }
-const nativeGrokPatchSearchSession = {
-  provider: 'grok-oauth',
-  tools: smokeCatalog.filter((tool) => fullDefaults.has(tool?.name) && tool?.name !== 'apply_patch'),
-  deferredToolCatalog: smokeCatalog.slice(),
-  deferredSelectedTools: [...fullDefaults].filter((name) => name !== 'apply_patch'),
-  deferredDiscoveredTools: [],
-  deferredProviderMode: 'native',
-  deferredNativeTools: true,
-};
-const nativeGrokPatchSelectResult = JSON.parse(__renderToolSearchForTest({ select: 'apply_patch' }, nativeGrokPatchSearchSession, 'full'));
-const nativeGrokPatchTool = nativeGrokPatchSelectResult.nativeToolSearch?.openaiTools?.find((tool) => tool?.name === 'apply_patch');
-if (nativeGrokPatchTool?.type !== 'function' || nativeGrokPatchTool?.format || nativeGrokPatchTool?.defer_loading !== true) {
-  throw new Error(`Grok native tool_search apply_patch must use JSON function schema, not OpenAI custom: ${JSON.stringify(nativeGrokPatchTool)}`);
-}
-if (nativeGrokPatchTool.parameters?.properties?.patch?.type !== 'string') {
-  throw new Error(`Grok native tool_search apply_patch must preserve patch JSON schema: ${JSON.stringify(nativeGrokPatchTool)}`);
-}
-// Native query-select discovers (without mutating active schemas); aliases expand.
+const grokCanonicalSession = { provider: 'grok-oauth', tools: [], messages: [] };
+applyDeferredToolSurface(grokCanonicalSession, 'full', smokeCatalog, { provider: 'grok-oauth' });
+const grokCanonicalJson = JSON.stringify(grokCanonicalSession.tools);
+const grokLoadResult = JSON.parse(__renderToolSearchForTest({ names: ['apply_patch'] }, grokCanonicalSession, 'full'));
+if (grokCanonicalSession.deferredNativeTools
+  || grokLoadResult.nativeToolSearch
+  || JSON.stringify(grokCanonicalSession.tools) !== grokCanonicalJson
+  || !grokLoadResult.alreadyActive.includes('apply_patch')) {
+  throw new Error(`Grok must use a fixed canonical ordinary-function surface: ${JSON.stringify(grokLoadResult)}`);
+}
+// Native query-select explicitly loads onto the active surface; aliases expand.
 const nativeSelectQuerySession = {
   tools: smokeCatalog.filter((tool) => fullDefaults.has(tool?.name)),
   deferredToolCatalog: smokeCatalog.slice(),
@@ -2061,13 +2198,10 @@ const nativeSelectQuerySession = {
 };
 const nativeSelectQueryResult = JSON.parse(__renderToolSearchForTest({ query: 'select:search' }, nativeSelectQuerySession, 'full'));
 for (const name of ['search', 'web_fetch']) {
-  if (!nativeSelectQueryResult.discoveredTools.includes(name)) {
-    throw new Error(`native tool_search query-select should discover ${name}: ${JSON.stringify(nativeSelectQueryResult)}`);
+  if (!nativeSelectQueryResult.activeTools.includes(name)) {
+    throw new Error(`native tool_search query-select should load ${name}: ${JSON.stringify(nativeSelectQueryResult)}`);
   }
 }
-if (nativeSelectQueryResult.activeTools.includes('search') || nativeSelectQueryResult.activeTools.includes('web_fetch')) {
-  throw new Error(`native tool_search must not mutate active schemas: ${JSON.stringify(nativeSelectQueryResult)}`);
-}
 if (!nativeSelectQueryResult.nativeToolSearch?.toolReferences?.includes('search')) {
   throw new Error(`native query-select must return nativeToolSearch payload: ${JSON.stringify(nativeSelectQueryResult.nativeToolSearch)}`);
 }
@@ -2083,6 +2217,9 @@ const nativeLateMcpSearchSession = {
   deferredNativeTools: true,
 };
 const nativeLateMcpSelectResult = JSON.parse(__renderToolSearchForTest({ names: ['mcp__late__ping'] }, nativeLateMcpSearchSession, 'full'));
+if (nativeLateMcpSearchSession.tools.some((tool) => tool?.name === 'mcp__late__ping')) {
+  throw new Error(`native late MCP load must not promote its schema onto session.tools: ${JSON.stringify(nativeLateMcpSearchSession.tools)}`);
+}
 if (!nativeLateMcpSelectResult.nativeToolSearch?.toolReferences?.includes('mcp__late__ping')) {
   throw new Error(`native late MCP load must include nativeToolSearch payload: ${JSON.stringify(nativeLateMcpSelectResult)}`);
 }
@@ -2104,6 +2241,22 @@ for (const q of ['run tests', 'web docs', 'memory previous', 'status']) {
     throw new Error(`native tool_search plain query "${q}" must not auto-load/discover: ${JSON.stringify(r)}`);
   }
 }
+const geminiManifestSession = { provider: 'gemini', tools: [], messages: [] };
+const manifestBase = [
+  { name: 'load_tool', inputSchema: { type: 'object', properties: {} } },
+  { name: 'read', annotations: { readOnlyHint: true }, inputSchema: { type: 'object', properties: {} } },
+];
+applyDeferredToolSurface(geminiManifestSession, 'full', manifestBase, { provider: 'gemini' });
+const geminiTurnManifest = JSON.stringify(geminiManifestSession.tools);
+const geminiLate = { name: 'mcp__gemini__late', inputSchema: { type: 'object', properties: {} } };
+// Continuations use the same array; only the next user-turn reconciliation may replace it.
+if (JSON.stringify(geminiManifestSession.tools) !== geminiTurnManifest) {
+  throw new Error('Gemini manifest changed within a user turn');
+}
+reconcileDeferredMcpToolCatalog(geminiManifestSession, [geminiLate]);
+if (!geminiManifestSession.tools.some((tool) => tool.name === 'mcp__gemini__late')) {
+  throw new Error('Gemini must adopt the complete ordered live manifest at the next user turn');
+}
 // Skill-style deferred manifest: `- name: description` lines, `<`/`>` sanitized,
 // bare names allowed, header instructs direct calls, empty pool → ''.
 const manifestText = buildDeferredToolManifest([
@@ -2158,8 +2311,38 @@ const grepHeadLimitDescription = grepTool?.inputSchema?.properties?.head_limit?.
 if (!/pattern\[\] batches variants/i.test(grepPatternDescription) || !/File\/dir scope/i.test(grepPathDescription)) {
   throw new Error('grep schema must keep compact pattern/path guidance');
 }
-if (!/content search/i.test(grepTool?.description || '')) {
-  throw new Error('grep description must state its content-search contract');
+const grepPredicateNegator = /\b(?:no|not|never|cannot|can(?:not|'t)|does(?:\s+not|n't)|do(?:\s+not|n't)|did(?:\s+not|n't)|unable(?:\s+|-)to|fail(?:s|ed|ing)?(?:\s*[-–]\s*|\s+)to|without|forbid(?:s|den)?|prohibit(?:s|ed|ing)?)(?:\s+\w+){0,2}\s+/i;
+const hasPositiveGrepSequence = (description, pattern, negatedPredicate) => {
+  const match = description.match(pattern);
+  return Boolean(match) && !(negatedPredicate?.test(match[0]));
+};
+const grepRoutingVerb = '(?:us(?:e|es|ed|ing)|rout(?:e|es|ed|ing)|target(?:s|ed|ing)?)';
+const grepRouteRelation = `(?:\\s*→\\s*|\\s+\\b${grepRoutingVerb}\\b(?:\\s+(?:to|via|with))?\\s+)\\bgrep\\b`;
+const grepGroupedRoutePattern = new RegExp(`\\bliteral\\b\\s*(?:or|and|/)\\s*\\bregex\\b(?:(?![.;]|→|\\b${grepRoutingVerb}\\b)[\\s\\S]){0,80}?${grepRouteRelation}`, 'i');
+const grepRoutePattern = (subject, alternateSubject) => new RegExp(`\\b${subject}\\b(?:(?![.;]|→|\\b(?:${alternateSubject}|${grepRoutingVerb})\\b)[\\s\\S]){0,80}?${grepRouteRelation}`, 'i');
+const grepNegatedRoute = new RegExp(`${grepPredicateNegator.source}\\bgrep\\b`, 'i');
+const hasGrepDescriptionContract = (description) => (
+  (hasPositiveGrepSequence(description, grepGroupedRoutePattern, grepNegatedRoute)
+    || (hasPositiveGrepSequence(description, grepRoutePattern('literal', 'regex'), grepNegatedRoute)
+      && hasPositiveGrepSequence(description, grepRoutePattern('regex', 'literal'), grepNegatedRoute)))
+  && hasPositiveGrepSequence(description, /\bnonzero\b[\s\S]{0,80}?\bcontent_with_context\b[\s\S]{0,80}?\bresolve\w*\b/i, new RegExp(`${grepPredicateNegator.source}\\bresolve\\w*\\b`, 'i'))
+  && hasPositiveGrepSequence(description, /\bonly\b[\s\S]{0,80}?\bzero(?:\s*\/\s*|\s+or\s+)error\b[\s\S]{0,80}?\bchange\w*\b[\s\S]{0,80}?\btoken(?:s)?\b[\s\S]{0,80}?\bscope\b/i, new RegExp(`${grepPredicateNegator.source}\\bchange\\w*\\b`, 'i'))
+  && hasPositiveGrepSequence(description, /\bfiles_with_matches(?:\s*\/\s*|\s+and\s+)count\b[\s\S]{0,80}?\bexistence\b[\s\S]{0,80}?\bmodes?\b/i, new RegExp(`${grepPredicateNegator.source}\\bexistence\\s+modes?\\b`, 'i'))
+);
+const grepDescriptionProbe = 'literal and regex → grep; nonzero content_with_context resolves; only zero/error results may change tokens and scope; files_with_matches/count are existence modes.';
+const grepEquivalentPositiveProbe = 'literal and regex use grep; nonzero content_with_context returns not an empty result and resolves; only zero/error results may change tokens and scope; files_with_matches/count are existence modes.';
+const grepSeparateClausePositiveProbe = 'literal uses grep; regex routes to grep; nonzero content_with_context resolves; only zero/error results may change tokens and scope; files_with_matches/count are existence modes.';
+const grepPolarityMutations = [
+  grepDescriptionProbe.replace('literal and regex → grep', 'literal → read; regex → grep'),
+  grepDescriptionProbe.replace('literal and regex → grep', 'literal targets read, while regex uses grep'),
+  grepDescriptionProbe.replace('literal and regex → grep', 'literal and regex do not use grep'),
+  grepDescriptionProbe.replace('resolves', 'does not resolve'),
+  grepDescriptionProbe.replace('resolves', 'fails to resolve'),
+  grepDescriptionProbe.replace('may change', 'cannot change'),
+  grepDescriptionProbe.replace('are existence modes', 'are never existence modes'),
+];
+if (!hasGrepDescriptionContract(grepTool?.description || '') || !hasGrepDescriptionContract(grepEquivalentPositiveProbe) || !hasGrepDescriptionContract(grepSeparateClausePositiveProbe) || grepPolarityMutations.some(hasGrepDescriptionContract)) {
+  throw new Error('grep description must state its literal/regex locator, resolution qualifiers, and result-mode contract');
 }
 if (!/Glob filter/i.test(grepGlobDescription)) {
   throw new Error('grep glob schema must describe scope narrowing');
@@ -2179,15 +2362,57 @@ const listTool = BUILTIN_TOOLS.find((tool) => tool.name === 'list');
 if (!/exact glob patterns/i.test(globTool?.description || '')) {
   throw new Error('glob description must route exact-pattern unknown paths before read/grep/list');
 }
-if (!/unknown partial paths\/names/i.test(findTool?.description || '') || !/verifies paths for grep\/glob/i.test(findTool?.description || '')) {
-  throw new Error('find description must advertise unverified path/name lookup and verified outputs');
+const findClauseNegator = '(?:not|never|(?:do|does|did)\\s+not|(?:do|does|did)n\'t|(?:is|are|was|were)\\s+not|(?:is|are|was|were)n\'t|should\\s+not|shouldn\'t|must\\s+not|mustn\'t|can(?:not|\\s+not)|can\'t|could\\s+not|couldn\'t|will\\s+not|won\'t|fail(?:s|ed|ing)?\\s+to)';
+const findPredicateModifiers = '(?:\\s+(?:necessarily|generally|strictly|really|simply|always|still|currently|typically|ordinarily|be|been|being|considered|deemed|regarded)){0,3}';
+const hasPositiveFindClause = (description, positive, negated) => positive.test(description) && !negated.test(description);
+const findUnknownPathsPattern = /\b(?:fuzzy\s+)?(?:lookup|find)\b(?:\s+[\w']+){0,3}\s+only\s+for\s+unknown\s+partial\s+paths\/names\b/i;
+const findUnknownPathsNegation = new RegExp(`\\b${findClauseNegator}${findPredicateModifiers}\\s+(?:use\\s+)?(?:fuzzy\\s+)?(?:lookup|find)\\b(?:\\s+[\\w']+){0,3}\\s+only\\s+for\\s+unknown\\s+partial\\s+paths\\/names|\\b(?:fuzzy\\s+)?(?:lookup|find)\\b(?:\\s+[\\w']+){0,3}\\s+${findClauseNegator}${findPredicateModifiers}\\s+only\\s+for\\s+unknown\\s+partial\\s+paths\\/names`, 'i');
+const findRootExclusionPattern = /\b(?:not\s+for|excludes?)\s+(?:the\s+)?project\s+root\s+(?:or|and)\s+already-verified\s+roots\b|\b(?:the\s+)?project\s+root\s+(?:or|and)\s+already-verified\s+roots\s+(?:are\s+)?excluded\b|\balready-verified\s+roots\s+(?:or|and)\s+(?:the\s+)?project\s+root\s+(?:are\s+)?excluded\b/i;
+const findRootExclusionNegation = new RegExp(`\\b${findClauseNegator}${findPredicateModifiers}\\s+exclude\\s+(?:the\\s+)?(?:project\\s+root|already-verified\\s+roots)\\b|\\b(?:project\\s+root\\s+(?:or|and)\\s+already-verified\\s+roots|already-verified\\s+roots\\s+(?:or|and)\\s+project\\s+root|project\\s+root|already-verified\\s+roots)\\s+(?:(?:is|are|was|were)\\s+)?${findClauseNegator}${findPredicateModifiers}\\s+excluded\\b`, 'i');
+const findVerifiedPathsPattern = /\b(?:output|returned)\s+paths\b(?:\s+[\w']+){0,4}\s+verified\s+(?:downstream|for\s+downstream\s+use)\b|\bdownstream\s+paths\b(?:\s+[\w']+){0,4}\s+verified\b|\bpaths\b(?:\s+[\w']+){0,4}\s+verified\s+(?:downstream|for\s+downstream\s+use)\b/i;
+const findVerifiedPathsNegation = new RegExp(`\\b(?:output|returned|downstream)\\s+paths\\b(?:\\s+[\\w']+){0,4}\\s+${findClauseNegator}${findPredicateModifiers}\\s+verified\\b|\\bpaths\\b(?:\\s+[\\w']+){0,4}\\s+${findClauseNegator}${findPredicateModifiers}\\s+verified\\b|\\b(?:output|returned|downstream)\\s+paths\\b(?:\\s+[\\w']+){0,4}\\s+unverified\\b`, 'i');
+const findFileContentsPattern = /\b(?:not\s+for|excludes?)\s+file\s+contents\b|\bfile\s+contents\b(?:\s+[\w']+){0,3}\s+excluded\b/i;
+const findFileContentsNegation = new RegExp(`\\b${findClauseNegator}${findPredicateModifiers}\\s+exclude\\s+file\\s+contents\\b|\\bfile\\s+contents\\s+(?:(?:is|are|was|were)\\s+)?${findClauseNegator}${findPredicateModifiers}\\s+excluded\\b`, 'i');
+const hasFindDescriptionContract = (description) => (
+  hasPositiveFindClause(description, findUnknownPathsPattern, findUnknownPathsNegation)
+  && hasPositiveFindClause(description, findRootExclusionPattern, findRootExclusionNegation)
+  && hasPositiveFindClause(description, findVerifiedPathsPattern, findVerifiedPathsNegation)
+  && hasPositiveFindClause(description, findFileContentsPattern, findFileContentsNegation)
+);
+const findDescriptionProbe = 'Fuzzy lookup only for unknown partial paths/names; excludes project root and already-verified roots. Output paths are verified downstream. Not for file contents.';
+const findEquivalentPositiveProbe = 'File contents are excluded. Paths verified downstream are returned. Already-verified roots and project root are excluded. Lookup is only for unknown partial paths/names.';
+const findPolarityMutations = [
+  findDescriptionProbe.replace('Fuzzy lookup only', 'Do not use fuzzy lookup only'),
+  findDescriptionProbe.replace('excludes project root', 'does not exclude project root'),
+  findDescriptionProbe.replace('Output paths are verified downstream', 'Downstream paths not verified'),
+  findDescriptionProbe.replace('Not for file contents', 'Does not exclude file contents'),
+  findDescriptionProbe.replace('Fuzzy lookup only', 'Fuzzy lookup is not only'),
+  findDescriptionProbe.replace('excludes project root', 'should not exclude project root'),
+  findDescriptionProbe.replace('excludes project root', 'must not exclude project root'),
+  findDescriptionProbe.replace('excludes project root', 'can not exclude project root'),
+  findDescriptionProbe.replace('Output paths are verified downstream', 'Output paths cannot be verified downstream'),
+  findDescriptionProbe.replace('Not for file contents', 'File contents must not be excluded'),
+  findDescriptionProbe.replace('Output paths are verified downstream', 'Output paths are verified'),
+  findDescriptionProbe.replace('Fuzzy lookup only', 'Fuzzy lookup isn\'t only'),
+  findDescriptionProbe.replace('excludes project root and already-verified roots', 'project root and already-verified roots shouldn\'t be excluded'),
+  findDescriptionProbe.replace('Output paths are verified downstream', 'Output paths can\'t be verified downstream'),
+  findDescriptionProbe.replace('Not for file contents', 'File contents aren\'t excluded'),
+  findDescriptionProbe.replace('Fuzzy lookup only', 'Lookup isn\'t necessarily only'),
+  findDescriptionProbe.replace('Output paths are verified downstream', 'Output paths shouldn\'t be considered verified downstream'),
+];
+if (!hasFindDescriptionContract(findTool?.description || '') || !hasFindDescriptionContract(findEquivalentPositiveProbe) || findPolarityMutations.some(hasFindDescriptionContract)) {
+  throw new Error('find description must limit lookup to unknown partial paths/names, exclude roots and file contents, and return verified paths');
 }
 if (!/List directory entries/i.test(listTool?.description || '') || !/path\[\]/i.test(listTool?.inputSchema?.properties?.path?.description || '')) {
   throw new Error('list description must require verified directories and locator-first unknown dirs');
 }
-if (!/symbol modes use symbols\[\]/i.test(codeGraphProps.mode?.description || '') || !/symbols \(file outline\) use files\[\]/i.test(codeGraphProps.mode?.description || '') || !/one symbols\[\] call/i.test(codeGraphProps.symbols?.description || '')) {
-  throw new Error('code_graph schema fields must stay compact and repo-local');
-}
+const codeGraphModeDescription = codeGraphProps.mode?.description || '';
+const codeGraphSymbolsDescription = codeGraphProps.symbols?.description || '';
+assertCodeGraphDescriptionContract({
+  description: codeGraphDescription,
+  modeDescription: codeGraphModeDescription,
+  symbolsDescription: codeGraphSymbolsDescription,
+});
 
 const longToolSearchText = compactToolSearchDescription(`${patchDescription}\n${patchDescription}`);
 if (longToolSearchText.length > 220 || /\n/.test(longToolSearchText)) {

package/scripts/tool-tui-presentation-test.mjs

@@ -24,7 +24,10 @@ import {
   agentArgsWithResultMetadata,
   parseAgentJob,
 } from '../src/tui/engine/agent-envelope.mjs';
-import { agentActionTitle } from '../src/tui/components/tool-execution/surface-detail.mjs';
+import {
+  agentActionTitle,
+  toolSearchLoadedSummary,
+} from '../src/tui/components/tool-execution/surface-detail.mjs';
 
 test('tool action copy keeps Add/Delete patch verbs and human read offsets', () => {
   assert.equal(
@@ -38,6 +41,19 @@ test('tool action copy keeps Add/Delete patch verbs and human read offsets', ()
   assert.match(summarizeToolArgs('read', { path: 'a.mjs', offset: 0, limit: 10 }), /lines 1-10/);
 });
 
+test('load_tool presentation distinguishes first load from already-active repeats', () => {
+  assert.equal(
+    toolSearchLoadedSummary('Loaded deferred tools: shell\nAlready active: task'),
+    'Loaded: shell · Already active: task',
+  );
+  assert.equal(
+    toolSearchLoadedSummary(JSON.stringify({
+      selected: { tools: { added: [], already: ['shell', 'task'] } },
+    })),
+    'Already active: shell, task',
+  );
+});
+
 test('Agent aggregation is batch-scoped and keeps category action wording', () => {
   const entry = aggregateToolCategoryEntry('agent', { type: 'spawn' }, 'Agent');
   assert.equal(formatAggregateHeader({ [entry.key]: { ...entry, count: 2 } }, { pending: false }), 'Called 2 agents');

package/scripts/tui-perf-run.ps1

@@ -0,0 +1,26 @@
+# TUI typing-lag perf measurement launcher.
+#
+# Enables the render/event-loop probes with tuned thresholds, routes probe
+# output to a DEDICATED fresh log, then launches mixdog exactly like `mixdog`.
+# Reproduce the lag (long transcript + streaming, type continuously), then
+# /exit. The log is then read to pin the bottleneck.
+$ErrorActionPreference = 'Stop'
+$repo = Split-Path -Parent $PSScriptRoot
+$log  = Join-Path $repo 'tui-perf.log'
+
+# Probe gates. Thresholds lowered below the defaults (80ms stall / 120ms gap)
+# because the synthetic measurement put real stalls at ~40-60ms, under the
+# defaults, so they would never be logged.
+$env:MIXDOG_TUI_PERF               = '1'
+$env:MIXDOG_TUI_PERF_STALL_MS      = '40'
+$env:MIXDOG_TUI_PERF_RENDER_GAP_MS = '50'
+$env:MIXDOG_TUI_LOOP_PROBE         = '1'
+$env:MIXDOG_TUI_STDERR_LOG         = $log
+
+# Start from a clean log so the read is unambiguous.
+if (Test-Path $log) { Remove-Item $log -Force }
+
+Write-Host "perf log -> $log" -ForegroundColor Cyan
+Write-Host 'Reproduce: long transcript + streaming, type continuously to trigger lag, then /exit.' -ForegroundColor Cyan
+
+node (Join-Path $repo 'src\cli.mjs') @args

package/scripts/tui-transcript-perf-test.mjs

@@ -8,7 +8,7 @@ import { buildTranscriptRowIndexIncremental } from '../src/tui/app/transcript-wi
 
 const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-function makeTurnHarness(ask, stateOverrides = {}) {
+function makeTurnHarness(ask, stateOverrides = {}, bagOverrides = {}) {
   let seq = 0;
   let state = {
     items: [],
@@ -84,18 +84,22 @@ function makeTurnHarness(ask, stateOverrides = {}) {
     flushDeferredExecutionPendingResumeKick: () => {},
     drain: async () => {},
     drainPendingSteering: () => [],
+    ...bagOverrides,
   };
   return { runTurn: createRunTurn(bag), getState: () => state };
 }
 
 test('successful mid-turn compact trims history but preserves live turn references', async () => {
   let preservedTail = false;
+  let contextSyncs = 0;
   const harness = makeTurnHarness(async (_text, options) => {
     options.onTextDelta('before compact\n');
     await wait(30);
     options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
+    assert.equal(contextSyncs, 1, 'compact event must refresh context before returning');
     preservedTail = harness.getState().streamingTail?.text === 'before compact\n';
     options.onCompactEvent({ status: 'compacted', trigger: 'reactive' });
+    assert.equal(contextSyncs, 2, 'each compact event refreshes context immediately');
     options.onTextDelta('after compact\n');
     return { result: { content: 'before compact\nafter compact\n' }, session: { messages: [] } };
   }, {
@@ -103,6 +107,8 @@ test('successful mid-turn compact trims history but preserves live turn referenc
       { id: 'old', kind: 'assistant', text: 'old history' },
       { id: 'current-user', kind: 'user', text: 'go' },
     ],
+  }, {
+    syncContextStats: () => { contextSyncs += 1; },
   });
 
   assert.equal(await harness.runTurn('go', { submittedIds: ['current-user'] }), 'done');