@xortex/xcode 3.0.0

package/utils/statusNoticeDefinitions.tsx

@@ -0,0 +1,198 @@
+// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
+import { Box, Text } from '../ink.js';
+import * as React from 'react';
+import { getLargeMemoryFiles, MAX_MEMORY_CHARACTER_COUNT, type MemoryFileInfo } from './claudemd.js';
+import figures from 'figures';
+import { getCwd } from './cwd.js';
+import { relative } from 'path';
+import { formatNumber } from './format.js';
+import type { getGlobalConfig } from './config.js';
+import { getAnthropicApiKeyWithSource, getApiKeyFromConfigOrMacOSKeychain, getAuthTokenSource, isClaudeAISubscriber } from './auth.js';
+import type { AgentDefinitionsResult } from '../tools/AgentTool/loadAgentsDir.js';
+import { getAgentDescriptionsTotalTokens, AGENT_DESCRIPTIONS_THRESHOLD } from './statusNoticeHelpers.js';
+import { isSupportedJetBrainsTerminal, toIDEDisplayName, getTerminalIdeType } from './ide.js';
+import { isJetBrainsPluginInstalledCachedSync } from './jetbrains.js';
+
+// Types
+export type StatusNoticeType = 'warning' | 'info';
+export type StatusNoticeContext = {
+  config: ReturnType<typeof getGlobalConfig>;
+  agentDefinitions?: AgentDefinitionsResult;
+  memoryFiles: MemoryFileInfo[];
+};
+export type StatusNoticeDefinition = {
+  id: string;
+  type: StatusNoticeType;
+  isActive: (context: StatusNoticeContext) => boolean;
+  render: (context: StatusNoticeContext) => React.ReactNode;
+};
+
+// Individual notice definitions
+const largeMemoryFilesNotice: StatusNoticeDefinition = {
+  id: 'large-memory-files',
+  type: 'warning',
+  isActive: ctx => getLargeMemoryFiles(ctx.memoryFiles).length > 0,
+  render: ctx => {
+    const largeMemoryFiles = getLargeMemoryFiles(ctx.memoryFiles);
+    return <>
+        {largeMemoryFiles.map(file => {
+        const displayPath = file.path.startsWith(getCwd()) ? relative(getCwd(), file.path) : file.path;
+        return <Box key={file.path} flexDirection="row">
+              <Text color="warning">{figures.warning}</Text>
+              <Text color="warning">
+                Large <Text bold>{displayPath}</Text> will impact performance (
+                {formatNumber(file.content.length)} chars &gt;{' '}
+                {formatNumber(MAX_MEMORY_CHARACTER_COUNT)})
+                <Text dimColor> · /memory to edit</Text>
+              </Text>
+            </Box>;
+      })}
+      </>;
+  }
+};
+const claudeAiSubscriberExternalTokenNotice: StatusNoticeDefinition = {
+  id: 'claude-ai-external-token',
+  type: 'warning',
+  isActive: () => {
+    const authTokenInfo = getAuthTokenSource();
+    return isClaudeAISubscriber() && (authTokenInfo.source === 'ANTHROPIC_AUTH_TOKEN' || authTokenInfo.source === 'apiKeyHelper');
+  },
+  render: () => {
+    const authTokenInfo = getAuthTokenSource();
+    return <Box flexDirection="row" marginTop={1}>
+        <Text color="warning">{figures.warning}</Text>
+        <Text color="warning">
+          Auth conflict: Using {authTokenInfo.source} instead of Claude account
+          subscription token. Either unset {authTokenInfo.source}, or run
+          `claude /logout`.
+        </Text>
+      </Box>;
+  }
+};
+const apiKeyConflictNotice: StatusNoticeDefinition = {
+  id: 'api-key-conflict',
+  type: 'warning',
+  isActive: () => {
+    const {
+      source: apiKeySource
+    } = getAnthropicApiKeyWithSource({
+      skipRetrievingKeyFromApiKeyHelper: true
+    });
+    return !!getApiKeyFromConfigOrMacOSKeychain() && (apiKeySource === 'ANTHROPIC_API_KEY' || apiKeySource === 'apiKeyHelper');
+  },
+  render: () => {
+    const {
+      source: apiKeySource
+    } = getAnthropicApiKeyWithSource({
+      skipRetrievingKeyFromApiKeyHelper: true
+    });
+    return <Box flexDirection="row" marginTop={1}>
+        <Text color="warning">{figures.warning}</Text>
+        <Text color="warning">
+          Auth conflict: Using {apiKeySource} instead of Anthropic Console key.
+          Either unset {apiKeySource}, or run `claude /logout`.
+        </Text>
+      </Box>;
+  }
+};
+const bothAuthMethodsNotice: StatusNoticeDefinition = {
+  id: 'both-auth-methods',
+  type: 'warning',
+  isActive: () => {
+    const {
+      source: apiKeySource
+    } = getAnthropicApiKeyWithSource({
+      skipRetrievingKeyFromApiKeyHelper: true
+    });
+    const authTokenInfo = getAuthTokenSource();
+    return apiKeySource !== 'none' && authTokenInfo.source !== 'none' && !(apiKeySource === 'apiKeyHelper' && authTokenInfo.source === 'apiKeyHelper');
+  },
+  render: () => {
+    const {
+      source: apiKeySource
+    } = getAnthropicApiKeyWithSource({
+      skipRetrievingKeyFromApiKeyHelper: true
+    });
+    const authTokenInfo = getAuthTokenSource();
+    return <Box flexDirection="column" marginTop={1}>
+        <Box flexDirection="row">
+          <Text color="warning">{figures.warning}</Text>
+          <Text color="warning">
+            Auth conflict: Both a token ({authTokenInfo.source}) and an API key
+            ({apiKeySource}) are set. This may lead to unexpected behavior.
+          </Text>
+        </Box>
+        <Box flexDirection="column" marginLeft={3}>
+          <Text color="warning">
+            · Trying to use{' '}
+            {authTokenInfo.source === 'claude.ai' ? 'claude.ai' : authTokenInfo.source}
+            ?{' '}
+            {apiKeySource === 'ANTHROPIC_API_KEY' ? 'Unset the ANTHROPIC_API_KEY environment variable, or claude /logout then say "No" to the API key approval before login.' : apiKeySource === 'apiKeyHelper' ? 'Unset the apiKeyHelper setting.' : 'claude /logout'}
+          </Text>
+          <Text color="warning">
+            · Trying to use {apiKeySource}?{' '}
+            {authTokenInfo.source === 'claude.ai' ? 'claude /logout to sign out of claude.ai.' : `Unset the ${authTokenInfo.source} environment variable.`}
+          </Text>
+        </Box>
+      </Box>;
+  }
+};
+const largeAgentDescriptionsNotice: StatusNoticeDefinition = {
+  id: 'large-agent-descriptions',
+  type: 'warning',
+  isActive: context => {
+    const totalTokens = getAgentDescriptionsTotalTokens(context.agentDefinitions);
+    return totalTokens > AGENT_DESCRIPTIONS_THRESHOLD;
+  },
+  render: context => {
+    const totalTokens = getAgentDescriptionsTotalTokens(context.agentDefinitions);
+    return <Box flexDirection="row">
+        <Text color="warning">{figures.warning}</Text>
+        <Text color="warning">
+          Large cumulative agent descriptions will impact performance (~
+          {formatNumber(totalTokens)} tokens &gt;{' '}
+          {formatNumber(AGENT_DESCRIPTIONS_THRESHOLD)})
+          <Text dimColor> · /agents to manage</Text>
+        </Text>
+      </Box>;
+  }
+};
+const jetbrainsPluginNotice: StatusNoticeDefinition = {
+  id: 'jetbrains-plugin-install',
+  type: 'info',
+  isActive: context => {
+    // Only show if running in JetBrains built-in terminal
+    if (!isSupportedJetBrainsTerminal()) {
+      return false;
+    }
+    // Don't show if auto-install is disabled
+    const shouldAutoInstall = context.config.autoInstallIdeExtension ?? true;
+    if (!shouldAutoInstall) {
+      return false;
+    }
+    // Check if plugin is already installed (cached to avoid repeated filesystem checks)
+    const ideType = getTerminalIdeType();
+    return ideType !== null && !isJetBrainsPluginInstalledCachedSync(ideType);
+  },
+  render: () => {
+    const ideType = getTerminalIdeType();
+    const ideName = toIDEDisplayName(ideType);
+    return <Box flexDirection="row" gap={1} marginLeft={1}>
+        <Text color="ide">{figures.arrowUp}</Text>
+        <Text>
+          Install the <Text color="ide">{ideName}</Text> plugin from the
+          JetBrains Marketplace:{' '}
+          <Text bold>https://docs.claude.com/s/claude-code-jetbrains</Text>
+        </Text>
+      </Box>;
+  }
+};
+
+// All notice definitions
+export const statusNoticeDefinitions: StatusNoticeDefinition[] = [largeMemoryFilesNotice, largeAgentDescriptionsNotice, claudeAiSubscriberExternalTokenNotice, apiKeyConflictNotice, bothAuthMethodsNotice, jetbrainsPluginNotice];
+
+// Helper functions for external use
+export function getActiveNotices(context: StatusNoticeContext): StatusNoticeDefinition[] {
+  return statusNoticeDefinitions.filter(notice => notice.isActive(context));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Box","Text","React","getLargeMemoryFiles","MAX_MEMORY_CHARACTER_COUNT","MemoryFileInfo","figures","getCwd","relative","formatNumber","getGlobalConfig","getAnthropicApiKeyWithSource","getApiKeyFromConfigOrMacOSKeychain","getAuthTokenSource","isClaudeAISubscriber","AgentDefinitionsResult","getAgentDescriptionsTotalTokens","AGENT_DESCRIPTIONS_THRESHOLD","isSupportedJetBrainsTerminal","toIDEDisplayName","getTerminalIdeType","isJetBrainsPluginInstalledCachedSync","StatusNoticeType","StatusNoticeContext","config","ReturnType","agentDefinitions","memoryFiles","StatusNoticeDefinition","id","type","isActive","context","render","ReactNode","largeMemoryFilesNotice","ctx","length","largeMemoryFiles","map","file","displayPath","path","startsWith","warning","content","claudeAiSubscriberExternalTokenNotice","authTokenInfo","source","apiKeyConflictNotice","apiKeySource","skipRetrievingKeyFromApiKeyHelper","bothAuthMethodsNotice","largeAgentDescriptionsNotice","totalTokens","jetbrainsPluginNotice","shouldAutoInstall","autoInstallIdeExtension","ideType","ideName","arrowUp","statusNoticeDefinitions","getActiveNotices","filter","notice"],"sources":["statusNoticeDefinitions.tsx"],"sourcesContent":["// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered\nimport { Box, Text } from '../ink.js'\nimport * as React from 'react'\nimport {\n  getLargeMemoryFiles,\n  MAX_MEMORY_CHARACTER_COUNT,\n  type MemoryFileInfo,\n} from './claudemd.js'\nimport figures from 'figures'\nimport { getCwd } from './cwd.js'\nimport { relative } from 'path'\nimport { formatNumber } from './format.js'\nimport type { getGlobalConfig } from './config.js'\nimport {\n  getAnthropicApiKeyWithSource,\n  getApiKeyFromConfigOrMacOSKeychain,\n  getAuthTokenSource,\n  isClaudeAISubscriber,\n} from './auth.js'\nimport type { AgentDefinitionsResult } from '../tools/AgentTool/loadAgentsDir.js'\nimport {\n  getAgentDescriptionsTotalTokens,\n  AGENT_DESCRIPTIONS_THRESHOLD,\n} from './statusNoticeHelpers.js'\nimport {\n  isSupportedJetBrainsTerminal,\n  toIDEDisplayName,\n  getTerminalIdeType,\n} from './ide.js'\nimport { isJetBrainsPluginInstalledCachedSync } from './jetbrains.js'\n\n// Types\nexport type StatusNoticeType = 'warning' | 'info'\n\nexport type StatusNoticeContext = {\n  config: ReturnType<typeof getGlobalConfig>\n  agentDefinitions?: AgentDefinitionsResult\n  memoryFiles: MemoryFileInfo[]\n}\n\nexport type StatusNoticeDefinition = {\n  id: string\n  type: StatusNoticeType\n  isActive: (context: StatusNoticeContext) => boolean\n  render: (context: StatusNoticeContext) => React.ReactNode\n}\n\n// Individual notice definitions\nconst largeMemoryFilesNotice: StatusNoticeDefinition = {\n  id: 'large-memory-files',\n  type: 'warning',\n  isActive: ctx => getLargeMemoryFiles(ctx.memoryFiles).length > 0,\n  render: ctx => {\n    const largeMemoryFiles = getLargeMemoryFiles(ctx.memoryFiles)\n    return (\n      <>\n        {largeMemoryFiles.map(file => {\n          const displayPath = file.path.startsWith(getCwd())\n            ? relative(getCwd(), file.path)\n            : file.path\n\n          return (\n            <Box key={file.path} flexDirection=\"row\">\n              <Text color=\"warning\">{figures.warning}</Text>\n              <Text color=\"warning\">\n                Large <Text bold>{displayPath}</Text> will impact performance (\n                {formatNumber(file.content.length)} chars &gt;{' '}\n                {formatNumber(MAX_MEMORY_CHARACTER_COUNT)})\n                <Text dimColor> · /memory to edit</Text>\n              </Text>\n            </Box>\n          )\n        })}\n      </>\n    )\n  },\n}\n\nconst claudeAiSubscriberExternalTokenNotice: StatusNoticeDefinition = {\n  id: 'claude-ai-external-token',\n  type: 'warning',\n  isActive: () => {\n    const authTokenInfo = getAuthTokenSource()\n    return (\n      isClaudeAISubscriber() &&\n      (authTokenInfo.source === 'ANTHROPIC_AUTH_TOKEN' ||\n        authTokenInfo.source === 'apiKeyHelper')\n    )\n  },\n  render: () => {\n    const authTokenInfo = getAuthTokenSource()\n    return (\n      <Box flexDirection=\"row\" marginTop={1}>\n        <Text color=\"warning\">{figures.warning}</Text>\n        <Text color=\"warning\">\n          Auth conflict: Using {authTokenInfo.source} instead of Claude account\n          subscription token. Either unset {authTokenInfo.source}, or run\n          `claude /logout`.\n        </Text>\n      </Box>\n    )\n  },\n}\n\nconst apiKeyConflictNotice: StatusNoticeDefinition = {\n  id: 'api-key-conflict',\n  type: 'warning',\n  isActive: () => {\n    const { source: apiKeySource } = getAnthropicApiKeyWithSource({\n      skipRetrievingKeyFromApiKeyHelper: true,\n    })\n    return (\n      !!getApiKeyFromConfigOrMacOSKeychain() &&\n      (apiKeySource === 'ANTHROPIC_API_KEY' || apiKeySource === 'apiKeyHelper')\n    )\n  },\n  render: () => {\n    const { source: apiKeySource } = getAnthropicApiKeyWithSource({\n      skipRetrievingKeyFromApiKeyHelper: true,\n    })\n    return (\n      <Box flexDirection=\"row\" marginTop={1}>\n        <Text color=\"warning\">{figures.warning}</Text>\n        <Text color=\"warning\">\n          Auth conflict: Using {apiKeySource} instead of Anthropic Console key.\n          Either unset {apiKeySource}, or run `claude /logout`.\n        </Text>\n      </Box>\n    )\n  },\n}\n\nconst bothAuthMethodsNotice: StatusNoticeDefinition = {\n  id: 'both-auth-methods',\n  type: 'warning',\n  isActive: () => {\n    const { source: apiKeySource } = getAnthropicApiKeyWithSource({\n      skipRetrievingKeyFromApiKeyHelper: true,\n    })\n    const authTokenInfo = getAuthTokenSource()\n    return (\n      apiKeySource !== 'none' &&\n      authTokenInfo.source !== 'none' &&\n      !(\n        apiKeySource === 'apiKeyHelper' &&\n        authTokenInfo.source === 'apiKeyHelper'\n      )\n    )\n  },\n  render: () => {\n    const { source: apiKeySource } = getAnthropicApiKeyWithSource({\n      skipRetrievingKeyFromApiKeyHelper: true,\n    })\n    const authTokenInfo = getAuthTokenSource()\n    return (\n      <Box flexDirection=\"column\" marginTop={1}>\n        <Box flexDirection=\"row\">\n          <Text color=\"warning\">{figures.warning}</Text>\n          <Text color=\"warning\">\n            Auth conflict: Both a token ({authTokenInfo.source}) and an API key\n            ({apiKeySource}) are set. This may lead to unexpected behavior.\n          </Text>\n        </Box>\n        <Box flexDirection=\"column\" marginLeft={3}>\n          <Text color=\"warning\">\n            · Trying to use{' '}\n            {authTokenInfo.source === 'claude.ai'\n              ? 'claude.ai'\n              : authTokenInfo.source}\n            ?{' '}\n            {apiKeySource === 'ANTHROPIC_API_KEY'\n              ? 'Unset the ANTHROPIC_API_KEY environment variable, or claude /logout then say \"No\" to the API key approval before login.'\n              : apiKeySource === 'apiKeyHelper'\n                ? 'Unset the apiKeyHelper setting.'\n                : 'claude /logout'}\n          </Text>\n          <Text color=\"warning\">\n            · Trying to use {apiKeySource}?{' '}\n            {authTokenInfo.source === 'claude.ai'\n              ? 'claude /logout to sign out of claude.ai.'\n              : `Unset the ${authTokenInfo.source} environment variable.`}\n          </Text>\n        </Box>\n      </Box>\n    )\n  },\n}\n\nconst largeAgentDescriptionsNotice: StatusNoticeDefinition = {\n  id: 'large-agent-descriptions',\n  type: 'warning',\n  isActive: context => {\n    const totalTokens = getAgentDescriptionsTotalTokens(\n      context.agentDefinitions,\n    )\n    return totalTokens > AGENT_DESCRIPTIONS_THRESHOLD\n  },\n  render: context => {\n    const totalTokens = getAgentDescriptionsTotalTokens(\n      context.agentDefinitions,\n    )\n    return (\n      <Box flexDirection=\"row\">\n        <Text color=\"warning\">{figures.warning}</Text>\n        <Text color=\"warning\">\n          Large cumulative agent descriptions will impact performance (~\n          {formatNumber(totalTokens)} tokens &gt;{' '}\n          {formatNumber(AGENT_DESCRIPTIONS_THRESHOLD)})\n          <Text dimColor> · /agents to manage</Text>\n        </Text>\n      </Box>\n    )\n  },\n}\n\nconst jetbrainsPluginNotice: StatusNoticeDefinition = {\n  id: 'jetbrains-plugin-install',\n  type: 'info',\n  isActive: context => {\n    // Only show if running in JetBrains built-in terminal\n    if (!isSupportedJetBrainsTerminal()) {\n      return false\n    }\n    // Don't show if auto-install is disabled\n    const shouldAutoInstall = context.config.autoInstallIdeExtension ?? true\n    if (!shouldAutoInstall) {\n      return false\n    }\n    // Check if plugin is already installed (cached to avoid repeated filesystem checks)\n    const ideType = getTerminalIdeType()\n    return ideType !== null && !isJetBrainsPluginInstalledCachedSync(ideType)\n  },\n  render: () => {\n    const ideType = getTerminalIdeType()\n    const ideName = toIDEDisplayName(ideType)\n    return (\n      <Box flexDirection=\"row\" gap={1} marginLeft={1}>\n        <Text color=\"ide\">{figures.arrowUp}</Text>\n        <Text>\n          Install the <Text color=\"ide\">{ideName}</Text> plugin from the\n          JetBrains Marketplace:{' '}\n          <Text bold>https://docs.claude.com/s/claude-code-jetbrains</Text>\n        </Text>\n      </Box>\n    )\n  },\n}\n\n\n// All notice definitions\nexport const statusNoticeDefinitions: StatusNoticeDefinition[] = [\n  largeMemoryFilesNotice,\n  largeAgentDescriptionsNotice,\n  claudeAiSubscriberExternalTokenNotice,\n  apiKeyConflictNotice,\n  bothAuthMethodsNotice,\n  jetbrainsPluginNotice,\n]\n\n// Helper functions for external use\nexport function getActiveNotices(\n  context: StatusNoticeContext,\n): StatusNoticeDefinition[] {\n  return statusNoticeDefinitions.filter(notice => notice.isActive(context))\n}\n"],"mappings":"AAAA;AACA,SAASA,GAAG,EAAEC,IAAI,QAAQ,WAAW;AACrC,OAAO,KAAKC,KAAK,MAAM,OAAO;AAC9B,SACEC,mBAAmB,EACnBC,0BAA0B,EAC1B,KAAKC,cAAc,QACd,eAAe;AACtB,OAAOC,OAAO,MAAM,SAAS;AAC7B,SAASC,MAAM,QAAQ,UAAU;AACjC,SAASC,QAAQ,QAAQ,MAAM;AAC/B,SAASC,YAAY,QAAQ,aAAa;AAC1C,cAAcC,eAAe,QAAQ,aAAa;AAClD,SACEC,4BAA4B,EAC5BC,kCAAkC,EAClCC,kBAAkB,EAClBC,oBAAoB,QACf,WAAW;AAClB,cAAcC,sBAAsB,QAAQ,qCAAqC;AACjF,SACEC,+BAA+B,EAC/BC,4BAA4B,QACvB,0BAA0B;AACjC,SACEC,4BAA4B,EAC5BC,gBAAgB,EAChBC,kBAAkB,QACb,UAAU;AACjB,SAASC,oCAAoC,QAAQ,gBAAgB;;AAErE;AACA,OAAO,KAAKC,gBAAgB,GAAG,SAAS,GAAG,MAAM;AAEjD,OAAO,KAAKC,mBAAmB,GAAG;EAChCC,MAAM,EAAEC,UAAU,CAAC,OAAOf,eAAe,CAAC;EAC1CgB,gBAAgB,CAAC,EAAEX,sBAAsB;EACzCY,WAAW,EAAEtB,cAAc,EAAE;AAC/B,CAAC;AAED,OAAO,KAAKuB,sBAAsB,GAAG;EACnCC,EAAE,EAAE,MAAM;EACVC,IAAI,EAAER,gBAAgB;EACtBS,QAAQ,EAAE,CAACC,OAAO,EAAET,mBAAmB,EAAE,GAAG,OAAO;EACnDU,MAAM,EAAE,CAACD,OAAO,EAAET,mBAAmB,EAAE,GAAGrB,KAAK,CAACgC,SAAS;AAC3D,CAAC;;AAED;AACA,MAAMC,sBAAsB,EAAEP,sBAAsB,GAAG;EACrDC,EAAE,EAAE,oBAAoB;EACxBC,IAAI,EAAE,SAAS;EACfC,QAAQ,EAAEK,GAAG,IAAIjC,mBAAmB,CAACiC,GAAG,CAACT,WAAW,CAAC,CAACU,MAAM,GAAG,CAAC;EAChEJ,MAAM,EAAEG,GAAG,IAAI;IACb,MAAME,gBAAgB,GAAGnC,mBAAmB,CAACiC,GAAG,CAACT,WAAW,CAAC;IAC7D,OACE;AACN,QAAQ,CAACW,gBAAgB,CAACC,GAAG,CAACC,IAAI,IAAI;QAC5B,MAAMC,WAAW,GAAGD,IAAI,CAACE,IAAI,CAACC,UAAU,CAACpC,MAAM,CAAC,CAAC,CAAC,GAC9CC,QAAQ,CAACD,MAAM,CAAC,CAAC,EAAEiC,IAAI,CAACE,IAAI,CAAC,GAC7BF,IAAI,CAACE,IAAI;QAEb,OACE,CAAC,GAAG,CAAC,GAAG,CAAC,CAACF,IAAI,CAACE,IAAI,CAAC,CAAC,aAAa,CAAC,KAAK;AACpD,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAACpC,OAAO,CAACsC,OAAO,CAAC,EAAE,IAAI;AAC3D,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS;AACnC,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,CAACH,WAAW,CAAC,EAAE,IAAI,CAAC;AACrD,gBAAgB,CAAChC,YAAY,CAAC+B,IAAI,CAACK,OAAO,CAACR,MAAM,CAAC,CAAC,WAAW,CAAC,GAAG;AAClE,gBAAgB,CAAC5B,YAAY,CAACL,0BAA0B,CAAC,CAAC;AAC1D,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,kBAAkB,EAAE,IAAI;AACvD,cAAc,EAAE,IAAI;AACpB,YAAY,EAAE,GAAG,CAAC;MAEV,CAAC,CAAC;AACV,MAAM,GAAG;EAEP;AACF,CAAC;AAED,MAAM0C,qCAAqC,EAAElB,sBAAsB,GAAG;EACpEC,EAAE,EAAE,0BAA0B;EAC9BC,IAAI,EAAE,SAAS;EACfC,QAAQ,EAAEA,CAAA,KAAM;IACd,MAAMgB,aAAa,GAAGlC,kBAAkB,CAAC,CAAC;IAC1C,OACEC,oBAAoB,CAAC,CAAC,KACrBiC,aAAa,CAACC,MAAM,KAAK,sBAAsB,IAC9CD,aAAa,CAACC,MAAM,KAAK,cAAc,CAAC;EAE9C,CAAC;EACDf,MAAM,EAAEA,CAAA,KAAM;IACZ,MAAMc,aAAa,GAAGlC,kBAAkB,CAAC,CAAC;IAC1C,OACE,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAC5C,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAACP,OAAO,CAACsC,OAAO,CAAC,EAAE,IAAI;AACrD,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS;AAC7B,+BAA+B,CAACG,aAAa,CAACC,MAAM,CAAC;AACrD,2CAA2C,CAACD,aAAa,CAACC,MAAM,CAAC;AACjE;AACA,QAAQ,EAAE,IAAI;AACd,MAAM,EAAE,GAAG,CAAC;EAEV;AACF,CAAC;AAED,MAAMC,oBAAoB,EAAErB,sBAAsB,GAAG;EACnDC,EAAE,EAAE,kBAAkB;EACtBC,IAAI,EAAE,SAAS;EACfC,QAAQ,EAAEA,CAAA,KAAM;IACd,MAAM;MAAEiB,MAAM,EAAEE;IAAa,CAAC,GAAGvC,4BAA4B,CAAC;MAC5DwC,iCAAiC,EAAE;IACrC,CAAC,CAAC;IACF,OACE,CAAC,CAACvC,kCAAkC,CAAC,CAAC,KACrCsC,YAAY,KAAK,mBAAmB,IAAIA,YAAY,KAAK,cAAc,CAAC;EAE7E,CAAC;EACDjB,MAAM,EAAEA,CAAA,KAAM;IACZ,MAAM;MAAEe,MAAM,EAAEE;IAAa,CAAC,GAAGvC,4BAA4B,CAAC;MAC5DwC,iCAAiC,EAAE;IACrC,CAAC,CAAC;IACF,OACE,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAC5C,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC7C,OAAO,CAACsC,OAAO,CAAC,EAAE,IAAI;AACrD,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS;AAC7B,+BAA+B,CAACM,YAAY,CAAC;AAC7C,uBAAuB,CAACA,YAAY,CAAC;AACrC,QAAQ,EAAE,IAAI;AACd,MAAM,EAAE,GAAG,CAAC;EAEV;AACF,CAAC;AAED,MAAME,qBAAqB,EAAExB,sBAAsB,GAAG;EACpDC,EAAE,EAAE,mBAAmB;EACvBC,IAAI,EAAE,SAAS;EACfC,QAAQ,EAAEA,CAAA,KAAM;IACd,MAAM;MAAEiB,MAAM,EAAEE;IAAa,CAAC,GAAGvC,4BAA4B,CAAC;MAC5DwC,iCAAiC,EAAE;IACrC,CAAC,CAAC;IACF,MAAMJ,aAAa,GAAGlC,kBAAkB,CAAC,CAAC;IAC1C,OACEqC,YAAY,KAAK,MAAM,IACvBH,aAAa,CAACC,MAAM,KAAK,MAAM,IAC/B,EACEE,YAAY,KAAK,cAAc,IAC/BH,aAAa,CAACC,MAAM,KAAK,cAAc,CACxC;EAEL,CAAC;EACDf,MAAM,EAAEA,CAAA,KAAM;IACZ,MAAM;MAAEe,MAAM,EAAEE;IAAa,CAAC,GAAGvC,4BAA4B,CAAC;MAC5DwC,iCAAiC,EAAE;IACrC,CAAC,CAAC;IACF,MAAMJ,aAAa,GAAGlC,kBAAkB,CAAC,CAAC;IAC1C,OACE,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AAC/C,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK;AAChC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAACP,OAAO,CAACsC,OAAO,CAAC,EAAE,IAAI;AACvD,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS;AAC/B,yCAAyC,CAACG,aAAa,CAACC,MAAM,CAAC;AAC/D,aAAa,CAACE,YAAY,CAAC;AAC3B,UAAU,EAAE,IAAI;AAChB,QAAQ,EAAE,GAAG;AACb,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AAClD,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS;AAC/B,2BAA2B,CAAC,GAAG;AAC/B,YAAY,CAACH,aAAa,CAACC,MAAM,KAAK,WAAW,GACjC,WAAW,GACXD,aAAa,CAACC,MAAM;AACpC,aAAa,CAAC,GAAG;AACjB,YAAY,CAACE,YAAY,KAAK,mBAAmB,GACjC,yHAAyH,GACzHA,YAAY,KAAK,cAAc,GAC7B,iCAAiC,GACjC,gBAAgB;AAClC,UAAU,EAAE,IAAI;AAChB,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS;AAC/B,4BAA4B,CAACA,YAAY,CAAC,CAAC,CAAC,GAAG;AAC/C,YAAY,CAACH,aAAa,CAACC,MAAM,KAAK,WAAW,GACjC,0CAA0C,GAC1C,aAAaD,aAAa,CAACC,MAAM,wBAAwB;AACzE,UAAU,EAAE,IAAI;AAChB,QAAQ,EAAE,GAAG;AACb,MAAM,EAAE,GAAG,CAAC;EAEV;AACF,CAAC;AAED,MAAMK,4BAA4B,EAAEzB,sBAAsB,GAAG;EAC3DC,EAAE,EAAE,0BAA0B;EAC9BC,IAAI,EAAE,SAAS;EACfC,QAAQ,EAAEC,OAAO,IAAI;IACnB,MAAMsB,WAAW,GAAGtC,+BAA+B,CACjDgB,OAAO,CAACN,gBACV,CAAC;IACD,OAAO4B,WAAW,GAAGrC,4BAA4B;EACnD,CAAC;EACDgB,MAAM,EAAED,OAAO,IAAI;IACjB,MAAMsB,WAAW,GAAGtC,+BAA+B,CACjDgB,OAAO,CAACN,gBACV,CAAC;IACD,OACE,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK;AAC9B,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAACpB,OAAO,CAACsC,OAAO,CAAC,EAAE,IAAI;AACrD,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS;AAC7B;AACA,UAAU,CAACnC,YAAY,CAAC6C,WAAW,CAAC,CAAC,YAAY,CAAC,GAAG;AACrD,UAAU,CAAC7C,YAAY,CAACQ,4BAA4B,CAAC,CAAC;AACtD,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,oBAAoB,EAAE,IAAI;AACnD,QAAQ,EAAE,IAAI;AACd,MAAM,EAAE,GAAG,CAAC;EAEV;AACF,CAAC;AAED,MAAMsC,qBAAqB,EAAE3B,sBAAsB,GAAG;EACpDC,EAAE,EAAE,0BAA0B;EAC9BC,IAAI,EAAE,MAAM;EACZC,QAAQ,EAAEC,OAAO,IAAI;IACnB;IACA,IAAI,CAACd,4BAA4B,CAAC,CAAC,EAAE;MACnC,OAAO,KAAK;IACd;IACA;IACA,MAAMsC,iBAAiB,GAAGxB,OAAO,CAACR,MAAM,CAACiC,uBAAuB,IAAI,IAAI;IACxE,IAAI,CAACD,iBAAiB,EAAE;MACtB,OAAO,KAAK;IACd;IACA;IACA,MAAME,OAAO,GAAGtC,kBAAkB,CAAC,CAAC;IACpC,OAAOsC,OAAO,KAAK,IAAI,IAAI,CAACrC,oCAAoC,CAACqC,OAAO,CAAC;EAC3E,CAAC;EACDzB,MAAM,EAAEA,CAAA,KAAM;IACZ,MAAMyB,OAAO,GAAGtC,kBAAkB,CAAC,CAAC;IACpC,MAAMuC,OAAO,GAAGxC,gBAAgB,CAACuC,OAAO,CAAC;IACzC,OACE,CAAC,GAAG,CAAC,aAAa,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;AACrD,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAACpD,OAAO,CAACsD,OAAO,CAAC,EAAE,IAAI;AACjD,QAAQ,CAAC,IAAI;AACb,sBAAsB,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAACD,OAAO,CAAC,EAAE,IAAI,CAAC;AACxD,gCAAgC,CAAC,GAAG;AACpC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,+CAA+C,EAAE,IAAI;AAC1E,QAAQ,EAAE,IAAI;AACd,MAAM,EAAE,GAAG,CAAC;EAEV;AACF,CAAC;;AAGD;AACA,OAAO,MAAME,uBAAuB,EAAEjC,sBAAsB,EAAE,GAAG,CAC/DO,sBAAsB,EACtBkB,4BAA4B,EAC5BP,qCAAqC,EACrCG,oBAAoB,EACpBG,qBAAqB,EACrBG,qBAAqB,CACtB;;AAED;AACA,OAAO,SAASO,gBAAgBA,CAC9B9B,OAAO,EAAET,mBAAmB,CAC7B,EAAEK,sBAAsB,EAAE,CAAC;EAC1B,OAAOiC,uBAAuB,CAACE,MAAM,CAACC,MAAM,IAAIA,MAAM,CAACjC,QAAQ,CAACC,OAAO,CAAC,CAAC;AAC3E","ignoreList":[]}

package/utils/statusNoticeHelpers.ts

@@ -0,0 +1,20 @@
+import { roughTokenCountEstimation } from '../services/tokenEstimation.js'
+import type { AgentDefinitionsResult } from '../tools/AgentTool/loadAgentsDir.js'
+
+export const AGENT_DESCRIPTIONS_THRESHOLD = 15_000
+
+/**
+ * Calculate cumulative token estimate for agent descriptions
+ */
+export function getAgentDescriptionsTotalTokens(
+  agentDefinitions?: AgentDefinitionsResult,
+): number {
+  if (!agentDefinitions) return 0
+
+  return agentDefinitions.activeAgents
+    .filter(a => a.source !== 'built-in')
+    .reduce((total, agent) => {
+      const description = `${agent.agentType}: ${agent.whenToUse}`
+      return total + roughTokenCountEstimation(description)
+    }, 0)
+}

package/utils/stream.ts

@@ -0,0 +1,76 @@
+export class Stream<T> implements AsyncIterator<T> {
+  private readonly queue: T[] = []
+  private readResolve?: (value: IteratorResult<T>) => void
+  private readReject?: (error: unknown) => void
+  private isDone: boolean = false
+  private hasError: unknown | undefined
+  private started = false
+
+  constructor(private readonly returned?: () => void) {}
+
+  [Symbol.asyncIterator](): AsyncIterableIterator<T> {
+    if (this.started) {
+      throw new Error('Stream can only be iterated once')
+    }
+    this.started = true
+    return this
+  }
+
+  next(): Promise<IteratorResult<T, unknown>> {
+    if (this.queue.length > 0) {
+      return Promise.resolve({
+        done: false,
+        value: this.queue.shift()!,
+      })
+    }
+    if (this.isDone) {
+      return Promise.resolve({ done: true, value: undefined })
+    }
+    if (this.hasError) {
+      return Promise.reject(this.hasError)
+    }
+    return new Promise<IteratorResult<T>>((resolve, reject) => {
+      this.readResolve = resolve
+      this.readReject = reject
+    })
+  }
+
+  enqueue(value: T): void {
+    if (this.readResolve) {
+      const resolve = this.readResolve
+      this.readResolve = undefined
+      this.readReject = undefined
+      resolve({ done: false, value })
+    } else {
+      this.queue.push(value)
+    }
+  }
+
+  done() {
+    this.isDone = true
+    if (this.readResolve) {
+      const resolve = this.readResolve
+      this.readResolve = undefined
+      this.readReject = undefined
+      resolve({ done: true, value: undefined })
+    }
+  }
+
+  error(error: unknown) {
+    this.hasError = error
+    if (this.readReject) {
+      const reject = this.readReject
+      this.readResolve = undefined
+      this.readReject = undefined
+      reject(error)
+    }
+  }
+
+  return(): Promise<IteratorResult<T, unknown>> {
+    this.isDone = true
+    if (this.returned) {
+      this.returned()
+    }
+    return Promise.resolve({ done: true, value: undefined })
+  }
+}

package/utils/streamJsonStdoutGuard.ts

@@ -0,0 +1,123 @@
+import { registerCleanup } from './cleanupRegistry.js'
+import { logForDebugging } from './debug.js'
+
+/**
+ * Sentinel written to stderr ahead of any diverted non-JSON line, so that
+ * log scrapers and tests can grep for guard activity.
+ */
+export const STDOUT_GUARD_MARKER = '[stdout-guard]'
+
+let installed = false
+let buffer = ''
+let originalWrite: typeof process.stdout.write | null = null
+
+function isJsonLine(line: string): boolean {
+  // Empty lines are tolerated in NDJSON streams — treat them as valid so a
+  // trailing newline or a blank separator doesn't trip the guard.
+  if (line.length === 0) {
+    return true
+  }
+  try {
+    JSON.parse(line)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Install a runtime guard on process.stdout.write for --output-format=stream-json.
+ *
+ * SDK clients consuming stream-json parse stdout line-by-line as NDJSON. Any
+ * stray write — a console.log from a dependency, a debug print that slipped
+ * past review, a library banner — breaks the client's parser mid-stream with
+ * no recovery path.
+ *
+ * This guard wraps process.stdout.write at the same layer the asciicast
+ * recorder does (see asciicast.ts). Writes are buffered until a newline
+ * arrives, then each complete line is JSON-parsed. Lines that parse are
+ * forwarded to the real stdout; lines that don't are diverted to stderr
+ * tagged with STDOUT_GUARD_MARKER so they remain visible without corrupting
+ * the JSON stream.
+ *
+ * The blessed JSON path (structuredIO.write → writeToStdout → stdout.write)
+ * always emits `ndjsonSafeStringify(msg) + '\n'`, so it passes straight
+ * through. Only out-of-band writes are diverted.
+ *
+ * Installing twice is a no-op. Call before any stream-json output is emitted.
+ */
+export function installStreamJsonStdoutGuard(): void {
+  if (installed) {
+    return
+  }
+  installed = true
+
+  originalWrite = process.stdout.write.bind(
+    process.stdout,
+  ) as typeof process.stdout.write
+
+  process.stdout.write = function (
+    chunk: string | Uint8Array,
+    encodingOrCb?: BufferEncoding | ((err?: Error) => void),
+    cb?: (err?: Error) => void,
+  ): boolean {
+    const text =
+      typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf-8')
+
+    buffer += text
+    let newlineIdx: number
+    let wrote = true
+    while ((newlineIdx = buffer.indexOf('\n')) !== -1) {
+      const line = buffer.slice(0, newlineIdx)
+      buffer = buffer.slice(newlineIdx + 1)
+      if (isJsonLine(line)) {
+        wrote = originalWrite!(line + '\n')
+      } else {
+        process.stderr.write(`${STDOUT_GUARD_MARKER} ${line}\n`)
+        logForDebugging(
+          `streamJsonStdoutGuard diverted non-JSON stdout line: ${line.slice(0, 200)}`,
+        )
+      }
+    }
+
+    // Fire the callback once buffering is done. We report success even when
+    // a line was diverted — the caller's intent (emit text) was honored,
+    // just on a different fd.
+    const callback = typeof encodingOrCb === 'function' ? encodingOrCb : cb
+    if (callback) {
+      queueMicrotask(() => callback())
+    }
+    return wrote
+  } as typeof process.stdout.write
+
+  registerCleanup(async () => {
+    // Flush any partial line left in the buffer at shutdown. If it's a JSON
+    // fragment it won't parse — divert it rather than drop it silently.
+    if (buffer.length > 0) {
+      if (originalWrite && isJsonLine(buffer)) {
+        originalWrite(buffer + '\n')
+      } else {
+        process.stderr.write(`${STDOUT_GUARD_MARKER} ${buffer}\n`)
+      }
+      buffer = ''
+    }
+    if (originalWrite) {
+      process.stdout.write = originalWrite
+      originalWrite = null
+    }
+    installed = false
+  })
+}
+
+/**
+ * Testing-only reset. Restores the real stdout.write and clears the line
+ * buffer so subsequent tests start from a clean slate.
+ */
+export function _resetStreamJsonStdoutGuardForTesting(): void {
+  if (originalWrite) {
+    process.stdout.write = originalWrite
+    originalWrite = null
+  }
+  buffer = ''
+  installed = false
+}

package/utils/streamlinedTransform.ts

@@ -0,0 +1,201 @@
+/**
+ * Transforms SDK messages for streamlined output mode.
+ *
+ * Streamlined mode is a "distillation-resistant" output format that:
+ * - Keeps text messages intact
+ * - Summarizes tool calls with cumulative counts (resets when text appears)
+ * - Omits thinking content
+ * - Strips tool list and model info from init messages
+ */
+
+import type { SDKAssistantMessage } from 'src/entrypoints/agentSdkTypes.js'
+import type { StdoutMessage } from 'src/entrypoints/sdk/controlTypes.js'
+import { FILE_EDIT_TOOL_NAME } from 'src/tools/FileEditTool/constants.js'
+import { FILE_READ_TOOL_NAME } from 'src/tools/FileReadTool/prompt.js'
+import { FILE_WRITE_TOOL_NAME } from 'src/tools/FileWriteTool/prompt.js'
+import { GLOB_TOOL_NAME } from 'src/tools/GlobTool/prompt.js'
+import { GREP_TOOL_NAME } from 'src/tools/GrepTool/prompt.js'
+import { LIST_MCP_RESOURCES_TOOL_NAME } from 'src/tools/ListMcpResourcesTool/prompt.js'
+import { LSP_TOOL_NAME } from 'src/tools/LSPTool/prompt.js'
+import { NOTEBOOK_EDIT_TOOL_NAME } from 'src/tools/NotebookEditTool/constants.js'
+import { TASK_STOP_TOOL_NAME } from 'src/tools/TaskStopTool/prompt.js'
+import { WEB_SEARCH_TOOL_NAME } from 'src/tools/WebSearchTool/prompt.js'
+import { extractTextContent } from 'src/utils/messages.js'
+import { SHELL_TOOL_NAMES } from 'src/utils/shell/shellToolUtils.js'
+import { capitalize } from 'src/utils/stringUtils.js'
+
+type ToolCounts = {
+  searches: number
+  reads: number
+  writes: number
+  commands: number
+  other: number
+}
+
+/**
+ * Tool categories for summarization.
+ */
+const SEARCH_TOOLS = [
+  GREP_TOOL_NAME,
+  GLOB_TOOL_NAME,
+  WEB_SEARCH_TOOL_NAME,
+  LSP_TOOL_NAME,
+]
+const READ_TOOLS = [FILE_READ_TOOL_NAME, LIST_MCP_RESOURCES_TOOL_NAME]
+const WRITE_TOOLS = [
+  FILE_WRITE_TOOL_NAME,
+  FILE_EDIT_TOOL_NAME,
+  NOTEBOOK_EDIT_TOOL_NAME,
+]
+const COMMAND_TOOLS = [...SHELL_TOOL_NAMES, 'Tmux', TASK_STOP_TOOL_NAME]
+
+function categorizeToolName(toolName: string): keyof ToolCounts {
+  if (SEARCH_TOOLS.some(t => toolName.startsWith(t))) return 'searches'
+  if (READ_TOOLS.some(t => toolName.startsWith(t))) return 'reads'
+  if (WRITE_TOOLS.some(t => toolName.startsWith(t))) return 'writes'
+  if (COMMAND_TOOLS.some(t => toolName.startsWith(t))) return 'commands'
+  return 'other'
+}
+
+function createEmptyToolCounts(): ToolCounts {
+  return {
+    searches: 0,
+    reads: 0,
+    writes: 0,
+    commands: 0,
+    other: 0,
+  }
+}
+
+/**
+ * Generate a summary text for tool counts.
+ */
+function getToolSummaryText(counts: ToolCounts): string | undefined {
+  const parts: string[] = []
+
+  // Use similar phrasing to collapseReadSearch.ts
+  if (counts.searches > 0) {
+    parts.push(
+      `searched ${counts.searches} ${counts.searches === 1 ? 'pattern' : 'patterns'}`,
+    )
+  }
+  if (counts.reads > 0) {
+    parts.push(`read ${counts.reads} ${counts.reads === 1 ? 'file' : 'files'}`)
+  }
+  if (counts.writes > 0) {
+    parts.push(
+      `wrote ${counts.writes} ${counts.writes === 1 ? 'file' : 'files'}`,
+    )
+  }
+  if (counts.commands > 0) {
+    parts.push(
+      `ran ${counts.commands} ${counts.commands === 1 ? 'command' : 'commands'}`,
+    )
+  }
+  if (counts.other > 0) {
+    parts.push(`${counts.other} other ${counts.other === 1 ? 'tool' : 'tools'}`)
+  }
+
+  if (parts.length === 0) {
+    return undefined
+  }
+
+  return capitalize(parts.join(', '))
+}
+
+/**
+ * Count tool uses in an assistant message and add to existing counts.
+ */
+function accumulateToolUses(
+  message: SDKAssistantMessage,
+  counts: ToolCounts,
+): void {
+  const content = message.message.content
+  if (!Array.isArray(content)) {
+    return
+  }
+
+  for (const block of content) {
+    if (block.type === 'tool_use' && 'name' in block) {
+      const category = categorizeToolName(block.name as string)
+      counts[category]++
+    }
+  }
+}
+
+/**
+ * Create a stateful transformer that accumulates tool counts between text messages.
+ * Tool counts reset when a message with text content is encountered.
+ */
+export function createStreamlinedTransformer(): (
+  message: StdoutMessage,
+) => StdoutMessage | null {
+  let cumulativeCounts = createEmptyToolCounts()
+
+  return function transformToStreamlined(
+    message: StdoutMessage,
+  ): StdoutMessage | null {
+    switch (message.type) {
+      case 'assistant': {
+        const content = message.message.content
+        const text = Array.isArray(content)
+          ? extractTextContent(content, '\n').trim()
+          : ''
+
+        // Accumulate tool counts from this message
+        accumulateToolUses(message, cumulativeCounts)
+
+        if (text.length > 0) {
+          // Text message: emit text only, reset counts
+          cumulativeCounts = createEmptyToolCounts()
+          return {
+            type: 'streamlined_text',
+            text,
+            session_id: message.session_id,
+            uuid: message.uuid,
+          }
+        }
+
+        // Tool-only message: emit cumulative tool summary
+        const toolSummary = getToolSummaryText(cumulativeCounts)
+        if (!toolSummary) {
+          return null
+        }
+
+        return {
+          type: 'streamlined_tool_use_summary',
+          tool_summary: toolSummary,
+          session_id: message.session_id,
+          uuid: message.uuid,
+        }
+      }
+
+      case 'result':
+        // Keep result messages as-is (they have structured_output, permission_denials)
+        return message
+
+      case 'system':
+      case 'user':
+      case 'stream_event':
+      case 'tool_progress':
+      case 'auth_status':
+      case 'rate_limit_event':
+      case 'control_response':
+      case 'control_request':
+      case 'control_cancel_request':
+      case 'keep_alive':
+        return null
+
+      default:
+        return null
+    }
+  }
+}
+
+/**
+ * Check if a message should be included in streamlined output.
+ * Useful for filtering before transformation.
+ */
+export function shouldIncludeInStreamlined(message: StdoutMessage): boolean {
+  return message.type === 'assistant' || message.type === 'result'
+}