elanous 0.2.42 → 0.2.44

package/src/skills/tools/omni-search.ts

@@ -2,8 +2,8 @@
 //
 // Skill-essence extraction of ~/.claude/skills/omni-crawl/. Different
 // from WebSearch (cascade — first available wins): omni_search runs
-// EVERY available web-search provider in PARALLEL and merges their
-// hits, so the LLM gets a wider net for research-intent queries.
+// every selected provider in parallel and merges hits. Research dispatch
+// has a narrower Exa/Firecrawl allowlist; Grok is reserved for explicit X intent.
 //
 // Probe: at least 2 providers available. With only 1, plain WebSearch
 // is sufficient — no point paying the parallel-fan-out cost.
@@ -13,7 +13,7 @@
 //   by-engine   — group hits under per-provider headings
 
 import type { LLMToolSpec } from '../../llm.js';
-import { getAvailableWebSearchProviders } from '../../web-search/index.js';
+import { getAvailableResearchWebSearchProviders, getAvailableWebSearchProviders } from '../../web-search/index.js';
 import type { WebSearchHit } from '../../web-search/provider.js';
 
 export interface OmniSearchArgs {
@@ -40,9 +40,12 @@ export type OmniSearchEngineEvent =
   | { engine: string; phase: 'complete'; hits: number; durationMs: number; error?: string };
 
 export interface OmniSearchDispatchOpts {
+  signal?: AbortSignal;
   /** Observational only: callback failures must not interrupt a provider search. */
   onEngine?: (event: OmniSearchEngineEvent) => void;
   onSource?: (source: WebSearchHit & { engine: string }) => void;
+  /** Test seam for verifying that sequential research providers share one deadline. */
+  now?: () => number;
 }
 
 const DEFAULT_LIMIT = 5;
@@ -52,9 +55,9 @@ export function buildOmniSearchTool(): LLMToolSpec {
   return {
     name: 'OmniSearch',
     description:
-      'Multi-provider web search — fans out to every configured search provider in parallel and ' +
-      'merges hits. Wider coverage than WebSearch (cascade). Use for research-intent queries ' +
-      'where you want triangulation across Grok / Firecrawl / etc. Probe-gated: requires at ' +
+      'Multi-provider web search — fans out to configured search providers in parallel and ' +
+      'merges hits. Wider coverage than WebSearch (cascade). Research searches use bounded ' +
+      'Exa / Firecrawl routes; Grok is reserved for explicit X/Twitter intent. Probe-gated: requires at ' +
       'least 2 available providers (otherwise WebSearch already covers it).',
     parameters: {
       type: 'object',
@@ -73,13 +76,22 @@ export function buildOmniSearchTool(): LLMToolSpec {
   };
 }
 
-const RESEARCH_GROK_TIMEOUT_MS = 8_000;
+const RESEARCH_SEARCH_BUDGET_MS = 14_500;
+const RESEARCH_WEB_FALLBACK_IDS = ['exa', 'firecrawl'];
+const RESEARCH_EXA_TIMEOUT_MS = 4_500;
+const researchHits = new WeakMap<OmniSearchResult, Record<string, WebSearchHit[]>>();
 
 export async function dispatchOmniSearch(
   rawArgs: Record<string, unknown>,
   opts: OmniSearchDispatchOpts = {},
 ): Promise<OmniSearchResult> {
-  return dispatchWithProviders(validate(rawArgs), opts);
+  const args = validate(rawArgs);
+  const allowed = getAvailableResearchProviders();
+  const requested = args.engines === undefined ? undefined : new Set(args.engines.map(id => id.toLowerCase()));
+  const providers = requested === undefined
+    ? allowed
+    : allowed.filter(provider => requested.has(provider.id.toLowerCase()));
+  return dispatchWithProviders(args, opts, providers);
 }
 
 export async function dispatchResearchOmniSearch(
@@ -87,19 +99,104 @@ export async function dispatchResearchOmniSearch(
   opts: OmniSearchDispatchOpts = {},
 ): Promise<OmniSearchResult> {
   const args = validate(rawArgs);
+  const now = opts.now ?? Date.now;
+  const deadlineAt = now() + RESEARCH_SEARCH_BUDGET_MS;
   const selected = getAvailableResearchProviders();
   const requested = args.engines === undefined ? undefined : new Set(args.engines.map(id => id.toLowerCase()));
   const providers = requested === undefined
     ? selected
     : selected.filter(provider => requested.has(provider.id.toLowerCase()));
-  return dispatchWithProviders(args, opts, providers, { grokTimeoutMs: RESEARCH_GROK_TIMEOUT_MS });
+  const webFallback = providers.filter(provider => RESEARCH_WEB_FALLBACK_IDS.includes(provider.id));
+  const webResult = await dispatchResearchWebFallback(args, opts, webFallback, deadlineAt);
+  return combineResearchResults(args, emptyOmniSearchResult(args), webResult);
+}
+
+function emptyOmniSearchResult(args: OmniSearchArgs): OmniSearchResult {
+  const result: OmniSearchResult = {
+    output: '',
+    metadata: { perEngine: {}, totalHits: 0, merge: args.merge ?? 'interleave' },
+  };
+  researchHits.set(result, {});
+  return result;
+}
+
+async function dispatchResearchWebFallback(
+  args: OmniSearchArgs,
+  opts: OmniSearchDispatchOpts,
+  providers: ReturnType<typeof getAvailableWebSearchProviders>,
+  deadlineAt: number,
+): Promise<OmniSearchResult> {
+  const accumulated = emptyOmniSearchResult(args);
+  for (const provider of providers) {
+    const result = await dispatchWithProviders(args, opts, [provider], {
+      deadlineAt,
+      now: opts.now ?? Date.now,
+    });
+    Object.assign(accumulated.metadata.perEngine, result.metadata.perEngine);
+    accumulated.metadata.totalHits += result.metadata.totalHits;
+    accumulated.output += accumulated.output && result.output ? `\n\n${result.output}` : result.output;
+    Object.assign(researchHits.get(accumulated)!, researchHits.get(result));
+    const details = result.metadata.perEngine[provider.id];
+    // A successful but empty response is no usable research evidence, so continue to the next provider.
+    if (details && !details.error && details.hits > 0) break;
+  }
+  return accumulated;
+}
+
+function combineResearchResults(
+  args: OmniSearchArgs,
+  grokResult: OmniSearchResult,
+  webResult: OmniSearchResult,
+): OmniSearchResult {
+  const perEngine = { ...grokResult.metadata.perEngine, ...webResult.metadata.perEngine };
+  const hitsByEngine = { ...researchHits.get(grokResult), ...researchHits.get(webResult) };
+  const merge = args.merge ?? 'interleave';
+  const limit = Math.max(1, Math.min(args.limit ?? DEFAULT_LIMIT, MAX_LIMIT));
+  const merged = (merge === 'interleave'
+    ? interleaveHits(Object.fromEntries(Object.entries(hitsByEngine).map(([id, hits]) => [id, { hits }])))
+    : groupByEngine(Object.fromEntries(Object.entries(hitsByEngine).map(([id, hits]) => [id, { hits }]))))
+    .slice(0, limit);
+  const selectedByEngine = new Map<string, WebSearchHit[]>();
+  for (const [id, hits] of Object.entries(hitsByEngine)) selectedByEngine.set(id, []);
+  // Keep merge order for the global limit while retaining each source heading.
+  for (const hit of merged) {
+    const id = Object.keys(hitsByEngine).find(engine => hitsByEngine[engine]!.includes(hit));
+    if (id) selectedByEngine.get(id)!.push(hit);
+  }
+  const output: string[] = [`omni_search "${args.query}" — ${merged.length} hits across ${Object.keys(perEngine).length} provider${Object.keys(perEngine).length === 1 ? '' : 's'}`];
+  for (const [id, info] of Object.entries(perEngine)) {
+    output.push(`  ${id}: ${selectedByEngine.get(id)?.length ?? 0} hits in ${info.durationMs}ms${info.error ? ` ERROR: ${info.error}` : ''}`);
+  }
+  output.push('');
+  if (merge === 'by-engine') {
+    for (const [id, hits] of selectedByEngine) {
+      if (hits.length === 0) continue;
+      output.push(`## ${id}`);
+      for (const hit of hits) output.push(formatHit(hit));
+      output.push('');
+    }
+  } else {
+    for (const hit of merged) output.push(formatHit(hit));
+  }
+  const result: OmniSearchResult = {
+    output: output.join('\n'),
+    metadata: {
+      perEngine: Object.fromEntries(Object.entries(perEngine).map(([id, info]) => [id, {
+        ...info, hits: selectedByEngine.get(id)?.length ?? 0,
+      }])),
+      totalHits: merged.length,
+      merge,
+    },
+  };
+  researchHits.set(result, hitsByEngine);
+  return result;
 }
 
 async function dispatchWithProviders(
   args: OmniSearchArgs,
   opts: OmniSearchDispatchOpts,
   selectedProviders?: ReturnType<typeof getAvailableWebSearchProviders>,
-  researchLimits?: { grokTimeoutMs: number },
+  researchLimits?: { deadlineAt: number; now: () => number },
 ): Promise<OmniSearchResult> {
   const merge = args.merge ?? 'interleave';
   const limit = Math.max(1, Math.min(args.limit ?? DEFAULT_LIMIT, MAX_LIMIT));
@@ -136,24 +233,30 @@ async function dispatchWithProviders(
         recencyDays: args.recency_days,
       };
       let result;
-      if (researchLimits && (p.id === 'grok' || p.id === 'grok-api')) {
+      if (researchLimits) {
+        const remainingMs = researchLimits.deadlineAt - researchLimits.now();
+        const timeoutMs = p.id === 'exa'
+          ? Math.min(RESEARCH_EXA_TIMEOUT_MS, remainingMs)
+          : remainingMs;
+        if (timeoutMs <= 0) throw new DOMException('Research search budget exhausted', 'TimeoutError');
         const controller = new AbortController();
+        const signal = opts.signal ? AbortSignal.any([controller.signal, opts.signal]) : controller.signal;
         let timer: ReturnType<typeof setTimeout> | undefined;
         try {
           result = await Promise.race([
-            p.search(query, controller.signal),
+            p.search(query, signal),
             new Promise<never>((_, reject) => {
               timer = setTimeout(() => {
                 controller.abort();
-                reject(new DOMException(`Grok research search timed out after ${researchLimits.grokTimeoutMs}ms`, 'TimeoutError'));
-              }, researchLimits.grokTimeoutMs);
+                reject(new DOMException(`Research search timed out after ${timeoutMs}ms`, 'TimeoutError'));
+              }, timeoutMs);
             }),
           ]);
         } finally {
           if (timer !== undefined) clearTimeout(timer);
         }
       } else {
-        result = await p.search(query);
+        result = await p.search(query, opts.signal);
       }
       perEngine[p.id] = { hits: result.hits, durationMs: Date.now() - start };
       for (const hit of result.hits) {
@@ -196,7 +299,7 @@ async function dispatchWithProviders(
     for (const h of merged) lines.push(formatHit(h));
   }
 
-  return {
+  const result: OmniSearchResult = {
     output: lines.join('\n'),
     metadata: {
       perEngine: Object.fromEntries(Object.entries(perEngine).map(([k, v]) => [k, {
@@ -206,16 +309,18 @@ async function dispatchWithProviders(
       merge,
     },
   };
+  researchHits.set(result, Object.fromEntries(Object.entries(perEngine).map(([id, info]) => [id, info.hits])));
+  return result;
 }
 
-/** Probe-compatible: at least 2 search providers available for ordinary omni_search. */
+/** Probe-compatible: at least 2 Exa/Firecrawl providers available for omni_search. */
 export function omniSearchAvailable(): boolean {
-  return getAvailableWebSearchProviders().length >= 2;
+  return getAvailableResearchProviders().length >= 2;
 }
 
-/** Research-only probe: require the bounded Grok/Firecrawl research pair. */
+/** Research-only probe: require one bounded Exa/Firecrawl web route. */
 export function researchOmniSearchAvailable(): boolean {
-  return getAvailableResearchProviders().length >= 2;
+  return getAvailableResearchProviders().some(provider => RESEARCH_WEB_FALLBACK_IDS.includes(provider.id));
 }
 
 export function getAvailableResearchSearchEngineIds(): string[] {
@@ -223,13 +328,8 @@ export function getAvailableResearchSearchEngineIds(): string[] {
 }
 
 function getAvailableResearchProviders(): ReturnType<typeof getAvailableWebSearchProviders> {
-  const available = getAvailableWebSearchProviders();
-  const grok = available.find(provider => provider.id === 'grok')
-    ?? available.find(provider => provider.id === 'grok-api');
-  return [
-    ...(grok ? [grok] : []),
-    ...available.filter(provider => provider.id === 'firecrawl'),
-  ];
+  const available = getAvailableResearchWebSearchProviders();
+  return RESEARCH_WEB_FALLBACK_IDS.flatMap(id => available.filter(provider => provider.id === id));
 }
 
 function interleaveHits(perEngine: Record<string, { hits: WebSearchHit[] }>): WebSearchHit[] {

package/src/task-agent/parent-host.ts

@@ -281,6 +281,7 @@ export interface ParentHostPreflight { ok: boolean; gaps: string[]; warnings: st
 export function preflightScript(target: ParentHostConfig): string {
   const elanous = remotePath(target.elanous ?? DEFAULT_REMOTE_ELANOUS);
   const configDir = remotePath(target.configDir ?? DEFAULT_REMOTE_CONFIG_DIR);
+  const codexCliMirrorDir = remotePath(REMOTE_CODEX_CLI_MIRROR_DIR);
   const grokCredentialFloorSeconds = Math.ceil(PARENT_CHILD_CREDENTIAL_MIN_REMAINING_MS / 1_000);
   return [
     `echo "version=$(${elanous} --version 2>/dev/null | tail -1 | cut -d' ' -f1)"`,
@@ -290,7 +291,10 @@ export function preflightScript(target: ParentHostConfig): string {
     `command -v kubectl >/dev/null 2>&1 && echo kubectl=1`,
     `{ command -v grok >/dev/null 2>&1 || [ -x "$HOME/.grok/bin/grok" ]; } && echo grokCli=1`,
     `{ command -v codex >/dev/null 2>&1 || [ -x "$HOME/.local/bin/codex" ]; } && echo codexCli=1`,
-    `n=$(grep -Ec '^[[:space:]]*"openai-codex(:[^"]*)?"[[:space:]]*:[[:space:]]*\\{' ${configDir}/auth.json 2>/dev/null); echo "codexAccounts=\${n:-0}"`,
+    // Default auth retains its historical provider-profile count, including expired entries.
+    // The CLI mirror is access-only; unusable/expired profiles do not count and duplicates do not count twice.
+    // A missing remote Bun is reported as unknown rather than a misleading zero.
+    `codexCount=$(grep -Ec '^[[:space:]]*"openai-codex(:[^"]*)?"[[:space:]]*:[[:space:]]*\\{' ${configDir}/auth.json 2>/dev/null); codexAccountsDefault=\${codexCount:-0}; if command -v bun >/dev/null 2>&1; then codexProbe=$(bun -e 'const fs=require("node:fs");const read=(p)=>{try{return JSON.parse(fs.readFileSync(p,"utf8"))}catch{return {}}};const isCodex=(key)=>/^openai-codex(?::[^\"]+)?$/.test(key);const parent=read(process.argv[1]).providers||{};const mirror=read(process.argv[2]).providers||{};const activeMirror=Object.entries(mirror).filter(([key,p])=>isCodex(key)&&typeof p?.tokens?.accessToken==="string"&&p.tokens.accessToken.length>0&&!p.tokens.refreshToken&&!p.tokens.refresh_token&&typeof p.tokens.expiresAt==="number"&&Number.isFinite(p.tokens.expiresAt)&&p.tokens.expiresAt>Date.now());const additional=activeMirror.filter(([key])=>!Object.prototype.hasOwnProperty.call(parent,key)).length;process.stdout.write([activeMirror.length,additional].join("|"))' ${configDir}/auth.json ${codexCliMirrorDir}/auth.json 2>/dev/null); codexProbeStatus=measured; else codexProbe=''; codexProbeStatus=unknown; fi; case "$codexProbe" in *'|'*) codexAccountsMirror=\${codexProbe%%|*}; codexAccountsMirrorAdditional=\${codexProbe#*|};; *) codexProbeStatus=unknown; codexAccountsMirror=unknown; codexAccountsMirrorAdditional=0;; esac; codexAccounts=$((codexAccountsDefault + codexAccountsMirrorAdditional)); echo "codexAccountsDefault=\${codexAccountsDefault}"; echo "codexAccountsMirror=\${codexAccountsMirror}"; echo "codexAccountsMirrorAdditional=\${codexAccountsMirrorAdditional}"; echo "codexAccountsMirrorStatus=\${codexProbeStatus}"; echo "codexAccounts=\${codexAccounts}"`,
     `{ grep -Eq '"key"[[:space:]]*:[[:space:]]*"[^"]+"' "$HOME/.grok/auth.json" 2>/dev/null || [ -n "\${XAI_API_KEY:-}\${GROK_API_KEY:-}\${GROK_CODE_XAI_API_KEY:-}" ]; } && echo grok=1`,
     // The remote host owns its device-auth session. Ignore the legacy HQ mirror entry; it can outlive and mask the host credential.
     // Read only expiry metadata, never credential values, and compare against the shared minimum lifetime.
@@ -366,6 +370,7 @@ export function judgeParentHostCredentials(facts: Record<string, string>): strin
   if (facts.unreachable) return [];
   const warnings: string[] = [];
   if (!(Number(facts.codexAccounts) > 1)) warnings.push('codex-accounts-low');
+  if (facts.codexAccountsMirrorStatus === 'unknown') warnings.push('codex-account-mirror-unmeasured');
   if (facts.grok !== '1') warnings.push('grok-credential-missing');
   if (facts.openrouter !== '1') warnings.push('openrouter-key-missing');
   return warnings;
@@ -391,6 +396,19 @@ export function preflightParentHost(input: PreflightInput): ParentHostPreflight
     } catch { /* fail-soft */ }
   }
   const warnings = judgeParentHostCredentials(facts);
+  try {
+    debug.log('task-agent.parent-host', 'codex-account-candidates', {
+      host: input.target.host,
+      sources: [
+        { path: `${input.target.configDir ?? '~/.elanous'}/auth.json`, count: Number(facts.codexAccountsDefault) || 0 },
+        { path: `${REMOTE_CODEX_CLI_MIRROR_DIR.replace(/^\$HOME/, '~')}/auth.json`,
+          count: facts.codexAccountsMirrorStatus === 'unknown' ? null : Number(facts.codexAccountsMirror) || 0,
+          additional: facts.codexAccountsMirrorStatus === 'unknown' ? null : Number(facts.codexAccountsMirrorAdditional) || 0 },
+      ],
+      mirrorStatus: facts.codexAccountsMirrorStatus ?? 'unknown',
+      totalCandidates: Number(facts.codexAccounts) || 0,
+    });
+  } catch { /* fail-soft */ }
   if (warnings.length) {
     try {
       debug.log('task-agent.parent-host', 'credential-warning', {
@@ -582,6 +600,16 @@ export function installRemoteCodexAccessBatch(target: ParentHostConfig, mirrors:
   if (result.status !== 0) throw new Error(`remote Codex access mirror batch failed (ssh rc=${result.status ?? 'unknown'})`);
 }
 
+/** Install the same refresh-free snapshot for direct CLI use, outside per-launch parent credentials. */
+export const REMOTE_CODEX_CLI_MIRROR_DIR = '$HOME/.elanous/remote-parent-credentials/cli-mirror';
+export function installRemoteCodexCliMirror(
+  target: ParentHostConfig,
+  mirrors: readonly { elanousAuth: string; codexAuth: string; account: string }[],
+  ssh: SshRunner = defaultSshRunner,
+): void {
+  installRemoteCodexAccessBatch({ ...target, configDir: REMOTE_CODEX_CLI_MIRROR_DIR }, mirrors, ssh);
+}
+
 // ── 관측: 원격 런 원장 거울 ─────────────────────────────────────────────────────────────
 
 const RUN_ID_RE = /^run-[A-Za-z0-9_-]{4,64}$/;

package/src/task-agent/recall-inject.ts

@@ -0,0 +1,98 @@
+import { readFileSync } from 'node:fs';
+import { readPriorMustFix, PRIOR_RESULT_NOT_RECOVERED } from './review-prior-fix.js';
+import type { TaskCard } from './task-hand.js';
+
+export const RECALL_MAX_ITEMS = 8;
+export const RECALL_MAX_CHARS = 2000;
+
+export interface PriorLessons {
+  block?: string;
+  priorCards: number;
+  items: number;
+  chars: number;
+  truncated: boolean;
+}
+
+type ReviewResultReader = (path: string) => string;
+
+function compact(value: string): string {
+  return value.replace(/\s+/gu, ' ').trim();
+}
+
+/** Same-cell failure and review lessons for the next hand; no broad memory query. */
+export function priorLessonsFor(
+  checklistId: string,
+  cards: readonly TaskCard[],
+  readReviewResult: ReviewResultReader = (path) => readFileSync(path, 'utf8'),
+): PriorLessons {
+  const prior = cards
+    .filter((card) => card.checklistId === checklistId)
+    .slice()
+    .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+  const candidates: Array<{ cardId: string; text: string }> = [];
+
+  for (const card of prior) {
+    if (card.status === 'failed' || card.status === 'launch-failed') {
+      const failure = [...card.history].reverse().find((event) => ['failed', 'run-failed', 'launch-failed',
+        'graph-run-failed', 'tier-split-failed', 'device-first-launch-failed'].includes(event.event));
+      const reason = compact(failure?.detail ?? failure?.reason ?? '');
+      candidates.push({ cardId: card.id, text: `${card.status} 사유: ${reason || '실패 사유 미기록'}` });
+    }
+    for (const request of card.reviewRequests ?? []) {
+      const result = readPriorMustFix(request.resultPath, request.pr, request.head, readReviewResult);
+      if (result.status === 'recovered') {
+        for (const finding of result.items) {
+          const normalized = compact(finding);
+          if (normalized) candidates.push({ cardId: card.id, text: `PR #${request.pr} must-fix: ${normalized}` });
+        }
+      } else {
+        candidates.push({ cardId: card.id, text: `PR #${request.pr} · ${PRIOR_RESULT_NOT_RECOVERED} (${result.reason})` });
+      }
+    }
+  }
+
+  if (candidates.length === 0) return { priorCards: prior.length, items: 0, chars: 0, truncated: false };
+
+  const itemLimited = candidates.length > RECALL_MAX_ITEMS;
+  const itemMarker = `… 항목 상한 ${RECALL_MAX_ITEMS}건 초과분 생략`;
+  const charMarker = `… 글자 상한 ${RECALL_MAX_CHARS}자에서 나머지 생략`;
+  const selected: typeof candidates = [];
+  const pool = candidates.slice(0, RECALL_MAX_ITEMS);
+  const headingFor = (items: typeof candidates) => items.length
+    ? `## 앞선 교훈(같은 칸 · 카드 ${[...new Set(items.map((item) => item.cardId))].join(', ')})`
+    : '## 앞선 교훈(같은 칸)';
+  let charLimited = false;
+  for (const candidate of pool) {
+    const next = [...selected, candidate];
+    const heading = headingFor(next);
+    const lines = [heading, ...next.map((item) => `- ${item.cardId}: ${item.text}`)];
+    const reserve = [...(itemLimited ? [itemMarker] : []), charMarker];
+    if ([...lines, ...reserve].join('\n').length > RECALL_MAX_CHARS) {
+      charLimited = true;
+      break;
+    }
+    selected.push(candidate);
+  }
+  const heading = headingFor(selected);
+  const lines = [heading, ...selected.map((item) => `- ${item.cardId}: ${item.text}`)];
+  const markers = [
+    ...(itemLimited ? [itemMarker] : []),
+    ...(charLimited || selected.length < pool.length ? [charMarker] : []),
+  ];
+  // A single oversized card is omitted as a whole, never sliced through its id or lesson text.
+  if (!selected.length) markers.unshift(`… 첫 항목이 ${RECALL_MAX_CHARS}자 상한을 넘어 생략`);
+  let block = [...lines, ...markers].join('\n');
+  while (block.length > RECALL_MAX_CHARS && selected.length) {
+    selected.pop();
+    charLimited = true;
+    const shortenedHeading = headingFor(selected);
+    const shortenedLines = [shortenedHeading, ...selected.map((item) => `- ${item.cardId}: ${item.text}`)];
+    const shortenedMarkers = [
+      ...(itemLimited ? [itemMarker] : []), charMarker,
+      ...(!selected.length ? [`… 첫 항목이 ${RECALL_MAX_CHARS}자 상한을 넘어 생략`] : []),
+    ];
+    block = [...shortenedLines, ...shortenedMarkers].join('\n');
+  }
+  return { block, priorCards: prior.length, items: selected.length,
+    chars: block.length, truncated: itemLimited || charLimited };
+}

package/src/task-agent/repair-outcomes.ts

@@ -27,3 +27,68 @@ export function measureRepairOutcomes(cards: readonly Pick<TaskCard, 'id' | 'his
   }
   return { ...counts, cards: affected.size };
 }
+
+export interface RepairTierModelCall {
+  card: string;
+  runId: string;
+  at: string;
+  tier: string;
+  model: string;
+  status: string;
+}
+
+/** Measure repair launch records in the requested window; missing dimensions stay explicit. */
+export function measureRepairTierModels(
+  cards: readonly Pick<TaskCard, 'id' | 'history' | 'repairs' | 'tier'>[],
+  window: { since: number; until: number },
+) {
+  const attempts = new Map<string, RepairTierModelCall & { called: boolean }>();
+  let invalidTimestamp = 0;
+  let missingRunId = 0;
+  for (const card of cards) {
+    for (const repair of card.repairs ?? []) {
+      const at = Date.parse(repair.at);
+      if (!Number.isFinite(at)) { invalidTimestamp++; continue; }
+      if (at < window.since || at >= window.until) continue;
+      if (!repair.runId) { missingRunId++; continue; }
+      const key = `${card.id}\0${repair.runId}`;
+      const previous = attempts.get(key);
+      if (previous && Date.parse(previous.at) > at) continue;
+      const called = card.history.some((entry) => entry.runId === repair.runId
+        && (entry.event === 'harness.role-llm' || entry.event === 'repair-result'));
+      attempts.set(key, {
+        card: card.id,
+        runId: repair.runId,
+        at: repair.at,
+        tier: card.tier ?? 'unknown',
+        model: repair.toModel || 'unknown',
+        status: repair.status,
+        called,
+      });
+    }
+  }
+  const rows = [...attempts.values()].sort((a, b) => a.at.localeCompare(b.at) || a.card.localeCompare(b.card) || a.runId.localeCompare(b.runId));
+  const grouped = new Map<string, number>();
+  for (const row of rows) {
+    const key = `${row.tier}\0${row.model}`;
+    grouped.set(key, (grouped.get(key) ?? 0) + 1);
+  }
+  const tiers = ['하', '중', '상', '특', ...(rows.some((row) => !['하', '중', '상', '특'].includes(row.tier)) ? ['unknown'] : [])];
+  const models = [...new Set([...rows.map((row) => row.model), 'openai-codex/gpt-6-sol'])];
+  const byTierModel = tiers.flatMap((tier) => models.map((model) => {
+    const observedN = grouped.get(`${tier}\0${model}`) ?? 0;
+    return { tier, model, n: observedN || null, measured: observedN > 0, observedN };
+  })).sort((a, b) => a.tier.localeCompare(b.tier) || a.model.localeCompare(b.model));
+  const publicRow = ({ called: _called, ...row }: RepairTierModelCall & { called: boolean }): RepairTierModelCall => row;
+  const solRows = rows.filter((row) => row.model.includes('gpt-6-sol'));
+  return {
+    samples: rows.length,
+    measured: rows.length > 0,
+    unmeasuredReason: rows.length ? null : 'no repair attempts in the requested window',
+    byTierModel,
+    solCalls: solRows.filter((row) => row.called).map(publicRow),
+    solCallUnmeasured: solRows.filter((row) => !row.called).map(publicRow),
+    invalidTimestamp,
+    missingRunId,
+  };
+}