elanous 0.2.34 → 0.2.36

package/src/harness/control-inbox.ts

@@ -448,6 +448,18 @@ function consumeRecord(
     return;
   }
   messages.push(message);
+  // A Pod sender asks for this exact record's acknowledgement before publishing
+  // it. Missing ack is safe: delivery has happened, but the sender must report
+  // read state as unobserved rather than infer it from file disappearance.
+  if (existsSync(`${recordPath}.ack-request`)) {
+    // Rename consumes the request atomically. If the sender already removed it,
+    // this cannot leave a late ack file after the sender's cleanup.
+    try { renameSync(`${recordPath}.ack-request`, `${recordPath}.ack`); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT')
+        logger(opts)('control-inbox', 'memo-ack-failed', { spaceId, path: recordPath, reason: String(error) });
+    }
+  }
 }
 
 /** Inspect existing ready records without claiming, deleting, or creating any inbox entry. */
@@ -541,7 +553,43 @@ export function cleanupStaleControlInbox(spaceId: string, maxAgeMs: number, opts
       restoreClaim(claimPath, recordPath, spaceId, opts);
     }
   }
-  logger(opts)('control-inbox', 'cleanup', { spaceId, path, maxAgeMs, count });
+  // A sender killed without an EXIT trap can leave receipt markers behind.
+  // Its wait is capped at 60s; keep at least two minutes before sweeping only
+  // markers whose exact record no longer exists. Never infer a read from cleanup.
+  let markerCount = 0;
+  let tempCount = 0;
+  let markerNames: string[] = [];
+  try { markerNames = readdirSync(ready); } catch { /* absent ready directory */ }
+  const markerCutoff = Date.now() - Math.max(maxAgeMs, 120_000);
+  for (const name of markerNames) {
+    // Only the Pod publisher's mktemp shape; local enqueue has a different name.
+    if (/^\.write-[A-Za-z0-9]{8}$/.test(name)) {
+      const tempPath = join(ready, name);
+      try {
+        if (statSync(tempPath).mtimeMs > markerCutoff) continue;
+        rmSync(tempPath);
+        tempCount += 1;
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT')
+          logger(opts)('control-inbox', 'cleanup-temp-failed', { spaceId, path: tempPath, reason: String(error) });
+      }
+      continue;
+    }
+    const suffix = name.endsWith('.ack-request') ? '.ack-request' : name.endsWith('.ack') ? '.ack' : null;
+    if (!suffix) continue;
+    const recordName = name.slice(0, -suffix.length);
+    if (!isReadyRecord(recordName) || existsSync(join(ready, recordName))) continue;
+    const markerPath = join(ready, name);
+    try {
+      if (statSync(markerPath).mtimeMs > markerCutoff) continue;
+      rmSync(markerPath);
+      markerCount += 1;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT')
+        logger(opts)('control-inbox', 'cleanup-marker-failed', { spaceId, path: markerPath, reason: String(error) });
+    }
+  }
+  logger(opts)('control-inbox', 'cleanup', { spaceId, path, maxAgeMs, count, markerCount, tempCount });
   return count;
 }
 

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

@@ -20,9 +20,10 @@ import { runGitCommand } from '../git-fs/runner.js';
 import { GOAL_TYPES, lintGoalFile, parseGoalId, parseGoalType, resolveGoalAuthorGrade, tracedPathReferences, type GoalAuthorGrade, type GoalAuthorGradeSelection, type GoalType } from '../self-implement/goal-author.js';
 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 { classifyPodExit, parsePodTermination, type PodExitClass, type PodTermination } from '../task-orchestrator/surfaces/pod-failure-reason.js';
 import type { PodChildEvidence } from '../task-orchestrator/surfaces/self-implement.js';
-import { classifyPodExitStop, recordRunStop, runStopRecorded, RUN_STOP_EVENT } from '../self-implement/run-stop.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';
@@ -418,7 +419,7 @@ function resolveLaunchSubstrate(opts: HarnessSubstrateOpts): ResolvedHarnessSubs
 }
 type PodExit = { status: number | null; signal?: string | null };
 type PodExitReason = 'signal' | 'human-stop' | 'supervisor' | 'no-launch' | 'unknown' | 'preflight-refused'
-  | 'pod-error' | 'launch-gate-blocked' | 'ENOBUFS' | 'OOMKilled';
+  | 'pod-error' | 'launch-gate-blocked' | 'dep-blocked' | 'ENOBUFS' | 'OOMKilled';
 
 function unknownPodExitTailReason(output: string): PodExitReason | undefined {
   const tail = output.slice(-16_000);
@@ -426,6 +427,7 @@ function unknownPodExitTailReason(output: string): PodExitReason | undefined {
   if (/\bENOBUFS\b/i.test(tail)) return 'ENOBUFS';
   if (/launch gate[^\r\n]*blocked|blocked[^\r\n]*launch gate/i.test(tail)) return 'launch-gate-blocked';
   if (/\bpod-error\b/i.test(tail)) return 'pod-error';
+  if (/\b(?:DEP_FAILED|DEPENDENCY_NEEDS_HUMAN|DEP_BLOCKED_REBASE_READY)\b/.test(tail)) return 'dep-blocked';
   return undefined;
 }
 /** GitHub lists at most this many files for one pull request; a list that reaches it is not provably complete. */
@@ -450,7 +452,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);
@@ -475,6 +477,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;
@@ -487,6 +490,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;
       }
@@ -505,7 +509,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}`
@@ -572,7 +576,9 @@ 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 ledger = reason === 'preflight-refused' ? undefined : loadRunLedger(runId);
+    const childEvidence = latestPodChildEvidence(ledger);
+    const podTermination = latestPodTermination(ledger);
     const signal = status > 128
       ? Object.entries(osConstants.signals).find(([, number]) => number === status - 128)?.[0] ?? null : null;
     const cwd = process.cwd();
@@ -583,17 +589,42 @@ export function recordClassifiedHarnessPodExit(runId: string | undefined, reason
       cwd: `${basename(dirname(cwd))}/${basename(cwd)}`, hostname: hostname().split('.')[0]!, pid: process.pid,
       ...(context.output ? { lastLines: incidentLastLines(context.output) } : {}),
       ...(childEvidence ? { childEvidence } : {}),
+      ...(podTermination ? { podTermination } : {}),
     }, effectiveInstanceRoot());
   } catch { /* incident writes cannot change Pod output or exit */ }
 }
 
-function latestPodChildEvidence(entries: readonly RunLedgerEntry[] | null | undefined): PodChildEvidence | undefined {
+/**
+ * The current attempt's `pod-child-evidence` rows (same job · childRunId as the last `pod-child-run`), oldest first.
+ * Also fenced by position: only rows written after that start count, so a reused job/childRunId pair cannot
+ * hand an earlier attempt's row (childEvidence or podTermination) to a later one.
+ */
+function currentPodChildEvidenceRows(entries: readonly RunLedgerEntry[] | null | undefined): { job: string; rows: Record<string, unknown>[] } | 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;
+  let startIndex = -1;
+  entries?.forEach((entry, index) => { if (entry.event === 'pod-child-run') startIndex = index; });
+  const current = startIndex >= 0 ? entries![startIndex]!.data : undefined;
   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 rows = (entries ?? []).filter((entry, index) => index > startIndex && entry.event === 'pod-child-evidence'
+    && entry.data?.job === current.job && entry.data?.childRunId === current.childRunId).map((entry) => entry.data);
+  return { job: current.job, rows };
+}
+
+/** JOB-FAILURE-TERMINATION-CAPTURE — the current attempt's latest well-formed capture of its own Job (a later
+ *  evidence row of the same attempt without one does not drop it); another Job's or round's never crosses over. */
+function latestPodTermination(entries: readonly RunLedgerEntry[] | null | undefined): PodTermination | undefined {
+  const current = currentPodChildEvidenceRows(entries);
+  if (!current) return undefined;
+  for (const row of current.rows.slice().reverse()) {
+    const parsed = parsePodTermination(row.podTermination, current.job);
+    if (parsed) return parsed;
+  }
+  return undefined;
+}
+
+function latestPodChildEvidence(entries: readonly RunLedgerEntry[] | null | undefined): PodChildEvidence | undefined {
+  const data = currentPodChildEvidenceRows(entries)?.rows.at(-1);
   const evidence = data?.childEvidence;
   if (!evidence || typeof evidence !== 'object' || Array.isArray(evidence)) return undefined;
   const row = evidence as Record<string, unknown>;
@@ -601,6 +632,8 @@ function latestPodChildEvidence(entries: readonly RunLedgerEntry[] | null | unde
   if (('scopeEscape' in row && row.scopeEscape !== true)
     || ('goalCauseObserved' in row && row.goalCauseObserved !== true)
     || ('classification' in row && typeof row.classification !== 'string')
+    || ('newScope' in row && !Array.isArray(row.newScope))
+    || ('scopeStopReasons' in row && !Array.isArray(row.scopeStopReasons))
     || ('abandonedClassification' in row && !object(row.abandonedClassification))
     || ('accountAvailability' in row && !object(row.accountAvailability))) return undefined;
   return row as PodChildEvidence;
@@ -769,7 +802,7 @@ 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 {
@@ -780,6 +813,14 @@ export function recordHarnessPodStop(
     if (ledger?.some((entry) => entry.event === RUN_STOP_EVENT)) return false;
     const childEvidence = latestPodChildEvidence(ledger);
     const scopeEscape = childEvidence?.scopeEscape === true;
+    // SCOPE-ESCAPE-AS-REFINE — out-of-scope edits without a stop reason are «new scope», not a scope-escape stop.
+    if (childEvidence?.newScope?.length || childEvidence?.scopeStopReasons?.length) {
+      try {
+        debug.log('harness.pod', scopeEscape ? 'scope-escape-stop' : 'scope-new-scope', { runId, scopeEscape,
+          ...(childEvidence.newScope ? { newScope: childEvidence.newScope } : {}),
+          ...(childEvidence.scopeStopReasons ? { scopeStopReasons: childEvidence.scopeStopReasons } : {}) });
+      } catch { /* observation cannot change the stop record */ }
+    }
     if (classified.reason === 'preflight-refused') {
       (deps.record ?? recordRunStop)({
         runId, site: 'preflight', class: 'launch-failed',
@@ -805,11 +846,32 @@ export function recordHarnessPodStop(
     }
     // 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)({
+    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 */ }
 }
@@ -2378,8 +2440,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;
 }
 
@@ -2407,10 +2470,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;
@@ -2421,9 +2484,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);
@@ -2433,8 +2497,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,
       };
@@ -2565,30 +2631,80 @@ export function githubDraftSweepAdapters(execute: GhExecute = executeGh, git: Dr
     }
     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[]> => {
@@ -2618,11 +2734,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)!;
   };
@@ -2677,6 +2797,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),
@@ -2943,7 +3065,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();
@@ -3454,7 +3576,13 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
   if (say) {
     registerHarnessAskSayOptions(harnessCmd.command('say <sentence...>').description('문장을 받아 구동한다'))
       .addOption(new Option('--author-grade <grade>', 'say 저작 등급 (full|lite)').choices(['full', 'lite']))
+      .option('--move-id <id>', 'NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 이 발사를 고른 TA next-move 결정의 수 id(관측 조인 칸 · 발사 동작은 바꾸지 않는다)')
       .action(async (sentence: string[], opts: HarnessAskSayChildLlmOptions & HarnessDryRunOpts) => {
+        const moveId = (opts as { moveId?: unknown }).moveId;
+        // 발사 쪽 영수증 — TA 일반 재발사가 실은 수 id 를 받았다는 한 줄(관측만 · fail-soft · 옵션은 아래로 내려가지 않는다).
+        if (typeof moveId === 'string' && moveId) {
+          try { debug.log('harness', 'move-id-received', { entrance: 'cli-harness-say', moveId }); } catch { /* fail-soft */ }
+        }
         const repair = opts as HarnessSubstrateOpts;
         if (repair.repairCommitOnly !== undefined && (repair.substrate !== 'pod' || !/^pr:[1-9]\d*$/.test(repair.source ?? '')
           || !/^[0-9a-f]{40}$/.test(repair.repairCommitOnly) || repair.autoMerge !== false || repair.target !== undefined)) {

package/src/harness/harness-incidents.ts

@@ -4,6 +4,7 @@ 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';
+import { parsePodTermination, type PodTermination } from '../task-orchestrator/surfaces/pod-failure-reason.js';
 
 export interface RunExit {
   runId: string;
@@ -18,6 +19,14 @@ export interface RunExit {
   pid?: number;
   lastLines?: string[];
   childEvidence?: PodChildEvidence;
+  /** JOB-FAILURE-TERMINATION-CAPTURE — the current attempt's Job/Pod termination facts, captured before GC. */
+  podTermination?: PodTermination;
+  /** INCIDENT-REASON-FROM-LASTLINES — 기록된 reason 이 unknown 이라 lastLines 로 다시 분류했으면 원래 값. */
+  recordedReason?: string;
+  /** reason 을 어디서 얻었나 — 'lastLines' 면 위 분류 규칙으로 정했다(기록 원문은 recordedReason). */
+  reasonSource?: 'lastLines';
+  /** lastLines 에 ux-sim 장치 조각 경로가 보였다 — 장치 먼저 조각의 실패를 따로 셀 수 있게. */
+  slice?: 'device';
 }
 
 export interface IncidentBurst {
@@ -44,6 +53,40 @@ function kstDate(at: number): string {
   return new Date(at + KST_OFFSET_MS).toISOString().slice(0, 10);
 }
 
+// ── INCIDENT-REASON-FROM-LASTLINES (0.2.36 · 10-22 · OP 대응 피처) ───────────────────────────────
+// 기록된 reason 이 «unknown» 인데 마지막 출력 줄에 사유가 그대로 있는 사고가 다수(10-22 경보) — 읽는 쪽에서
+// 결정론으로 다시 분류한다. 우선순위 = 더 구체적인 종료 사유 먼저. 아무것도 안 맞으면 unknown 그대로(추측 0).
+const LAST_LINE_REASONS: ReadonlyArray<[RegExp, string]> = [
+  // 근본 원인 먼저 — 뒤 조각의 DEPENDENCY_NEEDS_HUMAN 은 앞 조각 실패의 «증상»이라 맨 뒤 쪽.
+  [/goal-elaboration needs-human:\s*goal-elaboration-ungrounded-path\b/, 'goal-elaboration-ungrounded-path'],
+  [/goal-elaboration needs-human:\s*goal-elaboration-protected-path\b/, 'goal-elaboration-protected-path'],
+  [/goal-elaboration needs-human:\s*goal-elaboration-scope-conflict\b/, 'goal-elaboration-scope-conflict'],
+  [/goal-elaboration needs-human:\s*goal-elaboration-fixed-layer-conflict\b/, 'goal-elaboration-fixed-layer-conflict'],
+  [/pod-deadline-exceeded|DeadlineExceeded/, 'pod-deadline-exceeded'],
+  [/GOAL_DONE_BOUNDARY_MISSING/, 'goal-done-boundary-missing'],
+  [/BackoffLimitExceeded/, 'pod-backoff-limit'],
+  [/childError=no-resul/, 'pod-child-no-result'],
+  [/pod-job-failed/, 'pod-job-failed'],
+  [/DEPENDENCY_NEEDS_HUMAN/, 'dependency-needs-human'],
+  [/\[needs-human\]|needs-human/, 'needs-human'],
+];
+const DEVICE_SLICE_PATH = /src\/ux-sim\/[\w.-]*-device(?:\.test)?\.ts|DEVICE-FIRST/;
+
+/** lastLines 에서 종료 사유를 꺼낸다 — 안 맞으면 null(unknown 유지). */
+export function classifyIncidentReasonFromLastLines(lines: readonly string[] | undefined): string | null {
+  if (!lines?.length) return null;
+  const text = lines.join('\n');
+  for (const [pattern, reason] of LAST_LINE_REASONS) if (pattern.test(text)) return reason;
+  return null;
+}
+
+function refinedReasonFields(reason: string, lines: readonly string[] | undefined): Pick<RunExit, 'reason' | 'recordedReason' | 'reasonSource' | 'slice'> {
+  const slice = lines?.some((line) => DEVICE_SLICE_PATH.test(line)) ? { slice: 'device' as const } : {};
+  if (reason !== 'unknown') return { reason, ...slice };
+  const refined = classifyIncidentReasonFromLastLines(lines);
+  return refined ? { reason: refined, recordedReason: reason, reasonSource: 'lastLines', ...slice } : { reason, ...slice };
+}
+
 /** Read only recorded exits. Missing ledgers are not evidence that no runs failed. */
 export function readRunExits(root: string): RunExit[] {
   const dir = join(root, 'incidents');
@@ -71,7 +114,8 @@ export function readRunExits(root: string): RunExit[] {
         || !(row.status === null || typeof row.status === 'number')
         || !(row.signal === null || typeof row.signal === 'string')) continue;
       seen.add(row.runId);
-      rows.push({ runId: row.runId, reason: row.reason, status: row.status, signal: row.signal, at: row.at,
+      const lines = Array.isArray(row.lastLines) && row.lastLines.every((line) => typeof line === 'string') ? row.lastLines : undefined;
+      rows.push({ runId: row.runId, ...refinedReasonFields(row.reason, lines), status: row.status, signal: row.signal, at: row.at,
         ...(typeof row.entrance === 'string' ? { entrance: row.entrance } : {}),
         ...(typeof row.seat === 'string' ? { seat: row.seat } : {}),
         ...(typeof row.cwd === 'string' ? { cwd: row.cwd } : {}),
@@ -81,12 +125,19 @@ export function readRunExits(root: string): RunExit[] {
           ? { lastLines: row.lastLines } : {}),
         ...(row.childEvidence && typeof row.childEvidence === 'object' && !Array.isArray(row.childEvidence)
           ? { childEvidence: row.childEvidence } : {}),
+        ...podTerminationField(row.podTermination),
       });
     }
   }
   return rows.sort((a, b) => Date.parse(a.at) - Date.parse(b.at) || a.runId.localeCompare(b.runId));
 }
 
+function podTerminationField(value: unknown): { podTermination?: PodTermination } {
+  const job = value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>).job : undefined;
+  const parsed = typeof job === 'string' ? parsePodTermination(value, job) : undefined;
+  return parsed ? { podTermination: parsed } : {};
+}
+
 /** SQLite's process-owned write lock serializes ledger checks and appends across processes. */
 export function recordRunExit(row: RunExit, root: string): void {
   if (refuseProductionLedgerWriteInTest(root, 'incidents')) return;
@@ -209,6 +260,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 ?? '-'}]` : '';