elanous 0.2.32 → 0.2.35

package/src/self-implement/pod-warm-pool-profile.ts

@@ -0,0 +1,45 @@
+/** Warm-pool profile labels select a host/tier allocation policy. */
+export const WARM_POOL_PROFILES = ['fixed', 'gate', 'landing', 'feature'] as const;
+export type WarmPoolProfile = (typeof WARM_POOL_PROFILES)[number];
+export type WarmPoolTier = 'lite' | 'standard';
+const STANDARD_HOST_MAX: Readonly<Record<string, number>> = {
+  node-b: 16,
+  node-c: 4,
+  'host-e-wsl': 5,
+};
+
+// Only this host/tier pair has a measured lite allocation. Other pairs fail closed to zero.
+const LITE_HOST_MAX: Readonly<Record<string, number>> = { mbp: 7 };
+
+export function isWarmPoolProfile(value: unknown): value is WarmPoolProfile {
+  return typeof value === 'string' && (WARM_POOL_PROFILES as readonly string[]).includes(value);
+}
+
+/** Parse a configured profile. Missing or invalid values fail closed to the fixed profile. */
+function parseWarmPoolProfile(value: unknown): WarmPoolProfile {
+  return isWarmPoolProfile(value) ? value : 'fixed';
+}
+
+/** Read the profile from either the full config object or its pod section. */
+export function resolveWarmPoolProfile(config: unknown): WarmPoolProfile {
+  if (!config || typeof config !== 'object' || Array.isArray(config)) return 'fixed';
+  const root = config as Record<string, unknown>;
+  const pod = root.pod && typeof root.pod === 'object' && !Array.isArray(root.pod)
+    ? root.pod as Record<string, unknown>
+    : root;
+  const raw = root.raw && typeof root.raw === 'object' && !Array.isArray(root.raw)
+    ? root.raw as Record<string, unknown>
+    : undefined;
+  const rawPod = raw?.pod && typeof raw.pod === 'object' && !Array.isArray(raw.pod)
+    ? raw.pod as Record<string, unknown>
+    : undefined;
+  return parseWarmPoolProfile(pod.warmPoolProfile ?? rawPod?.warmPoolProfile);
+}
+
+/** Physical warm-worker cap for a host and worker memory tier; unknown pairs are unmeasured (0). */
+export function resolveWarmPoolQuota(profile: WarmPoolProfile, host: string, tier: WarmPoolTier): number {
+  if (!isWarmPoolProfile(profile) || !host.trim()) return 0;
+  if (tier === 'lite') return Object.hasOwn(LITE_HOST_MAX, host) ? LITE_HOST_MAX[host] : 0;
+  if (tier === 'standard') return Object.hasOwn(STANDARD_HOST_MAX, host) ? STANDARD_HOST_MAX[host] : 0;
+  return 0;
+}

package/src/self-implement/review-mustfix-class.ts

@@ -113,3 +113,206 @@ export function classifyMustFixRound(
   }
   return { class: 'new-defect', reason: '앞 회차에 없던 새 지적 — 새 실결함 수렴으로 그대로 간다' };
 }
+
+// ── 범위 판정 축 (REVIEW-MUSTFIX-CLASSIFY 첫 조각 · 대표 10-17 19:3x) ──
+//
+// 회차 분류(①②③) 위에 must-fix «한 줄마다» 범위를 가른다:
+//   in-scope   (가) 이 PR 범위 안 — 언급한 파일이 PR 변경 파일·칸 대상 경로 안이고, 쪼갤 신호가 없다 → 고친다.
+//   split      (나) 새 축 — PR 밖 파일 · 다른 PR · 설계 문서 · 다른 자리 결정 · 앞 라운드에 없던 축(r≥3) · ③ recurring
+//                    · ② 착지 뒤 증거(③·② 는 범위 입력·경로와 무관하게 split) → 같은 런에서 고치지 않고 «중간 착지 ⊕ 연결 골»로 뗀다.
+//   ask-owner  (다) 판단 불가 — 신호가 엇갈리거나, 범위 입력(변경 파일·대상 경로)이 없거나, 신호가 하나도 없다 → 칸 주인 HITL.
+// ⛔ 결정적 신호만(이 조각엔 LLM 판정 없음). ⛔ 입력이 없으면 «범위 밖 신호 없음»으로 읽지 않는다 — ask-owner.
+// ⛔ in-scope 는 «긍정 증거»(PR 안 파일 언급)가 있을 때만 — 신호가 없다고 범위 안이 아니다.
+
+export type MustFixScope = 'in-scope' | 'split' | 'ask-owner';
+
+export type MustFixScopeSignal =
+  | 'path-inside' | 'path-outside' | 'other-pr' | 'design-doc' | 'seat-decision'
+  | 'new-axis' | 'recurring' | 'post-land-evidence' | 'no-scope-input' | 'no-signal'
+  /** PR 번호를 언급했지만 이 PR 번호를 모른다 — 자기 번호일 수 있어 other-pr 로 단정하지 않는다. */
+  | 'pr-unknown'
+  /** 대상 경로 밖이지만 PR 변경 파일을 안 쟀다 — 실제 변경 파일일 수 있어 «밖»으로 단정하지 않는다. */
+  | 'path-unmeasured';
+
+export interface MustFixScopeInput {
+  /** PR 변경 파일 목록. undefined = 안 쟀다(빈 배열과 다르다). */
+  readonly changedFiles?: readonly string[];
+  /** 칸·골 대상 경로(hotPaths). undefined = 안 쟀다. */
+  readonly targetPaths?: readonly string[];
+  /** 이 PR 번호 — 자기 번호 언급은 «다른 PR» 이 아니다. */
+  readonly prNumber?: number;
+  /** 리뷰 라운드(1부터). undefined = 안 쟀다 → new-axis 신호를 안 낸다. */
+  readonly reviewRound?: number;
+  /** 앞 라운드 must-fix. undefined = 안 쟀다 → new-axis 신호를 안 낸다. */
+  readonly prevItems?: readonly MustFixItem[];
+  /** 이 회차 ③ recurring 으로 짝지어진 정규화 문면. */
+  readonly recurring?: readonly string[];
+}
+
+export interface MustFixScopeJudgement {
+  readonly text: string;
+  readonly scope: MustFixScope;
+  readonly signals: readonly MustFixScopeSignal[];
+  readonly reason: string;
+  /** 언급한 경로 중 PR 범위 밖인 것 — 연결 골 대상 경로 초안. */
+  readonly outsidePaths?: readonly string[];
+  /** 언급한 경로 중 PR 범위 안인 것. */
+  readonly insidePaths?: readonly string[];
+  /** ② 착지 뒤 증거 종류 — 연결 골 판정선을 시험이 아니라 착지 후 관측으로 낸다. */
+  readonly evidence?: MustFixEvidenceKind;
+}
+
+const SPLIT_SIGNALS: ReadonlySet<MustFixScopeSignal> = new Set([
+  'path-outside', 'other-pr', 'design-doc', 'seat-decision', 'new-axis', 'recurring', 'post-land-evidence',
+]);
+/** «앞 라운드에 없던 축»이 쪼갤 신호가 되는 첫 라운드(대표 규칙 «r3 부터 (나) 먼저 뗀다»). */
+export const NEW_AXIS_SPLIT_FROM_ROUND = 3;
+
+const PATH_RE = /(?:[\w@.-]+\/)+[\w@.-]+\.[A-Za-z]{1,5}\b|\b[\w-]+(?:\.[\w-]+)*\.(?:tsx?|mjs|cjs|jsx?|json|md|ya?ml|sh|py)\b/gu;
+const DESIGN_DOC_RE = /\b(?:RFC|MANUAL|DECISION)[-_\s]/u;
+const SEAT_DECISION_RE = /(?:다른\s*자리|자리\s*결정|대표\s*결정|\u{1F451}|owner\s+decision|another\s+seat)/iu;
+
+function normPath(p: string): string {
+  return p.replace(/^\.\//u, '').replace(/[),.;:]+$/u, '');
+}
+
+/** 경로가 범위 집합 안인가 — 정확 일치 · 디렉터리 접두 · (언급이 파일 이름뿐이면) 파일 이름 일치. */
+function pathInside(mention: string, scope: readonly string[]): boolean {
+  const m = normPath(mention);
+  return scope.some((raw) => {
+    const s = normPath(raw);
+    if (s === m) return true;
+    if (s.endsWith('/') ? m.startsWith(s) : m.startsWith(`${s}/`)) return true;
+    return !m.includes('/') && s.split('/').at(-1) === m;
+  });
+}
+
+/** 단순 토큰 자카드(2자 이상 · 소문자) — 앞 라운드에 없던 축 판정용. */
+export function mustFixTokenJaccard(a: string, b: string): number {
+  const tok = (s: string): Set<string> => new Set(s.toLowerCase().split(/[^\p{L}\p{N}_]+/u).filter((t) => t.length >= 2));
+  const x = tok(a);
+  const y = tok(b);
+  if (x.size === 0 && y.size === 0) return 0;
+  let inter = 0;
+  for (const t of x) if (y.has(t)) inter++;
+  return inter / (x.size + y.size - inter);
+}
+
+export function judgeMustFixScope(item: MustFixItem, input: MustFixScopeInput): MustFixScopeJudgement {
+  const signals: MustFixScopeSignal[] = [];
+  const scopePaths = [...(input.changedFiles ?? []), ...(input.targetPaths ?? [])];
+  const scopeMeasured = input.changedFiles !== undefined || input.targetPaths !== undefined;
+  const mentions = [...new Set((item.text.match(PATH_RE) ?? []).map(normPath))];
+  const insidePaths = scopeMeasured ? mentions.filter((m) => pathInside(m, scopePaths)) : [];
+  const outsidePaths = scopeMeasured ? mentions.filter((m) => !pathInside(m, scopePaths)) : mentions;
+  if (!scopeMeasured) signals.push('no-scope-input');
+  else {
+    if (insidePaths.length) signals.push('path-inside');
+    // 변경 파일을 안 쟀으면 대상 경로 밖이라는 사실만으로 «PR 밖»이 아니다.
+    if (outsidePaths.length) signals.push(input.changedFiles === undefined ? 'path-unmeasured' : 'path-outside');
+  }
+  const prs = [...item.text.matchAll(/#(\d{5})\b/gu)].map((m) => Number(m[1]));
+  if (prs.length > 0 && input.prNumber === undefined) signals.push('pr-unknown');
+  else if (prs.some((n) => n !== input.prNumber)) signals.push('other-pr');
+  if (DESIGN_DOC_RE.test(item.text)) signals.push('design-doc');
+  if (SEAT_DECISION_RE.test(item.text)) signals.push('seat-decision');
+  if (item.evidence !== undefined) signals.push('post-land-evidence');
+  if (input.recurring?.includes(mustFixKey(item.text))) signals.push('recurring');
+  if (input.reviewRound !== undefined && input.reviewRound >= NEW_AXIS_SPLIT_FROM_ROUND
+    && input.prevItems !== undefined && input.prevItems.length > 0
+    && input.prevItems.every((p) => mustFixTokenJaccard(p.text, item.text) === 0)) signals.push('new-axis');
+
+  const split = signals.filter((s) => SPLIT_SIGNALS.has(s));
+  const paths = {
+    ...(outsidePaths.length ? { outsidePaths } : {}),
+    ...(insidePaths.length ? { insidePaths } : {}),
+    ...(item.evidence !== undefined ? { evidence: item.evidence } : {}),
+  };
+  if (signals.includes('recurring')) {
+    return { text: item.text, scope: 'split', signals, reason: '같은 축이 수리 뒤 다시 나왔다 — 같은 런 재수리 대신 연결 골로 뗀다', ...paths };
+  }
+  // ② 착지 뒤 증거는 줄 단위 사실 — 경로가 PR 안이어도 같은 런에서 못 낸다. 회차 분류 ② 와 늘 같은 갈래(split)로 간다.
+  if (signals.includes('post-land-evidence')) {
+    return { text: item.text, scope: 'split', signals, reason: '증거는 착지 뒤에만 난다 — 그림자 착지 → 관측 → live 연결 골로 뗀다', ...paths };
+  }
+  if (signals.includes('path-unmeasured')) {
+    return { text: item.text, scope: 'ask-owner', signals, reason: '대상 경로 밖 경로를 언급했지만 PR 변경 파일을 안 쟀다 — PR 밖인지 못 가린다', ...paths };
+  }
+  if (signals.includes('pr-unknown')) {
+    return { text: item.text, scope: 'ask-owner', signals, reason: 'PR 번호를 언급했는데 이 PR 번호를 모른다 — 다른 PR 인지 못 가린다', ...paths };
+  }
+  if (split.length > 0 && !scopeMeasured) {
+    return { text: item.text, scope: 'ask-owner', signals, reason: `쪼갤 신호(${split.join(' · ')})는 있으나 범위 입력이 없다 — 이 PR 이 이미 맡았는지 못 가린다`, ...paths };
+  }
+  if (split.length > 0 && signals.includes('path-inside')) {
+    return { text: item.text, scope: 'ask-owner', signals, reason: `신호가 엇갈린다 — PR 안 파일 언급 ⊕ 쪼갤 신호(${split.join(' · ')})`, ...paths };
+  }
+  if (split.length > 0) {
+    return { text: item.text, scope: 'split', signals, reason: `이 PR 범위 밖 신호(${split.join(' · ')}) — 중간 착지 ⊕ 연결 골로 뗀다`, ...paths };
+  }
+  if (signals.includes('path-inside')) {
+    return { text: item.text, scope: 'in-scope', signals, reason: '언급한 파일이 PR 범위 안이고 쪼갤 신호가 없다 — 이 PR 에서 고친다', ...paths };
+  }
+  if (scopeMeasured) signals.push('no-signal');
+  return {
+    text: item.text, scope: 'ask-owner', signals,
+    reason: scopeMeasured ? '범위 신호가 하나도 없다 — «없다»를 범위 안으로 읽지 않고 칸 주인에게 묻는다' : '범위 입력(변경 파일·대상 경로)이 없다 — 칸 주인에게 묻는다',
+    ...paths,
+  };
+}
+
+/** (나) split 한 줄의 «중간 착지 ⊕ 연결 골» 제안 — 다음 라운드 intent 스코프 경계 문장 ⊕ 연결 골 초안. */
+export interface MustFixSplitProposal {
+  readonly text: string;
+  /** 다음 라운드 intent «의도적 스코프 경계» 에 넣을 문장(이유 포함). */
+  readonly intentScopeBoundary: string;
+  /** 연결 골 초안 — 대상 경로 ⊕ 판정선 한 줄. targetPaths 가 비면 «대상 경로 미상»(저작 단계에서 채운다). */
+  readonly linkGoal: { readonly targetPaths: readonly string[]; readonly verdictLine: string };
+}
+
+function clip(text: string, n = 120): string {
+  const t = text.trim().replace(/\s+/gu, ' ');
+  return t.length > n ? `${t.slice(0, n - 1)}…` : t;
+}
+
+function testPathFor(path: string): string | undefined {
+  if (/\.test\.tsx?$/u.test(path)) return path;
+  const m = /^(.*)\.(tsx?)$/u.exec(path);
+  return m ? `${m[1]}.test.${m[2]}` : undefined;
+}
+
+const EVIDENCE_OBSERVATION: Record<MustFixEvidenceKind, string> = {
+  'live-caller': 'live 호출자가 실제로 부르는 것',
+  'ops-consumption': '운영이 실제로 소비하는 것',
+  'artifact-landing': '실물이 실제로 착지한 것',
+};
+
+/**
+ * 연결 골 대상 경로는 지적이 «언급한» 경로만 — 원래 골의 hotPaths 를 끌어다 대지 않는다(근거 없음 → 미상, 저작 단계에서 채운다).
+ * ② 착지 뒤 증거는 시험 통과로 증명되지 않으므로 판정선을 «그림자 착지 뒤 관측»으로 낸다.
+ */
+export function proposeMustFixSplit(j: MustFixScopeJudgement): MustFixSplitProposal {
+  const targetPaths = j.outsidePaths?.length ? [...j.outsidePaths] : j.insidePaths?.length ? [...j.insidePaths] : [];
+  const test = targetPaths.map(testPathFor).find((p): p is string => p !== undefined);
+  const subject = clip(j.text, 80);
+  if (j.evidence !== undefined) {
+    return {
+      text: j.text,
+      intentScopeBoundary: `«${subject}» — 미완이 아니라 이 PR 의 결정이다: ${j.reason}(신호 ${j.signals.join(' · ')}). 연결 골로 뗐다 · 이것으로 must-fix 를 만들지 말 것`,
+      linkGoal: {
+        targetPaths,
+        verdictLine: `판정(착지 뒤 관측): 그림자 착지 뒤 ${EVIDENCE_OBSERVATION[j.evidence]}을 로그·원장에서 관측 — 관측 명령은 저작 단계에서 채운다(시험 통과만으로는 증명 아님)`,
+      },
+    };
+  }
+  return {
+    text: j.text,
+    intentScopeBoundary: `«${subject}» — 미완이 아니라 이 PR 의 결정이다: ${j.reason}(신호 ${j.signals.join(' · ')}). 연결 골로 뗐다 · 이것으로 must-fix 를 만들지 말 것`,
+    linkGoal: {
+      targetPaths,
+      verdictLine: test
+        ? `판정: bun test ${test} → «${subject}» 고정 시험 ⊕ 0 fail`
+        : `판정: «${subject}» 해소를 반증 명령 한 줄로 — 대상 경로 ${targetPaths.length ? targetPaths.join(' ') : '미상'}(저작 단계에서 채운다)`,
+    },
+  };
+}

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

@@ -1,4 +1,4 @@
-import { executeClassifyNode } from '../workflow-runtime/nodes/classify.js';
+import { runGraphClassifyNode } from '../graph-runner/runner.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';
@@ -155,13 +155,10 @@ export function createReworkBudgetJudgment(callLLM: WorkflowDeps['callLLM'], opt
     };
     let modelReasoning = '';
     let premiseReview: PremiseReviewCard | undefined;
-    const result = await executeClassifyNode(node, execContext, {
-      callLLM: async (args) => {
-        modelReasoning = await callLLM(args);
-        return modelReasoning;
-      },
-      runBash: async () => ({ stdout: '', stderr: '', exitCode: 0 }),
-    });
+    const result = await runGraphClassifyNode(node, execContext, async (args) => {
+      modelReasoning = await callLLM(args);
+      return modelReasoning;
+    }, { caller: 'rework-budget-judgment' });
     const evidence = (): ReworkBudgetEvidence => ({
       observations,
       modelReasoning,

package/src/self-implement/run-stop.ts

@@ -11,23 +11,30 @@
  */
 import { debug } from '../debug/log.js';
 import { appendRunLedgerEntry, type RunLedgerEntry, type RunLedgerWriter, type RunShardIdentity } from './run-ledger.js';
+import type { PodChildEvidence } from '../task-orchestrator/surfaces/self-implement.js';
 
 /** 닫힌 목록 — 못 고르면 `unclassified`. */
 export const RUN_STOP_CLASSES = [
   'env-unrelated', 'main-sync', 'pod-died', 'review-repeat',
-  'review-out-of-scope', 'evidence-uncovered', 'fabric', 'launch-failed', 'gate-failed', 'unclassified',
+  'review-out-of-scope', 'scope-escape', 'evidence-uncovered', 'fabric', 'launch-failed', 'gate-failed', 'unclassified',
 ] as const;
 export type RunStopClass = typeof RUN_STOP_CLASSES[number];
 
 /** 런 원장 `event='stop'` 줄의 `data` 모양(STOP-AUTOHEAL 이 소비한다). */
 export interface RunStopRecord {
   class: RunStopClass;
+  /** Last known stop site; absent in older ledger rows. */
+  site?: string;
   /** 한 줄 · ≤120자 · 결정 라벨(원 로그 꼬리 금지). */
   cause: string;
   /** 근거 위치 — PR URL · `run-ledger:<runId>:<event>` · 파일 경로. */
   evidenceRef: string;
   /** 다음 한 수(사람·힐러가 읽는다). */
   nextMove: string;
+  /** Facts from the complete child JSON, lifted before the Pod stdout tail is shortened. */
+  childEvidence?: PodChildEvidence;
+  /** Exact structured Pod error code, when the host received one. */
+  terminationReason?: 'pod-job-failed';
 }
 
 export const RUN_STOP_EVENT = 'stop';
@@ -44,6 +51,8 @@ export interface RunStopInput {
   nextMove: string;
   /** 관측용 — 어느 자리가 불렀나(merge-hold · implement-aborted · draft-pr-open-failed · pod-exit · launch-failed). */
   site?: string;
+  childEvidence?: PodChildEvidence;
+  terminationReason?: 'pod-job-failed';
 }
 
 export function isRunStopClass(value: unknown): value is RunStopClass {
@@ -96,9 +105,12 @@ export function forgetRunStop(runId: string): void {
 export function recordRunStop(input: RunStopInput, write: RunLedgerWriter = appendRunLedgerEntry): RunLedgerEntry {
   const record: RunStopRecord = {
     class: isRunStopClass(input.class) ? input.class : 'unclassified',
+    ...(input.site ? { site: input.site } : {}),
     cause: boundRunStopCause(input.cause),
     evidenceRef: input.evidenceRef,
     nextMove: input.nextMove,
+    ...(input.childEvidence ? { childEvidence: input.childEvidence } : {}),
+    ...(input.terminationReason ? { terminationReason: input.terminationReason } : {}),
   };
   const entry: RunLedgerEntry = {
     timestamp: new Date().toISOString(), runId: input.runId, event: RUN_STOP_EVENT,
@@ -120,5 +132,8 @@ export function readRunStopRecord(entry: RunLedgerEntry): RunStopRecord | undefi
   if (entry.event !== RUN_STOP_EVENT) return undefined;
   const data = entry.data as Partial<RunStopRecord>;
   if (typeof data.cause !== 'string' || typeof data.evidenceRef !== 'string' || typeof data.nextMove !== 'string') return undefined;
-  return { class: isRunStopClass(data.class) ? data.class : 'unclassified', cause: data.cause, evidenceRef: data.evidenceRef, nextMove: data.nextMove };
+  return { class: isRunStopClass(data.class) ? data.class : 'unclassified', cause: data.cause, evidenceRef: data.evidenceRef, nextMove: data.nextMove,
+    ...(typeof data.site === 'string' ? { site: data.site } : {}),
+    ...(data.childEvidence ? { childEvidence: data.childEvidence } : {}),
+    ...(data.terminationReason === 'pod-job-failed' ? { terminationReason: data.terminationReason } : {}) };
 }

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

@@ -424,6 +424,34 @@ export function assessRunningRuns(
   return { ...(partial ? { completeness: 'partial' as const, unreadable, count: { count: null, lowerBound: counts.running + counts['probable-running'], unreadable } } : {}), entries, counts, total, countedStatuses, quantities: quantitySummary({ entries, counts, total, countedStatuses, observation }), observation, lingeringLaunchParents: { observation: 'indeterminate' }, ledger: { ledgerDirectories: [], unreadableLedgerCount: ledgerObservation.unreadableLedgerCount, unreadableLedgerDirectoryCount: ledgerObservation.unreadableLedgerDirectoryCount, missingLedgerDirectoryCount: ledgerObservation.missingLedgerDirectoryCount, unreadableLedgerDirectoryAccessCount: ledgerObservation.unreadableLedgerDirectoryAccessCount, indeterminateLedgerDirectoryCount: ledgerObservation.indeterminateLedgerDirectoryCount }, pty: { unreadable: [...pty.unreadable], observedRefCount: pty.refs.length, withoutRunIdCount, notCountedRefCount }, phases: { targetCount: 0, readableTargetCount: 0, unreadableTargetCount: 0, unreadableTargets: [], discardedNonStageEventCount: 0 } };
 }
 
+/** A legacy state alias can point at the same physical ledger. Keep missing or unreadable
+ * directories in the query so they still contribute an incomplete-observation signal. */
+type LedgerDirectoryIdentity = { dev: bigint; ino: bigint; isDirectory(): boolean };
+
+export function distinctPhysicalLedgerDirectories(
+  directories: readonly string[],
+  statDirectory: (directory: string) => LedgerDirectoryIdentity = (directory) => statSync(directory, { bigint: true }),
+): string[] {
+  const seen = new Map<string, string>();
+  const distinct: string[] = [];
+  for (const directory of directories) {
+    try {
+      const stat = statDirectory(directory);
+      if (stat.isDirectory()) {
+        const identity = `${stat.dev}:${stat.ino}`;
+        const first = seen.get(identity);
+        if (first !== undefined) {
+          debug.log('self-implement.running-runs', 'ledger-directory-alias', { first, alias: directory });
+          continue;
+        }
+        seen.set(identity, directory);
+      }
+    } catch { /* Preserve this target for the federated query's missing/unreadable judgment. */ }
+    distinct.push(directory);
+  }
+  return distinct;
+}
+
 export function queryRunningRuns(options: { includeTest?: boolean; runIds?: readonly string[]; caller?: string; noCache?: boolean } = {}, deps: RunningRunsQueryDeps = {}): QueriedRunningRunsResult {
   const directoryFailures = new Map<string, ReturnType<typeof classifyFederatedLedgerDirectoryReadFailure>>();
   const queryLedgers = deps.queryLedgers ?? ((queryOptions: Parameters<typeof queryFederatedUnfinishedRunLedgers>[0]) => queryFederatedUnfinishedRunLedgers({
@@ -466,7 +494,7 @@ export function queryRunningRuns(options: { includeTest?: boolean; runIds?: read
     if (collectLedgerDirectories) {
       const ledgerDirectoryCollectionStartedAt = Date.now();
       try {
-        collectedLedgerDirectories = ledgerDirectories({ includeTest: options.includeTest });
+        collectedLedgerDirectories = distinctPhysicalLedgerDirectories(ledgerDirectories({ includeTest: options.includeTest }));
       } finally {
         ledgerDirectoryCollectionElapsedMs = Date.now() - ledgerDirectoryCollectionStartedAt;
       }

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

@@ -21,3 +21,116 @@ export function classifyOutOfScope(outsideFiles: readonly string[], declaredPath
   for (const file of outsideFiles) (folders.has(dirOf(normalize(file))) ? adjacent : other).push(file);
   return { adjacent, other };
 }
+
+// SCOPE-AS-DIRECTION (0.2.35 · 대표 10-21 «골은 방향·원칙·KPI 를 정하고 구현은 적응한다 — 파일 단위 마이크로 관리는 틀렸다»).
+// 10-20: 13 runs held with PR 0; half of the crossed files were necessary wiring (CLI registration, production callers,
+// ledger files). Target paths are now the starting point: outside edits are accepted, named with a kind, and handed to
+// the reviewer in the PR body. Only a deletion, a protected path, or an outside count over the cap stops the run.
+
+export type ScopeExpansionKind = 'neighbour' | 'caller-or-registration' | 'paired-test' | 'other';
+export interface ScopeExpansionFile { path: string; kind: ScopeExpansionKind }
+export interface ScopeExpansion { files: ScopeExpansionFile[]; count: number }
+export type ScopeStopReason = 'deletion' | 'protected-path' | 'over-cap' | 'name-cap';
+
+/** Accepted outside files above this count stop the run: past it the change is no longer «the goal, adapted». */
+export const SCOPE_EXPANSION_CAP = 10;
+
+const TEST_FILE = /\.(test|spec)\.[cm]?[jt]sx?$/;
+const CODE_EXT = /\.(?:[cm]?[jt]sx?)$/;
+const baseOf = (path: string): string => path.slice(path.lastIndexOf('/') + 1);
+const stemOf = (path: string): string => baseOf(path).replace(TEST_FILE, '').replace(/\.[^.]+$/, '');
+const withoutCodeExt = (path: string): string => path.replace(CODE_EXT, '');
+
+/** Paths an unattended run never edits on its own: rules, anything credential-like, production elanous config. */
+export function isProtectedScopePath(path: string): boolean {
+  const p = normalize(path);
+  if (p === '.rules' || p.startsWith('.rules/')) return true;
+  if (/credential|secret/i.test(p)) return true;
+  const base = baseOf(p);
+  if (base === 'auth.json' || base === '.env' || base.startsWith('.env.')) return true;
+  return /(^|\/)\.elanous[^/]*\/(.*\/)?config\.json$/.test(p);
+}
+
+function resolveRelative(fromFile: string, spec: string): string {
+  const parts = dirOf(fromFile) ? dirOf(fromFile).split('/') : [];
+  for (const seg of spec.split('/')) {
+    if (seg === '.' || seg === '') continue;
+    if (seg === '..') parts.pop(); else parts.push(seg);
+  }
+  return parts.join('/');
+}
+
+const escapeRegExp = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/** Name each outside file's relation to the declared targets. Deterministic: path shape and plain text only.
+ *  Order of kinds: paired-test → neighbour (same folder as a declared file) → caller-or-registration (index.ts,
+ *  *-cli.ts, imports a declared file, or names an exported symbol of one) → other. `readFile` is relative to the tree. */
+export function classifyScopeExpansion(
+  outsideFiles: readonly string[], declaredPaths: readonly string[], readFile: (path: string) => string | undefined = () => undefined,
+): ScopeExpansionFile[] {
+  const declared = declaredPaths.map(normalize);
+  const adjacentSet = new Set(classifyOutOfScope(outsideFiles, declaredPaths).adjacent);
+  const declaredFiles = declared.filter(path => /\.[A-Za-z0-9]+$/.test(baseOf(path)));
+  const declaredModules = new Set(declaredFiles.filter(path => CODE_EXT.test(path)).map(withoutCodeExt));
+  const pairStems = new Set([...declaredFiles, ...outsideFiles.map(normalize).filter(path => !TEST_FILE.test(path))].map(stemOf));
+  const exportedNames: string[] = [];
+  for (const file of declaredFiles) {
+    let text: string | undefined;
+    try { text = readFile(file); } catch { text = undefined; }
+    if (!text) continue;
+    for (const match of text.matchAll(/export\s+(?:default\s+)?(?:async\s+)?(?:function\*?|const|let|var|class|interface|type|enum)\s+([A-Za-z_$][\w$]*)/g)) {
+      if (match[1]!.length >= 4 && !exportedNames.includes(match[1]!)) exportedNames.push(match[1]!);
+    }
+  }
+  const namePatterns = exportedNames.map(name => new RegExp(`(^|[^\\w$])${escapeRegExp(name)}([^\\w$]|$)`));
+  const callsDeclared = (file: string): boolean => {
+    let text: string | undefined;
+    try { text = readFile(file); } catch { text = undefined; }
+    if (!text) return false;
+    for (const match of text.matchAll(/(?:from\s+|import\s*\(\s*|require\s*\(\s*|import\s+)['"]([^'"]+)['"]/g)) {
+      const spec = match[1]!;
+      if (spec.startsWith('.') && declaredModules.has(withoutCodeExt(resolveRelative(file, spec)))) return true;
+    }
+    return namePatterns.some(pattern => pattern.test(text!));
+  };
+  return outsideFiles.map(path => {
+    const p = normalize(path);
+    const base = baseOf(p);
+    const kind: ScopeExpansionKind = TEST_FILE.test(p) && pairStems.has(stemOf(p)) ? 'paired-test'
+      : adjacentSet.has(path) ? 'neighbour'
+      : /^index\.[cm]?[jt]sx?$/.test(base) || /-cli\.[cm]?[jt]sx?$/.test(base) || callsDeclared(p) ? 'caller-or-registration'
+      : 'other';
+    return { path, kind };
+  });
+}
+
+export type ScopeExpansionDecision =
+  | { accept: true; expansion: ScopeExpansion }
+  | { accept: false; reasons: ScopeStopReason[]; deleted: string[]; protectedPaths: string[]; expansion: ScopeExpansion };
+
+/** Accept outside edits by default; stop only on a deletion, a protected path, a count over the cap, or an
+ *  incomplete name list (the guard cannot judge files it did not see). */
+export function decideScopeExpansion(input: {
+  outsideFiles: readonly string[]; declaredPaths: readonly string[]; deleted: readonly string[]; nameCapReached: boolean;
+  cap?: number; readFile?: (path: string) => string | undefined;
+}): ScopeExpansionDecision {
+  const files = classifyScopeExpansion(input.outsideFiles, input.declaredPaths, input.readFile);
+  const expansion: ScopeExpansion = { files, count: files.length };
+  const protectedPaths = input.outsideFiles.filter(isProtectedScopePath);
+  const reasons: ScopeStopReason[] = [];
+  if (input.deleted.length) reasons.push('deletion');
+  if (protectedPaths.length) reasons.push('protected-path');
+  if (files.length > (input.cap ?? SCOPE_EXPANSION_CAP)) reasons.push('over-cap');
+  if (input.nameCapReached) reasons.push('name-cap');
+  return reasons.length ? { accept: false, reasons, deleted: [...input.deleted], protectedPaths, expansion } : { accept: true, expansion };
+}
+
+/** PR body section for the reviewer: each accepted outside file with its kind, judged against the goal's direction. */
+export function renderScopeExpansionSection(expansion: ScopeExpansion | undefined): string {
+  if (!expansion || expansion.files.length === 0) return '';
+  return [
+    '', '', `## 범위 확장 (${expansion.count})`,
+    '대상 경로는 출발점이다 — 아래 파일은 대상 밖에서 바뀌었고 자동으로 받아들였다. 골의 방향·원칙·KPI 에 비춰 판단해 달라.',
+    ...expansion.files.map(file => `- \`${file.path}\` — ${file.kind}`),
+  ].join('\n');
+}