elanous 0.2.42 → 0.2.43

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 {
@@ -43,6 +43,8 @@ export interface OmniSearchDispatchOpts {
   /** 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 +54,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 +75,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 +98,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,7 +232,12 @@ 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();
         let timer: ReturnType<typeof setTimeout> | undefined;
         try {
@@ -145,8 +246,8 @@ async function dispatchWithProviders(
             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 {
@@ -196,7 +297,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 +307,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 +326,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

@@ -582,6 +582,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/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,
+  };
+}

package/src/task-agent/task-hand.ts

@@ -15,6 +15,7 @@ import { fileURLToPath } from 'node:url';
 import { parse as parseYaml } from 'yaml';
 import { runGraph, validateUnitCalls, type GraphRunOptions, type GraphRunState } from '../graph-runner/runner.js';
 import type { GraphWizardDeps } from '../graph-wizard/generate.js';
+import type { PluginWizardDeps, PluginWizardInput } from '../graph-wizard/mission-compose.js';
 import { parseGraphTemplateYaml } from '../self-implement/graph-yaml.js';
 import { resolveDaemonHarnessTarget } from '../intake-plane/harness-target.js';
 import { getUserConfig } from '../user-config.js';
@@ -192,15 +193,19 @@ export const COMPOSITION_ROOT = join(dirname(fileURLToPath(import.meta.url)), '.
 export function selectTaskComposition(completion: CompletionKind, root?: string): CompositionSelection;
 export function selectTaskComposition(completion: CompletionKind, root: string, mission: {
   text: string; ledgerPath: string; cardId: string; callLLM?: GraphWizardDeps['callLLM']; onPersist?: (persist: () => void) => void;
+  pluginWizard?: PluginWizardInput; pluginWizardDeps?: PluginWizardDeps;
 }): Promise<CompositionSelection>;
 export function selectTaskComposition(completion: CompletionKind, root = COMPOSITION_ROOT, mission?: {
   text: string; ledgerPath: string; cardId: string; callLLM?: GraphWizardDeps['callLLM']; onPersist?: (persist: () => void) => void;
+  pluginWizard?: PluginWizardInput; pluginWizardDeps?: PluginWizardDeps;
 }): CompositionSelection | Promise<CompositionSelection> {
   if (mission) {
     const standard = selectTaskComposition(completion, root);
     return import('../graph-wizard/mission-compose.js').then(async ({ composeMissionGraph }) => {
       const result = await composeMissionGraph({ text: mission.text, completion, root, ledgerPath: mission.ledgerPath,
-        cardId: mission.cardId, standard }, { callLLM: mission.callLLM, deferPersistence: mission.onPersist !== undefined });
+        cardId: mission.cardId, standard, ...(mission.pluginWizard ? { pluginWizard: mission.pluginWizard } : {}) },
+      { callLLM: mission.callLLM, deferPersistence: mission.onPersist !== undefined,
+        ...(mission.pluginWizardDeps ? { pluginWizard: mission.pluginWizardDeps } : {}) });
       mission.onPersist?.(result.persist);
       return result.selection;
     });
@@ -1135,6 +1140,10 @@ export interface HandTaskOptions {
   composeGraph?: boolean;
   /** Injectable LLM boundary for isolated composition tests. */
   composeCallLLM?: GraphWizardDeps['callLLM'];
+  /** Explicit missing-tool handoff from the active assistant; keeps the wizard opt-in and uses the same task graph path. */
+  pluginWizard?: Omit<PluginWizardInput, 'mission' | 'root'> & { root?: string };
+  /** Host surfaces for Telegram, side-tab agents, trial/use, and progress reporting. */
+  pluginWizardDeps?: PluginWizardDeps;
   /** `--live` 일 때만 불린다. */
   launcher?: TaskLauncher;
   /**
@@ -1189,7 +1198,7 @@ export class TaskLaunchError extends Error {
   }
 }
 
-export interface HandTaskResult { card: TaskCard; move: TaskCardMove; mode: 'shadow' | 'live'; launched: boolean; cwd?: string }
+export interface HandTaskResult { card: TaskCard; move: TaskCardMove; mode: 'shadow' | 'live'; launched: boolean; reason?: string; cwd?: string }
 
 /** Dispatch evidence for a handed deliverable card; unlike handTask, this never launches work. */
 export function dispatchDeliverableCompletion(id: string, input: { ref: string; receipt?: boolean }, path: string, now: () => Date = () => new Date()): boolean {
@@ -1335,9 +1344,12 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     })
     : undefined;
   let persistComposition: (() => void) | undefined;
-  const selected = (opts.composeGraph ?? (process.env.ELANOUS_MISSION_GRAPH_COMPOSE === '1'))
+  const pluginWizard = opts.pluginWizard ? { ...opts.pluginWizard, mission: text,
+    root: opts.pluginWizard.root ?? opts.compositionRoot ?? COMPOSITION_ROOT } : undefined;
+  const selected = (pluginWizard !== undefined || (opts.composeGraph ?? (process.env.ELANOUS_MISSION_GRAPH_COMPOSE === '1')))
     ? await selectTaskComposition(completion, opts.compositionRoot ?? COMPOSITION_ROOT,
       { text, ledgerPath: path, cardId: id, callLLM: opts.composeCallLLM,
+        ...(pluginWizard ? { pluginWizard, pluginWizardDeps: opts.pluginWizardDeps } : {}),
         onPersist: persist => { persistComposition = persist; } })
     : selectTaskComposition(completion, opts.compositionRoot);
   // 2판 — launcher 'graph-run' 조합(단위 해석까지 완료)은 실제 graph run 으로 발사한다. 더 이상 거부하지 않는다.
@@ -1604,11 +1616,12 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
       reason: knowhow.reason, repoPath: knowhowRepo, repoRevision,
       repoSource: project ? 'project' : configuredRepo ? 'harness.defaultRepo' : 'package' }); } catch { /* fail-soft */ }
   }
-  // LAUNCH-SINGLE-DOOR-1C — 발사 직전 단일문: 모든 요청(중복 포함)은 원장에 append 되고, 소비 영수증은
-  // requestId 단위로 최초 1회만 발급된다. 주입된 문이 없으면 생산 우주의 기본 문을 쓴다(시험 환경은 건너뛴다).
+  // LAUNCH-SINGLE-DOOR — hand 재시도는 새 카드/시도이므로 문면만으로 만든 영구 requestId 를 재사용하지 않는다.
+  // 실제 실행 중인 같은 골은 자식 harness 의 active-run gate 가 막는다. 부모 영수증은 그 자식에 한 번 상속한다.
   const launchDoor = opts.launchRequestDoor
     ?? (process.env.NODE_ENV === 'test' ? undefined : openLaunchRequestDoor({ source: 'hand' }));
-  const launchDoorRequestId = launchDoor?.requestId(card.text);
+  const launchAttemptKey = `${card.id}\n${card.createdAt}\n${randomBytes(12).toString('hex')}\n${card.text}`;
+  const launchDoorRequestId = launchDoor?.requestId(launchAttemptKey);
   let inheritedLaunchDoorReceipt: string | undefined;
   if (launchDoor !== undefined && launchDoorRequestId !== undefined) {
     const doorConsumption = launchDoor.consume(launchDoorRequestId);
@@ -1617,7 +1630,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
       const refused: TaskCard = { ...card, history: [...card.history, { at, event: LAUNCH_REFUSED_DUPLICATE_EVENT, detail: doorConsumption.reason }] };
       writeCard(path, refused);
       try { debug.log('task-agent', 'launch-refused-duplicate', { taskId: id, requestId: launchDoorRequestId, reason: doorConsumption.reason }); } catch { /* fail-soft */ }
-      return { card: refused, move, mode, launched: false, ...(project ? { cwd: project.target } : {}) };
+      return { card: refused, move, mode, launched: false, reason: `${LAUNCH_REFUSED_DUPLICATE_EVENT}: ${doorConsumption.reason}`, ...(project ? { cwd: project.target } : {}) };
     }
     // 소비 영수증을 자식 say 에 물려줘 그 문을 다시 두드리지 않게 한다(한 번만 상속).
     inheritedLaunchDoorReceipt = doorConsumption.status === 'consumed' ? launchDoorRequestId : undefined;

package/src/task-orchestrator/dispatcher.ts

@@ -32,6 +32,8 @@ import {
   type AcceptanceReport,
 } from './acceptance.js';
 import { recordOpsEventSafe, type OpsEventInput } from '../domains/ops-log.js';
+import { getHarnessRunId } from '../harness/harness-space.js';
+import { collectLinearCaptureArtifacts } from './linear-capture-events.js';
 import { defaultAnomalyCluster, extractContainerExit, type AnomalyCluster } from '../loops/orchestrator/anomaly-cluster.js';
 
 // ───────────────────────── Concurrency caps ────────────────────────
@@ -309,7 +311,18 @@ export class TaskDispatcher {
     const kind = task.surface.kind;
     let savedExecution = false;
     try {
-      const exec = { ...await res.promise, id: res.executionId };
+      const completedExecution = { ...await res.promise, id: res.executionId };
+      // The run identity is taken from this dispatcher process, never from child-reported execution output.
+      const runId = getHarnessRunId();
+      let captureArtifacts: TaskExecution['captureArtifacts'] = [];
+      if (runId) {
+        try {
+          captureArtifacts = collectLinearCaptureArtifacts({ runId, startedAt: completedExecution.startedAt,
+            endedAt: completedExecution.endedAt ?? this.now() });
+        } catch { /* Capture observation is optional; an unavailable log store must not block task completion. */ }
+      }
+      const exec: TaskExecution = { ...completedExecution, runId: runId || undefined,
+        captureArtifacts: captureArtifacts.length ? captureArtifacts : undefined };
       // Keep the task row and execution in the same store read by GET /v1/tasks/:id.
       this.opts.store?.saveTask(this.opts.graph.getTask(task.id)!);
       this.opts.store?.saveExecution(exec);

package/src/task-orchestrator/linear-capture-events.ts

@@ -0,0 +1,55 @@
+import { existsSync } from 'node:fs';
+import { LogStore, logsDbPath, type LogStoreRow } from '../mss/logging/log-store.js';
+import type { TaskCaptureArtifact } from './types.js';
+
+export interface LinearCaptureEventWindow { runId: string; startedAt: number; endedAt: number }
+export type LinearCaptureEventStore = Pick<LogStore, 'queryByDataKeys' | 'close'>;
+
+function parseCaptureEvent(row: LogStoreRow, expectedRunId: string): TaskCaptureArtifact | undefined {
+  if (row.event !== 'executed' || !row.data) return undefined;
+  let data: Record<string, unknown>;
+  try {
+    const parsed: unknown = JSON.parse(row.data);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return undefined;
+    data = parsed as Record<string, unknown>;
+  } catch { return undefined; }
+  if (data.action !== 'read' || data.mode !== 'screenshot' || data.ok !== true || data.captureOutcome !== 'saved') return undefined;
+  const capture = data.capture;
+  if (!capture || typeof capture !== 'object' || Array.isArray(capture)) return undefined;
+  const descriptor = capture as Record<string, unknown>;
+  if (typeof descriptor.path !== 'string' || !descriptor.path || typeof descriptor.mimeType !== 'string' ||
+      descriptor.runId !== expectedRunId || typeof descriptor.linearIssueId !== 'string' || !descriptor.linearIssueId ||
+      descriptor.externalShare !== true || typeof descriptor.sensitivity !== 'string' ||
+      typeof descriptor.createdAt !== 'number' || !Number.isFinite(descriptor.createdAt)) return undefined;
+  return {
+    path: descriptor.path,
+    mimeType: descriptor.mimeType,
+    runId: expectedRunId,
+    linearIssueId: descriptor.linearIssueId,
+    externalShare: true,
+    sensitivity: descriptor.sensitivity,
+    createdAt: descriptor.createdAt,
+  };
+}
+
+/** Read only approved browser screenshot events emitted during this exact TOX execution. */
+export function collectLinearCaptureArtifacts(window: LinearCaptureEventWindow, deps: {
+  dbPath?: string;
+  openStore?: (path: string) => LinearCaptureEventStore;
+} = {}): TaskCaptureArtifact[] {
+  const runId = window.runId.trim();
+  if (!runId || !Number.isFinite(window.startedAt) || !Number.isFinite(window.endedAt) || window.endedAt < window.startedAt) return [];
+  const path = deps.dbPath ?? logsDbPath();
+  if (!existsSync(path)) return [];
+  const store = (deps.openStore ?? LogStore.openReadOnly)(path);
+  try {
+    const rows = store.queryByDataKeys({ exactCategories: ['harness.browser-action'], runIds: [runId] });
+    const found = new Map<string, TaskCaptureArtifact>();
+    for (const row of rows) {
+      if (row.ts_ms < window.startedAt || row.ts_ms > window.endedAt) continue;
+      const capture = parseCaptureEvent(row, runId);
+      if (capture) found.set(capture.path, capture);
+    }
+    return [...found.values()].sort((a, b) => a.createdAt - b.createdAt || a.path.localeCompare(b.path));
+  } finally { store.close(); }
+}

package/src/task-orchestrator/store.ts

@@ -56,7 +56,8 @@ import type {
 // v3 (Mission Fabric 통합 U1 · 2026-07-09) — tox_missions.autopilot_json
 //    (PFC Layer2 자율 메타 흡수 · apm Mission 병렬 table 제거 준비)
 // v4 — external task identity and approval
-export const TOX_SCHEMA_VERSION = 4;
+// v5 — run-scoped browser capture artifacts on executions
+export const TOX_SCHEMA_VERSION = 5;
 
 // ─────────────────────── Row shapes ────────────────────────────────
 
@@ -114,6 +115,8 @@ interface ExecutionRow {
   model_id: string | null;
   host_id: string | null;
   hostname: string | null;
+  run_id: string | null;
+  capture_artifacts_json: string | null;
 }
 
 interface EventRow {
@@ -262,7 +265,9 @@ export class TaskStore {
         token_input INTEGER,
         token_output INTEGER,
         cost_usd REAL,
-        model_id TEXT
+        model_id TEXT,
+        run_id TEXT,
+        capture_artifacts_json TEXT
       );
 
       CREATE TABLE IF NOT EXISTS tox_events (
@@ -314,6 +319,8 @@ export class TaskStore {
     this.db.exec('CREATE INDEX IF NOT EXISTS idx_tox_missions_project ON tox_missions(project_id)');
     this.addColumnIfMissing('tox_executions', 'host_id', 'TEXT');
     this.addColumnIfMissing('tox_executions', 'hostname', 'TEXT');
+    this.addColumnIfMissing('tox_executions', 'run_id', 'TEXT');
+    this.addColumnIfMissing('tox_executions', 'capture_artifacts_json', 'TEXT');
     this.db.exec('CREATE INDEX IF NOT EXISTS idx_tox_executions_host ON tox_executions(host_id, started_at)');
     this.addColumnIfMissing('tox_tasks', 'approval_json', 'TEXT');
     this.addColumnIfMissing('tox_tasks', 'external_provider', 'TEXT');
@@ -477,8 +484,8 @@ export class TaskStore {
         `INSERT OR REPLACE INTO tox_executions (
           id, task_id, started_at, ended_at, duration_ms, status, surface_json,
           surface_address, output, output_path, error_json, token_input,
-          token_output, cost_usd, model_id, host_id, hostname
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+          token_output, cost_usd, model_id, host_id, hostname, run_id, capture_artifacts_json
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
       )
       .run(
         exec.id,
@@ -497,7 +504,9 @@ export class TaskStore {
         exec.costUsd ?? null,
         exec.modelId ?? null,
         hostId ?? null,
-        hostname ?? null
+        hostname ?? null,
+        exec.runId ?? null,
+        exec.captureArtifacts ? JSON.stringify(exec.captureArtifacts) : null
       ));
   }
 
@@ -769,6 +778,8 @@ export class TaskStore {
       modelId: row.model_id ?? undefined,
       ...(row.host_id !== null ? { hostId: row.host_id } : {}),
       ...(row.hostname !== null ? { hostname: row.hostname } : {}),
+      ...(row.run_id !== null ? { runId: row.run_id } : {}),
+      ...(row.capture_artifacts_json ? { captureArtifacts: JSON.parse(row.capture_artifacts_json) as TaskExecution['captureArtifacts'] } : {}),
     };
   }
 }

package/src/task-orchestrator/surfaces/pod-artifact-return.ts

@@ -102,6 +102,10 @@ export function podNoResultDiagnostic(ledger: string): string | null {
     try {
       const entry = JSON.parse(line) as { event?: unknown; data?: Record<string, unknown> };
       if (!entry || typeof entry !== 'object' || !entry.data || typeof entry.data !== 'object' || typeof entry.event !== 'string' || entry.event === 'pod-ledger-incomplete') continue;
+      // Route evidence is not a child execution stage. The observer writes the category
+      // (`graph.path`) only to the log store; the run ledger keeps the event name
+      // (`path-signature`), which may be appended after the child failure.
+      if (entry.event === 'graph.path' || entry.event === 'path-signature') continue;
       if (typeof entry.data.round === 'number' && Number.isSafeInteger(entry.data.round)) round = entry.data.round;
       if (entry.event !== 'run-origin') stage = entry.event;
       // `reviewed` carries pointers only (count + finding ids); the text stays in the review artifact.