elanous 0.2.42 → 0.2.44

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/tool-hints/gate.ts

@@ -36,7 +36,7 @@ export function evaluateGate(
   const key = cacheKey(catalog, hints, signals);
   const cached = CACHE.get(key);
   if (cached) {
-    recordGateEvaluation(catalog.length, cached.filtered.length, {
+    recordGateEvaluation(catalog, cached, {
       defaultEnabled: notRunStage(),
       probe: notRunStage(),
       intentScope: notRunStage(),
@@ -58,10 +58,12 @@ export function evaluateGate(
   };
   const boost = new Map<string, number>();
   const paramDefaults = new Map<string, Record<string, unknown>>();
+  const excludedReasons = new Map<string, string>();
 
   // ─── Step 1: seed with defaultEnabled entries ──────────────────
   for (const tool of catalog) {
     if (tool.defaultEnabled) enabled.add(tool.id);
+    else excludedReasons.set(tool.id, 'default-disabled');
   }
   stages.defaultEnabled = executedStage(catalog.length, enabled.size);
 
@@ -74,6 +76,7 @@ export function evaluateGate(
     const mode = tool.probe.onFail ?? 'hide';
     if (mode === 'hide') enabled.delete(tool.id);
     else if (mode === 'disable') enabled.delete(tool.id);
+    if (mode === 'hide' || mode === 'disable') excludedReasons.set(tool.id, `probe-${mode}`);
     // 'warn': leave enabled; caller may read hintReasons to surface
   }
   stages.probe = executedStage(beforeProbe, enabled.size);
@@ -93,7 +96,10 @@ export function evaluateGate(
     for (const tool of catalog) {
       const scope: ToolIntentScope = tool.intentScope ?? 'always';
       if (scope === 'always') continue;
-      if (!activeScopes.has(scope)) enabled.delete(tool.id);
+      if (!activeScopes.has(scope)) {
+        enabled.delete(tool.id);
+        excludedReasons.set(tool.id, `intent-scope:${scope}`);
+      }
     }
     stages.intentScope = executedStage(beforeIntentScope, enabled.size);
   }
@@ -107,7 +113,10 @@ export function evaluateGate(
     for (const tool of catalog) {
       if (!tool.minTier) continue;
       const need = tierRank[tool.minTier] ?? 2;
-      if (activeRank < need) enabled.delete(tool.id);
+      if (activeRank < need) {
+        enabled.delete(tool.id);
+        excludedReasons.set(tool.id, `min-tier:${tool.minTier}`);
+      }
     }
     stages.minTier = executedStage(beforeMinTier, enabled.size);
   }
@@ -126,8 +135,14 @@ export function evaluateGate(
       if (seenForKind.has(comboKey)) continue;
       seenForKind.set(comboKey, { toolId, kind: h.kind });
 
-      if (h.kind === 'enable')  enabled.add(toolId);
-      if (h.kind === 'disable') enabled.delete(toolId);
+      if (h.kind === 'enable') {
+        enabled.add(toolId);
+        excludedReasons.delete(toolId);
+      }
+      if (h.kind === 'disable') {
+        enabled.delete(toolId);
+        excludedReasons.set(toolId, 'hint-disabled');
+      }
       if (h.kind === 'prefer') boost.set(toolId, (boost.get(toolId) ?? 0) + 2);
       if (h.kind === 'boost')  boost.set(toolId, (boost.get(toolId) ?? 0) + 1);
       if (h.kind === 'avoid')  boost.set(toolId, (boost.get(toolId) ?? 0) - 1);
@@ -144,6 +159,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);
@@ -180,11 +196,21 @@ export function evaluateGate(
     const beforeModelFamilyCap = keep.length;
     const cap = signals.researchAgent ? 16 : 8;
     if (keep.length > cap) {
-      keep = keep
+      const requiredResearchTools = signals.intentResearch
+        ? ['web_search', 'web_fetch'].filter(id => enabled.has(id))
+        : [];
+      const required = new Set(requiredResearchTools);
+      const ranked = keep
+        .filter(id => !required.has(id))
         .map(id => ({ id, score: boost.get(id) ?? 0 }))
         .sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
-        .slice(0, cap)
+        .slice(0, Math.max(0, cap - requiredResearchTools.length))
         .map(x => x.id);
+      keep = [...requiredResearchTools, ...ranked];
+      const selectedBeforeStableSort = new Set(keep);
+      for (const id of enabled) {
+        if (!selectedBeforeStableSort.has(id)) excludedReasons.set(id, 'model-family-cap');
+      }
     }
     stages.modelFamilyCap = executedStage(beforeModelFamilyCap, keep.length);
   }
@@ -203,6 +229,7 @@ export function evaluateGate(
     boost: Object.fromEntries(boost),
     paramDefaults: Object.fromEntries(paramDefaults),
     hintReasons,
+    excludedReasons: Object.fromEntries(excludedReasons),
   };
 
   if (CACHE.size >= CACHE_MAX) {
@@ -211,7 +238,7 @@ export function evaluateGate(
     if (firstKey !== undefined) CACHE.delete(firstKey);
   }
   CACHE.set(key, decision);
-  recordGateEvaluation(catalog.length, decision.filtered.length, stages, false);
+  recordGateEvaluation(catalog, decision, stages, false);
   return decision;
 }
 
@@ -236,18 +263,23 @@ function executedStage(before: number, after: number): GateStage {
 }
 
 function recordGateEvaluation(
-  catalogCount: number,
-  filteredCount: number,
+  catalog: NativeToolCatalogEntry[],
+  decision: GateDecision,
   stages: GateStages,
   cacheHit: boolean,
 ): void {
-  // This is a per-call summary: names stay out so high-cardinality catalogs do not flood observability.
+  const active = new Set(decision.filtered);
   debug.log('capability.resolve', 'tool-gate-evaluated', {
     cacheHit,
-    catalogCount,
-    filteredCount,
-    removedCount: catalogCount - filteredCount,
+    catalogCount: catalog.length,
+    filteredCount: decision.filtered.length,
+    removedCount: catalog.length - decision.filtered.length,
     stages,
+    activeTools: decision.filtered.map((id) => catalog.find((tool) => tool.id === id)?.displayName ?? id),
+    excludedTools: catalog.filter((tool) => !active.has(tool.id)).map((tool) => ({
+      name: tool.displayName,
+      reason: decision.excludedReasons?.[tool.id] ?? 'unclassified-filter',
+    })),
   });
 }
 

package/src/tool-hints/signals.ts

@@ -120,7 +120,7 @@ const RESEARCH_ASCII_RE = /\b(research|find out|look up|investigate|latest (on|n
 const RESEARCH_KO_RE = /(최신|뉴스|찾아(?:줘|봐)|알아봐|조사|리서치)/;
 const RESEARCH_SKILL_RE = /\b(?:omni[ -]market|omni[ -]crawl|social[ -]pulse)\b/i;
 const RESEARCH_EXPLANATION_RE = /(?:왜|이유|원인|전망|분석|비교|조사|\bwhy\b|\bcause\b|\boutlook\b|\banalysis\b|\bcompare\b)/i;
-const RESEARCH_TOPIC_RE = /(?:금리|채권|시장|경제|물가|환율|주가|기업|산업|정책|선거|역사|기후|질병|의학|과학|\bbond\b|\byield\b|\bmarket\b|\beconomy\b|\binflation\b|\bstock\b|\bpolicy\b|\belection\b|\bhistory\b|\bclimate\b|\bhealth\b|\bscience\b)/i;
+const RESEARCH_TOPIC_RE = /(?:금리|채권|시장|경제|물가|환율|주가|기업|산업|정책|선거|역사|기후|질병|의학|과학|반도체|HBM\d?|메모리|공급망|양산|인증|마이크론|삼성전자|SK하이닉스|\bbond\b|\byield\b|\bmarket\b|\beconomy\b|\binflation\b|\bstock\b|\bpolicy\b|\belection\b|\bhistory\b|\bclimate\b|\bhealth\b|\bscience\b)/i;
 const RESEARCH_CODING_RE = /(?:코드|함수|버그|테스트|빌드|커밋|하니스|설정|오류|구현|수리|고쳐|수정|저장소|\brepo\b|\bcode\b|\bfunction\b|\bbug\b|\btest\b|\bbuild\b|\bcommit\b|\bconfig\b|\bimplement\b|\bfix\b)/i;
 const DEEP_RESEARCH_INTENT_TERMS = [
   'research', 'deep research', 'triangulate', 'compare sources',

package/src/tool-hints/types.ts

@@ -102,4 +102,6 @@ export interface GateDecision {
   paramDefaults: Record<string, Record<string, unknown>>;
   /** Reasons surfaced by current hints — for prompt injection. */
   hintReasons: string[];
+  /** Why a catalog entry was not selected, keyed by stable catalog id. */
+  excludedReasons?: Record<string, string>;
 }

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

@@ -15,6 +15,7 @@ export const agentRuntime: ToolRuntime<Record<string, unknown>, AgentToolResult>
       hostTools: ctx.agentHostTools,
       dispatchTool: ctx.agentDispatchTool,
       buildChildToolCatalog: ctx.buildChildToolCatalog,
+      inheritGeneralPurposeToolCatalog: ctx.inheritGeneralPurposeToolCatalog,
       signal: ctx.signal,
     });
   },