elanous 0.2.42 → 0.2.44

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';
@@ -22,6 +23,7 @@ import { readBudgetInputsLive, type BudgetInputs } from '../self-implement/budge
 import { HARNESS_RUN_ID_ENV, mintRunId, normalizeRunId } from '../harness/harness-space.js';
 import { newLaunchUtteranceId, recordLaunchUtterance } from '../harness/launch-utterance-ledger.js';
 import { debug } from '../debug/log.js';
+import { priorLessonsFor } from './recall-inject.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { LAUNCH_DOOR_RECEIPT_ENV, openLaunchRequestDoor, type LaunchRequestDoor } from '../execution-loop/launch-gate.js';
 import { withFileLockSync } from '../storage/file-lock.js';
@@ -192,15 +194,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 +1141,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 +1199,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 {
@@ -1271,6 +1281,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   const { normalizeEvidenceCommandLines } = await import('./evidence-command-normalize.js');
   const normalized = normalizeEvidenceCommandLines(opts.text.trim());
   let text = normalized.text;
+  let metadataText = text;
   if (!text) throw new Error('과제 한 줄이 비어 있다');
   for (const warning of normalized.warnings) {
     console.error(`⚠ ${warning}`);
@@ -1310,6 +1321,18 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   const completion = opts.completion ?? 'code-pr';
   const now = (opts.now ?? (() => new Date()))();
   const id = opts.id ?? `${TASK_CARD_PREFIX}${now.toISOString().slice(0, 10).replaceAll('-', '')}-${randomBytes(3).toString('hex')}`;
+  if (opts.checklistId) {
+    const priorCards = withFileLockSync(`${path}.lock`, () =>
+      Object.values(readState(path).tasks ?? {}).filter((card) => card.id !== id));
+    const recall = priorLessonsFor(opts.checklistId, priorCards);
+    if (recall.block) {
+      text = `${text}\n\n${recall.block}`;
+    }
+    try {
+      debug.log('task-agent', 'recall-inject-filled', { card: id, checklistId: opts.checklistId,
+        priorCards: recall.priorCards, items: recall.items, chars: recall.chars, truncated: recall.truncated });
+    } catch { /* fail-soft observation */ }
+  }
   let project: TaskCard['project'];
   let targetIsGit: boolean | null = null;
   if (opts.project) {
@@ -1335,9 +1358,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 으로 발사한다. 더 이상 거부하지 않는다.
@@ -1437,17 +1463,19 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   // Injected launchers are test seams and opt in explicitly at the contract test.
   if (opts.live && opts.preflightGoalDoneBoundary && !selectionFailure && tierSplitBlocked === undefined && move?.kind === 'launch') {
     readTaskAgentState(path);
-    const drafted = draftMissingGoalDoneBoundary(text, targetPaths);
+    const metadataBeforeDraft = metadataText;
+    const drafted = draftMissingGoalDoneBoundary(metadataText, targetPaths);
     if (drafted.added.length > 0) {
-      text = drafted.document;
+      metadataText = drafted.document;
+      text = `${text}${drafted.document.slice(metadataBeforeDraft.length)}`;
       card = { ...card, text };
       move = graphRun && graphRunPath ? { kind: 'launch' as const, command: ['graph', 'run', graphRunPath], reason: `조합 launcher graph-run — ${graphRun.file}` } : nextMoveFor(card, opts.landed);
       try { debug.log('task-agent.hand', 'boundary-autodrafted', { taskId: id, labels: drafted.added, targetPathCount: targetPaths.length }); } catch { /* fail-soft */ }
     }
-    const { missing } = inspectGoalDoneBoundary(text);
+    const { missing } = inspectGoalDoneBoundary(metadataText);
     if (missing.length > 0) throw new Error(`goal-revision-required: 완료 경계 누락 ${missing.join(' · ')}`);
     // ENTRANCE-EVIDENCE-COMMAND-ONLY — 존재 검사와 구분된 형태 판정: 증거 명령 줄은 명령 원문만 받는다.
-    const formViolations = goalEvidenceCommandFormViolations(text);
+    const formViolations = goalEvidenceCommandFormViolations(metadataText);
     if (formViolations.length > 0) {
       throw new Error(`goal-revision-required: 완료 경계 증거 명령은 명령 원문이어야 한다 ${formViolations.join(' · ')} — 증거 명령 줄에 설명 접미(예: → 0 fail)나 백틱 장식을 붙이지 말고 명령만 적은 뒤 다시 넘기세요`);
     }
@@ -1508,6 +1536,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
         runId,
         input: { ask: text, context: project ? { worktree: project.target } : {}, prior: {} },
         quiet: true,
+        deps: { growthScope: 'task-agent' },
       });
     } catch (error) {
       // 조합 파일·대상 node가 없으면 runGraph 가 구체 사유로 던진다 — 임의 성공 처리하지 않는다.
@@ -1604,11 +1633,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 +1647,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;
@@ -1692,13 +1722,15 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   writeCard(path, launched);
   // INFLIGHT-REGISTRY — 출발 때 맥락을 남긴다(머지 때 같은 파일 줄의 의도를 스마트 머지가 읽는다 · 착지하면 지운다).
   try {
-    const [head = '', ...rest] = text.split(/\r?\n/);
+    // Preserve any completion-boundary draft while keeping the recall-only suffix out of intent/path metadata.
+    const inflightText = metadataText;
+    const [head = '', ...rest] = inflightText.split(/\r?\n/);
     const intentLines = (/^\s*(?:대상\s*경로|target\s*paths?)\s*[:：]/i.test(head) ? rest : [head, ...rest])
       .filter((line) => !/^\s*(?:[-*]\s*)?완료 경계 (?:코드|실물|증거 명령)\s*:/.test(line));
     registerInflight({
       runId: boundRunId ?? runId, cell: card.checklistId ?? card.id, cardId: card.id,
-      intent: intentLines.join(' ').trim() || text,
-      files: parseAskTargetPathHints(text),
+      intent: intentLines.join(' ').trim() || inflightText,
+      files: parseAskTargetPathHints(inflightText),
     }, { path: join(dirname(path), INFLIGHT_REGISTRY_FILE), ...(opts.now ? { now: opts.now } : {}) });
   } catch (error) {
     try { debug.log('pr-tool.inflight', 'register-failed', { taskId: id, error: String((error as Error)?.message ?? error).slice(0, 200) }, { level: 'warn' }); } catch { /* fail-soft */ }

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

@@ -1,7 +1,7 @@
 import { lstatSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { gunzipSync } from 'node:zlib';
-import { debug } from '../../debug/log.js';
+import { debug, redactSecretText } from '../../debug/log.js';
 import { getDefaultLogStore, type LogStore } from '../../mss/logging/log-store.js';
 import { fromJsonl, type LogRecord } from '../../mss/logging/record.js';
 
@@ -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.
@@ -114,6 +118,24 @@ export function podNoResultDiagnostic(ledger: string): string | null {
   return stage ? `child terminal result missing; last ledger stage=${stage}; round=${round ?? 'unknown'}; mustFix=${mustFix ?? 'unknown'}` : null;
 }
 
+/** A failed child can lose its terminal JSON line after recording the actionable PR-open error. */
+export function podNoResultChildError(ledger: string): string | null {
+  let error = '';
+  for (const line of ledger.split(/\r?\n/)) {
+    try {
+      const entry = JSON.parse(line) as { event?: unknown; data?: Record<string, unknown> };
+      if (entry?.event === 'pr-open-failed' && entry.data && typeof entry.data === 'object') {
+        error = typeof entry.data.error === 'string' ? entry.data.error : '';
+      }
+      // A later successful PR open proves the earlier guard failure was recovered.
+      if (entry?.event === 'pr-opened') error = '';
+    } catch { /* malformed lines do not replace a valid failure row */ }
+  }
+  if (!error) return null;
+  const line = redactSecretText(error).replace(/[\r\n\t\x00-\x1f\x7f]+/g, ' ').replace(/\s+/gu, ' ').trim();
+  return line.length > 240 ? `${line.slice(0, 228)}…[truncated]` : line;
+}
+
 /** Import valid JSONL log records into the launching host store, with durable per-job line receipts. */
 export function importPodLogs(bytes: Buffer, job: string, store: LogStore | null = getDefaultLogStore()): { imported: number; skipped: number } {
   if (!store) return { imported: 0, skipped: 0 };

package/src/task-orchestrator/surfaces/pod-failure-reason.ts

@@ -1,3 +1,5 @@
+import { podChildProviderOf, type PodChildProvider } from './pod-child-providers.js';
+
 /** STOP-RECORD stop_class values used by the card terminal classifier. */
 export const STOP_CLASS_POD_FAILURE = 'pod-failure' as const;
 export const STOP_CLASS_NO_LAUNCH = 'no-launch' as const;
@@ -20,12 +22,19 @@ export function nestedPodResult(row: Record<string, unknown>): {
   const result = row.result as Record<string, unknown>;
   if (typeof result.stage !== 'string' || typeof result.ok !== 'boolean') return null;
   if (result.ok) return { stage: result.stage, ok: true };
+  // The terminal stage/node/outcome often says only `aborted` or `abandoned`.
+  // Keep the child's explicit stop detail (for example a same-cell PR guard
+  // failure) while retaining the established node/outcome/classification text.
+  // Forward only the typed guard failure this path owns. Other aborted children
+  // can carry verbose PTY summaries in `detail`; those are not parent attribution.
+  const explicitDetail = result.detailKind === 'blocked-draft-pr-guard' ? ledgerString(result.detail) : '';
   const classification = result.abandonedClassification;
   const detail = typeof result.supervisorVerdict === 'string' ? result.supervisorVerdict
     : classification && typeof classification === 'object' && !Array.isArray(classification)
       ? (classification as Record<string, unknown>).classification : undefined;
   const reason = [result.node, result.outcome].filter((part): part is string => typeof part === 'string' && part.length > 0).join(' ');
-  const error = [reason || (typeof result.error === 'string' ? result.error : ''), typeof detail === 'string' && detail ? detail : ''].filter(Boolean).join(' · ');
+  const error = [reason || (typeof result.error === 'string' ? result.error : ''), typeof detail === 'string' && detail ? detail : '', explicitDetail]
+    .filter(Boolean).join(' · ');
   // PREFLIGHT-RESULT-LINE: a nested preflight rejection carries its blockers under result.blockers — the same ledger fields as the flat row.
   const blockers = result.stage === 'preflight-blocked' ? preflightBlockerText(result.blockers)
     : { error: '', preflightChecks: [] as PreflightCheck[] };
@@ -121,6 +130,27 @@ export function podTerminalRow(row: Record<string, unknown>): {
   return nestedPodResult(row);
 }
 
+/**
+ * OBS-GAP-BATCH-1030 — 자식 LLM 실패의 «누가·어떤 HTTP status 로» 죽었나를 부모 원장에 얹는 두 스칼라.
+ * ⛔ 응답 본문·메시지·자격증명은 담지 않는다 — provider 는 정규 id, status 는 4xx/5xx 숫자뿐이다.
+ */
+export interface PodProviderFailureFact {
+  readonly provider?: PodChildProvider;
+  readonly httpStatusCode?: number;
+}
+
+export interface PodFirstLlmFact {
+  readonly status: 'started' | 'ok' | 'error';
+  readonly provider: string;
+  readonly model: string;
+  readonly accountName: string | null;
+  readonly startedAt: string;
+  readonly respondedAt?: string;
+  readonly httpStatus?: number;
+  readonly errorFirstLine?: string;
+  readonly firstToolCallAt?: string;
+}
+
 export const POD_EXIT_CLASSES = ['oom-killed', 'deadline-exceeded', 'gh-login-failed', 'pod-secret', 'ask-reprompt', 'provider-error', 'child-unconverged', 'child-error', 'no-result-line', 'unknown'] as const;
 
 export type PodExitClass = typeof POD_EXIT_CLASSES[number];
@@ -143,6 +173,10 @@ export function podChildEvidenceLedgerRow(input: {
   noResultDiagnostic?: string | null;
   noResultLogEvidence?: Record<string, unknown> | null;
   podTermination?: PodTermination | null;
+  /** OBS-GAP-BATCH-1030 — 실패 행에만 붙는 두 스칼라(provider · HTTP status). 없으면 종전 행 그대로. */
+  providerFailure?: PodProviderFailureFact | null;
+  /** POD-CHILD-FIRST-LLM-CALL-OBS — collected child-ledger first-call timeline. */
+  firstLlm?: PodFirstLlmFact | null;
 }): Record<string, unknown> | null {
   const { result } = input;
   const persist = input.state === 'failed' || input.state === 'aborted' || input.noResultLogEvidence != null
@@ -163,6 +197,9 @@ export function podChildEvidenceLedgerRow(input: {
     childEvidence,
     childRunId: input.childRunId,
     job: input.job,
+    ...(input.providerFailure?.provider ? { provider: input.providerFailure.provider } : {}),
+    ...(input.providerFailure?.httpStatusCode !== undefined ? { httpStatusCode: input.providerFailure.httpStatusCode } : {}),
+    ...(input.firstLlm ? { firstLlm: input.firstLlm } : {}),
     ...(input.podTermination ? { podTermination: input.podTermination } : {}),
     ...(childResult && Object.keys(childResult).length > 0 ? { childResult } : {}),
   };
@@ -195,6 +232,75 @@ function isPodProviderErrorLine(line: string): boolean {
   return POD_PROVIDER_ERROR_LINE.test(line);
 }
 
+/** 401·429·503 같은 «상태 숫자»만 — 응답 본문·메시지는 돌려주지 않는다. 4xx/5xx 밖의 수는 상태가 아니다. */
+function podProviderHttpStatus(line: string): number | undefined {
+  const explicit = /"status"\s*:\s*(\d{3})/u.exec(line) ?? /\b(?:LLM API|HTTP|status(?:[ _-]?code)?)\b\s*[:=]?\s*(\d{3})\b/iu.exec(line);
+  // 맨숫자 형태는 «상태 자리»에 선 것만 — `500ms`·`1.5e3` 같은 수를 상태로 세지 않는다.
+  const digits = (explicit ?? /(?:^|[^\d])([45]\d{2})(?![\d\p{L}.])/u.exec(line))?.[1];
+  const value = digits === undefined ? NaN : Number(digits);
+  return Number.isSafeInteger(value) && value >= 400 && value <= 599 ? value : undefined;
+}
+
+/** 줄이 이름한 provider — `llm.<id>` 접두 우선, 없으면 줄 안의 정식 이름/별칭. 목록 밖 이름은 세지 않는다. */
+function podLineProvider(line: string): PodChildProvider | undefined {
+  const scoped = /\bllm\.([a-z0-9_-]+)\b/iu.exec(line)?.[1];
+  const scopedProvider = podChildProviderOf(scoped);
+  if (scopedProvider) return scopedProvider;
+  for (const token of line.match(/[A-Za-z][A-Za-z0-9_-]{1,31}/gu) ?? []) {
+    const provider = podChildProviderOf(token);
+    if (provider) return provider;
+  }
+  return undefined;
+}
+
+/** provider 실패를 «말하는» 줄 — 분류기가 provider-error 로 읽는 줄, 또는 자식이 낸 `LLM API <status>` 문면. */
+const isPodProviderFailureSource = (line: string): boolean => isPodProviderErrorLine(line) || /\bLLM API\s+\d{3}\b/iu.test(line);
+
+/**
+ * 마지막 canonical 자식 terminal 과 «그 직전» 구간 — duplicate-cap 귀속의 한 자리(classifyPodExit 과 같은 규칙).
+ * terminal 이 없으면 구간은 전체 로그다(결과행 없는 자식도 provider 실패는 귀속된다).
+ */
+function podTerminalWindow(logs: string): { terminal: ReturnType<typeof podTerminalRow>; window: string[] } {
+  const lines = logs.split(/\r\n|\n|\r/u);
+  let terminal: ReturnType<typeof podTerminalRow> = null;
+  let lastIndex = -1;
+  let previousIndex = -1;
+  for (const [index, raw] of lines.entries()) {
+    const line = raw.trim();
+    if (!line.startsWith('{')) continue;
+    let parsed: unknown;
+    try { parsed = JSON.parse(line); } catch { continue; }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) continue;
+    const row = podTerminalRow(parsed as Record<string, unknown>);
+    if (!row) continue;
+    previousIndex = lastIndex;
+    terminal = row;
+    lastIndex = index;
+  }
+  const window = lines.slice(previousIndex + 1, lastIndex === -1 ? undefined : lastIndex)
+    .map((line) => line.trim()).filter(Boolean);
+  return { terminal, window };
+}
+
+/**
+ * OBS-GAP-BATCH-1030 — 자식 실패를 «공급자 + HTTP status» 로 귀속한다(응답 본문·자격증명 제외).
+ * 마지막 canonical terminal 이 성공이면 null — 과거(재시도 전) provider 실패를 성공한 결과에 재사용하지 않는다.
+ * 줄이 공급자를 이름하지 않으면 호출자가 준 hint(Pod 의 자식 provider)를 정규 id 로만 쓴다.
+ */
+export function podChildProviderFailureFact(logs: string, opts?: { providerHint?: string }): PodProviderFailureFact | null {
+  const { terminal, window } = podTerminalWindow(logs);
+  if (terminal?.ok === true) return null;
+  const terminalErrors = typeof terminal?.error === 'string'
+    ? terminal.error.split(/\r\n|\n|\r/u).map((line) => line.trim()).filter(Boolean) : [];
+  const sources = [...window, ...terminalErrors].filter((line) => isPodProviderFailureSource(line)).reverse();
+  if (!sources.length) return null;
+  // 마지막 줄이 `LLM API <status>` 만 말할 수 있다 — 공급자는 «이름한» 줄에서 따로 찾는다.
+  const provider = sources.map(podLineProvider).find((named) => named !== undefined) ?? podChildProviderOf(opts?.providerHint);
+  const httpStatusCode = sources.map(podProviderHttpStatus).find((status) => status !== undefined);
+  if (!provider && httpStatusCode === undefined) return null;
+  return { ...(provider ? { provider } : {}), ...(httpStatusCode !== undefined ? { httpStatusCode } : {}) };
+}
+
 /**
  * POD-FAIL-EVIDENCE-CAPTURE-FU — duplicate-cap 귀속: 마지막 «canonical» 자식 terminal 하나에만 실패를 붙인다.
  * canonical 접두(`self`/`external`)가 아닌 lookalike kind 행은 건너뛰고, 마지막 canonical terminal 이 성공이거나