elanous 0.2.34 → 0.2.35

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

@@ -23,6 +23,8 @@ 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>` · 파일 경로. */
@@ -31,6 +33,8 @@ export interface RunStopRecord {
   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';
@@ -48,6 +52,7 @@ export interface RunStopInput {
   /** 관측용 — 어느 자리가 불렀나(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 {
@@ -100,10 +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,
@@ -126,5 +133,7 @@ export function readRunStopRecord(entry: RunLedgerEntry): RunStopRecord | undefi
   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,
-    ...(data.childEvidence ? { childEvidence: data.childEvidence } : {}) };
+    ...(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');
+}

package/src/self-implement/seams.ts

@@ -1260,11 +1260,126 @@ type DefaultSeamsDiagnoseInput = Omit<Parameters<NonNullable<SelfImplementSeams[
   kind: SupervisionReworkSource;
 };
 
-type DefaultSeamsResult = Omit<SelfImplementSeams, 'diagnose'> & {
+/** 같은 칸 카드 재결속 사유 — debug.log `same-cell-card-rebind-<reason>` 이름과 1:1 로 대응한다. */
+export type SameCellCardRebindReason =
+  | 'card-id-absent'
+  | 'card-store-absent'
+  | 'card-missing'
+  | 'manual-ref'
+  | 'bound-other-pr'
+  | 'already-rebound'
+  | 'rebound'
+  | 'card-store-unreadable';
+
+/** openPr 반환이 싣는 재결속 관측 — `deferred` 면 PR 은 열렸고 카드 결속은 부모 pr-terminal(#29948) 몫이다. */
+export interface SameCellCardRebindObservation {
+  outcome: 'rebound' | 'already-rebound' | 'deferred';
+  reason: SameCellCardRebindReason;
+  cardId: string | null;
+  oldPr: number;
+  newPr: number;
+  boundPr?: number;
+  detail?: string;
+}
+
+export type OpenPrOutcome = { url: string; number: number; rebind?: SameCellCardRebindObservation };
+
+type DefaultSeamsResult = Omit<SelfImplementSeams, 'diagnose' | 'openPr'> & {
   diagnose: (ctx: DefaultSeamsDiagnoseInput) => Promise<string>;
   closePr: (prUrl: string, comment?: string) => boolean;
+  openPr: (input: Parameters<NonNullable<SelfImplementSeams['openPr']>>[0]) => Promise<OpenPrOutcome>;
 };
 
+type SameCellRebindDecision =
+  | { kind: 'rebound' }
+  | { kind: 'already-rebound' }
+  | { kind: 'card-missing' }
+  | { kind: 'manual-ref' }
+  | { kind: 'bound-other-pr'; boundPr: number };
+
+type SameCellRebindExtra = { boundPr?: number; detail?: string };
+
+/** 같은 칸 새 draft 뒤 카드 재결속 — 사유를 다섯 갈래로 나눠 남기고, 카드 저장소가 없는 실행은 던지지 않고
+ *  deferred 로 돌려준다(Pod 자식은 본부 카드 저장소가 없다 · 부모 pr-terminal 결속은 #29948 이 맡는다). */
+function rebindSameCellCardToPr(input: {
+  taskCardId: string | undefined;
+  storePath: string;
+  oldPr: number;
+  newPr: number;
+  url: string;
+}): SameCellCardRebindObservation {
+  const cardId = input.taskCardId ?? null;
+  const base = { cardId, oldPr: input.oldPr, newPr: input.newPr, url: input.url };
+  const observe = (reason: SameCellCardRebindReason, extra: SameCellRebindExtra = {}, level: 'info' | 'warn' = 'info'): void => {
+    debug.log('self-implement.pr', `same-cell-card-rebind-${reason}`, { ...base, ...extra }, { level });
+  };
+  const deferred = (reason: SameCellCardRebindReason, extra: SameCellRebindExtra = {}): SameCellCardRebindObservation => {
+    observe(reason, extra, 'warn');
+    debug.log('self-implement.pr', 'same-cell-card-rebind-deferred', { ...base, ...extra, reason }, { level: 'warn' });
+    return { outcome: 'deferred', reason, cardId, oldPr: input.oldPr, newPr: input.newPr, ...extra };
+  };
+  const failed = (reason: SameCellCardRebindReason, extra: SameCellRebindExtra = {}): never => {
+    const reasonText = reason === 'bound-other-pr' ? `bound-other-pr(${String(extra.boundPr)})` : reason;
+    observe(reason, extra, 'warn');
+    debug.log('self-implement.pr', 'same-cell-card-rebind-failed', { ...base, ...extra, reason }, { level: 'warn' });
+    throw new Error(`same-cell 새 draft ${input.url} 개설됨; 카드 재결속 실패(${reasonText}) — 새 PR 수확 필요`);
+  };
+  if (!input.taskCardId) return deferred('card-id-absent');
+  if (!existsSync(input.storePath)) return deferred('card-store-absent');
+  let decision: SameCellRebindDecision | undefined;
+  let updated: ReturnType<typeof updateTaskCard>;
+  try {
+    updated = updateTaskCard(input.storePath, input.taskCardId, (card) => {
+      if (!card) {
+        decision = { kind: 'card-missing' };
+        return undefined;
+      }
+      if (card.refSource === 'manual') {
+        decision = { kind: 'manual-ref' };
+        return undefined;
+      }
+      const currentPr = cardPrNumber(card);
+      if (currentPr !== undefined && currentPr !== input.oldPr && currentPr !== input.newPr) {
+        decision = { kind: 'bound-other-pr', boundPr: currentPr };
+        return undefined;
+      }
+      if (currentPr === input.newPr && card.history.some((event) => event.event === 'same-cell-pr-rebound' && event.pr === input.newPr)) {
+        decision = { kind: 'already-rebound' };
+        return undefined;
+      }
+      decision = { kind: 'rebound' };
+      return {
+        ...card,
+        pr: { number: input.newPr, url: input.url },
+        history: [...card.history, {
+          at: new Date().toISOString(), event: 'same-cell-pr-rebound', pr: input.newPr,
+          detail: `이전 draft #${input.oldPr} 정리 후속 · 새 PR #${input.newPr} 결속`,
+        }],
+      };
+    });
+  } catch (error) {
+    return failed('card-store-unreadable', { detail: error instanceof Error ? error.message : String(error) });
+  }
+  const decided: SameCellRebindDecision = decision ?? { kind: 'card-missing' };
+  switch (decided.kind) {
+    case 'bound-other-pr':
+      return failed('bound-other-pr', { boundPr: decided.boundPr });
+    case 'manual-ref':
+      return failed('manual-ref');
+    case 'card-missing':
+      return deferred('card-missing');
+    case 'already-rebound':
+      observe('already-rebound');
+      return { outcome: 'already-rebound', reason: 'already-rebound', cardId, oldPr: input.oldPr, newPr: input.newPr };
+    case 'rebound':
+      if (!updated || cardPrNumber(updated) !== input.newPr) {
+        return failed('card-store-unreadable', { detail: '카드 갱신 결과가 새 PR 을 가리키지 않는다' });
+      }
+      observe('rebound');
+      return { outcome: 'rebound', reason: 'rebound', cardId, oldPr: input.oldPr, newPr: input.newPr };
+  }
+}
+
 const GOAL_DESCRIPTION_MAX_CHARS = 250;
 const DEFAULT_GOAL_SUMMARY_TIMEOUT_MS = 10_000;
 
@@ -2492,14 +2607,16 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
     // ⛔ await 한다 — spawn 실패를 삼키면 발사 실패도 `salvage:'launched'` 로 거짓 관측된다(3차 M4).
     launchReworkSalvage: async (input) => { await launchReworkSalvage(input); },
 
-    openPr: async ({ title, body, head, base, draft, labels, cwd }) => {
+    openPr: async ({ title, body, head, base, draft, labels, cwd, runId }) => {
       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 prRunId = runId ?? getHarnessRunId();
       const outcome = (o.prManager ?? makePrManager()).upsertPr({
         branch: head,
+        ...(prRunId ? { runId: prRunId } : {}),
         worktreePath: cwd,
         title,
         body: buildPrBody(cwd, bodyWithCard),
@@ -2515,34 +2632,18 @@ 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);
+      let rebind: SameCellCardRebindObservation | undefined;
       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 결속 충돌');
+        rebind = rebindSameCellCardToPr({
+          taskCardId, storePath: taskAgentStatePath(), oldPr: outcome.supersededPr, newPr: number, url: outcome.url,
+        });
       }
-      return { url: outcome.url, number: Number.isFinite(number) ? number : 0 };
+      const opened: OpenPrOutcome = { url: outcome.url, number: Number.isFinite(number) ? number : 0, ...(rebind ? { rebind } : {}) };
+      return opened;
     },
 
     // 재발명 0 — PrManager.closePr 시그니처·동작을 그대로 위임한다(mission-lifecycle 이 이미 쓴다).
@@ -2720,6 +2821,8 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       //   소화(C1 Bug2 "replace it with" 자기모순류를 스스로 진단). llmReview(동일 LLM 래퍼) 재사용·fail-soft.
       judgmentCallLLM: async ({ prompt }) => o.llmReview!(prompt),
       classifyCallLLM: async ({ prompt }) => o.llmReview!(prompt),
+      // E1 GOAL-ELABORATE-ON-ARRIVAL — 착수 구체화 카드 작성·판정(같은 LLM 래퍼 · 실패는 카드 없이 진행).
+      elaborateCallLLM: async ({ prompt, systemPrompt }) => o.llmReview!(systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt),
       diagnose: async ({ runId, note, kind, round, goal, history, supervisorDecisionHistory = [], judgePredictionAccuracy: predictionAccuracy, effectiveMax, priorRuns, reviewFindingTelemetry, refutations = [], refutationRound, purpose = 'budget' }: DefaultSeamsDiagnoseInput): Promise<string> => {
         const goalDigest = supervisorGoalDigest(goal, 3000);
         const predictionAccuracyForPrompt = predictionAccuracy

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

@@ -25,11 +25,15 @@
  * 관측 = `debug.log('self-implement.autoheal', …)` ⊕ 원장 `event='autoheal'`.
  */
 import { debug } from '../debug/log.js';
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { withFileLockSync } from '../storage/file-lock.js';
 import { applyGraphOverlays, defaultOverlaysDir, loadGraphOverlays, selectOverlays, type GraphOverlaySpec } from './graph-overlay-yaml.js';
 import type { GraphTemplateSpec } from './graph-yaml.js';
 import { GRAPH_SPECS } from './graph-templates.js';
 import { appendRunLedgerEntry, loadRunLedger, type RunLedgerEntry, type RunLedgerWriter } from './run-ledger.js';
-import type { RunStopClass, RunStopRecord } from './run-stop.js';
+import { boundRunStopCause, type RunStopClass, type RunStopRecord } from './run-stop.js';
 
 export const AUTOHEAL_EVENT = 'autoheal';
 export type AutohealMode = 'shadow' | 'live';
@@ -171,6 +175,80 @@ export interface AutohealDeps {
    * 안 주면 지금과 똑같이 동작한다.
    */
   priorStops?: readonly RunStopRecord[];
+  /** Parent-only candidate store. Omit in pure consumers/tests; the orchestrator supplies its instance root. */
+  knowhowCandidateDir?: string;
+}
+
+export type IntermediateStopReason = 'no-progress' | 'scope-escape' | 'wallclock-cap' | 'pod-job-failed';
+export interface StopKnowhowCandidate {
+  cell: string | null;
+  cellUnknownReason?: string;
+  reason: IntermediateStopReason;
+  stage: string;
+  stageUnknownReason?: string;
+  causeLine: string;
+  nextLaunchChange: string;
+  firstAt: string;
+  lastAt: string;
+  occurrences: number;
+  runIds: string[];
+}
+
+function intermediateStopReason(record: RunStopRecord): IntermediateStopReason | undefined {
+  const termination = record.childEvidence?.terminationReason;
+  if (record.class === 'scope-escape' || record.childEvidence?.scopeEscape === true || termination === 'scope-escape') return 'scope-escape';
+  if (termination === 'wallclock-cap') return 'wallclock-cap';
+  if (termination === 'no-progress') return 'no-progress';
+  if (record.terminationReason === 'pod-job-failed' || termination === 'pod-job-failed') return 'pod-job-failed';
+  return undefined;
+}
+
+const NEXT_LAUNCH_CHANGE: Record<IntermediateStopReason, string> = {
+  'no-progress': '골·완료 경계와 이미 끝난 범위를 다시 확인하고 남은 한 조각으로 고쳐 발사한다.',
+  'scope-escape': '허용 대상 경로와 범위 밖 편집 원문을 대조해 골의 경계를 수정한다.',
+  'wallclock-cap': '실행 시간을 넘긴 단계를 확인해 독립 조각으로 줄이고 중간 산출을 보존한다.',
+  'pod-job-failed': '자식 첫 오류와 Pod 종료 원인을 확인한 뒤 실행 환경 또는 골을 고쳐 발사한다.',
+};
+
+/** One file per cell and reason; the lock makes repeated parent stops one candidate. */
+export function captureStopKnowhowCandidate(ctx: AutohealContext, dir: string, now: () => Date = () => new Date()): { path: string; candidate: StopKnowhowCandidate; created: boolean } | undefined {
+  const reason = intermediateStopReason(ctx.record);
+  if (!reason) return undefined;
+  const cell = ctx.goalId?.trim() || null;
+  const key = createHash('sha256').update(`${cell ?? `unknown:${ctx.runId}`}\0${reason}`).digest('hex');
+  const path = join(dir, `${key}.json`);
+  mkdirSync(dir, { recursive: true });
+  return withFileLockSync(`${path}.lock`, () => {
+    const at = now().toISOString();
+    const old = existsSync(path) ? JSON.parse(readFileSync(path, 'utf8')) as StopKnowhowCandidate : undefined;
+    if (old?.runIds.includes(ctx.runId)) return { path, candidate: old, created: false };
+    const created = old === undefined;
+    const candidate: StopKnowhowCandidate = old ? {
+      ...old,
+      stage: ctx.record.site ?? '미상',
+      ...(ctx.record.site ? { stageUnknownReason: undefined } : { stageUnknownReason: '기존 stop 원장에 site가 기록되지 않음' }),
+      causeLine: boundRunStopCause(String(ctx.record.childEvidence?.detail ?? ctx.record.cause)),
+      lastAt: at,
+      occurrences: old.occurrences + 1,
+      runIds: [...old.runIds, ctx.runId],
+    } : {
+      cell,
+      ...(cell ? {} : { cellUnknownReason: '칸 미상 · stop 호출에 goalId가 전달되지 않음' }),
+      reason,
+      stage: ctx.record.site ?? '미상',
+      ...(ctx.record.site ? {} : { stageUnknownReason: '기존 stop 원장에 site가 기록되지 않음' }),
+      causeLine: boundRunStopCause(String(ctx.record.childEvidence?.detail ?? ctx.record.cause)),
+      nextLaunchChange: NEXT_LAUNCH_CHANGE[reason],
+      firstAt: at,
+      lastAt: at,
+      occurrences: 1,
+      runIds: [ctx.runId],
+    };
+    const temp = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(candidate, null, 2)}\n`, { mode: 0o600 });
+    renameSync(temp, path);
+    return { path, candidate, created };
+  });
 }
 
 /**
@@ -208,6 +286,14 @@ function observe(event: string, data: Record<string, unknown>): void {
  * stop 레코드 하나 → 최대 한 번의 힐 시도. 예외를 던지지 않는다(행동 seam 의 throw 도 needs-owner 로 접는다).
  */
 export async function autohealFromStop(ctx: AutohealContext, deps: AutohealDeps = {}): Promise<AutohealResult> {
+  if (deps.knowhowCandidateDir) {
+    try {
+      const captured = captureStopKnowhowCandidate(ctx, deps.knowhowCandidateDir);
+      if (captured) observe('knowhow-candidate', { runId: ctx.runId, cell: captured.candidate.cell, reason: captured.candidate.reason, created: captured.created, occurrences: captured.candidate.occurrences, path: captured.path });
+    } catch (error) {
+      observe('knowhow-candidate-failed', { runId: ctx.runId, error: error instanceof Error ? error.message : String(error) });
+    }
+  }
   const mode = deps.mode ?? DEFAULT_AUTOHEAL_MODE;
   const cls = ctx.record.class;
   const { action, source, overlayId } = pickAutohealAction(cls, deps.loadLadder);

package/src/session-runtime/index.ts

@@ -689,7 +689,7 @@ const SESSION_RUNTIME_TOOL_FAMILY_RULES: SessionRuntimeToolFamilyRule[] = [
   {
     id: 'ops-ledger',
     description: 'In-process seat messages and release checklist operations.',
-    names: ['msg_list', 'msg_post', 'msg_ack', 'checklist_list', 'checklist_add', 'checklist_set', 'checklist_edit', 'checklist_move'],
+    names: ['msg_list', 'msg_post', 'msg_ask', 'msg_ack', 'checklist_list', 'checklist_add', 'checklist_set', 'checklist_edit', 'checklist_move'],
     match: () => false,
   },
   {

package/src/setup/llm-env-detect.ts

@@ -77,6 +77,11 @@ export const PROVIDER_ENV_SPEC: readonly ProviderEnvSpec[] = [
     primaryKeyEnv: 'OPENROUTER_API_KEY',
     modelEnv: 'OPENROUTER_MODEL',
   },
+  {
+    provider: 'opengateway',
+    primaryKeyEnv: 'OPENGATEWAY_API_KEY',
+    modelEnv: 'OPENGATEWAY_MODEL',
+  },
 ] as const;
 
 export interface ProviderEnvDetection {