elanous 0.2.32 → 0.2.35

package/src/harness/harness-cli-command.ts

@@ -21,7 +21,9 @@ import { GOAL_TYPES, lintGoalFile, parseGoalId, parseGoalType, resolveGoalAuthor
 import { templateForGoalType } from '../self-implement/graph-templates.js';
 import { appendRunLedgerEntry, listRunLedgers, loadFederatedRunLedger, loadRunLedger, queryRunScreenKey, runLedgerDir, type RunLedgerEntry, type RunLedgerMatch, type RunLedgerWriter } from '../self-implement/run-ledger.js';
 import { classifyPodExit, type PodExitClass } from '../task-orchestrator/surfaces/pod-failure-reason.js';
-import { classifyPodExitStop, recordRunStop, runStopRecorded, RUN_STOP_EVENT } from '../self-implement/run-stop.js';
+import type { PodChildEvidence } from '../task-orchestrator/surfaces/self-implement.js';
+import { classifyPodExitStop, readRunStopRecord, recordRunStop, runStopRecorded, RUN_STOP_EVENT } from '../self-implement/run-stop.js';
+import { captureStopKnowhowCandidate } from '../self-implement/stop-autoheal.js';
 import { ensureOpenRouterChildModelLive, resolveChildLlmEffort, resolveImplementationChildModel } from '../self-dev/dev-cli.js';
 import { resolveHarnessTarget } from '../self-implement/harness-target-options.js';
 import { buildRunProgressRows, isPartialRunningRuns, queryRunningRuns, renderRunProgressTable } from '../self-implement/running-runs.js';
@@ -449,7 +451,7 @@ export function classifyHarnessPodExit(
     loadCheckpoint?: typeof loadSelfDevRun;
     runId?: string;
   } = {},
-): { lines: string[]; reason: PodExitReason | 'pod-failure' } {
+): { lines: string[]; reason: PodExitReason | 'pod-failure'; podErrorCode?: 'pod-job-failed' } {
   const occupiedNewLine = output.split('\n').find((line) =>
     /^\[self-dev\] run run-[a-z0-9_-]{8,64} \[preflight:new-path-occupied:[0-9a-f-]{36}\] /.test(line));
   const observedRunId = deps.runId ?? harnessPodRunId(output);
@@ -474,6 +476,7 @@ export function classifyHarnessPodExit(
   }
   let podFailure: string | undefined;
   let podJobFailed = false;
+  let podJobFailedFromResult = false;
   let podChildFailed = false;
   for (const line of output.split('\n').reverse()) {
     if (!line.trimStart().startsWith('[{') || !line.includes('"error"')) continue;
@@ -486,6 +489,7 @@ export function classifyHarnessPodExit(
         if (typeof error?.code !== 'string' || typeof error.message !== 'string' || !error.code.startsWith('pod-')) continue;
         podFailure = error.message;
         podJobFailed = error.code === 'pod-job-failed';
+        podJobFailedFromResult = podJobFailed;
         podChildFailed = error.code === 'pod-child-failed';
         break;
       }
@@ -504,7 +508,7 @@ export function classifyHarnessPodExit(
   if (podFailure) {
     const childError = podJobFailed ? podFailure.split('childError=')[1]?.split('\\n', 1)[0]?.split('\n', 1)[0] : undefined;
     try { debug.log('harness.pod', 'exit-classified', { runId, reason: 'pod-failure', status: exit.status, signal: exit.signal ?? null }); } catch { /* observation is fail-soft */ }
-    return { reason: 'pod-failure', lines: [podChildFailed
+    return { reason: 'pod-failure', ...(podJobFailedFromResult ? { podErrorCode: 'pod-job-failed' as const } : {}), lines: [podChildFailed
       ? `Pod 안 자식이 실패했다 — ${podFailure.split('\\n', 1)[0]}`
       : podJobFailed && childError && childError !== 'no-result-line'
         ? `Pod 안 자식이 실패했다 — ${childError}`
@@ -571,19 +575,40 @@ export function recordClassifiedHarnessPodExit(runId: string | undefined, reason
   context: { entrance?: string; seat?: string; output?: string } = {}): void {
   if (!runId) return;
   try {
+    const childEvidence = reason === 'preflight-refused' ? undefined : latestPodChildEvidence(loadRunLedger(runId));
     const signal = status > 128
       ? Object.entries(osConstants.signals).find(([, number]) => number === status - 128)?.[0] ?? null : null;
     const cwd = process.cwd();
     const seat = context.seat ?? process.env.ELANOUS_HARNESS_SEAT;
-    recordRunExit({ runId, reason, status, signal, at: new Date().toISOString(),
+    recordRunExit({ runId, reason: childEvidence?.scopeEscape === true ? 'scope-escape' : reason, status, signal, at: new Date().toISOString(),
       ...(context.entrance ? { entrance: context.entrance } : {}),
       ...(['OP', 'TC', 'MK', 'UX'].includes(seat ?? '') ? { seat } : {}),
       cwd: `${basename(dirname(cwd))}/${basename(cwd)}`, hostname: hostname().split('.')[0]!, pid: process.pid,
       ...(context.output ? { lastLines: incidentLastLines(context.output) } : {}),
+      ...(childEvidence ? { childEvidence } : {}),
     }, effectiveInstanceRoot());
   } catch { /* incident writes cannot change Pod output or exit */ }
 }
 
+function latestPodChildEvidence(entries: readonly RunLedgerEntry[] | null | undefined): PodChildEvidence | undefined {
+  // The current attempt's start is the fence. An earlier Pod's terminal facts cannot
+  // classify a later attempt when that attempt has no JSON or its ledger write failed.
+  const current = entries?.filter((entry) => entry.event === 'pod-child-run').at(-1)?.data;
+  if (typeof current?.job !== 'string' || typeof current.childRunId !== 'string') return undefined;
+  const data = entries?.filter((entry) => entry.event === 'pod-child-evidence'
+    && entry.data?.job === current.job && entry.data?.childRunId === current.childRunId).at(-1)?.data;
+  const evidence = data?.childEvidence;
+  if (!evidence || typeof evidence !== 'object' || Array.isArray(evidence)) return undefined;
+  const row = evidence as Record<string, unknown>;
+  const object = (value: unknown): boolean => value !== null && typeof value === 'object' && !Array.isArray(value);
+  if (('scopeEscape' in row && row.scopeEscape !== true)
+    || ('goalCauseObserved' in row && row.goalCauseObserved !== true)
+    || ('classification' in row && typeof row.classification !== 'string')
+    || ('abandonedClassification' in row && !object(row.abandonedClassification))
+    || ('accountAvailability' in row && !object(row.accountAvailability))) return undefined;
+  return row as PodChildEvidence;
+}
+
 /** Every Pod launch entrance (harness ask/say · dev ask --substrate pod) warns once after a recent burst; it never blocks the launch. */
 export function warnRecentIncidentBurst(
   root: string = effectiveInstanceRoot(), now: Date = new Date(), write: (line: string) => void = (line) => console.error(line),
@@ -747,14 +772,17 @@ async function onPod(opts: unknown, entrance: 'cli-harness-ask' | 'cli-harness-s
 export function recordHarnessPodStop(
   runId: string | undefined,
   status: number,
-  classified: { reason: string; lines: string[] },
+  classified: { reason: string; lines: string[]; podErrorCode?: 'pod-job-failed' },
   output?: string,
   deps: { loadLedger?: typeof loadRunLedger; record?: typeof recordRunStop; write?: RunLedgerWriter } = {},
 ): boolean {
   if (!runId) return false;
   try {
     if (runStopRecorded(runId)) return false;
-    if ((deps.loadLedger ?? loadRunLedger)(runId)?.some((entry) => entry.event === RUN_STOP_EVENT)) return false;
+    const ledger = (deps.loadLedger ?? loadRunLedger)(runId);
+    if (ledger?.some((entry) => entry.event === RUN_STOP_EVENT)) return false;
+    const childEvidence = latestPodChildEvidence(ledger);
+    const scopeEscape = childEvidence?.scopeEscape === true;
     if (classified.reason === 'preflight-refused') {
       (deps.record ?? recordRunStop)({
         runId, site: 'preflight', class: 'launch-failed',
@@ -772,19 +800,40 @@ export function recordHarnessPodStop(
     if (detail) {
       const write = deps.write ?? ((entry: RunLedgerEntry) => appendRunLedgerEntry(entry));
       (deps.record ?? recordRunStop)({
-        runId, site: 'pod-exit', class: classifyPodExitStop(classified.reason),
+        runId, site: 'pod-exit', class: scopeEscape ? 'scope-escape' : classifyPodExitStop(classified.reason),
         cause: `Pod exit ${status}: ${detail.podExitClass}${detail.lead ? ` — ${detail.lead}` : ''}`,
-        evidenceRef, nextMove,
+        evidenceRef, nextMove, ...(childEvidence ? { childEvidence } : {}),
       }, (entry) => write({ ...entry, data: { ...entry.data, podExitClass: detail.podExitClass, tail: detail.tail } }));
       return true;
     }
     // The classified line is our own one-line verdict («Pod 안 자식이 실패했다 — OOMKilled»), not the raw output tail.
     const verdict = classified.lines[0]?.split(' — ').slice(1).join(' — ').trim();
-    (deps.record ?? recordRunStop)({
-      runId, site: 'pod-exit', class: classifyPodExitStop(classified.reason),
-      cause: `Pod exit ${status}: ${classified.reason}${verdict ? ` — ${verdict}` : ''}`,
-      evidenceRef, nextMove,
+    const stopEntry = (deps.record ?? recordRunStop)({
+      runId, site: 'pod-exit', class: scopeEscape ? 'scope-escape' : classifyPodExitStop(classified.reason),
+      cause: `Pod exit ${status}: ${scopeEscape ? 'scope-escape' : classified.reason}${verdict ? ` — ${verdict}` : ''}`,
+      evidenceRef, nextMove, ...(childEvidence ? { childEvidence } : {}),
+      ...(classified.podErrorCode === 'pod-job-failed' ? { terminationReason: classified.podErrorCode } : {}),
     }, ...(deps.write ? [deps.write] : []));
+    // Host-only Pod exits do not pass through orchestrator.autohealRecordedStop. Capture the
+    // exact Job failure here, after the durable stop write, without initiating a heal action.
+    if (classified.podErrorCode === 'pod-job-failed' && stopEntry) {
+      try {
+        const record = readRunStopRecord(stopEntry);
+        if (record) {
+          const goalId = ledger?.find((entry) => entry.goalId)?.goalId;
+          const captured = captureStopKnowhowCandidate({ runId, ...(goalId ? { goalId } : {}), record },
+          join(effectiveInstanceRoot(), 'self-implement', 'knowhow-candidates'));
+          if (captured) debug.log('self-implement.autoheal', 'knowhow-candidate', {
+            runId, cell: captured.candidate.cell, reason: captured.candidate.reason,
+            created: captured.created, occurrences: captured.candidate.occurrences, path: captured.path,
+          });
+        }
+      } catch (error) {
+        try { debug.log('self-implement.autoheal', 'knowhow-candidate-failed', {
+          runId, error: error instanceof Error ? error.message : String(error),
+        }); } catch { /* observation is fail-soft */ }
+      }
+    }
     return true;
   } catch { return false; /* ledger observation cannot change Pod output or exit */ }
 }
@@ -2116,6 +2165,7 @@ const executeGh: GhExecute = (args) => {
 export async function supersedeMergedGoalDrafts(
   number: number, cwd: string,
   execute: GhExecute = executeGh, git: DraftSweepGitExecute = runGitCommand,
+  options: { onlyExplicitSameCell?: boolean } = {},
 ): Promise<void> {
   const remote = git(cwd, ['config', '--get', 'remote.origin.url']);
   const repository = remote.status === 0 ? githubRemoteRepository(remote.stdout) : undefined;
@@ -2132,8 +2182,10 @@ export async function supersedeMergedGoalDrafts(
     number: pr.number, title: pr.title, body: pr.body ?? undefined, branch: pr.head.ref,
     createdAt: pr.created_at, mergedAt: pr.merged_at,
   };
+  if (options.onlyExplicitSameCell && !/^Supersedes:\s*#\d+\s*$/m.test(merged.body ?? '')) return;
   const { supersedeDraftsOnMerge } = await import('../self-dev/draft-sweep.js');
-  await supersedeDraftsOnMerge({ repository, merged, adapters: githubDraftSweepAdapters(execute, git, cwd) });
+  await supersedeDraftsOnMerge({ repository, merged, adapters: githubDraftSweepAdapters(execute, git, cwd),
+    ...(options.onlyExplicitSameCell ? { onlyExplicitSameCell: true } : {}) });
 }
 
 /**
@@ -2350,8 +2402,9 @@ function githubRemoteRepository(url: string): string | undefined {
 interface GraphqlPrDetail {
   readonly files: string[] | null;
   readonly comments: string[] | null;
-  readonly reviews: Array<{ state?: string; body?: string }> | null;
+  readonly reviews: Array<{ state?: string; body?: string; submittedAt?: string; commitOid?: string }> | null;
   readonly headSha: string | null;
+  readonly headCommittedAt: string | null;
   readonly mergeCommit: { oid: string; message: string } | null;
 }
 
@@ -2379,10 +2432,10 @@ async function graphqlPrDetails(repository: string, numbers: readonly number[],
   // Fields the batch could not prove complete (each one is read again over REST by the caller).
   const incompleteFields = { files: 0, comments: 0, reviews: 0 };
   await mapBounded(batches, DRAFT_SWEEP_CONCURRENCY, async (batch) => {
-    const fields = batch.map((number) => `p${number}: pullRequest(number: ${number}) { number headRefOid `
+    const fields = batch.map((number) => `p${number}: pullRequest(number: ${number}) { number headRefOid headRef { target { ... on Commit { committedDate } } } `
       + 'files(first: 100) { totalCount nodes { path } pageInfo { hasNextPage } } '
       + 'comments(first: 100) { totalCount nodes { body } pageInfo { hasNextPage } } '
-      + 'reviews(first: 100) { totalCount nodes { state body } pageInfo { hasNextPage } } '
+      + 'reviews(first: 100) { totalCount nodes { state body submittedAt commit { oid } } pageInfo { hasNextPage } } '
       + 'mergeCommit { oid message } }').join(' ');
     const query = `query { repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) { ${fields} } }`;
     let repositoryNode: Record<string, unknown> | undefined;
@@ -2393,9 +2446,10 @@ async function graphqlPrDetails(repository: string, numbers: readonly number[],
     if (!repositoryNode || typeof repositoryNode !== 'object' || Array.isArray(repositoryNode)) { failedBatches += 1; return; }
     for (const number of batch) {
       const pr = repositoryNode[`p${number}`] as {
-        number?: number; headRefOid?: string;
+        number?: number; headRefOid?: string; headRef?: { target?: { committedDate?: string } | null } | null;
         files?: GraphqlConnection<{ path?: string }>; comments?: GraphqlConnection<{ body?: string }>;
-        reviews?: GraphqlConnection<{ state?: string; body?: string }>; mergeCommit?: { oid?: string; message?: string } | null;
+        reviews?: GraphqlConnection<{ state?: string; body?: string; submittedAt?: string; commit?: { oid?: string } | null }>;
+        mergeCommit?: { oid?: string; message?: string } | null;
       } | null | undefined;
       if (!pr || pr.number !== number) continue;
       const files = completeNodes(pr.files);
@@ -2405,8 +2459,10 @@ async function graphqlPrDetails(repository: string, numbers: readonly number[],
         files: files && files.every((file) => typeof file?.path === 'string') ? files.map((file) => file.path!) : null,
         comments: comments && comments.every((comment) => typeof comment?.body === 'string') ? comments.map((comment) => comment.body!) : null,
         reviews: reviews && reviews.every((review) => review && typeof review === 'object')
-          ? reviews.map((review) => ({ state: review.state, body: review.body })) : null,
+          ? reviews.map((review) => ({ state: review.state, body: review.body, submittedAt: review.submittedAt,
+            commitOid: review.commit?.oid })) : null,
         headSha: typeof pr.headRefOid === 'string' && pr.headRefOid ? pr.headRefOid : null,
+        headCommittedAt: typeof pr.headRef?.target?.committedDate === 'string' ? pr.headRef.target.committedDate : null,
         mergeCommit: pr.mergeCommit && typeof pr.mergeCommit.oid === 'string' && typeof pr.mergeCommit.message === 'string'
           ? { oid: pr.mergeCommit.oid, message: pr.mergeCommit.message } : null,
       };
@@ -2527,7 +2583,7 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
     }
     return undefined;
   };
-  const issueCommentsFor = async (repository: string, number: number, what: 'review' | 'landing'): Promise<string[]> => {
+  const issueCommentsFor = async (repository: string, number: number, what: 'review' | 'landing' | 'same-cell'): Promise<string[]> => {
     const comments: string[] = [];
     for (let page = 1; page <= 100; page++) {
       const batch = await ghJsonAsync<Array<{ body?: string }>>(['api', `repos/${repository}/issues/${number}/comments?per_page=100&page=${page}`]);
@@ -2535,32 +2591,82 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
       comments.push(...batch.map((comment) => comment.body ?? ''));
       if (batch.length < 100) return comments;
     }
-    throw new Error(`${what === 'review' ? 'Review' : 'Landing'} comment inventory exceeded pagination limit`);
+    throw new Error(`${what === 'review' ? 'Review' : what === 'same-cell' ? 'Same-cell' : 'Landing'} comment inventory exceeded pagination limit`);
+  };
+  const reviewsFor = async (repository: string, number: number): Promise<Array<{ state?: string; body?: string; submittedAt?: string; commitOid?: string }>> => {
+    const reviews: Array<{ state?: string; body?: string; submittedAt?: string; commitOid?: string }> = [];
+    for (let page = 1; page <= 100; page++) {
+      const batch = await ghJsonAsync<Array<{ state?: string; body?: string; submitted_at?: string; commit_id?: string }>>(
+        ['api', `repos/${repository}/pulls/${number}/reviews?per_page=100&page=${page}`]);
+      if (!Array.isArray(batch) || batch.length > 100) throw new Error('Incomplete review inventory');
+      reviews.push(...batch.map((review) => ({ state: review.state, body: review.body,
+        submittedAt: review.submitted_at, commitOid: review.commit_id })));
+      if (batch.length < 100) return reviews;
+    }
+    throw new Error('Review inventory exceeded pagination limit');
+  };
+  const checkRunsFor = async (repository: string, sha: string): Promise<Array<{ conclusion?: string | null }> | undefined> => {
+    const runs: Array<{ conclusion?: string | null }> = [];
+    for (let page = 1; page <= 100; page++) {
+      const result = await ghJsonAsync<{ total_count?: number; check_runs?: Array<{ conclusion?: string | null }> }>(
+        ['api', `repos/${repository}/commits/${sha}/check-runs?per_page=100&page=${page}`]);
+      if (!Array.isArray(result?.check_runs) || result.check_runs.length > 100) throw new Error('Incomplete check-run inventory');
+      runs.push(...result.check_runs);
+      if (Number.isSafeInteger(result.total_count) && runs.length >= result.total_count!) return runs;
+      if (result.check_runs.length < 100) return Number.isSafeInteger(result.total_count) && runs.length < result.total_count! ? undefined : runs;
+    }
+    return undefined;
+  };
+  const headCommitTimeFor = async (repository: string, number: number): Promise<string | undefined> => {
+    let latest: string | undefined;
+    for (let page = 1; page <= 100; page++) {
+      const batch = await ghJsonAsync<Array<{ commit?: { committer?: { date?: string } } }>>(
+        ['api', `repos/${repository}/pulls/${number}/commits?per_page=100&page=${page}`]);
+      if (!Array.isArray(batch) || batch.length > 100) throw new Error('Incomplete PR commit inventory');
+      for (const commit of batch) {
+        const date = commit.commit?.committer?.date;
+        if (!date || !Number.isFinite(Date.parse(date))) throw new Error('Incomplete PR commit timestamp');
+        latest = date;
+      }
+      if (batch.length < 100) return latest;
+    }
+    throw new Error('PR commit inventory exceeded pagination limit');
   };
   const reviewGateForDraft = async (draft: SweepDraft, repository: string): Promise<SweepReviewGate | undefined> => {
     const cached = await detailFor(repository, draft.number);
     const sha = cached?.headSha
       ?? (await ghJsonAsync<{ head?: { sha?: string } }>(['api', `repos/${repository}/pulls/${draft.number}`]))?.head?.sha;
     if (!sha) return undefined;
+    const reviews = cached?.reviews ?? await reviewsFor(repository, draft.number);
+    if (!Array.isArray(reviews)) throw new Error('Incomplete review inventory');
     const comments = cached?.comments ?? await issueCommentsFor(repository, draft.number, 'review');
-    const reviews = cached?.reviews
-      ?? await ghJsonAsync<Array<{ state?: string; body?: string }>>(['api', `repos/${repository}/pulls/${draft.number}/reviews?per_page=100`]);
-    if (!Array.isArray(reviews) || reviews.length > 100) throw new Error('Incomplete review inventory');
-    const text = [...comments, ...reviews.map((review) => review.body ?? '')].join('\n');
+    const legacyText = [...comments, ...reviews.map((review) => review.body ?? '')].join('\n');
+    const currentHeadReviews = reviews.filter((review) => review && typeof review === 'object'
+      && review.commitOid === sha
+      && typeof review.submittedAt === 'string' && Number.isFinite(Date.parse(review.submittedAt)))
+      .sort((a, b) => Date.parse(a.submittedAt!) - Date.parse(b.submittedAt!));
+    const latestHeadReview = currentHeadReviews.at(-1);
+    const triageReview = latestHeadReview?.state === 'APPROVED' ? 'approved'
+      : latestHeadReview?.state === 'CHANGES_REQUESTED' ? 'changes-requested'
+        : latestHeadReview?.state === 'COMMENTED' ? 'commented'
+          : latestHeadReview?.state === 'DISMISSED' ? 'dismissed'
+            : latestHeadReview?.state === 'PENDING' ? 'pending' : 'unknown';
     const [status, checkRuns] = await Promise.all([
       ghJsonAsync<{ state?: string }>(['api', `repos/${repository}/commits/${sha}/status`]),
-      ghJsonAsync<{ check_runs?: Array<{ conclusion?: string | null }> }>(['api', `repos/${repository}/commits/${sha}/check-runs?per_page=100`]),
+      checkRunsFor(repository, sha),
     ]);
-    if (!checkRuns || !Array.isArray(checkRuns.check_runs)) throw new Error('Incomplete check-run inventory');
-    const conclusions = checkRuns.check_runs.map((run) => run.conclusion ?? null);
-    const gatePass = (status?.state === 'success' || status?.state === undefined)
-      && conclusions.length > 0 && conclusions.every((conclusion) => conclusion === 'success' || conclusion === 'skipped' || conclusion === 'neutral');
+    const conclusions = checkRuns?.map((run) => run.conclusion ?? null) ?? [];
+    const gatePass = status?.state === 'success'
+      && checkRuns !== undefined && conclusions.length > 0
+      && conclusions.every((conclusion) => conclusion === 'success' || conclusion === 'skipped' || conclusion === 'neutral');
     const gateFail = status?.state === 'failure' || status?.state === 'error'
       || conclusions.some((conclusion) => conclusion === 'failure' || conclusion === 'cancelled' || conclusion === 'timed_out' || conclusion === 'action_required');
     return {
-      ...(reviews.some((review) => review.state === 'APPROVED') || /(?:^|\n)\s*VERDICT:\s*PASS\b/i.test(text) ? { review: 'pass' as const } : {}),
-      ...(mustFixRemains(text) ? { mustFix: true } : {}),
+      ...(reviews.some((review) => review.state === 'APPROVED') || /(?:^|\n)\s*VERDICT:\s*PASS\b/i.test(legacyText)
+        ? { review: 'pass' as const } : {}),
+      ...(mustFixRemains(legacyText) ? { mustFix: true } : {}),
       ...(gatePass && !gateFail ? { gate: 'pass' as const } : gateFail ? { gate: 'fail' as const } : {}),
+      triageReview,
     };
   };
   const claimCommentsFor = async (repository: string, number: number): Promise<string[]> => {
@@ -2590,11 +2696,15 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
       const prs = (await listed(open, repository, 'open')).filter((pr) => pr.draft);
       await prefetchDetails(repository, prs.map((pr) => pr.number));
       const matches = ledgerMatches ??= listRunLedgers().matches;
-      return mapBounded(prs, DRAFT_SWEEP_CONCURRENCY, async (pr): Promise<SweepDraft> => ({
-        number: pr.number, title: pr.title, branch: pr.head.ref,
-        labels: pr.labels.map((item) => item.name), createdAt: pr.created_at, body: pr.body ?? undefined,
-        changedFiles: await prFiles(repository, pr.number), ...(pr.updated_at ? { updatedAt: pr.updated_at } : {}),
-        runId: currentDraftSweepRunId(matches, repository, pr.number) }));
+      return mapBounded(prs, DRAFT_SWEEP_CONCURRENCY, async (pr): Promise<SweepDraft> => {
+        return {
+          number: pr.number, title: pr.title, branch: pr.head.ref,
+          labels: pr.labels.map((item) => item.name), createdAt: pr.created_at, body: pr.body ?? undefined,
+          changedFiles: await prFiles(repository, pr.number),
+          ...(pr.updated_at ? { updatedAt: pr.updated_at } : {}),
+          runId: currentDraftSweepRunId(matches, repository, pr.number),
+        };
+      });
     })());
     return draftRows.get(repository)!;
   };
@@ -2649,6 +2759,8 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
     },
     listDrafts: async (page, perPage, repository): Promise<SweepDraft[]> =>
       (await enrichedDrafts(repository)).slice((page - 1) * perPage, page * perPage),
+    getHeadCommitTime: async (repository, number) => (await detailFor(repository, number))?.headCommittedAt
+      ?? await headCommitTimeFor(repository, number).catch(() => undefined),
     listMerged: async (page, perPage, repository): Promise<SweepMergedPr[]> =>
       (await enrichedMerged(repository)).slice((page - 1) * perPage, page * perPage),
     getRunStatus: async (draft, repository) => runStatusFor(draft, repository),
@@ -2716,6 +2828,7 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
     listPrTerminals: async () => listRunLedgers().matches.flatMap((match) => match.entries.filter((entry) => entry.event === 'pr-terminal')
       .map((entry) => entry.data as unknown as PrTerminalRecord)),
     commentDraft: async (repository, number, body) => { execute(['pr', 'comment', String(number), '--repo', repository, '--body', body]); },
+    listIssueComments: async (repository, number) => issueCommentsFor(repository, number, 'same-cell'),
     removeLabel: async (repository, number, name) => { execute(['pr', 'edit', String(number), '--repo', repository, '--remove-label', name]); },
     getReviewGate: async (draft, repository) => reviewGateForDraft(draft, repository),
     // DRAFT-LINEAGE-ONE-1 — the sweep calls this only with `--apply`, only for a live run whose newer same-lineage run
@@ -2914,7 +3027,7 @@ function installHarnessDraftSweepCommand(harnessCmd: Command, deps: HarnessDraft
               owner: 'unknown', ownerSource: 'unknown', step: 'replay', reason: sweepFailureReason(error) });
           }
         }
-        const result: DraftSweepResult = await runDraftSweep({ repository, apply: opts.apply === true, adapters: deps.adapters ?? github!,
+        const result: DraftSweepResult = await runDraftSweep({ repository, apply: opts.apply === true, includeTriage: opts.json === true, adapters: deps.adapters ?? github!,
           closeCap: cap.closeCap, closeCapSource: cap.closeCapSource, alreadyClosed: replayClosed });
         const reason = result.error ? sweepFailureReason(result.error) : undefined;
         const ttlStarted = Date.now();

package/src/harness/harness-incidents.ts

@@ -3,6 +3,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statS
 import { join } from 'node:path';
 import { redactSecretText } from '../debug/log.js';
 import { refuseProductionLedgerWriteInTest } from './ledger-write-guard.js';
+import type { PodChildEvidence } from '../task-orchestrator/surfaces/self-implement.js';
 
 export interface RunExit {
   runId: string;
@@ -16,6 +17,7 @@ export interface RunExit {
   hostname?: string;
   pid?: number;
   lastLines?: string[];
+  childEvidence?: PodChildEvidence;
 }
 
 export interface IncidentBurst {
@@ -77,6 +79,8 @@ export function readRunExits(root: string): RunExit[] {
         ...(typeof row.pid === 'number' && Number.isSafeInteger(row.pid) ? { pid: row.pid } : {}),
         ...(Array.isArray(row.lastLines) && row.lastLines.every((line) => typeof line === 'string')
           ? { lastLines: row.lastLines } : {}),
+        ...(row.childEvidence && typeof row.childEvidence === 'object' && !Array.isArray(row.childEvidence)
+          ? { childEvidence: row.childEvidence } : {}),
       });
     }
   }
@@ -205,6 +209,39 @@ export function recentBurst(root: string, now: Date | number, { lookbackMs = 15
   return recent.sort((a, b) => Date.parse(a.lastAt) - Date.parse(b.lastAt)).at(-1) ?? null;
 }
 
+/** 사고 선례 1건 — 현재 사고 이전의 같은 reason 종료 기록(결정론 · 기록된 실제 exit 만). */
+export interface IncidentPrecedent {
+  runId: string;
+  reason: string;
+  status: number | null;
+  signal: string | null;
+  at: string;
+  lastLines?: string[];
+}
+
+/**
+ * 사고 선례 연결 — 현재 사고(reason·at) 이전에 같은 reason 으로 종료된 기록된 실제 exit 만
+ * 돌려준다(유사 과거 지어내기 금지 · readRunExits 재사용 · READ-ONLY). 현재 runId 는 제외하고
+ * 시간 내림차순, 기본 5건까지. 기록이 없으면 빈 배열(«기록 없음»).
+ */
+export function findIncidentPrecedents(
+  current: { reason: string; at: string; runId?: string },
+  root: string,
+  { limit = 5 }: { limit?: number } = {},
+): IncidentPrecedent[] {
+  const at = Date.parse(current.at);
+  if (!current.reason.trim() || !Number.isFinite(at)) return [];
+  return readRunExits(root)
+    .filter((row) => row.reason === current.reason && row.runId !== current.runId
+      && Date.parse(row.at) < at)
+    .sort((a, b) => Date.parse(b.at) - Date.parse(a.at) || b.runId.localeCompare(a.runId))
+    .slice(0, Math.max(0, limit))
+    .map((row) => ({
+      runId: row.runId, reason: row.reason, status: row.status, signal: row.signal, at: row.at,
+      ...(Array.isArray(row.lastLines) ? { lastLines: row.lastLines } : {}),
+    }));
+}
+
 export function formatIncidentBurstWarning(burst: IncidentBurst): string {
   const time = new Date(Date.parse(burst.lastAt) + KST_OFFSET_MS).toISOString().slice(11, 16);
   const owner = burst.seat || burst.entrance ? ` [seat=${burst.seat ?? '-'} entrance=${burst.entrance ?? '-'}]` : '';

package/src/harness/harness-pod-dispatch.ts

@@ -58,11 +58,41 @@ export interface HarnessPodDispatchInput {
   readonly authorGradeSource?: import('../self-implement/goal-author.js').GoalAuthorGradeSource;
 }
 
+/** The mbp fleet alias must select the installed local k3d context, with a deliberately small first capacity. */
+export function resolveHarnessPodPool(spec: string | undefined): string | undefined {
+  if (!spec) return spec;
+  let changed = false;
+  let mbpCapacity = 0;
+  let mbpMembers = 0;
+  const members = spec.split(',').map((raw) => {
+    const part = raw.trim();
+    const alias = /^pool-mbp@mbp:(\d+)$/.exec(part);
+    const local = /^k3d-monad-h1:(\d+)$/.exec(part);
+    if (!alias && !local) {
+      if (/^pool-mbp@mbp(?::|$)/.test(part) || /^k3d-monad-h1(?::|$)/.test(part)) {
+        throw new Error(`mbp Pod 풀 스펙 오류: ${part}`);
+      }
+      return part;
+    }
+    const capacity = Number((alias ?? local)![1]);
+    if (!Number.isInteger(capacity) || capacity < 1 || capacity > 2) {
+      throw new Error(`mbp Pod 풀 상한은 1~2: ${part}`);
+    }
+    mbpCapacity += capacity;
+    mbpMembers++;
+    if (mbpCapacity > 2) throw new Error(`mbp Pod 풀 합산 상한은 2: ${spec}`);
+    if (mbpMembers > 1) throw new Error(`mbp Pod 풀 컨텍스트 중복: ${spec}`);
+    if (alias) changed = true;
+    return `k3d-monad-h1:${capacity}`;
+  });
+  return changed ? members.join(',') : spec;
+}
+
 export function podOrchestrateArgs(input: HarnessPodDispatchInput, goalFile: string): string[] {
   return [
     ELANOUS_ENTRY_SCRIPT, 'self', 'orchestrate', '--goal-file', goalFile,
     '--substrate', 'pod',
-    ...(input.podPool ? ['--pod-pool', input.podPool] : []),
+    ...(input.podPool ? ['--pod-pool', resolveHarnessPodPool(input.podPool)!] : []),
     // 하니스 기본(자동 병합)을 따른다 · 끄면 PR 까지 — 어느 쪽이든 Pod 가 사라져도 결과가 남는다.
     ...(input.repairCommitOnly ? [] : input.autoMerge === false ? ['--open-pr'] : ['--auto-merge']),
     ...(input.repairCommitOnly && input.source ? ['--base', `pr-${input.source.slice(3)}`] : input.base ? ['--base', input.base] : []),
@@ -99,6 +129,13 @@ export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDi
 export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps?: PodDispatchDeps): number | Promise<number>;
 export function dispatchHarnessOnPod(input: HarnessPodDispatchInput, deps: PodDispatchDeps = {}): number | Promise<number> {
   const cwd = deps.cwd ?? process.cwd();
+  try { resolveHarnessPodPool(input.podPool); }
+  catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    debug.log('harness.substrate', 'pod-pool-refused', { entrance: input.entrance, reason });
+    console.error(reason);
+    return 2;
+  }
   if (input.source !== undefined) {
     try {
       parsePodSourceSpec(input.source);

package/src/harness/harness-salvage-cli.ts

@@ -5,7 +5,9 @@
 import type { Command } from 'commander';
 import { debug } from '../debug/log.js';
 import { normalizeRunId } from './harness-space.js';
-import { loadFederatedRunLedger } from '../self-implement/run-ledger.js';
+import { loadFederatedRunLedger, loadRunLedger } from '../self-implement/run-ledger.js';
+import { prodInstanceRoot } from '../instance/resolve.js';
+import { remoteLedgerMirrorDirs } from '../task-agent/parent-host.js';
 import { getUserConfig } from '../user-config.js';
 import { resolveRepositoryName } from './repository-name.js';
 import {
@@ -35,9 +37,19 @@ export interface HarnessSalvageDeps {
   print?: (line: string) => void;
 }
 
+/** 원격 부모 거울 원장 — remoteLedgerMirrorDirs(prodInstanceRoot()) 를 로컬·연합 원장 «뒤에»만 붙인다(tasks 쪽 원장 조회와 같은 재사용 경로 · 거울 생성·SSH 는 별개 칸). */
+function loadMirroredRunLedger(runId: string): ReturnType<typeof loadRunLedger> {
+  for (const directory of remoteLedgerMirrorDirs(prodInstanceRoot())) {
+    const ledger = loadRunLedger(runId, directory);
+    if (ledger !== null) return ledger;
+  }
+  return null;
+}
+
 function defaultReadPr(runId: string): RunPrState {
   try {
-    return prStateFromLedger(loadFederatedRunLedger(runId, { includeTest: true }));
+    // 로컬·연합 원장 먼저, 없으면 원격 부모 거울 — 순서는 tasks 쪽 원장 조회와 같다.
+    return prStateFromLedger(loadFederatedRunLedger(runId, { includeTest: true }) ?? loadMirroredRunLedger(runId));
   } catch (error) {
     return { status: 'unknown', reason: `원장 읽기 실패 · ${error instanceof Error ? error.message : String(error)}` };
   }