elanous 0.2.0 → 0.2.4

package/src/self-dev/run-supervisor.ts

@@ -4,6 +4,7 @@ import { hasDelivered, triageRun, type FailureClassification } from './orchestra
 import type { DeployVerifyFinding } from '../harness/browser-verify.js';
 import type { SelfDevJobResult } from './orchestrate.js';
 import { recordSelfDevRunSupervisorStop, selfDevRunsDir } from './run-store.js';
+import { debug } from '../debug/log.js';
 
 export interface SupervisorRound {
   round: number;
@@ -20,6 +21,7 @@ export type SupervisorStopReason =
   | 'parent-signals-red'
   | 'needs-human'
   | 'no-actionable-work'
+  | 'handed-off-to-salvage'
   | 'max-rounds'
   | 'no-progress'
   | 'provider-exhausted'
@@ -36,6 +38,7 @@ export const SUPERVISOR_STOP_REASONS = [
   'parent-signals-red',
   'needs-human',
   'no-actionable-work',
+  'handed-off-to-salvage',
   'max-rounds',
   'no-progress',
   'provider-exhausted',
@@ -88,6 +91,15 @@ export interface SupervisorLimits {
 const DEFAULT_MAX_ROUNDS = 3;
 const DEFAULT_STALL_ROUNDS = 2;
 
+export function parentUnlandedProgressLine(feature: string, parentPrNumber?: number, parentNoPr = false): string {
+  const detail = parentNoPr
+    ? '앞 조각 커밋 main 미착지'
+    : parentPrNumber === undefined
+      ? '앞 조각 PR 번호 미확인 · main 착지 미확인'
+      : `앞 조각 PR #${parentPrNumber} 미병합`;
+  return `[supervisor] ⏸ 조각 ${feature} 대기 — ${detail}`;
+}
+
 export function countLanded(results: readonly SelfDevJobResult[]): number {
   return results.filter(hasDelivered).length;
 }
@@ -146,6 +158,7 @@ function formatGoalPlanRevisionObservation(results: readonly SelfDevJobResult[])
 
 export type SupervisorJobResult = SelfDevJobResult & {
   reviewReason?: string;
+  salvage?: 'launched' | 'parked';
 };
 
 export function decideNextRun(input: {
@@ -169,7 +182,12 @@ export function decideNextRun(input: {
     ? 'unmeasured'
     : input.deliverableMerge.merged >= input.deliverableMerge.expected ? 'complete' : 'incomplete';
   const reviewMustFixTrend: SupervisorDecision['reviewMustFixTrend'] = input.reviewMustFixTrend ?? 'unmeasured';
-  const t = triageRun(results, input.deployFindings, observation === 'failed');
+  const handedOff = results.filter((result) => result.salvage === 'launched');
+  const activeResults = results.filter((result) => result.salvage !== 'launched');
+  const handedOffIds = new Set(handedOff.map((result) => result.taskId));
+  const deployFindings = input.deployFindings === undefined ? undefined
+    : new Map([...input.deployFindings].filter(([taskId]) => !handedOffIds.has(taskId)));
+  const t = triageRun(activeResults, deployFindings, observation === 'failed');
   const round = history.length;
   const landed = countLanded(results);
   const actionable = countActionable(t);
@@ -197,6 +215,16 @@ export function decideNextRun(input: {
     classifications: t.classifications,
   };
 
+  const unlandedParents = results.filter((result) => result.blockReason === 'parent-unlanded');
+  if (unlandedParents.length > 0) {
+    return {
+      ...base,
+      action: 'stop',
+      stopReason: 'needs-human',
+      why: unlandedParents.map((result) => parentUnlandedProgressLine(result.feature.split('\n')[0]!, result.parentPrNumber, result.parentNoPr === true)).join(' · '),
+    };
+  }
+
   if (deliverableMergeCompleteness === 'complete') {
     return {
       ...base,
@@ -206,6 +234,18 @@ export function decideNextRun(input: {
     };
   }
 
+  if (handedOff.length > 0 && t.classifications.length === 0) {
+    for (const { taskId: jobId } of handedOff) {
+      try { debug.log('self-dev.supervisor', 'handed-off-to-salvage', { jobId }); } catch { /* fail-open */ }
+    }
+    return {
+      ...base,
+      action: 'stop',
+      stopReason: 'handed-off-to-salvage',
+      why: withGoalPlanRevisionObservation(`수확 자식에게 넘겼다 — ${handedOff.map((result) => result.taskId).join(' · ')}`),
+    };
+  }
+
   if (t.classifications.length === 0) {
     if (input.reviewed === false && input.reviewReason !== 'no-diff') {
       return {
@@ -345,10 +385,10 @@ export function decideNextRun(input: {
 
 export function appendRound(
   history: readonly SupervisorRound[],
-  results: readonly SelfDevJobResult[],
+  results: readonly SupervisorJobResult[],
   reviewMustFixTrend?: SupervisorDecision['reviewMustFixTrend'],
 ): SupervisorRound[] {
-  const t = triageRun([...results]);
+  const t = triageRun(results.filter((result) => result.salvage !== 'launched'));
   return [...history, {
     round: history.length,
     landed: countLanded(results),

package/src/self-implement/abandoned-classification.ts

@@ -40,7 +40,7 @@ export interface QuotaAccountAvailabilityEvidence {
 
 import type { SelfImplementCompletionDisposition } from './seams.js';
 
-export type AbandonedClassification = 'report-deficit' | 'implementation-deficit' | 'artifact-deficit' | 'contract-conflict' | 'goal-unconvergeable-candidate' | 'pr-declined' | 'merge-approved-abandoned' | 'quota-exhausted' | 'credential-failure' | 'provider-error' | 'already-satisfied';
+export type AbandonedClassification = 'report-deficit' | 'implementation-deficit' | 'artifact-deficit' | 'contract-conflict' | 'goal-unconvergeable-candidate' | 'pr-declined' | 'merge-approved-abandoned' | 'run-deadline-exceeded' | 'quota-exhausted' | 'credential-failure' | 'provider-error' | 'already-satisfied';
 
 const ABANDONED_CLASSIFICATION_VALUES = {
   'report-deficit': true,
@@ -50,6 +50,7 @@ const ABANDONED_CLASSIFICATION_VALUES = {
   'goal-unconvergeable-candidate': true,
   'pr-declined': true,
   'merge-approved-abandoned': true,
+  'run-deadline-exceeded': true,
   'quota-exhausted': true,
   'credential-failure': true,
   'provider-error': true,
@@ -65,6 +66,8 @@ type AbandonedClassificationBasis =
   | 'supervisor-unconvergeable-goal-candidate'
   | 'pr-declined-stage'
   | 'merge-approval-received'
+  // 기한 사망은 호스트가 읽은 Job 종료 이유다. 사후 쿼터 상관보다 앞선다.
+  | 'substrate-deadline-outranks-postmortem-quota'
   // 🩸 2026-09-20: 이 셋은 분류 «이름을 되풀이»했다 — 근거 칸이 동어반복이면 중재를 못 한다.
   //   📏 실물(block 아티팩트)에서 네 칸이 2:2 로 갈렸다:
   //        reason·stage = 게이트   ↔   중단원인·classification = 쿼타
@@ -109,6 +112,9 @@ interface AbandonedClassificationInput {
   readonly goalCauseObserved?: true;
   /** Preserved when the merge decision authorized automatic merge before this run was abandoned. */
   readonly mergeApprovalReceived?: boolean;
+  /** 호스트가 k8s Job 종료 reason `DeadlineExceeded` 를 읽었을 때만 참이다.
+   *  ⛔ 사후 쿼터 상관(`quotaExhausted`)보다 앞선다 — 기한 사망을 할당량 소진으로 읽지 않는다. */
+  readonly substrateDeadlineExceeded?: boolean;
   /** ⭐ provider 쿼터가 «찬 것으로 관측»되었을 때만 참이다.
    *  ⛔ 이 값은 «추론하지 않는다» — 호출자가 provider 응답(`rateLimitReachedType`)을 읽어 넘긴다.
    *  ⚠️ 그 읽기는 런이 죽은 «뒤»에 일어나므로 「죽은 원인」이 아니라 「죽을 무렵 쿼터가 찼다」는 상관이다.
@@ -160,6 +166,8 @@ export interface AbandonedClassificationResult {
   readonly credentialFailure?: true;
   /** Preserved independently of the selected classification. */
   readonly providerError?: true;
+  /** Category of the provider error admitted by the caller, when observed. */
+  readonly providerErrorCategory?: 'quota' | 'credential' | 'request' | 'other';
   /** Preserved independently of the selected classification. Only `true` is recorded. */
   readonly citedEvidenceExists?: true;
   readonly mustFixReported: boolean;
@@ -201,6 +209,10 @@ export function classifyAbandonedRun(input: AbandonedClassificationInput): Aband
         //   ⛔ 다만 머지 승인보다는 «뒤»다 — 승인은 「이 물건은 합격이었다」는 더 강한 완료 주장이고,
         //     쿼터 사실은 그 경우에도 결과 payload 에 그대로 실려 잃지 않는다.
         // 결정적 요청 거부는 계정 가용성보다 앞선다 — 회전 후보 부재는 요청 오류의 원인이 아니다.
+        // 기한 사망은 호스트가 읽은 종료 이유다. 사후 쿼터·자격·provider 오류보다 앞이고,
+        // 머지 승인·계약 충돌·pr-declined 보다는 뒤다. 쿼터 사실은 결과에 그대로 남긴다.
+        : input.substrateDeadlineExceeded === true
+        ? 'run-deadline-exceeded'
         : input.providerError === true && input.providerErrorCategory === 'request'
         ? 'provider-error'
         : input.quotaExhausted === true
@@ -228,6 +240,7 @@ export function classifyAbandonedRun(input: AbandonedClassificationInput): Aband
       case 'goal-unconvergeable-candidate': return 'supervisor-unconvergeable-goal-candidate';
       case 'pr-declined': return 'pr-declined-stage';
       case 'merge-approved-abandoned': return 'merge-approval-received';
+      case 'run-deadline-exceeded': return 'substrate-deadline-outranks-postmortem-quota';
       // ⛔ 분류 이름을 되풀이하지 않는다 — 근거는 «왜 그것이 이겼나»를 말해야 한다.
       case 'quota-exhausted': return 'environment-quota-outranks-run-stage-evidence';
       case 'credential-failure': return 'environment-credential-outranks-run-stage-evidence';
@@ -265,6 +278,7 @@ export function classifyAbandonedRun(input: AbandonedClassificationInput): Aband
     ...(input.quotaAccountAvailability ? { quotaAccountAvailability: input.quotaAccountAvailability } : {}),
     ...(input.credentialFailure === true ? { credentialFailure: true } : {}),
     ...(input.providerError === true ? { providerError: true } : {}),
+    ...(input.providerError === true && input.providerErrorCategory ? { providerErrorCategory: input.providerErrorCategory } : {}),
     ...(input.citedEvidenceExists === true ? { citedEvidenceExists: true } : {}),
     mustFixReported,
     ...(blocked

package/src/self-implement/blocked-draft-policy.ts

@@ -0,0 +1,6 @@
+/** Environment interruptions have a resumable branch, not a human draft decision. */
+export function blockedDraftDisposition(classification: string | undefined): 'open-draft' | 'preserve-branch' {
+  return classification === 'provider-error' || classification === 'quota-exhausted' || classification === 'credential-failure'
+    ? 'preserve-branch'
+    : 'open-draft';
+}

package/src/self-implement/budget-gate.ts

@@ -0,0 +1,236 @@
+// 발사 전 «이번 판을 누구로 · 돌릴까 말까» — 순수 판정과 읽기를 가른다.
+// 회전·사용량 저장소·선호 해석은 기존 함수를 부른다. 여기선 다시 만들지 않는다.
+
+import type { RotationCandidate } from '../oauth/codex-account-rotation.js';
+import { inspectCodexRotation } from '../oauth/codex-account-store.js';
+import { getUsageStore } from '../budget/usage-store.js';
+import type { UsageSnapshot } from '../budget/types.js';
+import {
+  DEFAULT_BUDGET_GATE_MAX_USED_PERCENT,
+  type BudgetGateMaxUsedPercent,
+  type BudgetGateOnShortfall,
+} from '../user-config.js';
+import {
+  resolveChildLlmPreference,
+  type ChildLlmPreferenceInput,
+  type ResolvedChildLlmPreference,
+} from './child-llm-preference.js';
+
+export const CODEX_PROVIDER = 'openai-codex';
+export const GROK_PROVIDER = 'grok';
+
+export type BudgetAction = 'proceed' | 'next-provider' | 'wait-reset' | 'stop';
+
+export interface BudgetCodexCandidate {
+  readonly name: string;
+  readonly reached?: boolean;
+  readonly usedPercent?: number;
+}
+
+export interface DecideBudgetInput {
+  readonly preference: {
+    readonly chain: readonly { readonly provider: string; readonly model?: string }[];
+    readonly budgetGate: { readonly onShortfall: BudgetGateOnShortfall };
+  };
+  readonly codexCandidates: readonly BudgetCodexCandidate[];
+  /** 주간 사용률. `undefined` 는 «모름» — 쓸 수 있다고 보지 않는다. */
+  readonly grokUsedPercent: number | undefined;
+  readonly maxUsedPercent: BudgetGateMaxUsedPercent;
+}
+
+export interface BudgetDecision {
+  readonly action: BudgetAction;
+  readonly provider?: string;
+  readonly model?: string;
+  readonly reasons: readonly string[];
+}
+
+export interface BudgetInputs {
+  readonly preference: ResolvedChildLlmPreference;
+  readonly codexCandidates: readonly BudgetCodexCandidate[];
+  readonly grokUsedPercent: number | undefined;
+  readonly maxUsedPercent: BudgetGateMaxUsedPercent;
+}
+
+const WEEKLY_WINDOW_MINUTES = 7 * 24 * 60;
+
+function capFor(maxUsedPercent: BudgetGateMaxUsedPercent, provider: string): number | undefined {
+  if (!Object.prototype.hasOwnProperty.call(maxUsedPercent, provider)) {
+    const fallback = DEFAULT_BUDGET_GATE_MAX_USED_PERCENT[provider];
+    return typeof fallback === 'number' ? fallback : undefined;
+  }
+  const configured = maxUsedPercent[provider];
+  // 칸을 비우거나 지운 값(undefined)은 상한 없음. 숫자만 상한이다.
+  return typeof configured === 'number' && Number.isFinite(configured) ? configured : undefined;
+}
+
+function formatPercent(value: number | undefined): string {
+  return value === undefined || !Number.isFinite(value) ? '모름' : `${value}%`;
+}
+
+/** codex 칸 한 줄. 예: «codex: default 100%·team 95%·third 96% ≥ 95» */
+export function formatCodexReason(candidates: readonly BudgetCodexCandidate[], cap: number | undefined): string {
+  const capLabel = cap === undefined ? '상한없음' : String(cap);
+  if (candidates.length === 0) return `codex: 후보 없음 ≥ ${capLabel}`;
+  const parts = candidates.map((candidate) => {
+    if (candidate.reached === true && candidate.usedPercent === undefined) {
+      return `${candidate.name} 한도도달`;
+    }
+    return `${candidate.name} ${formatPercent(candidate.usedPercent)}`;
+  });
+  const anyUsable = cap !== undefined && candidates.some((candidate) => codexCandidateUsable(candidate, cap));
+  const relation = anyUsable ? '<' : '≥';
+  return `codex: ${parts.join('·')} ${relation} ${capLabel}`;
+}
+
+/** grok 칸 한 줄. 모르면 «grok: 모름». 예: «grok: 7% < 48» */
+export function formatGrokReason(usedPercent: number | undefined, cap: number | undefined): string {
+  if (usedPercent === undefined || !Number.isFinite(usedPercent)) return 'grok: 모름';
+  if (cap === undefined) return `grok: ${usedPercent}% (상한 없음)`;
+  const relation = usedPercent < cap ? '<' : '≥';
+  return `grok: ${usedPercent}% ${relation} ${cap}`;
+}
+
+function codexCandidateUsable(candidate: BudgetCodexCandidate, cap: number | undefined): boolean {
+  if (cap === undefined) return false;
+  if (candidate.reached === true) return false;
+  if (typeof candidate.usedPercent !== 'number' || !Number.isFinite(candidate.usedPercent)) return false;
+  return candidate.usedPercent < cap;
+}
+
+function slotUsable(
+  provider: string,
+  input: DecideBudgetInput,
+): { usable: boolean; reason: string } {
+  if (provider === CODEX_PROVIDER) {
+    const cap = capFor(input.maxUsedPercent, CODEX_PROVIDER);
+    const usable = input.codexCandidates.some((candidate) => codexCandidateUsable(candidate, cap));
+    return { usable, reason: formatCodexReason(input.codexCandidates, cap) };
+  }
+  if (provider === GROK_PROVIDER) {
+    const cap = capFor(input.maxUsedPercent, GROK_PROVIDER);
+    const known = typeof input.grokUsedPercent === 'number' && Number.isFinite(input.grokUsedPercent);
+    const usable = cap === undefined
+      ? known
+      : known && (input.grokUsedPercent as number) < cap;
+    return {
+      usable,
+      reason: formatGrokReason(input.grokUsedPercent, cap),
+    };
+  }
+  return { usable: false, reason: `${provider}: 예산 판정 없음` };
+}
+
+/**
+ * 선호 chain 을 차례로 본다.
+ * 첫 칸이 쓸 수 있으면 proceed, 첫 칸은 못 쓰고 뒤 칸이 되면 next-provider,
+ * 아무것도 못 쓰면 onShortfall 이 wait-reset 일 때만 wait-reset, 아니면 stop.
+ */
+export function decideBudget(input: DecideBudgetInput): BudgetDecision {
+  const reasons: string[] = [];
+  if (input.preference.chain.length === 0) {
+    reasons.push('chain: 비었음 — tools.selfImplement.childLlm.chain 도 llm.fallbackChain 도 없다');
+  }
+  let firstUnusable = false;
+  for (let index = 0; index < input.preference.chain.length; index++) {
+    const slot = input.preference.chain[index]!;
+    const judged = slotUsable(slot.provider, input);
+    reasons.push(judged.reason);
+    if (!judged.usable) {
+      if (index === 0) firstUnusable = true;
+      continue;
+    }
+    const action: BudgetAction = index === 0 || !firstUnusable ? 'proceed' : 'next-provider';
+    return {
+      action,
+      provider: slot.provider,
+      ...(slot.model !== undefined ? { model: slot.model } : {}),
+      reasons,
+    };
+  }
+  const onShortfall = input.preference.budgetGate.onShortfall;
+  return {
+    action: onShortfall === 'wait-reset' ? 'wait-reset' : 'stop',
+    reasons,
+  };
+}
+
+/** grok 스냅숏의 주간 창 `used`. 창이 없으면 «모름». */
+export function grokWeeklyUsedPercent(snapshot: UsageSnapshot | undefined): number | undefined {
+  if (!snapshot) return undefined;
+  const weekly = snapshot.windows.find((window) => window.kind === 'weekly')
+    ?? snapshot.windows.find((window) => window.windowMinutes >= WEEKLY_WINDOW_MINUTES);
+  if (!weekly) return undefined;
+  return Number.isFinite(weekly.used) ? weekly.used : undefined;
+}
+
+export function codexCandidatesFromRotation(
+  candidates: readonly RotationCandidate[],
+): BudgetCodexCandidate[] {
+  return candidates.map((candidate) => ({
+    name: candidate.name,
+    ...(candidate.reached !== undefined ? { reached: candidate.reached } : {}),
+    ...(candidate.usedPercent !== undefined ? { usedPercent: candidate.usedPercent } : {}),
+  }));
+}
+
+export interface ReadBudgetInputsDeps {
+  readonly config?: ChildLlmPreferenceInput;
+  readonly loadConfig?: () => ChildLlmPreferenceInput;
+  readonly inspectCodex?: typeof inspectCodexRotation;
+  readonly grokSnapshot?: () => UsageSnapshot | undefined;
+}
+
+/** 설정·codex 회전·grok 스냅숏을 읽어 판정 입력을 만든다. 판정 자체는 하지 않는다. */
+export function readBudgetInputs(deps: ReadBudgetInputsDeps = {}): BudgetInputs {
+  const config = deps.config ?? deps.loadConfig?.() ?? loadLiveConfig();
+  const preference = resolveChildLlmPreference(config);
+  const rotation = (deps.inspectCodex ?? inspectCodexRotation)();
+  const snapshot = deps.grokSnapshot
+    ? deps.grokSnapshot()
+    : getUsageStore().getSnapshot('grok');
+  const maxUsedPercent = preference.budgetGate.maxUsedPercent ?? { ...DEFAULT_BUDGET_GATE_MAX_USED_PERCENT };
+  return {
+    preference,
+    codexCandidates: codexCandidatesFromRotation(rotation.candidates),
+    grokUsedPercent: grokWeeklyUsedPercent(snapshot),
+    maxUsedPercent,
+  };
+}
+
+/** `elanous usage` 와 같은 조회(`collectUnifiedUsage`)로 grok 주간 사용률을 읽는다.
+ *  ⭐ 메모리 스냅숏(`getUsageStore`)은 데몬 «안»에서만 채워진다 — CLI 프로세스에선 비어 «모름»이 된다(2026-09-27 실측: grok 7% 인데 `grok: 모름 → stop`). 못 읽으면 undefined(«모름»). */
+export async function readLiveGrokUsedPercent(
+  collect: () => Promise<{ rows: ReadonlyArray<{ provider: string; credits: unknown }> }> = async () => {
+    const { collectUnifiedUsage } = await import('../budget/unified-usage.js');
+    return collectUnifiedUsage();
+  },
+): Promise<number | undefined> {
+  try {
+    const report = await collect();
+    const row = report.rows.find((r) => r.provider === 'grok');
+    const credits = row?.credits;
+    const used = credits && typeof credits === 'object' && 'usedPercent' in credits
+      ? (credits as { usedPercent: unknown }).usedPercent
+      : undefined;
+    return typeof used === 'number' && Number.isFinite(used) ? used : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** CLI 용 — 스냅숏이 «모름»이면 실제 조회로 채운다(판정 입력 모양은 같다). */
+export async function readBudgetInputsLive(
+  deps: ReadBudgetInputsDeps & { readLiveGrok?: () => Promise<number | undefined> } = {},
+): Promise<BudgetInputs> {
+  const inputs = readBudgetInputs(deps);
+  if (inputs.grokUsedPercent !== undefined) return inputs;
+  const live = await (deps.readLiveGrok ?? (() => readLiveGrokUsedPercent()))();
+  return live === undefined ? inputs : { ...inputs, grokUsedPercent: live };
+}
+
+function loadLiveConfig(): ChildLlmPreferenceInput {
+  // 지연 로드 — 판정 단위 테스트가 user-config 캐시·디스크를 건드리지 않게.
+  const { getUserConfig } = require('../user-config.js') as typeof import('../user-config.js');
+  return getUserConfig();
+}

package/src/self-implement/child-llm-preference.ts

@@ -0,0 +1,84 @@
+// 사용자 자식 모델 선호와 예산 부족 행동을 한 함수로 해석한다.
+// 계정 회전은 여기 없다 — 계정이 여럿일 때 기존 회전이 선택된 프로바이더 안에서 한다.
+
+import type {
+  BudgetGateMaxUsedPercent,
+  BudgetGateOnShortfall,
+  ChildLlmChainEntry,
+  ChildLlmPreferenceMode,
+  UserConfig,
+} from '../user-config.js';
+import { DEFAULT_BUDGET_GATE } from '../user-config.js';
+import { debug } from '../debug/log.js';
+
+export interface ResolvedChildLlmPreference {
+  mode: ChildLlmPreferenceMode;
+  chain: ChildLlmChainEntry[];
+  budgetGate: {
+    minHeadroomPercent: number;
+    onShortfall: BudgetGateOnShortfall;
+    maxUsedPercent?: BudgetGateMaxUsedPercent;
+  };
+  source: { mode: 'explicit' | 'inferred'; chain: 'config' | 'pinned' | 'fallbackChain' };
+}
+
+export type ChildLlmPreferenceInput = Pick<UserConfig, 'tools' | 'llm'> & Partial<Pick<UserConfig, 'harness'>>;
+
+const FALLBACK_NAME_TO_PROVIDER: Readonly<Record<string, string>> = {
+  'codex-rotate': 'openai-codex',
+  grok: 'grok',
+};
+
+function warnPreference(detail: string): void {
+  try {
+    debug.log('harness.child-llm-preference', 'config-warning', { detail });
+  } catch { /* observation must not block resolution */ }
+  try {
+    process.stderr.write(`[child-llm-preference] ${detail}\n`);
+  } catch { /* stderr closed */ }
+}
+
+/** `llm.fallbackChain` 이름을 자식 프로바이더 칸으로 옮긴다. 모르는 이름은 경고하고 건너뛴다. */
+export function chainFromFallbackNames(names: readonly string[] | undefined): ChildLlmChainEntry[] {
+  const chain: ChildLlmChainEntry[] = [];
+  for (const name of names ?? []) {
+    const provider = FALLBACK_NAME_TO_PROVIDER[name];
+    if (!provider) {
+      warnPreference(`llm.fallbackChain 의 모르는 이름 '${name}' 을 건너뜀`);
+      continue;
+    }
+    if (!chain.some((entry) => entry.provider === provider)) chain.push({ provider });
+  }
+  return chain;
+}
+
+export function resolveChildLlmPreference(config: ChildLlmPreferenceInput): ResolvedChildLlmPreference {
+  const childLlm = config.tools.selfImplement.childLlm;
+  const provider = childLlm?.provider?.trim() ? childLlm.provider : undefined;
+  // mode 가 없으면 provider 가 있을 때만 pinned. model 만 있어도 provider 가 없으면 auto.
+  const explicitMode = childLlm?.mode;
+  const mode: ChildLlmPreferenceMode = explicitMode ?? (provider ? 'pinned' : 'auto');
+  const modeSource: ResolvedChildLlmPreference['source']['mode'] = explicitMode ? 'explicit' : 'inferred';
+
+  let chain: ChildLlmChainEntry[];
+  let chainSource: ResolvedChildLlmPreference['source']['chain'];
+  if (mode === 'pinned') {
+    // 계정 회전은 여기 없다. provider 없는 model 은 pinned 가 아니다.
+    chain = provider
+      ? [{ provider, ...(childLlm?.model !== undefined ? { model: childLlm.model } : {}) }]
+      : [];
+    chainSource = 'pinned';
+  } else if (childLlm?.chain && childLlm.chain.length > 0) {
+    chain = childLlm.chain.map((entry) => ({
+      provider: entry.provider,
+      ...(entry.model !== undefined ? { model: entry.model } : {}),
+    }));
+    chainSource = 'config';
+  } else {
+    chain = chainFromFallbackNames(config.llm.fallbackChain);
+    chainSource = 'fallbackChain';
+  }
+
+  const budgetGate = config.harness?.budgetGate ?? { ...DEFAULT_BUDGET_GATE };
+  return { mode, chain, budgetGate, source: { mode: modeSource, chain: chainSource } };
+}

package/src/self-implement/decision-events.ts

@@ -0,0 +1,57 @@
+import type { DecisionEvent } from '../live/detail-switch.js';
+import { redactSecretText } from '../debug/log.js';
+
+const line = (value: string): string => value.replace(/\s+/g, ' ').trim().slice(0, 200) || 'unknown';
+
+export function reworkDecision(input: { runId?: string; round: number; effectiveMax: number; escalateTier: string; kind: string }): DecisionEvent {
+  return {
+    kind: 'HEAL', phase: 'implement', refs: { round: input.round, max: input.effectiveMax },
+    what: line(`구현 재작업 ${input.round}/${input.effectiveMax}`),
+    reason: line(`${input.kind} · 에스컬레이션 ${input.escalateTier}`),
+    purpose: '검증에서 발견한 문제를 고친다', target: '다음 구현 라운드',
+    ...(input.runId ? { runId: input.runId } : {}),
+  };
+}
+
+export function gateDecision(input: { runId?: string; reason: string; testStepSkipped: boolean }): DecisionEvent {
+  return {
+    kind: 'VERIFY', phase: 'gate', what: '구현 게이트 시험 범위',
+    reason: line(input.reason), purpose: '변경된 파일에 맞는 검증을 선택한다',
+    target: input.testStepSkipped ? '시험 생략 · 나머지 게이트' : '대상 시험 · 나머지 게이트',
+    ...(input.runId ? { runId: input.runId } : {}),
+  };
+}
+
+export function reviewDecision(input: { runId?: string; verdict: string; reviewed: boolean; mustFix?: number; shouldFix?: number; topFinding?: string; reason?: string }): DecisionEvent {
+  const fallback = input.mustFix !== undefined && input.mustFix > 0 && input.topFinding?.trim()
+    ? `must-fix ${input.mustFix} · ${redactSecretText(input.topFinding)}`
+    : `${input.verdict} · 실제 리뷰 ${input.reviewed ? '완료' : '미실행'} · must-fix ${input.mustFix ?? 0} · should-fix ${input.shouldFix ?? 0}`;
+  return {
+    kind: 'VERIFY', phase: 'review',
+    refs: { ...(input.mustFix !== undefined ? { mustFix: input.mustFix } : {}), ...(input.shouldFix !== undefined ? { shouldFix: input.shouldFix } : {}) },
+    what: '구현물 리뷰 결과',
+    reason: line(redactSecretText(input.reason ?? fallback)),
+    purpose: '병합 전에 변경을 검토한다',
+    target: input.reviewed && input.verdict === 'pass' ? '병합 판단' : '리뷰 또는 재작업',
+    ...(input.runId ? { runId: input.runId } : {}),
+  };
+}
+
+export function escalateDecision(input: { runId?: string; shellId: string; answer: string | null; interactive: boolean; mode: 'question' | 'confirm'; safeDecline?: boolean }): DecisionEvent {
+  return {
+    kind: 'ESCALATE', phase: 'implement', refs: { shell: input.shellId }, what: '셸 응답 요청',
+    reason: `${input.mode} · ${input.interactive ? '대화형' : '비대화형'} · 응답 ${input.answer === null ? '없음' : '수신'}${input.safeDecline ? ' · 안전 거절 선택' : ''}`,
+    purpose: '셸 프롬프트의 operator 결정을 받는다', target: line(`셸 ${input.shellId}`),
+    ...(input.runId ? { runId: input.runId } : {}),
+  };
+}
+
+export function mergeDecision(input: { number: number; merged: boolean; reason: string; runId?: string }): DecisionEvent {
+  return {
+    kind: input.merged ? 'SHIP' : 'ESCALATE', phase: 'land', refs: { pr: input.number },
+    what: line(`PR #${input.number} ${input.merged ? '병합 확인' : '병합 실패'}`),
+    reason: line(input.reason), purpose: '확인된 병합 결과만 배송한다',
+    target: input.merged ? '병합 완료' : '사람',
+    ...(input.runId ? { runId: input.runId } : {}),
+  };
+}

package/src/self-implement/decision-signal-press.ts

@@ -154,10 +154,13 @@ export function parseSafeDecisionSignalCommand(command: string): ParsedDecisionS
   if (executable === 'bun' && args[0] === 'bin/elanous.mjs') {
     const elanousArgs = args.slice(1);
     const [command, subcommand, reference, output] = elanousArgs;
+    // METHOD v116(🅢 · 2026-09-26): 그래프 원장 값 신호(`pipeline-node-entry`·`graph.heal` 등)는 `--event` 로 읽는다 — v115 가 권한 모양.
     const logsObservation =
       command === 'logs' &&
-      elanousArgs.includes('--category') &&
+      (elanousArgs.includes('--category') || elanousArgs.includes('--event')) &&
       (elanousArgs.includes('--json') || elanousArgs.includes('--json-data'));
+    // 그래프 판 상태 «읽기»만 — `graph run` 은 dry-run 이어도 실행 상태 파일을 쓰므로 받지 않는다.
+    const graphStatus = command === 'graph' && subcommand === 'status' && reference !== undefined && output === '--json' && elanousArgs.length === 4;
     const ptySnapshot = command === 'pty' && subcommand === 'snapshot' && reference !== undefined && elanousArgs.length === 3;
     const ptyLineage =
       command === 'pty' &&
@@ -171,7 +174,7 @@ export function parseSafeDecisionSignalCommand(command: string): ParsedDecisionS
       reference === '--json' &&
       elanousArgs.length === 3;
 
-    if (logsObservation || ptySnapshot || ptyLineage || selfObservation) {
+    if (logsObservation || graphStatus || ptySnapshot || ptyLineage || selfObservation) {
       return { executable, args };
     }
   }