elanous 0.2.23 → 0.2.25

package/src/self-implement/premise-review.ts

@@ -0,0 +1,159 @@
+/**
+ * 전제 다섯 되짚기 — premise-review 카드 순수 계산(FLEX-RFC §A-③).
+ *
+ * P1 골 · P2 자(판정 시험) · P3 범위(대상 경로) · P4 쪼갬 · P5 환경.
+ * ⛔ LLM 없이 잴 수 있는 둘만 판정한다 — P3(범위) · P2(preexisting 자).
+ * ⛔ unknown 은 «맞다(ok)»가 아니다 — 못 잰 전제는 ok 로 지어내지 않는다.
+ */
+
+import type { FlexSignalsInput } from './flex-signals.js';
+
+/** 못 잰 근거의 표기 — P1·P4·P5 는 이 값으로 unknown 으로만 나간다. */
+const UNMEASURED = '못 잼';
+
+export type PremiseKey = 'P1' | 'P2' | 'P3' | 'P4' | 'P5';
+export type PremiseVerdict = 'ok' | 'wrong' | 'unknown';
+
+export interface PremiseFinding {
+  premise: PremiseKey;
+  verdict: PremiseVerdict;
+  evidence: string;
+}
+
+/** `computeFlexSignals` 와 같은 꼴의 값 객체 + 카드가 가리킬 run 식별자와 P3 판정의 경계. */
+export interface PremiseReviewInput extends FlexSignalsInput {
+  runId: string;
+  /** 이 골이 선언한 대상 경로 — 없으면 P3 는 unknown(경계를 못 잼). */
+  targetPaths?: readonly string[] | undefined;
+}
+
+export interface PremiseReviewCard {
+  runId: string;
+  findings: PremiseFinding[];
+  /** wrong 이 있을 때만 «가장 좁은 것» 하나 — wrong 이 없으면 undefined. */
+  proposal: PremiseFinding | undefined;
+}
+
+/** 최신 라운드의 실패 id 목록 — `gateFailedIdsByRound` 의 마지막 칸이 최신(`computeFlexSignals` 와 같은 순서). */
+function latestFailingIds(input: FlexSignalsInput): readonly string[] | undefined {
+  const latest = input.gateFailedIdsByRound.length === 0
+    ? undefined
+    : input.gateFailedIdsByRound[input.gateFailedIdsByRound.length - 1];
+  return latest !== undefined && latest.length > 0 ? latest : undefined;
+}
+
+/**
+ * 게이트 실패 id — 생산자(orchestrator 의 roundSummaryEntries.failedIds)와 P3 파서가 «같은 꼴»을 쓰도록
+ * 둘 다 이 함수 짝을 거친다. 꼴: `${name}@${file ?? '?'} (${attribution})`.
+ */
+export function formatGateFailedId(failure: { name: string; file?: string | undefined; attribution: string }): string {
+  return `${failure.name}@${failure.file ?? '?'} (${failure.attribution})`;
+}
+
+/**
+ * 실패 id 에서 시험 파일을 뽑는다 — `name@` 접두와 ` (귀속)` 접미를 뗀다. 이름에 `@` 가 섞여도
+ * (`user@example.com`·`@scope/pkg`)·경로에 `@`(`src/@scope/x.ts`)가 있어도 가른다: 경로 안의 `@` 는
+ * 세그먼트 머리(맨 앞 또는 `/` 바로 뒤)에만 온다. 그래서 «공백 없고 · 확장자로 끝나고 · 안의 `@` 가 전부
+ * 세그먼트 머리인» 후보를 처음 주는 `@` 가 구분자다. 그런 `@` 가 없거나 파일이 `?`·빈 값이면 undefined
+ * (못 잼) — fail-closed. 남는 모호함: 이름이 `/` 로 끝나면(`a/@src/x.ts`) 구분자를 경로로 읽는다.
+ */
+export function gateFailedIdFile(id: string): string | undefined {
+  const withoutAttribution = id.replace(/\s*\([^)]*\)\s*$/, '');
+  for (let at = withoutAttribution.indexOf('@'); at >= 0; at = withoutAttribution.indexOf('@', at + 1)) {
+    const file = withoutAttribution.slice(at + 1);
+    if (file === '' || file === '?' || /\s/.test(file)) continue;
+    if (!/\.[A-Za-z0-9]+$/.test(file)) continue;
+    if (/[^/]@/.test(file)) continue;
+    return file;
+  }
+  return undefined;
+}
+
+/**
+ * 시험 파일 → 짝 소스. `dir/x.test.ts` → `dir/x.ts`(같은 폴더). 시험 전용 폴더(`test/`·`__tests__/`)의 시험은
+ * 짝을 추측하지 않는다(undefined · fail-closed). 시험 꼴이 아닌 파일은 그 자신이 소스다.
+ */
+export function pairedSourceOf(file: string): string | undefined {
+  const normalized = file.replace(/^\.\//, '');
+  const testMatch = /^(.*)\.test\.([cm]?[jt]sx?)$/.exec(normalized);
+  if (!testMatch) return normalized;
+  if (/(^|\/)(test|tests|__tests__)\//.test(normalized)) return undefined;
+  return `${testMatch[1]}.${testMatch[2]}`;
+}
+
+function insideTargets(path: string, targets: readonly string[]): boolean {
+  return targets.some((target) => {
+    const t = target.replace(/^\.\//, '').replace(/\/+$/, '');
+    return path === t || path.startsWith(`${t}/`);
+  });
+}
+
+/** P2 자 — 판정 시험이 base 에서도 실패(preexisting)면 wrong. 귀속을 못 잼·하나라도 unknown 이면 unknown. */
+function judgeP2(input: PremiseReviewInput): PremiseFinding {
+  const attributions = input.failureAttributions;
+  if (attributions === undefined || attributions.length === 0) {
+    return { premise: 'P2', verdict: 'unknown', evidence: UNMEASURED };
+  }
+  const preexistingIndex = attributions.indexOf('preexisting');
+  if (preexistingIndex >= 0) {
+    const latest = latestFailingIds(input);
+    const evidence = latest !== undefined && preexistingIndex < latest.length
+      ? latest[preexistingIndex]!
+      : 'preexisting';
+    return { premise: 'P2', verdict: 'wrong', evidence };
+  }
+  if (attributions.includes('unknown')) {
+    return { premise: 'P2', verdict: 'unknown', evidence: UNMEASURED };
+  }
+  return { premise: 'P2', verdict: 'ok', evidence: `preexisting 0/${attributions.length}` };
+}
+
+/**
+ * P3 범위 — 실패 시험 파일을 짝 소스로 옮겨 대상 경로와 견준다. 짝지은 소스(또는 시험 파일 자체)가
+ * 대상 경로 안이면 in · 짝은 지었는데 밖이면 wrong(그 시험 파일을 근거로). 파일을 못 읽거나 짝을 못 지은
+ * 실패가 하나라도 있고 wrong 이 없으면 unknown — 추측으로 ok 를 만들지 않는다.
+ */
+function judgeP3(input: PremiseReviewInput): PremiseFinding {
+  const latest = latestFailingIds(input);
+  const targets = input.targetPaths;
+  if (latest === undefined) return { premise: 'P3', verdict: 'unknown', evidence: UNMEASURED };
+  if (targets === undefined || targets.length === 0) return { premise: 'P3', verdict: 'unknown', evidence: UNMEASURED };
+  let unmeasured: string | undefined;
+  for (const id of latest) {
+    const file = gateFailedIdFile(id);
+    if (file === undefined) { unmeasured ??= `${UNMEASURED}: 실패 파일 없음 (${id})`; continue; }
+    if (insideTargets(file, targets)) continue;
+    const source = pairedSourceOf(file);
+    if (source === undefined) { unmeasured ??= `${UNMEASURED}: 짝 소스 없음 (${file})`; continue; }
+    if (!insideTargets(source, targets)) return { premise: 'P3', verdict: 'wrong', evidence: file };
+  }
+  if (unmeasured !== undefined) return { premise: 'P3', verdict: 'unknown', evidence: unmeasured };
+  return { premise: 'P3', verdict: 'ok', evidence: `failing files all inside target paths (${latest.length})` };
+}
+
+/**
+ * wrong 이 여럿이면 «가장 좁은 것» 하나만 제안한다(RFC §A-③ — F6 카드 → F7 조치). 좁음 = 수정 폭:
+ * P2 자가 가장 좁다(판정 자만 고친다 · 골을 안 건드린다) → P5 환경(재무대) → P4 쪼갬 → P3 범위(경계를 넓힌다)
+ * → P1 골(요구 자체를 바꾼다)이 가장 넓다. findings 배열 순서에 우연히 맡기지 않고 이 rank 로 고른다.
+ */
+const NARROWEST_FIRST: readonly PremiseKey[] = ['P2', 'P5', 'P4', 'P3', 'P1'];
+
+export function narrowestWrong(findings: readonly PremiseFinding[]): PremiseFinding | undefined {
+  for (const premise of NARROWEST_FIRST) {
+    const wrong = findings.find((finding) => finding.premise === premise && finding.verdict === 'wrong');
+    if (wrong !== undefined) return wrong;
+  }
+  return undefined;
+}
+
+/** 전제 다섯을 되짚어 카드를 세운다 — 순수 계산, LLM 을 부르지 않는다. */
+export function buildPremiseCard(input: PremiseReviewInput): PremiseReviewCard {
+  const findings: PremiseFinding[] = [
+    { premise: 'P1', verdict: 'unknown', evidence: UNMEASURED },
+    judgeP2(input),
+    judgeP3(input),
+    { premise: 'P4', verdict: 'unknown', evidence: UNMEASURED },
+    { premise: 'P5', verdict: 'unknown', evidence: UNMEASURED },
+  ];
+  return { runId: input.runId, findings, proposal: narrowestWrong(findings) };
+}

package/src/self-implement/regate-detail.ts

@@ -0,0 +1,79 @@
+/**
+ * HOST-REGATE-REASON-LOST (2nd · 2026-10-12): a host-regate failure must say «why» on the ledger.
+ *
+ * The first repair (#26215) put `hostRegateFailure` on the pr-terminal row but kept only the first 300 characters,
+ * and the gate's own `run()` cut every git/gh error to its first 300 characters as well. A git merge lists one
+ * `CONFLICT` line per file and gh puts the GraphQL reason at the end, so a head cut loses exactly the cause
+ * (run-caaf045f · PR #26472: the autopsy could not tell a conflict from a gate failure).
+ *
+ * The detail is bounded (ledger rows are append-only and replayed) but keeps both ends.
+ */
+export const HOST_REGATE_DETAIL_MAX = 4096;
+
+/** Keep `text` within `max` characters, preserving its head (an eighth) and its tail (the rest). */
+export function clipRegateDetail(text: string, max = HOST_REGATE_DETAIL_MAX): string {
+  if (text.length <= max) return text;
+  const marker = ` …[${text.length - max} chars elided]… `;
+  const head = Math.floor(max / 8);
+  const tail = Math.max(0, max - head - marker.length);
+  return text.slice(0, head) + marker + text.slice(text.length - tail);
+}
+
+/** Files named by `git merge` CONFLICT lines (`CONFLICT (content): Merge conflict in <path>` and the rename/delete forms). */
+export function parseConflictFiles(text: string): string[] {
+  const files = new Set<string>();
+  for (const raw of text.split('\n')) {
+    const line = /^CONFLICT \(([^)]*)\): (.*)$/.exec(raw);
+    if (!line) continue;
+    const rest = line[2]!;
+    const inPath = /Merge conflict in (.+)$/.exec(rest);
+    // modify/delete · rename/delete · file/directory name the path first; other free text is not a path.
+    const path = inPath ? inPath[1] : /^(?:modify\/delete|rename\/delete)$/.test(line[1]!)
+      ? /^(.+?) (?:deleted|renamed) in /.exec(rest)?.[1]
+      : undefined;
+    if (path) files.add(path);
+  }
+  return [...files].sort();
+}
+
+export type MergeFailureKind = 'base-modified' | 'head-moved' | 'conflict' | 'branch-policy' | 'other';
+
+/** Classify a `gh pr merge` failure so a reader can tell a race from a conflict from a policy block without the raw text. */
+export function classifyMergeFailure(detail: string, expectedHead?: string, actualHead?: string | null): MergeFailureKind {
+  if (/base branch was modified/i.test(detail)) return 'base-modified';
+  if (/head branch was modified/i.test(detail)) return 'head-moved';
+  if (expectedHead && actualHead && expectedHead !== actualHead) return 'head-moved';
+  if (/required status|review is required|protected branch|branch policy|not authorized|merge queue/i.test(detail)) return 'branch-policy';
+  if (/\bconflicts?\b/i.test(detail) && !/\bno conflicts?\b/i.test(detail)) return 'conflict';
+  return 'other';
+}
+
+/** One host-regate failure. The optional facts are filled for the pr-head, merge-conflict and merge steps. */
+export interface HostRegateFailure {
+  step: string;
+  detail: string;
+  expectedHead?: string;
+  actualHead?: string | null;
+  conflictFiles?: string[];
+  /** Number omitted from conflictFiles when the ledger's 200-path bound is reached. */
+  conflictFilesOmitted?: number;
+  mergeFailureKind?: MergeFailureKind;
+}
+
+/** The optional facts of a failure, copied only when well-formed (ledger rows come back from disk). */
+export function regateFailureFacts(failure: unknown): Omit<HostRegateFailure, 'step' | 'detail'> {
+  if (!failure || typeof failure !== 'object') return {};
+  const f = failure as Record<string, unknown>;
+  const sha = (value: unknown): value is string => typeof value === 'string' && /^[0-9a-f]{40}$/i.test(value);
+  const kinds: readonly MergeFailureKind[] = ['base-modified', 'head-moved', 'conflict', 'branch-policy', 'other'];
+  const conflictFiles = Array.isArray(f.conflictFiles) ? f.conflictFiles.filter((p): p is string => typeof p === 'string') : undefined;
+  const priorOmitted = Number.isSafeInteger(f.conflictFilesOmitted) && (f.conflictFilesOmitted as number) > 0 ? f.conflictFilesOmitted as number : 0;
+  const conflictFilesOmitted = Math.max(0, (conflictFiles?.length ?? 0) - 200) + priorOmitted;
+  return {
+    ...(sha(f.expectedHead) ? { expectedHead: f.expectedHead } : {}),
+    ...(sha(f.actualHead) || f.actualHead === null ? { actualHead: f.actualHead as string | null } : {}),
+    ...(conflictFiles ? { conflictFiles: conflictFiles.slice(0, 200) } : {}),
+    ...(conflictFilesOmitted > 0 ? { conflictFilesOmitted } : {}),
+    ...(typeof f.mergeFailureKind === 'string' && kinds.includes(f.mergeFailureKind as MergeFailureKind) ? { mergeFailureKind: f.mergeFailureKind as MergeFailureKind } : {}),
+  };
+}

package/src/self-implement/review-deferred-to-host.ts

@@ -0,0 +1,21 @@
+// REVIEW-ACP-POD ②-b — Pod 안 리뷰를 «호스트 리뷰로 미룸».
+//
+// S  ②-a(#26457)로 호스트가 Pod merge-ready PR 을 Claude ACP 로 리뷰한다. 그런데 Pod 안 하니스 리뷰는 그대로 api 로 돌아
+//    켜면 리뷰가 «둘»(돈 두 번)이다.
+// C  오케스트레이터는 «실제 리뷰»(`reviewed=true`)가 있어야 merge-ready 를 낸다 — 그냥 끄면 `no-real-review` 로 멎는다.
+// Q  Pod 안 리뷰를 어떻게 «정직하게» 비우나?
+// A  발사 호스트가 ACP 리뷰를 맡을 때만 자식 env 에 표지를 싣는다. 자식은 api 리뷰를 부르지 않고
+//    `reviewed=false` ⊕ `failureReason=deferred-to-host` 를 낸다(⛔ verdict 를 clean 으로 꾸미지 않는다).
+//    오케스트레이터는 «호스트 병합(mergeByHost)» 런에서만 그 상태를 merge-ready 로 받고 `mergeReason` 에 적어 호스트로 돌려보낸다.
+//    호스트는 그 표지를 보면 ACP 리뷰를 «반드시» 하고, 못 하면(refused) 병합하지 않는다(fail-closed).
+
+/** 발사 호스트 → Pod 자식: 「리뷰는 호스트가 Claude ACP 로 한다 — Pod 안 api 리뷰를 부르지 마라」. 값 `1` 만 켠다. */
+export const REVIEW_DEFERRED_TO_HOST_ENV = 'ELANOUS_REVIEW_DEFERRED_TO_HOST';
+/** 미룬 리뷰의 `failureReason`(`reviewed=false` 의 «왜»). */
+export const REVIEW_DEFERRED_TO_HOST_FAILURE = 'deferred-to-host';
+/** 자식 merge-ready 결과의 `mergeReason` — 호스트가 이 값으로 «Pod 리뷰 없음»을 안다. */
+export const REVIEW_DEFERRED_TO_HOST_MERGE_REASON = 'review-deferred-to-host';
+
+export function reviewDeferredToHostFromEnv(env: Readonly<Record<string, string | undefined>>): boolean {
+  return env[REVIEW_DEFERRED_TO_HOST_ENV]?.trim() === '1';
+}

package/src/self-implement/rework-budget-judgment.ts

@@ -1,4 +1,5 @@
 import { executeClassifyNode } from '../workflow-runtime/nodes/classify.js';
+import { buildPremiseCard, type PremiseReviewCard, type PremiseReviewInput } from './premise-review.js';
 import { SUPERVISION_REWORK_SOURCES, type SupervisionReworkSource } from './supervision-vocabulary.js';
 import type { ClassifyNode, JudgmentContext, JudgmentResult, NodeExecContext, WorkflowDefinition, WorkflowDeps } from '../workflow-runtime/types.js';
 
@@ -22,6 +23,8 @@ interface ObservedValue {
 interface ReworkBudgetEvidence {
   observations: Record<'goal' | 'outcome' | 'history' | 'kind', ObservedValue>;
   modelReasoning: string;
+  /** UNCONVERGEABLE 직전에 세운 premise-review 카드(FLEX-RFC §A-③). 카드를 안 만든 판정에는 키가 없다. */
+  premiseReview?: PremiseReviewCard | undefined;
 }
 
 type EvidencedJudgmentResult = JudgmentResult & { evidence: ReworkBudgetEvidence };
@@ -108,7 +111,13 @@ export function reworkBudgetEvidenceForObservation(readEvidence: () => unknown):
   }
 }
 
-export function createReworkBudgetJudgment(callLLM: WorkflowDeps['callLLM']) {
+/** `createReworkBudgetJudgment` 의 선택 인자 — 주지 않으면 카드 없이 지금 동작 그대로. */
+export interface ReworkBudgetJudgmentOpts {
+  /** UNCONVERGEABLE 판정 직전에 세울 premise-review 카드의 입력(값 객체). */
+  premiseInput?: PremiseReviewInput | undefined;
+}
+
+export function createReworkBudgetJudgment(callLLM: WorkflowDeps['callLLM'], opts: ReworkBudgetJudgmentOpts = {}) {
   let latestEvidence: ReworkBudgetEvidence | undefined;
   const provider = async (contractId: string, ctx: JudgmentContext): Promise<JudgmentResult> => {
     if (contractId !== REWORK_BUDGET_JUDGMENT) {
@@ -145,6 +154,7 @@ export function createReworkBudgetJudgment(callLLM: WorkflowDeps['callLLM']) {
       toolPolicy: {},
     };
     let modelReasoning = '';
+    let premiseReview: PremiseReviewCard | undefined;
     const result = await executeClassifyNode(node, execContext, {
       callLLM: async (args) => {
         modelReasoning = await callLLM(args);
@@ -152,7 +162,11 @@ export function createReworkBudgetJudgment(callLLM: WorkflowDeps['callLLM']) {
       },
       runBash: async () => ({ stdout: '', stderr: '', exitCode: 0 }),
     });
-    const evidence = (): ReworkBudgetEvidence => ({ observations, modelReasoning });
+    const evidence = (): ReworkBudgetEvidence => ({
+      observations,
+      modelReasoning,
+      ...(premiseReview === undefined ? {} : { premiseReview }),
+    });
     const evidenced = (judgment: JudgmentResult): EvidencedJudgmentResult => {
       const resultWithEvidence = withEvidence(judgment, evidence());
       latestEvidence = resultWithEvidence.evidence;
@@ -172,7 +186,13 @@ export function createReworkBudgetJudgment(callLLM: WorkflowDeps['callLLM']) {
           + ` expected one of EXTEND|SUFFICIENT|UNCONVERGEABLE`,
       });
     }
-    return evidenced({ ok: true, output: picked, verdict: mapReworkBudgetVerdict(picked, kind) });
+    const verdict = mapReworkBudgetVerdict(picked, kind);
+    // FLEX-RFC §A-③ — UNCONVERGEABLE 을 «내기 전에» 전제를 되짚는다. 카드는 기존 증거 관측에 실려
+    // 원장('rework-budget' 사건)으로 나간다 — 사건 형식은 그대로, 카드는 증거 안의 추가 칸이다.
+    if (picked === 'UNCONVERGEABLE' && opts.premiseInput !== undefined) {
+      premiseReview = buildPremiseCard(opts.premiseInput);
+    }
+    return evidenced({ ok: true, output: picked, verdict });
   };
   return Object.assign(provider, { evidenceForObservation: () => latestEvidence });
 }

package/src/self-implement/running-runs.ts

@@ -566,13 +566,83 @@ export function queryRunningRuns(options: { includeTest?: boolean; runIds?: read
   }
 }
 
-export function renderRunningRuns(result: RunningRunsResult): string {
-  const lingeringLaunchParents = result.lingeringLaunchParents ?? { observation: 'indeterminate' } as const;
-  const partial = (result.count !== undefined && typeof result.count !== 'number' && result.count.count === null)
+export function isPartialRunningRuns(result: RunningRunsResult): boolean {
+  return (result.count !== undefined && typeof result.count !== 'number' && result.count.count === null)
     || result.completeness === 'partial' || hasUnreadableLedgerObservation(result.ledger) || (result.unreadable?.length ?? 0) > 0;
-  const lowerBound = result.count !== undefined && typeof result.count !== 'number'
+}
+
+function runningRunsLowerBound(result: RunningRunsResult): number {
+  return result.count !== undefined && typeof result.count !== 'number'
     ? result.count.lowerBound : result.counts.running + result.counts['probable-running'];
-  const unreadable = result.unreadable ?? (result.count !== undefined && typeof result.count !== 'number' ? result.count.unreadable : []);
+}
+
+function runningRunsUnreadable(result: RunningRunsResult): readonly UnreadableRunningRunsLedger[] {
+  return result.unreadable ?? (result.count !== undefined && typeof result.count !== 'number' ? result.count.unreadable : []);
+}
+
+export interface RunProgressRow {
+  readonly runId: string;
+  readonly status: RunningRunStatus;
+  /** null = no phase observed; never rendered as «none». */
+  readonly lastPhase: string | null;
+  readonly lastPhaseObservedAt: string | null;
+  readonly lastActivityTimestamp: string | null;
+  /** Milliseconds since lastActivityTimestamp; null when the timestamp is absent or unparseable. */
+  readonly elapsedMs: number | null;
+  readonly ptyRefs: readonly string[];
+  readonly phaseObservation: RunningRunPhaseObservation;
+}
+
+export function buildRunProgressRows(result: RunningRunsResult, nowMs: number = Date.now()): RunProgressRow[] {
+  return result.entries.map((entry) => {
+    const activityMs = entry.lastActivityTimestamp === null ? Number.NaN : Date.parse(entry.lastActivityTimestamp);
+    return {
+      runId: entry.runId,
+      status: entry.status,
+      lastPhase: entry.lastPhase ?? null,
+      lastPhaseObservedAt: entry.lastPhaseObservedAt ?? null,
+      lastActivityTimestamp: entry.lastActivityTimestamp,
+      elapsedMs: Number.isFinite(activityMs) ? Math.max(0, nowMs - activityMs) : null,
+      ptyRefs: entry.ptyRefs.map((ref) => `${ref.instance}:${ref.id}`),
+      phaseObservation: entry.phaseObservation ?? 'not-observed',
+    };
+  });
+}
+
+function formatElapsed(ms: number): string {
+  const totalSeconds = Math.floor(ms / 1000);
+  const days = Math.floor(totalSeconds / 86_400);
+  const hours = Math.floor((totalSeconds % 86_400) / 3_600);
+  const minutes = Math.floor((totalSeconds % 3_600) / 60);
+  const seconds = totalSeconds % 60;
+  if (days > 0) return `${days}d${hours}h`;
+  if (hours > 0) return `${hours}h${minutes}m`;
+  if (minutes > 0) return `${minutes}m${seconds}s`;
+  return `${seconds}s`;
+}
+
+export function renderRunProgressTable(result: RunningRunsResult, nowMs: number = Date.now()): string {
+  const partial = isPartialRunningRuns(result);
+  const header = partial
+    ? `부분 관측 — 최소 ${runningRunsLowerBound(result)} (읽지 못한 원장: ${runningRunsUnreadable(result).map((item) => `${item.dir}:${item.reason}`).join(',') || '목록 미관측'})`
+    : `도는 런 ${result.counts.running + result.counts['probable-running']} (확인 ${result.counts.running} · 추정 ${result.counts['probable-running']})`;
+  const rows = buildRunProgressRows(result, nowMs).map((row) => {
+    const phaseUnreadable = row.phaseObservation === 'unreadable' || row.phaseObservation === 'partially-unreadable';
+    const phase = row.lastPhase ?? (phaseUnreadable ? '미관측 (단계 저장소 읽기 실패)' : '미관측');
+    const phaseAt = row.lastPhaseObservedAt ?? '미관측';
+    const progress = row.lastActivityTimestamp === null
+      ? '미관측'
+      : `${row.lastActivityTimestamp} (경과 ${row.elapsedMs === null ? '알 수 없음' : formatElapsed(row.elapsedMs)})`;
+    return `${row.runId} · ${row.status} · 단계 ${phase} · 진입 ${phaseAt} · 마지막 진전 ${progress} · pty ${row.ptyRefs.join(',') || '없음'}`;
+  });
+  return [header, ...rows].join('\n');
+}
+
+export function renderRunningRuns(result: RunningRunsResult): string {
+  const lingeringLaunchParents = result.lingeringLaunchParents ?? { observation: 'indeterminate' } as const;
+  const partial = isPartialRunningRuns(result);
+  const lowerBound = runningRunsLowerBound(result);
+  const unreadable = runningRunsUnreadable(result);
   return [
     partial
       ? `running runs: unknown (at least ${lowerBound}) unreadable: ${unreadable.map((item) => `${item.dir}:${item.reason}`).join(',')}`

package/src/self-implement/scope-adjacency.ts

@@ -0,0 +1,23 @@
+// SCOPE-HELD-DELIVER (0.2.25) — which out-of-scope edits sit right next to a declared target.
+// 10-11~12: 34 scope-held runs auto-answered «Stay in scope» after 30 unanswered minutes and threw away finished work;
+// the outside files were a declared file's same-folder neighbours (its other tests, a sibling helper, the folder's
+// plugin.json). Those are adjacent: the run goes on to its gate instead of parking on a question nobody answers.
+
+const normalize = (path: string): string => path.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');
+const dirOf = (path: string): string => { const at = path.lastIndexOf('/'); return at < 0 ? '' : path.slice(0, at); };
+
+/** Split out-of-scope files into those adjacent to a declared target and the rest. A file is adjacent when it sits in
+ *  the same folder as a declared file. A declared folder adds nothing (its contents are already in scope), and a
+ *  declared repo-root file adds nothing (the root holds the whole repo's config). */
+export function classifyOutOfScope(outsideFiles: readonly string[], declaredPaths: readonly string[]): { adjacent: string[]; other: string[] } {
+  const folders = new Set<string>();
+  for (const declared of declaredPaths.map(normalize)) {
+    const dir = dirOf(declared);
+    // A path with an extension names a file; without one it names a folder.
+    if (dir && /\.[A-Za-z0-9]+$/.test(declared.slice(dir.length + 1))) folders.add(dir);
+  }
+  const adjacent: string[] = [];
+  const other: string[] = [];
+  for (const file of outsideFiles) (folders.has(dirOf(normalize(file))) ? adjacent : other).push(file);
+  return { adjacent, other };
+}

package/src/self-implement/seams.ts

@@ -15,6 +15,7 @@
 import { fileURLToPath } from 'node:url';
 import { judgePredictionAccuracy, mustFixTrendFromHistory, renderJudgeOwnSignals, renderJudgePredictionAccuracy } from './judge-prediction-accuracy.js';
 import { isElanousRuntimeArtifactPath } from './gate-scope.js';
+import { buildPrConclusionCard, firstParagraphOf, prConclusionCardHeader } from '../context-card/index.js';
 import { spawn, spawnSync, execFile } from 'node:child_process';
 import { randomUUID, timingSafeEqual } from 'node:crypto';
 import { existsSync, lstatSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
@@ -34,6 +35,7 @@ import { isWorktreeInUse, listActiveTerminalDirectories } from '../harness/harne
 import { readWorktreePorcelain } from './abandoned-classification.js';
 import { recordHarnessWorktreeGoalMetadata, recordHarnessWorktreeProvenance, type HarnessWorktreeGoalMetadata } from '../harness/harness-worktree-add.js';
 import { runGitCommand } from '../git-fs/runner.js';
+import { BENCH_LABEL, BENCH_LOG_CATEGORY, benchIdFromBase, parseBenchArmBranch } from '../bench/bench.js';
 import { provisionDerivedUniverse } from '../instance/provision.js';
 import { DEFAULT_GATE_STEPS, runIntegrityGate, type GateResult, type GateStepName } from '../autopilot/build/integrity-gate.js';
 import { androidFilesIn, runAndroidUnitTestGate } from '../../scripts/ci-android-unit-tests.js';
@@ -70,6 +72,7 @@ import { ghAutomationEnv, makePrManager, type PrManager } from '../autopilot/pr-
 import { defaultSpawnGh, lookupOpenDraftPrs } from '../cli/logs-abandoned-draft-prs.js';
 import { loadRunLedger, runLedgerDir } from './run-ledger.js';
 import { readdirSync } from 'node:fs';
+import { REVIEW_DEFERRED_TO_HOST_FAILURE } from './review-deferred-to-host.js';
 import { budgetReviewerContext, reviewDiffBudgetObservation, reviewPullRequest, renderReview, type ReviewerContextItem } from '../agent-substrate/pr-reviewer.js';
 import { buildReviewIntent, type ReviewIntentInput } from '../agent-substrate/review-intent.js';
 import { OFF_DIFF_EVIDENCE_PROMPT, requiredEvidenceFromGoal, renderRequiredEvidencePrompt, tailWithOmissionMarker } from './off-diff-evidence.js';
@@ -94,6 +97,7 @@ import { isSupervisorDecisionSection, splitGoalSections, supervisorGoalDigest }
 import type { SupervisionReworkSource } from './supervision-vocabulary.js';
 import type { ReworkBudgetVerdict } from './run-outcome.js';
 import { pickImplementRoleForGoal, runHeadlessGoalLoopPty } from './headless-elanous-driver.js';
+import { isClaudeAcpChild, runClaudeAcpImplement } from './claude-acp-implement.js';
 import { childLlmSelectionEnv } from '../agent/run-context.js';
 import { observeExternalEvent } from '../context-bus/external-events.js';
 import { buildLlmHitlRelay, SIDE_EFFECT_RE } from '../harness/llm-hitl-relay.js';
@@ -847,16 +851,34 @@ export function changedFileTypecheck(
   }
 }
 
-/** 헤드리스 elanous 가 이 feature 를 구현하도록 주입하는 프롬프트. goal-loop 계약 + 검증된 클린-빌드
- *  앵커(측정→운영·[[REPORT-gemma-goalloop-lever-2026-07-20]])를 명시. 앵커가 gemma 를 99 로 끌어올렸고
- *  강한 모델엔 무해 — self-run 어느 provider 든 동일 규율. */
-export function buildPrBody(cwd: string, body: string): string {
+export interface PrBodyConclusionInput {
+  /** 결론줄 «포인터:» 에 붙일 원본 위치(원문 전문을 가리키는 참조). */
+  readonly pointers?: readonly string[];
+  /** 원문 본문을 읽지 못한 경우 — «결론: 확인 불가» 로 떨어진다. */
+  readonly unreadable?: boolean;
+}
+
+/** RFC context-diet §3a — PR 본문 첫 단락을 «결론: <한 줄> · 포인터: <원본>» 결론줄로 앞세우고
+ *  원문 본문은 결론줄 아래 그대로 둔다(지우지 않는다). 결론이 없으면 «결론: 없음(원문에 결론 없음)». */
+export function buildPrBody(cwd: string, body: string, conclusion?: PrBodyConclusionInput): string {
+  const card = buildPrConclusionCard({
+    id: 'pr-body-conclusion',
+    firstParagraph: firstParagraphOf(body),
+    ...(conclusion?.unreadable ? { unreadable: true } : {}),
+    pointers: [...(conclusion?.pointers ?? [])],
+    source: 'pr-body',
+    updatedAt: new Date().toISOString(),
+  });
+  const header = prConclusionCardHeader(card);
   const templatePath = join(cwd, '.github', 'pull_request_template.md');
-  if (!existsSync(templatePath)) return body;
-  const template = readFileSync(templatePath, 'utf8').trim();
-  return template ? `${template}\n\n${body}` : body;
+  const template = existsSync(templatePath) ? readFileSync(templatePath, 'utf8').trim() : '';
+  const withConclusion = `${header}\n\n${body}`;
+  return template ? `${template}\n\n${withConclusion}` : withConclusion;
 }
 
+/** 헤드리스 elanous 가 이 feature 를 구현하도록 주입하는 프롬프트. goal-loop 계약 + 검증된 클린-빌드
+ * 앵커(측정→운영·[[REPORT-gemma-goalloop-lever-2026-07-20]])를 명시. 앵커가 gemma 를 99 로 끌어올렸고
+ * 강한 모델엔 무해 — self-run 어느 provider 든 동일 규율. */
 export function featurePrompt(feature: string, cwd?: string, reviewerContext?: readonly ReviewerContextItem[]): string {
   const worktreeNotice = cwd?.trim()
     ? `작업 디렉토리는 \`${cwd}\`다. 이 트리 안에서만 편집하고, 경로가 필요하면 추측하지 말고 이 경로를 기준으로 삼아라.`
@@ -1061,12 +1083,17 @@ export interface DefaultSeamsOptions {
    * ⛔ llmReview 시그니처는 그대로(prompt-in/text-out · 도구 채널 없음).
    */
   reviewerCanSelfRead?: boolean;
+  /** REVIEW-ACP-POD ②-b — 참이면 reviewDiff 가 리뷰어를 부르지 않고 `reviewed=false` ⊕ `failureReason=deferred-to-host` 를 낸다
+   *  (발사 호스트가 Claude ACP 로 리뷰한다). 기본 거짓 = 종전. */
+  reviewDeferredToHost?: boolean;
   /** CLI가 적재한 리뷰어 컨텍스트. 비어 있으면 기존 ReviewInput 형태를 유지한다. */
   reviewerContext?: ReviewerContextItem[];
   /** 기존 LLM HITL relay builder의 테스트 seam. 생성 실패 시 기본 dispatch를 그대로 유지한다. */
   buildLlmHitlRelay?: typeof buildLlmHitlRelay;
   /** 테스트용 PTY executor 주입. */
   runHeadlessGoalLoopPty?: typeof runHeadlessGoalLoopPty;
+  /** CLAUDE-IMPL-LANE 시험 주입 — claude-acp 자식의 구독 ACP 구현 실행. */
+  runClaudeAcpImplement?: typeof runClaudeAcpImplement;
   /** 테스트용 PTY 가용성 주입. */
   ptyAvailable?: () => boolean;
   /** Tests may inject the shared provenance writer to exercise the self-implement failure contract. */
@@ -1367,6 +1394,8 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
   const removeCleanupWorktree = o.removeWorktree ?? removeWorktree;
   const runCleanupGitCommand = o.runGitCommand ?? runGitCommand;
   const baselineRefs = new Map<string, string>();
+  // BENCH-ISOLATED-ARMS — 벤치 base(`bench/<id>/base`) 위에서 만든 작업 트리 → bench id.
+  const benchWorktrees = new Map<string, string>();
   const gateVerifyOrdinals = new Map<string, number>();
   const gateVerifyIdentity = (runId: string | undefined) => {
     if (!runId?.trim()) return { runId: runId === undefined ? null : runId, ordinal: null };
@@ -1535,6 +1564,18 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
     defaultBranchRef,
     // ★ G2(2026-07-21) — 호출부가 해석한 대상만 PR 직전에 정합한다.
     mergeMain: async (worktreePath, mergeTarget) => {
+      // BENCH-ISOLATED-ARMS ③ — 벤치 팔은 main 에 정합하지 않는다: 판정은 고정 base 위 게이트·시험·리뷰.
+      //   ⭐ 표지는 둘 중 하나 — 이 프로세스가 벤치 base 로 만든 트리이거나, 트리 가지가 `bench/<id>/<arm>` 이다
+      //   (재개 프로세스는 앞의 Map 이 비어 있으므로 가지 이름으로 다시 안다).
+      const benchArm = benchWorktrees.has(worktreePath) ? undefined : (() => {
+        const head = runGitCommand(worktreePath, ['rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf8', timeout: GIT_TIMEOUT });
+        return head.status === 0 ? parseBenchArmBranch(String(head.stdout).trim()) : null;
+      })();
+      const benchId = benchWorktrees.get(worktreePath) ?? benchArm?.id;
+      if (benchId) {
+        debug.log(BENCH_LOG_CATEGORY, 'main-sync-skipped', { benchId, worktreePath, mergeTarget, source: benchWorktrees.has(worktreePath) ? 'base' : 'branch' });
+        return { status: 'up-to-date' as const };
+      }
       const { mergeMainIntoWorktreeWithLlm } = await import('../autopilot/build/llm-conflict-merge.js');
       return mergeMainIntoWorktreeWithLlm(worktreePath, mergeTarget);
     },
@@ -1586,6 +1627,8 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         ...(runId ? { currentOwner: `dev:${runId}` } : {}),
       });
       if (r.resolvedBase) baselineRefs.set(r.path, r.resolvedBase);
+      const benchId = benchIdFromBase(base);
+      if (benchId) benchWorktrees.set(r.path, benchId);
       const provenance = runId ? {
         owner: `dev:${runId}`,
         command: 'elanous dev',
@@ -1686,6 +1729,28 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         ...(runId ? { runId } : {}),
       });
       const prompt = featurePrompt(feature, cwd, o.reviewerContext);
+      // CLAUDE-IMPL-LANE — claude-acp 는 PTY 자식(`elanous chat` → getProvider)으로 보내지 않는다:
+      //   거기서는 모델 이름(claude-…)이 anthropic(API 키 provider)으로 풀려 «구독» 런이 API 로 과금된다(#26277 보류 판독).
+      //   구독 ACP 구현기만 쓰고, 구독 확인이 안 되면 실패로 끝낸다(다른 공급자로 조용히 새지 않는다).
+      if (isClaudeAcpChild(childLlm)) {
+        const outcome = await (o.runClaudeAcpImplement ?? runClaudeAcpImplement)({
+          cwd, prompt, ...(childLlm?.model ? { model: childLlm.model } : {}), ...(runId ? { runId } : {}),
+        });
+        if (outcome.kind === 'refused') {
+          debug.log('self-implement', 'implement.result', { reached: false, changed: false, transport: 'claude-acp', refused: outcome.reason, ...(runId ? { runId } : {}) });
+          return { ok: false, summary: `claude-acp 구현 레인 거부: ${outcome.reason}` };
+        }
+        const changed = worktreeHasChanges(cwd, harnessSeededPaths ?? []);
+        // 도구 호출 수 = 허가를 요청한 호출(허가 ⊕ 거부) — ACP 는 읽기 전용 호출 일부를 묻지 않으니 하한이다.
+        const toolCalls = outcome.result.allowed + outcome.result.denied;
+        debug.log('self-implement', 'implement.result', { reached: true, changed, toolCalls, transport: 'claude-acp', allowed: outcome.result.allowed, denied: outcome.result.denied, ...(runId ? { runId } : {}) });
+        return {
+          ok: changed,
+          ...buildImplementReport(outcome.result.text, { changed, toolCalls, reached: true, timedOut: false }),
+          toolCalls,
+          terminalStatus: { reached: true, changed, toolCalls, timedOut: false },
+        };
+      }
       // S4 P2b/P3: input은 관측만 하며, done만 config와 stall 확증을 모두 만족할 때 부모 대기를 끝낸다.
       // 이 종료-보고 규칙은 self-implement child에만 적용한다. 범용 brain의 기본 프롬프트를 바꾸지 않는다.
       const brain = createSelfImplementControlBrain({ goal: feature });
@@ -2436,7 +2501,11 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         commitMessage: title,
         ...(resolvedBase ? { base: resolvedBase } : {}),
         ...(draft !== undefined ? { draft } : {}),
-        ...(labels?.length ? { labels } : {}),
+        // BENCH-ISOLATED-ARMS ② — base 가 `bench/<id>/base` 면 라벨 `elanous:bench` 를 더한다.
+        ...(() => {
+          const all = benchIdFromBase(resolvedBase) && !labels?.includes(BENCH_LABEL) ? [...(labels ?? []), BENCH_LABEL] : labels;
+          return all?.length ? { labels: all } : {};
+        })(),
       });
       if (!outcome.ok) throw new Error(`self-implement PR ${outcome.reason} 실패: ${outcome.detail}`);
       const number = Number.parseInt(outcome.url.match(/\/pull\/(\d+)/)?.[1] ?? '', 10);
@@ -2541,6 +2610,18 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
             ...(o.reviewerCanSelfRead !== undefined ? { canSelfRead: o.reviewerCanSelfRead } : {}),
           };
         }
+        if (o.reviewDeferredToHost) {
+          // REVIEW-ACP-POD ②-b — 리뷰어 호출 0. ⛔ 통과로 꾸미지 않는다(reviewed=false) — 판정은 호스트 ACP 리뷰가 맡는다.
+          debug.log('self-implement', 'review.done', {
+            verdict: 'warn', reviewed: false, reason: REVIEW_DEFERRED_TO_HOST_FAILURE,
+            ...(ctx?.round !== undefined ? { round: ctx.round } : {}),
+          });
+          try { emitDecision(reviewDecision({ runId: ctx?.runId, verdict: 'warn', reviewed: false, reason: REVIEW_DEFERRED_TO_HOST_FAILURE })); } catch { /* observation must not change the review result */ }
+          return {
+            verdict: 'warn' as const, mustFix: [], shouldFix: [], summary: '(리뷰를 호스트 Claude ACP 리뷰로 미뤘다)', reviewed: false,
+            failureReason: REVIEW_DEFERRED_TO_HOST_FAILURE, deferredToHost: true as const,
+          };
+        }
         const intentInput = toReviewIntentInput(ctx);
         const phaseIntent = intentInput ? buildReviewIntent(intentInput) : 'self-implement 변경 리뷰';
         const evidenceNote = [