elanous 0.2.31 → 0.2.34

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/run-ledger.ts

@@ -1667,9 +1667,9 @@ interface UnfinishedLedgerFacts {
   nonBlocking: NonBlockingRunLedgerRecord | null;
 }
 
-// A full federated scan can exceed 5,000 files; keep the previous scan resident for mtime-checked reuse.
+// A full federated scan can exceed 5,000 files; keep the previous scan resident for stat-checked reuse.
 const UNFINISHED_LEDGER_CACHE_LIMIT = 32_768;
-const unfinishedLedgerCache = new Map<string, { size: number; mtimeMs: number; facts: UnfinishedLedgerFacts }>();
+const unfinishedLedgerCache = new Map<string, { size: number; mtimeMs: number; ctimeMs: number; facts: UnfinishedLedgerFacts }>();
 const unfinishedReaderIds = new WeakMap<RunLedgerReader, number>();
 let nextUnfinishedReaderId = 1;
 
@@ -1686,10 +1686,10 @@ function unfinishedLedgerCacheKey(path: string, read?: RunLedgerReader): string
 // ⭐ 프로세스 간 유효 스캔 색인(칸 CONTEXT-NOW-RUN-SCAN-INDEX).
 //   `/now`(contextNowInWorker)는 요청마다 «새 워커 프로세스»를 띄우므로 위 프로세스 캐시는 매번 빈 채로 시작한다
 //   (실측 2026-10-14: scanned=7893, cacheHits=0, 조회 6.3~8.9초). 색인은 파싱된 파일별 facts 를
-//   원장 옆에 (size, mtimeMs) 스탬프로 저장하고, 스탬프가 같으면 재사용한다. 원장에 무엇이 «붙으면»
-//   스탬프가 바뀌므로 무효화는 자동이다. 읽기 실패는 전부 fail-soft: 색인이 없으면 그냥 새로 읽는다.
+//   원장 옆에 (size, mtimeMs, ctimeMs) 스탬프로 저장하고, 스탬프가 같으면 재사용한다. 원장에 무엇이 «붙으면»
+//   스탬프가 바뀌므로 무효화는 자동이다 (같은 크기로 덮고 mtime 을 되돌려도 ctime 이 바뀐다). 읽기 실패는 전부 fail-soft: 색인이 없으면 그냥 새로 읽는다.
 const RUN_LEDGER_SCAN_INDEX_FILE = '.unfinished-scan-index.json';
-const RUN_LEDGER_SCAN_INDEX_VERSION = 1;
+const RUN_LEDGER_SCAN_INDEX_VERSION = 2;
 const RUN_LEDGER_SCAN_INDEX_LIMIT = 32_768;
 
 /** Where the persisted scan index lives: beside its ledgers, never mistaken for one (readdir filters canonical names). */
@@ -1700,6 +1700,7 @@ export function runLedgerScanIndexPath(dir: string): string {
 export interface RunLedgerScanIndexRecord {
   size: number;
   mtimeMs: number;
+  ctimeMs: number;
   facts: UnfinishedLedgerFacts;
 }
 
@@ -1726,7 +1727,7 @@ function isScanIndexFacts(value: unknown): value is UnfinishedLedgerFacts {
 function isScanIndexRecord(value: unknown): value is RunLedgerScanIndexRecord {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
   const record = value as Record<string, unknown>;
-  return Number.isFinite(record.size) && Number.isFinite(record.mtimeMs) && isScanIndexFacts(record.facts);
+  return Number.isFinite(record.size) && Number.isFinite(record.mtimeMs) && Number.isFinite(record.ctimeMs) && isScanIndexFacts(record.facts);
 }
 
 const scanIndexCache = new Map<string, { stamp: string; entries: Map<string, RunLedgerScanIndexRecord> }>();
@@ -1800,7 +1801,7 @@ function readUnfinishedLedgerFacts(
   const key = noCache ? null : unfinishedLedgerCacheKey(path, read);
   const stamp = noCache ? null : statSync(path);
   const cached = key === null ? undefined : unfinishedLedgerCache.get(key);
-  if (cached && stamp && key !== null && cached.size === stamp.size && cached.mtimeMs === stamp.mtimeMs) {
+  if (cached && stamp && key !== null && cached.size === stamp.size && cached.mtimeMs === stamp.mtimeMs && cached.ctimeMs === stamp.ctimeMs) {
     unfinishedLedgerCache.delete(key);
     unfinishedLedgerCache.set(key, cached);
     return { facts: cached.facts, hit: true, source: 'process' };
@@ -1810,8 +1811,8 @@ function readUnfinishedLedgerFacts(
   //   주입된 reader 는 실제 파일 내용과 무관한 대역이라 색인에 넣지 «도», 색인에서 읽지 «도» 않는다.
   if (index !== undefined && stamp && read === undefined) {
     const record = index.get(runId);
-    if (record && record.size === stamp.size && record.mtimeMs === stamp.mtimeMs) {
-      if (key !== null) unfinishedLedgerCache.set(key, { size: stamp.size, mtimeMs: stamp.mtimeMs, facts: record.facts });
+    if (record && record.size === stamp.size && record.mtimeMs === stamp.mtimeMs && record.ctimeMs === stamp.ctimeMs) {
+      if (key !== null) unfinishedLedgerCache.set(key, { size: stamp.size, mtimeMs: stamp.mtimeMs, ctimeMs: stamp.ctimeMs, facts: record.facts });
       return { facts: record.facts, hit: true, source: 'index' };
     }
   }
@@ -1821,14 +1822,15 @@ function readUnfinishedLedgerFacts(
     const facts = unfinishedLedgerFacts(ledger ?? []);
     if (stamp !== null && key !== null) {
       const after = statSync(path);
-      if (after.size === stamp.size && after.mtimeMs === stamp.mtimeMs) {
-        unfinishedLedgerCache.set(key, { size: stamp.size, mtimeMs: stamp.mtimeMs, facts });
+      if (after.size === stamp.size && after.mtimeMs === stamp.mtimeMs && after.ctimeMs === stamp.ctimeMs) {
+        unfinishedLedgerCache.set(key, { size: stamp.size, mtimeMs: stamp.mtimeMs, ctimeMs: stamp.ctimeMs, facts });
         if (unfinishedLedgerCache.size > UNFINISHED_LEDGER_CACHE_LIMIT) unfinishedLedgerCache.delete(unfinishedLedgerCache.keys().next().value!);
+        // Persist only facts read from a stable ledger; an append during the read must be retried next scan.
+        if (index !== undefined && read === undefined) index.set(runId, { size: stamp.size, mtimeMs: stamp.mtimeMs, ctimeMs: stamp.ctimeMs, facts });
+      } else {
+        index?.delete(runId);
       }
     }
-    if (index !== undefined && stamp !== null && read === undefined) {
-      index.set(runId, { size: stamp.size, mtimeMs: stamp.mtimeMs, facts });
-    }
     return { facts, hit: false, source: 'read' };
   } catch (error) {
     if (key !== null) unfinishedLedgerCache.delete(key);

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

@@ -11,11 +11,12 @@
  */
 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];
 
@@ -28,6 +29,8 @@ export interface RunStopRecord {
   evidenceRef: string;
   /** 다음 한 수(사람·힐러가 읽는다). */
   nextMove: string;
+  /** Facts from the complete child JSON, lifted before the Pod stdout tail is shortened. */
+  childEvidence?: PodChildEvidence;
 }
 
 export const RUN_STOP_EVENT = 'stop';
@@ -44,6 +47,7 @@ export interface RunStopInput {
   nextMove: string;
   /** 관측용 — 어느 자리가 불렀나(merge-hold · implement-aborted · draft-pr-open-failed · pod-exit · launch-failed). */
   site?: string;
+  childEvidence?: PodChildEvidence;
 }
 
 export function isRunStopClass(value: unknown): value is RunStopClass {
@@ -99,6 +103,7 @@ export function recordRunStop(input: RunStopInput, write: RunLedgerWriter = appe
     cause: boundRunStopCause(input.cause),
     evidenceRef: input.evidenceRef,
     nextMove: input.nextMove,
+    ...(input.childEvidence ? { childEvidence: input.childEvidence } : {}),
   };
   const entry: RunLedgerEntry = {
     timestamp: new Date().toISOString(), runId: input.runId, event: RUN_STOP_EVENT,
@@ -120,5 +125,6 @@ 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,
+    ...(data.childEvidence ? { childEvidence: data.childEvidence } : {}) };
 }

package/src/self-implement/seams.ts

@@ -69,6 +69,7 @@ import { stageNonGitDir, stageFile, applyShadowToTarget, applyFileToTarget } fro
 import type { TargetKind } from './target-kind.js';
 import { basename } from 'node:path';
 import { ghAutomationEnv, makePrManager, type PrManager } from '../autopilot/pr-manager.js';
+import { cardPrNumber, taskAgentStatePath, updateTaskCard } from '../task-agent/task-hand.js';
 import { defaultSpawnGh, lookupOpenDraftPrs } from '../cli/logs-abandoned-draft-prs.js';
 import { loadRunLedger, runLedgerDir } from './run-ledger.js';
 import { readdirSync } from 'node:fs';
@@ -2494,11 +2495,14 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
     openPr: async ({ title, body, head, base, draft, labels, cwd }) => {
       const resolvedBase = assertBaseBranchOnOrigin(cwd, base);
       const harnessSeat = process.env.ELANOUS_HARNESS_SEAT;
+      const taskCardId = process.env.ELANOUS_TASK_CARD_ID;
+      const bodyWithCard = taskCardId && /^[A-Za-z0-9][A-Za-z0-9._:-]{2,}$/.test(taskCardId)
+        ? `${body}\n\n카드: ${taskCardId}` : body;
       const outcome = (o.prManager ?? makePrManager()).upsertPr({
         branch: head,
         worktreePath: cwd,
         title,
-        body: buildPrBody(cwd, body),
+        body: buildPrBody(cwd, bodyWithCard),
         commitMessage: title,
         ...(resolvedBase ? { base: resolvedBase } : {}),
         ...(draft !== undefined ? { draft } : {}),
@@ -2511,6 +2515,33 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       });
       if (!outcome.ok) throw new Error(`self-implement PR ${outcome.reason} 실패: ${outcome.detail}`);
       const number = Number.parseInt(outcome.url.match(/\/pull\/(\d+)/)?.[1] ?? '', 10);
+      if (outcome.supersededPr && Number.isSafeInteger(number) && number > 0) {
+        const rebindFailed = (reason: string): never => {
+          debug.log('self-implement.pr', 'same-cell-card-rebind-failed', {
+            cardId: taskCardId ?? null, oldPr: outcome.supersededPr, newPr: number,
+            url: outcome.url, reason,
+          }, { level: 'warn' });
+          throw new Error(`same-cell 새 draft ${outcome.url} 개설됨; 카드 재결속 실패(${reason}) — 새 PR 수확 필요`);
+        };
+        debug.log('self-implement.pr', 'same-cell-rebound', {
+          cardId: taskCardId ?? null, oldPr: outcome.supersededPr, newPr: number, url: outcome.url,
+          oldDraftCleanup: 'deferred',
+        });
+        const cardId = taskCardId ?? rebindFailed('카드 ID 없음');
+        let rebound: ReturnType<typeof updateTaskCard>;
+        try {
+          rebound = updateTaskCard(taskAgentStatePath(), cardId, (card) => {
+            if (!card || card.refSource === 'manual' || (cardPrNumber(card) !== undefined
+              && cardPrNumber(card) !== outcome.supersededPr && cardPrNumber(card) !== number)) return undefined;
+            if (cardPrNumber(card) === number && card.history.some((event) => event.event === 'same-cell-pr-rebound' && event.pr === number)) return undefined;
+            return { ...card, pr: { number, url: outcome.url }, history: [...card.history, {
+              at: new Date().toISOString(), event: 'same-cell-pr-rebound', pr: number,
+              detail: `이전 draft #${outcome.supersededPr} 정리 후속 · 새 PR #${number} 결속`,
+            }] };
+          });
+        } catch (error) { rebindFailed(error instanceof Error ? error.message : String(error)); }
+        if (!rebound || cardPrNumber(rebound) !== number) rebindFailed('카드 없음 또는 기존 PR 결속 충돌');
+      }
       return { url: outcome.url, number: Number.isFinite(number) ? number : 0 };
     },
 

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

@@ -13,7 +13,7 @@
  *   main-sync          → rebase-regate            리베이스(MERGE-INTENT-RESOLVE 의도 해석) 뒤 재게이트
  *   pod-died           → resume-from-salvage      `salvage/run-<6hex>/<leaf>` 가지에서 resume(DRAFT-NOT-ARCHIVE)
  *   evidence-uncovered → derive-evidence-rejudge  런 출력·시험·배선에서 증거를 끌어내 1회 재판정
- *   review-repeat · review-out-of-scope · fabric · launch-failed · gate-failed · unclassified → needs-owner(새 라운드 없음)
+ *   review-repeat · review-out-of-scope · scope-escape · fabric · launch-failed · gate-failed · unclassified → needs-owner(새 라운드 없음)
  *
  * 사다리의 «출처»: `graphs/overlays/stop-heal-ladder.yaml` 이 갈래마다 처방 노드(id = 처방 이름)를 선언한다.
  *    그 갈래에 얹힌 오버레이가 더한 노드 id 가 처방이다(source='graph'). 선언이 없거나 못 읽으면
@@ -50,6 +50,7 @@ export const AUTOHEAL_ACTION_BY_CLASS: Readonly<Record<RunStopClass, AutohealAct
   'evidence-uncovered': 'derive-evidence-rejudge',
   'review-repeat': 'needs-owner',
   'review-out-of-scope': 'needs-owner',
+  'scope-escape': 'needs-owner',
   fabric: 'needs-owner',
   'launch-failed': 'needs-owner',
   'gate-failed': 'needs-owner',
@@ -164,6 +165,12 @@ export interface AutohealDeps {
   writeLedger?: RunLedgerWriter;
   /** 사다리 선언 읽기 — 기본은 활성 템플릿 ⊕ `graphs/overlays`. 던지면 코드 표로 간다. */
   loadLadder?: () => AutohealLadder;
+  /**
+   * 같은 골·칸의 «앞 런» stop 레코드(원장 줄은 `readRunStopRecord` 로 읽는다).
+   * 같은 갈래(class)의 멈춤이 반복되면 자동 재시도를 하지 않고 사유를 골 되먹임 대상으로 넘긴다.
+   * 안 주면 지금과 똑같이 동작한다.
+   */
+  priorStops?: readonly RunStopRecord[];
 }
 
 /**
@@ -184,6 +191,15 @@ export function autohealAlreadyAttempted(ledger: readonly RunLedgerEntry[] | nul
   return ledger.some((e) => e.event === AUTOHEAL_EVENT && e.data?.class === cls && e.data?.mode === mode);
 }
 
+/**
+ * 반복 멈춤 가드 — 앞 런의 stop 레코드 중 같은 갈래(class)가 `threshold` 이상이면 참.
+ * 같은 골에서 같은 갈래가 반복되면 자동 재시도를 끊고 사유를 골 되먹임 대상으로 넘긴다.
+ */
+export function repeatedStop(prior: readonly RunStopRecord[] | undefined, record: RunStopRecord, threshold = 2): boolean {
+  if (!prior) return false;
+  return prior.filter((p) => p.class === record.class).length >= threshold;
+}
+
 function observe(event: string, data: Record<string, unknown>): void {
   try { debug.log('self-implement.autoheal', event, data); } catch { /* observation is fail-soft */ }
 }
@@ -197,6 +213,14 @@ export async function autohealFromStop(ctx: AutohealContext, deps: AutohealDeps
   const { action, source, overlayId } = pickAutohealAction(cls, deps.loadLadder);
   const base = { runId: ctx.runId, class: cls, action, source, ...(overlayId ? { overlayId } : {}), mode };
 
+  if (repeatedStop(deps.priorStops, ctx.record)) {
+    // ⛔ 같은 골에서 같은 갈래의 멈춤이 반복되면 자동 재시도를 하지 않는다 — 사유를 골 되먹임 대상으로 넘긴다.
+    const n = deps.priorStops!.filter((p) => p.class === cls).length;
+    const reason = `repeat-stop: ${cls} ×${n} — feed back to goal: ${ctx.record.cause}`;
+    observe('repeat-stop', { ...base, reason });
+    return { ...base, outcome: 'needs-owner', reason };
+  }
+
   let ledger: readonly RunLedgerEntry[] | null = null;
   try {
     ledger = (deps.loadLedger ?? ((id) => loadRunLedger(id)))(ctx.runId);

package/src/session/chat.ts

@@ -42,6 +42,8 @@ import {
 // chat 툴루프를 canonical 엔진(runGoalLoop→runCoreTurn→streamLLMWithTools)으로 라우팅.
 // ACP bridge(core-turn-bridge.ts)·dashboard(runGoalLoopHook)와 동일 엔진 재사용(재발명 제거).
 import { runGoalLoop, type CoreTurnContext, type CoreTurnDispatchTool } from '../core-turn/index.js';
+import { composeChildContext, type ChildContextProfile } from '../self-implement/child-context-composition.js';
+import { getHarnessSpace } from '../harness/harness-space.js';
 
 export interface RunTurnOpts {
   userConfig: UserConfig;
@@ -272,6 +274,10 @@ export function buildRecentToolObservations(
   return `[직전 턴에 네가 실행한 도구와 결과 (참고용 컨텍스트) — 이어서 교정·판단할 때 근거로 삼되, 사용자가 이 원문을 봤다고 가정하지 말 것]\n${body}`;
 }
 
+/** CHILD-CONTEXT-BUDGET — 세션별 첫 goal-loop 턴 계측 1회 플래그(모듈 인메모리 —
+ * 원장·세션 저장소 형식은 무변경). 키: runTurn sessionId. */
+const childContextComposedSessions = new Set<string>();
+
 /** Run one conversational turn, persisting both sides to the session
  *  JSONL. Never throws on LLM failure — reraises with context. */
 export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
@@ -435,6 +441,27 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     const goalLoopCfg = opts.userConfig.llm.goalLoop;
     const armGoalLoop = opts.goalLoop === true || goalLoopCfg?.enabled === true;
     if (armGoalLoop) {
+      // ⭐ CHILD-CONTEXT-BUDGET(0.2.35 칸) — 구현 자식(self-implement 공간)의 첫 goal-loop
+      //    턴에서 실제 effectiveSystemPrompt·turnTools 스키마·userText(골)의 구성 바이트를
+      //    composeChildContext 로 계측해 child.context-composition 사건 1회로 남긴다.
+      //    관측 전용 — 프롬프트·메시지는 무변경, 계측이 턴을 깨지 않는다(fail-open).
+      //    게이트: harness-space SSOT 로 구현 자식만 판별(getHarnessSpace().kind === 'self-implement')·
+      //    세션 첫 goal-loop 무장 턴 1회(모듈 인메모리 플래그 — 원장·세션 저장소는 무변경).
+      //    profile 은 자식 프롬프트 예산 신호(ELANOUS_PROMPT_BUDGET=lean — local 자식 스폰 시 주입)에서
+      //    실측 파생한다: lean → small(32k 바이트 상한), 아니면 default(무상한).
+      const isSelfImplementChild = getHarnessSpace()?.kind === 'self-implement';
+      if (isSelfImplementChild && !childContextComposedSessions.has(opts.sessionId)) {
+        childContextComposedSessions.add(opts.sessionId);
+        const childContextProfile: ChildContextProfile
+          = process.env.ELANOUS_PROMPT_BUDGET?.trim() === 'lean' ? 'small' : 'default';
+        try {
+          composeChildContext({
+            systemPrompt: effectiveSystemPrompt,
+            toolSchemas: JSON.stringify(turnTools),
+            goal: opts.userText,
+          }, { profile: childContextProfile });
+        } catch { /* 계측은 턴을 깨지 않는다 */ }
+      }
       const coreCtx: CoreTurnContext = {
         sessionId: opts.sessionId,
         // ⭐ 이 턴의 «사람 문장» 운반자. 없으면 표면 판정이 늘 기본값으로 떨어진다