elanous 0.2.41 → 0.2.43

package/src/self-implement/graph-overlay-yaml.ts

@@ -31,6 +31,8 @@ export interface GraphOverlaySpec {
   /** ⛔ 조건도 «값»이다 — 사람이 판단해 얹는 경로를 두지 않는다. */
   readonly appliesWhen: string;
   readonly patch: readonly OverlayPatchOp[];
+  /** Stop-reason vocabulary lives with heal declarations, not in TypeScript tables. */
+  readonly reasonMap?: Readonly<Record<string, string>>;
 }
 
 export interface OverlayParseResult {
@@ -93,6 +95,10 @@ function overlayFromRaw(raw: unknown, label: string): { overlay?: GraphOverlaySp
   if (!appliesWhen) errors.push({ path: `${label}/applies_when`, message: 'applies_when 이 없거나 문자열이 아니다' });
 
   const patch: OverlayPatchOp[] = [];
+  const reasonMapRaw = doc.reason_map;
+  const reasonMap = reasonMapRaw && typeof reasonMapRaw === 'object' && !Array.isArray(reasonMapRaw)
+    ? Object.fromEntries(Object.entries(reasonMapRaw as Record<string, unknown>).filter((entry): entry is [string, string] => typeof entry[1] === 'string'))
+    : undefined;
   const rawPatch = Array.isArray(doc.patch) ? doc.patch : [];
   if (rawPatch.length === 0) errors.push({ path: `${label}/patch`, message: 'patch 가 비었다 — 아무것도 안 바꾸는 오버레이다' });
   for (const [index, entry] of rawPatch.entries()) {
@@ -109,6 +115,7 @@ function overlayFromRaw(raw: unknown, label: string): { overlay?: GraphOverlaySp
   return {
     overlay: {
       overlayId: overlayId!, target: target!, stage: stage!, appliesWhen: appliesWhen!, patch,
+      ...(reasonMap && Object.keys(reasonMap).length ? { reasonMap } : {}),
     },
     errors,
   };
@@ -160,8 +167,10 @@ export function applyGraphOverlays(
       rejections.push({ kind: 'unknown-target', overlayId: overlay.overlayId, target: overlay.target });
       continue;
     }
+    const beforeNodes = new Map(next.nodes.map((node) => [node.nodeId, node]));
     const beforeVisits = new Map(next.nodes.map((node) => [node.nodeId, node.maxVisits]));
-    const beforeRoutes = edgeMapOf(next);
+    const beforeRoutes = graphRouteMap(next);
+    const beforeEdgeMap = edgeMapOf(next);
     for (const op of overlay.patch) {
       const resolved = resolvePointer(next, op.path);
       if (!resolved) { rejections.push({ kind: 'bad-pointer', overlayId: overlay.overlayId, path: op.path }); continue; }
@@ -183,15 +192,27 @@ export function applyGraphOverlays(
         if (op.op === 'remove') delete bag[key]; else bag[key] = op.value;
       } else rejections.push({ kind: 'bad-pointer', overlayId: overlay.overlayId, path: op.path });
     }
+    for (const node of next.nodes) {
+      if (beforeNodes.has(node.nodeId)) continue;
+      patches.push({ overlayId: overlay.overlayId, field: 'node-added', node: node.nodeId, kind: node.kind, maxVisits: node.maxVisits });
+    }
+    const afterRoutes = graphRouteMap(next);
+    for (const [key, route] of afterRoutes) {
+      const before = beforeRoutes.get(key);
+      if (before && before.to !== route.to) {
+        patches.push({ overlayId: overlay.overlayId, field: 'edge-rerouted', from: route.from, outcome: route.outcome, was: before.to, to: route.to });
+      }
+    }
     for (const node of next.nodes) {
       const before = beforeVisits.get(node.nodeId);
       if (before !== undefined && before !== node.maxVisits) {
         patches.push({ overlayId: overlay.overlayId, field: 'maxVisits', node: node.nodeId, before, after: node.maxVisits });
       }
     }
-    const afterRoutes = edgeMapOf(next);
-    for (const [node, before] of Object.entries(beforeRoutes)) {
-      const after = afterRoutes[node] ?? [];
+    const afterEdgeMap = edgeMapOf(next);
+    for (const node of Object.keys(beforeEdgeMap)) {
+      const before = beforeEdgeMap[node] ?? [];
+      const after = afterEdgeMap[node] ?? [];
       if (before.length !== after.length || before.some((destination, index) => destination !== after[index])) {
         patches.push({ overlayId: overlay.overlayId, field: 'routes', node, before, after });
       }
@@ -239,6 +260,18 @@ export function applyGraphOverlays(
   return { ok: true, template: next, overlayIds: applied, patches };
 }
 
+/** Keep outcome names while comparing route changes; the compiled edge map deliberately drops them. */
+function graphRouteMap(template: GraphTemplateSpec): Map<string, { from: string; outcome: string; to: string }> {
+  const routes = new Map<string, { from: string; outcome: string; to: string }>();
+  for (const [index, edge] of template.edges.entries()) {
+    if (edge.to) routes.set(`${edge.from}\u0000direct\u0000${index}`, { from: edge.from, outcome: '', to: edge.to });
+    for (const [outcome, to] of Object.entries(edge.map ?? {})) {
+      routes.set(`${edge.from}\u0000${edge.on ?? 'outcome'}\u0000${outcome}`, { from: edge.from, outcome, to });
+    }
+  }
+  return routes;
+}
+
 export interface OverlayLoadResult {
   readonly overlays: readonly GraphOverlaySpec[];
   readonly errors: readonly GraphParseIssue[];

package/src/self-implement/graph-overlay.ts

@@ -26,7 +26,9 @@ export type OverlayRejection =
 
 export type OverlayPatch =
   | { readonly overlayId: string; readonly field: 'maxVisits'; readonly node: string; readonly before: number; readonly after: number }
-  | { readonly overlayId: string; readonly field: 'routes'; readonly node: string; readonly before: readonly string[]; readonly after: readonly string[] };
+  | { readonly overlayId: string; readonly field: 'routes'; readonly node: string; readonly before: readonly string[]; readonly after: readonly string[] }
+  | { readonly overlayId: string; readonly field: 'node-added'; readonly node: string; readonly kind: string; readonly maxVisits: number }
+  | { readonly overlayId: string; readonly field: 'edge-rerouted'; readonly from: string; readonly outcome: string; readonly was: string; readonly to: string };
 
 export type OverlayResult =
   | { ok: true; template: GraphTemplate; patches: readonly OverlayPatch[] }

package/src/self-implement/graph-profile-yaml.ts

@@ -0,0 +1,107 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse as parseYaml } from 'yaml';
+import { evaluateOverlayCondition, parseOverlayCondition } from './graph-overlay-condition.js';
+import type { GraphParseIssue } from './graph-yaml.js';
+
+/** L1 profile: a deterministic state bundle and references to already-declared overlays. */
+export interface GraphProfileSpec {
+  readonly profileId: string;
+  readonly appliesWhen: string;
+  readonly state: Readonly<Record<string, string | number | boolean>>;
+  readonly overlays: readonly string[];
+}
+
+export interface GraphProfileParseResult {
+  readonly profile?: GraphProfileSpec;
+  readonly errors: readonly GraphParseIssue[];
+}
+
+export function parseGraphProfileYaml(source: string, label = '<inline>'): GraphProfileParseResult {
+  let raw: unknown;
+  try { raw = parseYaml(source); }
+  catch (error) {
+    return { errors: [{ path: label, message: `YAML 파싱 실패: ${error instanceof Error ? error.message : String(error)}` }] };
+  }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+    return { errors: [{ path: label, message: 'YAML 최상위가 맵이 아니다' }] };
+  const doc = raw as Record<string, unknown>;
+  const errors: GraphParseIssue[] = [];
+  const profileId = typeof doc.profile_id === 'string' && /^[a-z][a-z0-9-]*$/.test(doc.profile_id) ? doc.profile_id : undefined;
+  if (!profileId) errors.push({ path: `${label}/profile_id`, message: 'profile_id는 소문자·숫자·하이픈 식별자여야 한다' });
+  const appliesWhen = typeof doc.applies_when === 'string' ? doc.applies_when : undefined;
+  if (!appliesWhen || !parseOverlayCondition(appliesWhen).ok)
+    errors.push({ path: `${label}/applies_when`, message: 'applies_when은 오버레이 조건 한 개(key op literal)여야 한다' });
+  const stateRaw = doc.state;
+  const state: Record<string, string | number | boolean> = {};
+  if (!stateRaw || typeof stateRaw !== 'object' || Array.isArray(stateRaw)) {
+    errors.push({ path: `${label}/state`, message: 'state는 스칼라 값만 담는 맵이어야 한다' });
+  } else {
+    for (const [key, value] of Object.entries(stateRaw as Record<string, unknown>)) {
+      if (!/^[a-z_][a-z0-9_]*$/i.test(key) || !['string', 'number', 'boolean'].includes(typeof value)
+        || (typeof value === 'number' && !Number.isFinite(value))) {
+        errors.push({ path: `${label}/state/${key}`, message: 'state 키와 값은 조건 파서가 다루는 키·문자열·유한수·불리언이어야 한다' });
+      } else state[key] = value as string | number | boolean;
+    }
+  }
+  const overlaysRaw = doc.overlays;
+  const overlays = Array.isArray(overlaysRaw) ? overlaysRaw.filter((value): value is string => typeof value === 'string') : undefined;
+  if (!Array.isArray(overlaysRaw) || !overlays || overlays.length !== overlaysRaw.length || new Set(overlays).size !== overlays.length)
+    errors.push({ path: `${label}/overlays`, message: 'overlays는 중복 없는 문자열 목록이어야 한다' });
+  if (errors.length > 0) return { errors };
+  return { profile: { profileId: profileId!, appliesWhen: appliesWhen!, state, overlays: overlays! }, errors };
+}
+
+export interface GraphProfileLoadResult {
+  readonly profiles: readonly GraphProfileSpec[];
+  readonly errors: readonly GraphParseIssue[];
+  readonly scannedFiles: number;
+}
+
+export function loadGraphProfiles(dir: string): GraphProfileLoadResult {
+  let files: string[];
+  try { files = readdirSync(dir).filter((file) => file.endsWith('.yaml') || file.endsWith('.yml')).sort(); }
+  catch (error) { return { profiles: [], errors: [{ path: dir, message: `프로필 디렉토리를 못 읽었다: ${error instanceof Error ? error.message : String(error)}` }], scannedFiles: 0 }; }
+  const errors: GraphParseIssue[] = [];
+  const profiles: GraphProfileSpec[] = [];
+  for (const file of files) {
+    try {
+      const parsed = parseGraphProfileYaml(readFileSync(join(dir, file), 'utf8'), file);
+      errors.push(...parsed.errors);
+      if (parsed.profile) profiles.push(parsed.profile);
+    } catch (error) { errors.push({ path: file, message: `읽기 실패: ${error instanceof Error ? error.message : String(error)}` }); }
+  }
+  const seen = new Set<string>();
+  for (const profile of profiles) {
+    if (seen.has(profile.profileId)) errors.push({ path: `${dir}/${profile.profileId}`, message: `profile_id '${profile.profileId}'가 중복이다` });
+    seen.add(profile.profileId);
+  }
+  return errors.length ? { profiles: [], errors, scannedFiles: files.length } : { profiles, errors, scannedFiles: files.length };
+}
+
+export function defaultProfilesDir(): string {
+  return join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'graphs', 'profiles');
+}
+
+export interface GraphProfileSelection {
+  readonly applied: readonly GraphProfileSpec[];
+  readonly errors: readonly string[];
+  readonly state: Readonly<Record<string, unknown>>;
+}
+
+/** Match all profiles deterministically; conflicting owned state rejects the whole profile set. */
+export function selectGraphProfiles(
+  profiles: readonly GraphProfileSpec[],
+  state: Readonly<Record<string, unknown>>,
+): GraphProfileSelection {
+  const applied = profiles.filter((profile) => evaluateOverlayCondition(profile.appliesWhen, state).kind === 'applies');
+  const owned = new Map<string, string | number | boolean>();
+  const errors: string[] = [];
+  for (const profile of applied) for (const [key, value] of Object.entries(profile.state)) {
+    if (owned.has(key) && owned.get(key) !== value) errors.push(`profile state conflict: ${key} (${String(owned.get(key))} vs ${String(value)})`);
+    else owned.set(key, value);
+  }
+  if (errors.length) return { applied: [], errors, state };
+  return { applied, errors, state: { ...state, ...Object.fromEntries(owned) } };
+}

package/src/self-implement/graph-yaml.ts

@@ -37,6 +37,8 @@ export interface GraphNodeSpec {
   /** Entry selected by this call when a unit exposes more than one entry. */
   readonly callEntry?: string;
   readonly budget?: { readonly innerSteps: number };
+  /** ARG L upper bound inherited by this child graph call. */
+  readonly allowance?: { readonly innerSteps: number };
   /** L1: skip this optional node when a measured state condition holds. */
   readonly skipWhen?: string;
 }
@@ -65,6 +67,8 @@ export interface GraphTemplateSpec {
   /** 문서 전용 변경이면 gate 노드를 건너뛸 수 있다는 템플릿 정책. */
   readonly docsOnlyGateSkip?: boolean;
   readonly state?: readonly string[];
+  /** ARG L upper bound for this graph's total executed steps. */
+  readonly allowance?: { readonly innerSteps: number };
   /** ⭐ 런 계약(선택) — 이 그래프가 «기본으로» 요구하는 실행 칸 등. 발사 인자가 덮는다(graph-run-contract.ts). */
   readonly runContract?: GraphRunContractSpec;
   readonly unit?: { readonly inputs: readonly string[]; readonly outputs: readonly string[]; readonly exits: readonly string[]; readonly entries?: readonly string[] };
@@ -148,6 +152,14 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
 
   const terminalNodes = asArray(doc.terminal_nodes).filter((v): v is string => typeof v === 'string');
   if (terminalNodes.length === 0) errors.push({ path: `${label}/terminal_nodes`, message: 'terminal_nodes 가 비었다 — 끝날 수 없는 그래프다' });
+  let allowance: GraphTemplateSpec['allowance'];
+  if (doc.allowance !== undefined) {
+    const value = doc.allowance as Record<string, unknown> | undefined;
+    if (!value || typeof value !== 'object' || Array.isArray(value) || !Number.isSafeInteger(value.inner_steps) ||
+        (value.inner_steps as number) < 1 || Object.keys(value).some(key => key !== 'inner_steps'))
+      errors.push({ path: `${label}/allowance/inner_steps`, message: 'inner_steps 는 1 이상의 안전한 정수여야 한다' });
+    else allowance = { innerSteps: value.inner_steps as number };
+  }
 
   const journeyStages = doc.journey_stages;
   if (journeyStages !== undefined && (!Array.isArray(journeyStages) || journeyStages.length === 0
@@ -202,21 +214,28 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
       : undefined;
     // A subgraph node becomes a unit call only when it names `call:`; without it the node keeps the
     // pre-unit meaning (catalog role / recipe node), so existing declarations stay valid.
-    if (kind === 'subgraph' && (n.call !== undefined || n.budget !== undefined || n.call_entry !== undefined)) {
+    if (kind === 'subgraph' && (n.call !== undefined || n.budget !== undefined || n.allowance !== undefined || n.call_entry !== undefined)) {
       if (typeof n.call !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]*@(?:\^?[1-9]\d*)$/.test(n.call))
         errors.push({ path: `${at}/call`, message: 'call 은 id@정수판 또는 id@^주판이어야 한다' });
       const budget = n.budget as Record<string, unknown> | undefined;
       if (!budget || typeof budget !== 'object' || Array.isArray(budget) ||
           !Number.isSafeInteger(budget.inner_steps) || (budget.inner_steps as number) < 1 || Object.keys(budget).some(key => key !== 'inner_steps'))
         errors.push({ path: `${at}/budget/inner_steps`, message: 'inner_steps 는 1 이상의 안전한 정수여야 한다' });
+      if (n.allowance !== undefined) {
+        const childAllowance = n.allowance as Record<string, unknown> | undefined;
+        if (!childAllowance || typeof childAllowance !== 'object' || Array.isArray(childAllowance) ||
+            !Number.isSafeInteger(childAllowance.inner_steps) || (childAllowance.inner_steps as number) < 1 ||
+            Object.keys(childAllowance).some(key => key !== 'inner_steps'))
+          errors.push({ path: `${at}/allowance/inner_steps`, message: 'inner_steps 는 1 이상의 안전한 정수여야 한다' });
+      }
       if (!contractRaw || !Array.isArray(contractRaw.inputs) || !contractRaw.inputs.every(v => typeof v === 'string') ||
           !Array.isArray(contractRaw.outputs) || !contractRaw.outputs.every(v => typeof v === 'string'))
         errors.push({ path: `${at}/contract`, message: 'subgraph 에는 inputs·outputs 계약이 필요하다' });
       if (recipe !== 'none') errors.push({ path: `${at}/recipe`, message: 'subgraph 는 recipe 를 실행하지 않는다' });
       if (n.call_entry !== undefined && (typeof n.call_entry !== 'string' || !n.call_entry.trim()))
         errors.push({ path: `${at}/call_entry`, message: 'call_entry 는 비어 있지 않은 노드 id 여야 한다' });
-    } else if (kind !== 'subgraph' && (n.call !== undefined || n.budget !== undefined || n.call_entry !== undefined)) {
-      errors.push({ path: at, message: 'call·call_entry·budget 은 subgraph 전용이다' });
+    } else if (kind !== 'subgraph' && (n.call !== undefined || n.budget !== undefined || n.allowance !== undefined || n.call_entry !== undefined)) {
+      errors.push({ path: at, message: 'call·call_entry·budget·allowance 은 subgraph 전용이다' });
     }
     // ⛔ 계약이 없으면 「이 노드가 무엇을 할 수 있나」를 답할 수 없다 — 경고로 남긴다(거절은 오버레이 쪽).
     if (contract === undefined) warnings.push({ path: `${at}/contract`, message: '계약(inputs·tools·outputs)이 없다 — 권한을 코드에서만 알 수 있다' });
@@ -235,6 +254,9 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
       ...(kind === 'subgraph' && n.budget && typeof n.budget === 'object' && !Array.isArray(n.budget) &&
         typeof (n.budget as Record<string, unknown>).inner_steps === 'number'
         ? { budget: { innerSteps: (n.budget as { inner_steps: number }).inner_steps } } : {}),
+      ...(kind === 'subgraph' && n.allowance && typeof n.allowance === 'object' && !Array.isArray(n.allowance) &&
+        typeof (n.allowance as Record<string, unknown>).inner_steps === 'number'
+        ? { allowance: { innerSteps: (n.allowance as { inner_steps: number }).inner_steps } } : {}),
       ...(typeof n.skip_when === 'string' ? { skipWhen: n.skip_when } : {}),
     });
   }
@@ -358,6 +380,7 @@ export function parseGraphTemplateYaml(source: string, label = '<inline>'): Grap
       ...(loop ? { loop } : {}),
       ...(typeof doc.docs_only_gate_skip === 'boolean' ? { docsOnlyGateSkip: doc.docs_only_gate_skip } : {}),
       ...(Array.isArray(doc.state) ? { state: doc.state.filter((v): v is string => typeof v === 'string') } : {}),
+      ...(allowance ? { allowance } : {}),
       ...(runContract.spec ? { runContract: runContract.spec } : {}),
     },
     errors, warnings,

package/src/self-implement/headless-elanous-driver.ts

@@ -87,14 +87,14 @@ import type { ChannelBus } from '../terminal-matrix/channel-bus.js';
 import { federationObservation } from './orchestrator.js';
 // ⛔ 배달 상태는 「정하는 쪽」(orchestrator)이 소유한다 — 여기는 받아서 찍기만 한다.
 import type { SupervisorDeliveryLine, SupervisorDeliveryState } from './orchestrator.js';
-import type { RunShardIdentity } from './run-ledger.js';
+import { runLedgerDir, type RunShardIdentity } from './run-ledger.js';
+import { readRunChart, recordRunChartDecision, recordRunChartWaitHandoff, RUN_DOCTOR_HANDOFF_WAIT_THRESHOLD, RUN_DOCTOR_HANDOFF_INPUT_PREFIX } from './run-chart.js';
 
 const sleep = (ms: number) => new Promise<void>((r) => setTimeout(r, ms));
 
 // Boundary requests observed up to about 788 characters; preserve the complete request record.
 const HARNESS_BOUNDARY_REQUEST_STRING_MAX = 1024;
 const WAIT_SUPERVISION_PROGRESS_BATCH_SIZE = 5;
-
 /** Renders untrusted boundary metadata as one inert terminal line for the parent surface. */
 export function singleLineBoundarySurfaceValue(value: string): string {
   return value
@@ -1267,6 +1267,9 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
   let sameCommandStallCount = 0;
   let pendingWaitSupervisionCount = 0;
   let pendingWaitLatestJudgment: string | undefined;
+  let consecutiveWaitDecisionCount = 0;
+  let waitStreakHandoffSent = false;
+  let waitStreakIndex = 0;
   // Repetition identity is exact full instruction-text equality after the existing delivery trim;
   // the first occurrence omits the surface marker, and later occurrences are only annotated.
   const inputInstructionOccurrences = new Map<string, number>();
@@ -1699,6 +1702,8 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
                 descriptor: { controlStance: stance },
               });
               previousIntervention = intervention;
+              const chartDir = runLedgerDir(opts.stateDir);
+              const chartBeforeJudgment = readRunChart(runId, 'run-supervisor', chartDir);
               const controlObs: ControlObservation = {
                   screen: rendered,
                   state: curState,
@@ -1708,6 +1713,8 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
                   sameScreenMs: Math.max(0, nowMs - frameObs.screenSinceMs),
                   stallRung: frameObs.stallRung,
                   ...(roundContext ? { roundContext } : {}),
+                  runId,
+                  runChart: chartBeforeJudgment,
                 };
                 const controller = new AbortController();
                 let rejectParentAbort: ((reason: Error) => void) | undefined;
@@ -1821,11 +1828,14 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
                   debug.log('self-implement', 'brain.suggestion', supervisionVerdictPayload);
                   debug.log('self-implement', 'run-supervision.verdict', supervisionVerdictPayload);
                   if (decision.action === 'wait') {
+                    consecutiveWaitDecisionCount += 1;
                     pendingWaitSupervisionCount += 1;
                     pendingWaitLatestJudgment = decision.action;
                     if (pendingWaitSupervisionCount >= WAIT_SUPERVISION_PROGRESS_BATCH_SIZE) flushWaitSupervisionProgress();
                   } else {
                     flushWaitSupervisionProgress();
+                    consecutiveWaitDecisionCount = 0;
+                    waitStreakHandoffSent = false;
                     const input = decision.action === 'input' ? decision.text.trim() : '';
                     const inputInstructionOccurrence = input ? countInputInstructionOccurrence(input) : undefined;
                     const delivery = input ? (opts.onSupervisorInput ? 'queued' : 'not-delivered') : undefined;
@@ -1858,6 +1868,25 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
                       }), 'supervision');
                     });
                   }
+                  const handoffNow = decision.action === 'wait'
+                    && consecutiveWaitDecisionCount >= RUN_DOCTOR_HANDOFF_WAIT_THRESHOLD && !waitStreakHandoffSent;
+                  const chartStopKey = handoffNow ? `${runId}:wait-streak:${waitStreakIndex + 1}` : `${runId}:supervisor:${i}`;
+                  const chartWrite = handoffNow
+                    ? recordRunChartWaitHandoff({ runId, stopKey: chartStopKey, waitCount: consecutiveWaitDecisionCount,
+                      readStopKeys: chartBeforeJudgment.map((cell) => cell.stopKey), dir: chartDir })
+                    : recordRunChartDecision({ runId, device: 'run-supervisor', stopKey: chartStopKey,
+                      observed: `${curState}; stallRung=${st?.rung ?? NO_STALL}`, verdict: decision.action,
+                      action: decision.action === 'input' ? decision.text.slice(0, 120) : decision.action,
+                      handoff: decision.action === 'no-progress' ? 'macrophage' : null,
+                      why: decision.action === 'no-progress' ? decision.reason : `supervisor ${decision.action}`,
+                      readStopKeys: chartBeforeJudgment.map((cell) => cell.stopKey), dir: chartDir });
+                  if (handoffNow && (chartWrite === 'recorded' || chartWrite === 'already-recorded')) {
+                    waitStreakHandoffSent = true; waitStreakIndex += 1;
+                    debug.log('run-supervisor', 'doctor-handoff', { runId, stopKey: chartStopKey, waitCount: consecutiveWaitDecisionCount, handoff: 'doctor' });
+                    opts.onSupervisorInput?.(`${RUN_DOCTOR_HANDOFF_INPUT_PREFIX} runId=${runId} stopKey=${chartStopKey} waitCount=${consecutiveWaitDecisionCount}`, (delivery, reason) => {
+                      try { debug.log('run-supervisor', 'doctor-handoff-delivery', { runId, stopKey: chartStopKey, delivery, ...(reason ? { reason } : {}) }); } catch { /* observation is fail-soft */ }
+                    });
+                  }
                   debug.log('self-implement', 'brain.input-outcome', {
                     ptyId: h.id, runId, step: i, axis: 'assist', action: decision.action,
                     applied: autoAssist.assist, why: autoAssist.why,

package/src/self-implement/heal-intake.ts

@@ -6,6 +6,7 @@ import { debug } from '../debug/log.js';
 import { passJourneyNode } from '../self-dev/graph-journey-nodes.js';
 import { getUserConfig } from '../user-config.js';
 import { psProcessStartMs, START_TOLERANCE_MS } from '../harness/harness-stop.js';
+import { appendRunLedgerEntry, runLedgerDir } from './run-ledger.js';
 
 export type FailureSource = 'release-run' | 'harness-run' | 'loop-tick' | 'cron';
 
@@ -14,14 +15,19 @@ export interface FailureEvent {
   kind: string;
   ref: string;
   summary: string;
+  goalText?: string;
+  goalId?: string;
+  goalFile?: string;
+  cellKey?: string;
   at: string;
 }
 
 const FOLD_WINDOW_MS = 60 * 60 * 1_000;
 const HEAL_GRAPH = join(import.meta.dir, '../../graphs/heal/heal-loop.yaml');
 
-type HealLoopOptions = { runId: string; input: { failureEvent: FailureEvent }; deps: { root: string } };
+type HealLoopOptions = { runId: string; input: { failureEvent: FailureEvent; runId?: string; goal?: string; goalId?: string; goalFile?: string }; deps: { root: string } };
 type StartHealLoop = (file: string, options: HealLoopOptions) => Promise<unknown>;
+export type HealRelaunch = (input: { runId: string; goalText: string; goalId?: string; goalFile?: string; cellKey: string; stateRoot: string }) => Promise<unknown>;
 
 function healRunId(event: FailureEvent): string {
   return `heal-${createHash('sha256').update(JSON.stringify([event.source, event.ref, event.at])).digest('hex')}`;
@@ -68,7 +74,8 @@ function liveHealRuns(root: string): Set<string> {
 
 /** A test process must never start the real heal loop — it spawns external grounding (10-05 load 150 incident). */
 export async function startHealLoop(file: string, options: HealLoopOptions, env: NodeJS.ProcessEnv = process.env,
-  run: StartHealLoop = async (graph, args) => (await import('../graph-runner/runner.js')).runGraph(graph, args)): Promise<unknown> {
+  run: StartHealLoop = async (graph, args) => (await import('../graph-runner/runner.js')).runGraph(graph, args),
+  relaunch: HealRelaunch = runReauthoredGoal): Promise<unknown> {
   if (env.ELANOUS_POD_NAME) {
     debug.log('heal.intake', 'skipped-in-pod', { ref: options.input.failureEvent.ref });
     return undefined;
@@ -112,8 +119,40 @@ export async function startHealLoop(file: string, options: HealLoopOptions, env:
   if (!selected) return undefined;
   let started = false;
   try {
-    const result = await run(file, { runId: selected.runId, input: { failureEvent: selected.event }, deps: { root } });
+    const result = await run(file, { runId: selected.runId, input: { failureEvent: selected.event, runId: selected.event.ref, goal: selected.event.goalText, goalId: selected.event.goalId, goalFile: selected.event.goalFile }, deps: { root } });
     started = true;
+    const request = reauthorRequest(result);
+    if (request) {
+      const cellKey = selected.event.goalId || selected.event.goalFile || selected.event.cellKey
+        || (selected.event.goalText?.trim() ? `goal:${createHash('sha256').update(selected.event.goalText.replace(/\s+/g, ' ').trim()).digest('hex')}` : `run:${selected.event.ref}`);
+      if (!claimReauthorAttempt(root, cellKey, selected.runId)) {
+        debug.log('heal.intake', 'reauthor-already-attempted', { runId: selected.runId, goalId: selected.event.goalId ?? null });
+        return { result, reauthor: 'already-attempted' };
+      }
+      try {
+        debug.log('self-dev.supervisor', 'reauthor-relaunch-requested', { runId: selected.runId, goalId: selected.event.goalId ?? null });
+        const relaunched = await relaunch({ runId: selected.event.ref, goalText: request.revisedGoal,
+          ...(selected.event.goalId ? { goalId: selected.event.goalId } : {}),
+          ...(selected.event.goalFile ? { goalFile: selected.event.goalFile } : {}), cellKey, stateRoot: root });
+        if (relaunched && typeof relaunched === 'object' && 'ok' in relaunched && (relaunched as { ok?: unknown }).ok !== true) {
+          const value = relaunched as { stage?: unknown; node?: unknown; outcome?: unknown };
+          throw new Error(`needs-human: reauthored run failed (${String(value.stage ?? value.node ?? value.outcome ?? 'unknown')})`);
+        }
+        appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId: selected.event.ref, event: 'reauthor-relaunch-result',
+          data: { outcome: 'started', goalId: selected.event.goalId ?? null, requestRunId: selected.runId, result: summarizeRelaunch(relaunched) } }, runLedgerDir(root));
+        return { result, reauthor: 'relaunched', relaunched };
+      } catch (error) {
+        appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId: selected.event.ref, event: 'reauthor-relaunch-result',
+          data: { outcome: 'needs-human', reason: error instanceof Error ? error.message : String(error) } }, runLedgerDir(root));
+        return { result, reauthor: 'needs-human', reason: error instanceof Error ? error.message : String(error) };
+      }
+    }
+    const replanFailure = reauthorFailure(result);
+    if (replanFailure) {
+      appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId: selected.event.ref, event: 'reauthor-relaunch-result',
+        data: { outcome: 'needs-human', reason: replanFailure, graphRunId: selected.runId } }, runLedgerDir(root));
+      return { result, reauthor: 'needs-human', reason: replanFailure };
+    }
     return result;
   } finally {
     withInboxLock(inboxPath(root), () => {
@@ -125,12 +164,81 @@ export async function startHealLoop(file: string, options: HealLoopOptions, env:
       }
     });
     // A completed run opens a slot; a pre-ledger failure waits for the next intake rather than retrying in a tight loop.
-    if (started) void Promise.resolve().then(() => startHealLoop(file, options, env, run)).catch(error => {
+    if (started) void Promise.resolve().then(() => startHealLoop(file, options, env, run, relaunch)).catch(error => {
       debug.log('heal.intake', 'loop-start-failed', { runId: selected.runId, error: String(error) }, { level: 'error' });
     });
   }
 }
 
+function graphOutput(result: unknown, nodeId: string): Record<string, unknown> | undefined {
+  if (!result || typeof result !== 'object') return undefined;
+  const nodes = (result as { nodes?: unknown }).nodes;
+  if (!Array.isArray(nodes)) return undefined;
+  const node = nodes.find((item) => item && typeof item === 'object' && (item as { nodeId?: unknown }).nodeId === nodeId) as { output?: unknown } | undefined;
+  if (typeof node?.output === 'string') {
+    const text = node.output.trim().split(/\r?\n/).at(-1) ?? '';
+    try { return JSON.parse(text) as Record<string, unknown>; } catch { return undefined; }
+  }
+  return node?.output && typeof node.output === 'object' ? node.output as Record<string, unknown> : undefined;
+}
+
+function reauthorRequest(result: unknown): { revisedGoal: string } | undefined {
+  const output = graphOutput(result, 'replan');
+  return output?.outcome === 'ok' && output.reauthor === true && typeof output.revisedGoal === 'string' && output.revisedGoal.trim()
+    ? { revisedGoal: output.revisedGoal } : undefined;
+}
+
+function reauthorFailure(result: unknown): string | undefined {
+  const output = graphOutput(result, 'replan');
+  return output?.outcome === 'fail' && output.needsHuman === true
+    ? (typeof output.reason === 'string' ? output.reason : 'reauthor could not produce a safe revised goal') : undefined;
+}
+
+function claimReauthorAttempt(root: string, cellKey: string, runId: string): boolean {
+  const path = join(root, 'heal', 'reauthor-attempts', `${createHash('sha256').update(cellKey).digest('hex')}.json`);
+  return withInboxLock(path, () => {
+    if (existsSync(path)) return false;
+    writeFileSync(path, JSON.stringify({ cellKey, runId, claimedAt: new Date().toISOString() }), { flag: 'wx', mode: 0o600 });
+    return true;
+  });
+}
+
+function summarizeRelaunch(result: unknown): Record<string, unknown> {
+  if (!result || typeof result !== 'object') return { resultType: typeof result };
+  const value = result as Record<string, unknown>;
+  return Object.fromEntries(['ok', 'stage', 'node', 'runId', 'worktreePath', 'branch', 'detail'].flatMap((key) => key in value ? [[key, value[key]]] : []));
+}
+
+async function runReauthoredGoal(input: Parameters<HealRelaunch>[0]): Promise<unknown> {
+  const [{ runSelfImplement, readQuotaExhausted }, { defaultSeams }, devCli, { reselectChildForRework }, { resolveGrokCredential }, { inspectCodexRotation }, ledger] = await Promise.all([
+    import('./orchestrator.js'), import('./seams.js'), import('../self-dev/dev-cli.js'), import('./rework-child-provider.js'),
+    import('../grok/credential.js'), import('../oauth/codex-account-store.js'), import('./run-ledger.js'),
+  ]);
+  let childLlm = devCli.buildChildLlmSelection({});
+  if (childLlm?.provider === 'grok') {
+    const grokQuota = devCli.readGrokQuotaForLaunch();
+    const grokCredential = resolveGrokCredential() ? 'available' as const : 'unavailable' as const;
+    const rotation = inspectCodexRotation();
+    const quota = readQuotaExhausted(inspectCodexRotation, 'openai-codex');
+    const hasCodex = rotation.knownAccountCount > 0;
+    const alternate = hasCodex ? { provider: 'openai-codex', model: devCli.defaultChildLlmModel('openai-codex'), source: 'config' as const } : undefined;
+    const decision = reselectChildForRework({ current: childLlm, grokQuota, grokCredential, ...(alternate ? { alternate } : {}),
+      alternateCredential: hasCodex ? 'available' : 'unavailable', alternateQuotaExhausted: quota.exhausted });
+    if (decision.action === 'reselect') {
+      childLlm = decision.selection;
+      ledger.appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId: input.runId, event: 'rework-child-model-reselected',
+        data: { previousProvider: decision.previous.provider, previousModel: decision.previous.model, provider: childLlm.provider,
+          model: childLlm.model, reason: decision.reason, quota: grokQuota, grokCredential,
+          alternateQuotaExhausted: quota.exhausted ?? null } }, runLedgerDir(input.stateRoot));
+    }
+    else if (grokQuota === 'exhausted' || grokCredential === 'unavailable') throw new Error('needs-human: Grok unusable and no measured alternate provider');
+  }
+  const runId = `reauthor-${createHash('sha256').update(`${input.runId}\0${input.goalId ?? ''}`).digest('hex').slice(0, 20)}`;
+  return runSelfImplement({ feature: input.goalText, runId, ...(input.goalId ? { goalId: input.goalId } : {}),
+    ...(input.goalFile ? { goalFile: input.goalFile } : {}), healCellKey: input.cellKey, ...(childLlm ? { childLlm } : {}),
+    completion: 'worktree-only', draft: true, maxReworkRounds: 0, seams: defaultSeams({ stateDir: input.stateRoot }) });
+}
+
 function inboxPath(root: string): string {
   return join(root, 'heal', 'inbox.jsonl');
 }

package/src/self-implement/heal-triage.ts

@@ -11,6 +11,7 @@ export type HealTriageOutcome =
   | 'needs-deeper-observation'
   | 'needs-grounding'
   | 'rework-with-citations'
+  | 'reauthor-from-materialized'
   | 'exhausted';
 
 export interface HealCitation {
@@ -30,6 +31,12 @@ export interface HealFailureSignature {
   readonly importerUnrunTests?: number;
   readonly environmentClaim?: string;
   readonly namedSource?: string;
+  /** Observations from the failed materialized run; no new collector is implied. */
+  readonly noProgressReason?: string;
+  readonly reportDeficit?: boolean;
+  readonly mustFix?: readonly string[];
+  readonly materializedPaths?: readonly string[];
+  readonly goalText?: string;
 }
 
 /** 게이트 사실로 채울 수 있는 칸. 없는 칸만 채운다. */
@@ -227,6 +234,19 @@ export function triageFailure(signature: HealFailureSignature, history?: HealTri
   const importer = signature.importerUnrunTests ?? 0;
   const claim = signature.environmentClaim?.trim() ?? '';
 
+  const mustFix = (signature.mustFix ?? []).map((item) => item.trim()).filter(Boolean);
+  const repeatedMustFix = mustFix.some((item, index) => mustFix.slice(0, index).includes(item));
+  if (signature.noProgressReason?.trim() || signature.reportDeficit || signature.materializedPaths?.length === 0
+    || repeatedMustFix || (signature.errorText ?? '').includes('tdd-evidence-missing')) {
+    return { outcome: 'reauthor-from-materialized', evidence: [
+      ...(signature.noProgressReason ? [`no-progress: ${signature.noProgressReason}`] : []),
+      ...(signature.reportDeficit ? ['report-deficit'] : []),
+      ...(signature.materializedPaths?.length === 0 ? ['actual target paths: 0'] : []),
+      ...(repeatedMustFix ? ['same must-fix repeated'] : []),
+      ...((signature.errorText ?? '').includes('tdd-evidence-missing') ? ['tdd-evidence-missing'] : []),
+    ] };
+  }
+
   if (claim && ENVIRONMENT_CLAIM.test(claim) && !visited(history, 'verify-evidence')) {
     return {
       outcome: 'environment-claimed',

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

@@ -12,7 +12,7 @@ import { detectTestInterference, failedNamesFromStreams, parseFailureCount, runB
 import { MAX_INSPECTED_TEST_FILES, runTestInterferenceGate } from '../../scripts/ci-test-interference-gate.js';
 import { pwaGraph, pwaReach } from '../../scripts/ci-pwa-build-gate.js';
 import { changedPathPairs, changedTsFiles, readGitFile, requiredExportFieldsInChanges } from '../../scripts/ci-typecheck-changed.js';
-import { classifyMergeFailure, clipRegateDetail, parseConflictFiles, type HostRegateFailure } from './regate-detail.js';
+import { classifyMergeFailure, clipRegateDetail, parseConflictFiles, type HostRegateFailure, type HostRegatePrHeadFailureCondition, type HostRegatePrHeadSnapshot } from './regate-detail.js';
 import { buildImporterTestIndex, isTestPath } from './importer-test-index.js';
 import type { GateReceipt, GateReceiptIdentity } from './gate-receipt-registry.js';
 
@@ -386,9 +386,32 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     release = await (deps.acquire ?? acquireSlot)(input.repoRoot);
     type PrView = { headRefOid?: string; baseRefName?: string; baseRefOid?: string; state?: string; isDraft?: boolean };
     const readPr = (): PrView => JSON.parse(run('gh', ['pr', 'view', String(input.prNumber), '--json', 'headRefOid,baseRefName,baseRefOid,state,isDraft'], input.repoRoot));
-    const prHeadFailure = (seen: PrView): HostRegateResult => result('unmeasured', 'pr-head',
-      `PR head, base commit, ready state or open state unavailable or changed (state=${seen.state ?? 'unknown'} · isDraft=${String(seen.isDraft)} · base=${seen.baseRefName ?? 'unknown'}@${seen.baseRefOid ?? 'unknown'})`,
-      { expectedHead: input.headCommit, actualHead: typeof seen.headRefOid === 'string' ? seen.headRefOid : null });
+    const prHeadFailure = (seen: PrView): HostRegateResult => {
+      const failedConditions: HostRegatePrHeadFailureCondition[] = [];
+      const validHead = typeof seen.headRefOid === 'string' && /^[0-9a-f]{40}$/i.test(seen.headRefOid);
+      if (!validHead) failedConditions.push('head-unavailable');
+      else if (seen.headRefOid !== input.headCommit) failedConditions.push('head-mismatch');
+      if (typeof seen.state !== 'string') failedConditions.push('state-unavailable');
+      else if (seen.state !== 'OPEN') failedConditions.push('state-not-open');
+      if (typeof seen.isDraft !== 'boolean') failedConditions.push('draft-status-unavailable');
+      else if (seen.isDraft && !input.allowDraft) failedConditions.push('pr-is-draft');
+      if (!seen.baseRefName) failedConditions.push('base-name-unavailable');
+      const validBaseOid = typeof seen.baseRefOid === 'string' && /^[0-9a-f]{40}$/i.test(seen.baseRefOid);
+      if (!validBaseOid) failedConditions.push('base-oid-invalid');
+      failedConditions.sort();
+      const state: HostRegatePrHeadSnapshot['state'] =
+        seen.state === 'OPEN' || seen.state === 'CLOSED' || seen.state === 'MERGED' ? seen.state : typeof seen.state === 'string' ? 'OTHER' : null;
+      const snapshot: HostRegatePrHeadSnapshot = {
+        headRefOid: validHead ? seen.headRefOid! : null,
+        state,
+        isDraft: typeof seen.isDraft === 'boolean' ? seen.isDraft : null,
+        baseRefName: !seen.baseRefName ? null : seen.baseRefName === 'main' ? 'main' : 'other',
+        baseRefOid: validBaseOid ? seen.baseRefOid! : null,
+      };
+      return result('unmeasured', 'pr-head',
+        `PR head preflight failed: ${failedConditions.join(', ') || 'unknown'} (state=${snapshot.state ?? 'unknown'} · isDraft=${String(snapshot.isDraft)} · base=${snapshot.baseRefName ?? 'unknown'}@${snapshot.baseRefOid ?? 'unknown'})`,
+        { expectedHead: input.headCommit, actualHead: snapshot.headRefOid, failedConditions, prHeadSnapshot: snapshot });
+    };
     let view: PrView;
     try { view = readPr(); }
     catch (e) { return result('unmeasured', 'pr-view', String(e)); }