elanous 0.2.41 → 0.2.42

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)); }

package/src/self-implement/merge-train.ts

@@ -18,6 +18,11 @@ export type TrainObservation = {
 export type TrainGit = (args: readonly string[], repo: string) => { status: number | null; stdout: string; stderr: string };
 export type TangledPair = { first: number; then: number; failures: number };
 
+/**
+ * Same PR-number axis as TrainDeferred.with and planTrain overlap deferrals: normalize each sibling
+ * pair ({5,7}={7,5}), count its conflict-resolution/regate failures, and return only pairs at or
+ * above threshold (default 2) — first = smaller number = lands first, then = re-synced later.
+ */
 export function tangledPairs(
   failures: readonly { pr: number; with: number }[],
   { threshold = 2 }: { threshold?: number } = {},

package/src/self-implement/orchestrator.ts

@@ -106,11 +106,12 @@ export function formatAutoMergeSuccessMessage(input: {
 import { GoalRunStore, insertGoalRunRecord, type GoalPriorRuns } from './goal-run-store.js';
 import { writeGoalRunRecordFragment } from './goal-execution-records.js';
 import { getUserConfig } from '../user-config.js';
-import { appendRunLedgerEntry, loadRunLedger, parseRunShardIdentity, queryRunChain, type RunChainShardSibling, type RunLedgerEntry, type RunLedgerWriter, type RunOriginData, type RunShardIdentity } from './run-ledger.js';
-import { classifyMergeHoldStop, classifyTerminalHarnessFailure, forgetRunStop, isRunStopClass, readRunStopRecord, recordRunStop, runStopRecorded } from './run-stop.js';
+import { appendRunLedgerEntry, loadRunLedger, parseRunShardIdentity, queryRunChain, runLedgerDir, type RunChainShardSibling, type RunLedgerEntry, type RunLedgerWriter, type RunOriginData, type RunShardIdentity } from './run-ledger.js';
+import { buildRunStopTerminalEvidence, classifyMergeHoldStop, classifyTerminalHarnessFailure, forgetRunStop, isRunStopClass, readRunStopRecord, recordRunStop, runStopRecorded } from './run-stop.js';
 import { autohealFromStop, parseAutohealMode, pickAutohealAction, type AutohealActions, type AutohealResult } from './stop-autoheal.js';
 import { operationalAutohealActions } from './stop-autoheal-operational.js';
-import { recordParentNeedsOwnerVisit } from './doctor-visit.js';
+import { recordParentNeedsOwnerVisit, runDoctorHandoff } from './doctor-visit.js';
+import { readRunChart, recordRunChartDecision, RUN_DOCTOR_HANDOFF_INPUT_PREFIX } from './run-chart.js';
 import { emitSessionEvent, type SessionEventInput } from '../context-bus/session-events.js';
 import { decideLineageSupersede, lineageSupersedeCloseComment, type LineageSupersedeOpenDraft } from './lineage-supersede.js';
 import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
@@ -356,6 +357,9 @@ import {
 } from '../ask-user-question/tool.js';
 import { acquireClarificationResolverLease, decideClarificationResolverInstall } from './clarification-resolver-lease.js';
 import { inspectCodexRotation } from '../oauth/codex-account-store.js';
+import { resolveGrokCredential } from '../grok/credential.js';
+import { resolveChildLlmPreference } from './child-llm-preference.js';
+import { reselectChildForRework } from './rework-child-provider.js';
 import { resolveDefaultProvider } from '../llm.js';
 import { createWidgetAskUserResolver } from '../expression/widget/adapters/ask-user-resolver.js';
 import { createNodeReadlineHost } from '../expression/widget/readline-host.js';
@@ -1077,6 +1081,8 @@ export interface SelfImplementSeams {
   emitContextEvent?: (input: SessionEventInput) => void;
   /** Registers this run as an ephemeral loop-agent asset; failures are observed but never affect execution. */
   registerLoopAgent?: (input: LoopAgentInput) => void;
+  /** Executes a persisted run-doctor supervisor handoff; injectable to verify the parent delivery route. */
+  runDoctorHandoff?: typeof runDoctorHandoff;
   /** Wraps implementation and gate promises with their effective wall-clock timeout; tests observe the actual stage budgets. */
   withStepTimeout?: <T>(promise: Promise<T>, ms: number, step: keyof StepTimeouts) => Promise<T>;
   /** Samples the one-minute machine load at the end of a gate observation. */
@@ -2208,6 +2214,8 @@ export interface SelfImplementOptions {
   runId?: string;
   /** Authored goal document's stable identity, carried into self-implement observations when present. */
   goalId?: string;
+  /** Stable heal-cell identity propagated across supervisor reauthor retries. */
+  healCellKey?: string;
   /** Optional opaque ID for joining this request with correlated execution records. */
   correlationId?: string;
   /** Optional opaque ID for the parent correlation in a nested request. */
@@ -3580,6 +3588,9 @@ async function autohealRecordedStop(stopEntry: RunLedgerEntry, s: SelfImplementS
   try {
     const record = readRunStopRecord(stopEntry);
     if (!record) return;
+    const chartDir = runLedgerDir();
+    const chartBefore = readRunChart(stopEntry.runId, 'macrophage', chartDir);
+    const chartStopKey = JSON.stringify([stopEntry.timestamp, record.site ?? '', record.class, record.cause, record.evidenceRef]);
     try { debug.log('harness.heal', 'symptom', { runId: stopEntry.runId, class: record.class, cause: record.cause, evidenceRef: record.evidenceRef }); } catch { /* observation is fail-soft */ }
     const pick = pickAutohealAction(record.class);
     try { debug.log('harness.heal', 'prescription', { runId: stopEntry.runId, class: record.class, action: pick.action, source: pick.source, ...(pick.overlayId ? { overlayId: pick.overlayId } : {}) }); } catch { /* observation is fail-soft */ }
@@ -3596,10 +3607,13 @@ async function autohealRecordedStop(stopEntry: RunLedgerEntry, s: SelfImplementS
       ...(s?.writeRunLedger ? { writeLedger: s.writeRunLedger } : {}),
     });
     try { debug.log('harness.heal', 'outcome', { runId: stopEntry.runId, class: result.class, action: result.action, mode: result.mode, outcome: result.outcome, ...(result.reason ? { reason: result.reason } : {}), ...(result.detail ? { detail: result.detail } : {}) }); } catch { /* observation is fail-soft */ }
+    recordRunChartDecision({ runId: stopEntry.runId, device: 'macrophage', stopKey: chartStopKey,
+      observed: `${record.class}: ${record.cause}`, verdict: result.action, action: result.outcome,
+      handoff: result.action === 'needs-owner' ? 'outer-supervisor' : null,
+      why: result.reason ?? result.detail ?? record.cause, readStopKeys: chartBefore.map((cell) => cell.stopKey), dir: chartDir });
     if (result.action === 'needs-owner') {
       try {
-        const stopKey = JSON.stringify([stopEntry.timestamp, record.site ?? '', record.class, record.cause, record.evidenceRef]);
-        const visit = recordParentNeedsOwnerVisit({ runId: stopEntry.runId, stopKey, evidence: result.reason ?? record.cause });
+        const visit = recordParentNeedsOwnerVisit({ runId: stopEntry.runId, stopKey: chartStopKey, evidence: result.reason ?? record.cause });
         if (visit.status === 'missing-ledger') {
           debug.log('run-doctor', 'visit-failed', { runId: stopEntry.runId, from: 'parent', symptom: 'needs-owner', error: 'run-ledger-missing' });
         }
@@ -3626,11 +3640,23 @@ async function dispatchTerminalHarnessHeal(input: {
   if (runStopRecorded(runId)) return;
   const stopClass = mergeHeld ? classifyMergeHoldStop(result.mergeReason) : classifyTerminalHarnessFailure({
     stage: result.stage,
+    cause: result.detail,
     mergeReason: result.mergeReason,
     abandonedClassification: result.abandonedClassification?.classification,
     providerErrorCategory: result.providerErrors?.category,
     supervisorVerdict: result.supervisorVerdict,
   });
+  let priorLedger: RunLedgerEntry[] = [];
+  try { priorLedger = loadRunLedger(runId) ?? []; } catch { /* terminal observation must not change the run result */ }
+  const terminalEvidence = buildRunStopTerminalEvidence({
+    stage: result.stage,
+    node: result.node,
+    outcome: result.outcome,
+    detail: result.detail,
+    terminationReason: result.terminationReason,
+    providerErrorCategory: result.providerErrors?.category,
+    entries: priorLedger,
+  });
   let stopEntry: RunLedgerEntry | undefined;
   try {
     stopEntry = recordRunStop({
@@ -3639,9 +3665,11 @@ async function dispatchTerminalHarnessHeal(input: {
       shardIdentity,
       site: mergeHeld ? 'merge-hold' : `terminal-${result.stage}`,
       class: stopClass,
-      cause: mergeHeld ? `merge held: ${result.mergeReason}` : result.detail ?? `terminal failure: ${result.stage}`,
+      // Never copy free-form provider/child text into the durable stop summary.
+      cause: mergeHeld ? `merge held: ${result.mergeReason}` : `terminal failure: ${result.stage}; ${terminalEvidence.reasonCode}`,
       evidenceRef: result.prUrl ?? `run-ledger:${runId}:${result.stage}`,
       nextMove: `Existing heal ladder: ${stopClass}; failure disposition remains until its prescribed action resolves`,
+      terminalEvidence,
     }, seams.writeRunLedger ?? appendRunLedgerEntry);
   } catch { /* stop observation cannot change the run outcome */ }
   if (stopEntry) await autohealRecordedStop(stopEntry, seams);
@@ -4661,6 +4689,10 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
           summary: reworkCap
             ? reworkCapFailureSummary(opts.feature, reworkCap)
             : opts.feature.split(/\r?\n/, 1)[0]?.trim() || `Harness run ${runId} failed`,
+          goalText: opts.feature,
+          ...(opts.goalId ? { goalId: opts.goalId } : {}),
+          ...(opts.goalFile ? { goalFile: opts.goalFile } : {}),
+          ...(opts.healCellKey ? { cellKey: opts.healCellKey } : {}),
           at: new Date().toISOString(),
         });
       }
@@ -6112,6 +6144,7 @@ async function runSelfImplementInner(
   };
   let preservationBase = wt.resolvedBase;
   const runProviderName = opts.childLlm?.provider ?? (s.currentProviderName?.() ?? currentProviderName());
+  let activeChildLlm = opts.childLlm;
   let cachedQuotaExhaustionAssessment: QuotaExhaustionAssessment | undefined;
   const quotaExhaustionAssessmentForRun = (): QuotaExhaustionAssessment => {
     cachedQuotaExhaustionAssessment ??= readQuotaExhausted(s.inspectCodexRotation, runProviderName);
@@ -7240,7 +7273,38 @@ async function runSelfImplementInner(
           if (fabricObservation) observe('rework-budget-fabric-shadow', fabricObservation);
         }
       } catch (error) {
-        if (judgmentStarted) throw error;
+        if (judgmentStarted) {
+          const failureKind = classifyReviewProviderFailure(safeErrorDescription(error));
+          if (failureKind === 'credentials-unavailable') {
+            const blockedStage = isReviewRework(reworkKind) ? 'review-blocked' : 'gate-failed';
+            const reason = 'rework skipped: provider credentials unavailable';
+            observe('rework-skipped-provider-unavailable', { round, kind: reworkKind, reason: failureKind }, { level: 'warn' });
+            finalizeSupervisorDeliveries('rework-provider-credentials-unavailable');
+            if (blockedStage === 'review-blocked') recordPendingReviewTriage('follow-up', 'review-blocked', effectiveMax);
+            const pr = await preserveBlockedArtifacts({
+              stage: blockedStage,
+              reason,
+              gate,
+              failureKind,
+              salvageStatusExpected: false,
+            });
+            const common = {
+              ok: false as const,
+              node: 'rework' as const,
+              ...resolveRunOutcome({ termination: 'abandoned' }),
+              sessionId,
+              worktreePath: wt.path,
+              branch: wt.branch,
+              gate,
+              ...(review ? { review } : {}),
+              quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(),
+            };
+            return blockedStage === 'review-blocked'
+              ? { ...common, ...reviewBlockedResult(pr), detail: reason }
+              : { ...common, stage: 'gate-failed' as const, ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: reason };
+          }
+          throw error;
+        }
         consecutiveUnresolvedBudget = 0;
       }
     } else if (round > 0) {
@@ -7513,6 +7577,29 @@ async function runSelfImplementInner(
     let supervisorInputClosed = false;
     const closeSupervisorInput = (): void => { supervisorInputClosed = true; };
     try {
+      if (round > 0 && activeChildLlm?.provider === 'grok') {
+        const { readGrokQuotaForLaunch, defaultChildLlmModel } = await import('../self-dev/dev-cli.js');
+        const grokQuota = readGrokQuotaForLaunch();
+        const grokCredential = resolveGrokCredential() ? 'available' as const : 'unavailable' as const;
+        let codexRotation: ReturnType<typeof inspectCodexRotation> | undefined;
+        try { codexRotation = (s.inspectCodexRotation ?? inspectCodexRotation)(); } catch { codexRotation = undefined; }
+        const preference = resolveChildLlmPreference(getUserConfig());
+        const alternateSlot = preference.chain.find((slot) => slot.provider === 'openai-codex' && slot.provider !== activeChildLlm!.provider);
+        const hasCodexCredential = (codexRotation?.knownAccountCount ?? 0) > 0;
+        const codexQuota = readQuotaExhausted(s.inspectCodexRotation, 'openai-codex');
+        const alternate = hasCodexCredential ? {
+          provider: 'openai-codex', model: alternateSlot?.model ?? defaultChildLlmModel('openai-codex'), source: 'config' as const,
+        } : undefined;
+        const decision = reselectChildForRework({ current: activeChildLlm, grokQuota, grokCredential,
+          ...(alternate ? { alternate } : {}), alternateCredential: hasCodexCredential ? 'available' : 'unavailable',
+          alternateQuotaExhausted: codexQuota.exhausted });
+        if (decision.action === 'reselect') {
+          activeChildLlm = decision.selection;
+          observe('rework-child-model-reselected', { round, previousProvider: decision.previous.provider, previousModel: decision.previous.model,
+            provider: activeChildLlm.provider, model: activeChildLlm.model, reason: decision.reason, quota: grokQuota,
+            grokCredential, alternateQuotaExhausted: codexQuota.exhausted ?? null });
+        }
+      }
       implementPromise = s.implement({
       sessionId, cwd: wt.path, feature, runId, shardIdentity, signal: implementAbortController.signal,
       ...(harnessSeededPaths.length ? { harnessSeededPaths } : {}),
@@ -7525,6 +7612,31 @@ async function runSelfImplementInner(
           updateDelivery?.('not-delivered', 'empty-supervisor-input');
           return;
         }
+        if (normalized.startsWith(RUN_DOCTOR_HANDOFF_INPUT_PREFIX)) {
+          const runIdMatch = /(?:^|\s)runId=([^\s]+)/u.exec(normalized);
+          const stopKeyMatch = /(?:^|\s)stopKey=([^\s]+)/u.exec(normalized);
+          if (!runIdMatch?.[1] || runIdMatch[1] !== runId || !stopKeyMatch?.[1]) {
+            updateDelivery?.('not-delivered', 'invalid-run-doctor-handoff');
+            return;
+          }
+          void (s.runDoctorHandoff ?? runDoctorHandoff)({ runId, stopKey: stopKeyMatch[1], dir: runLedgerDir(elanousStateRoot() || undefined),
+            dispatch: (action, handoff) => {
+              if (action !== 'reauthor-from-materialized') return { outcome: 'needs-human', detail: `prescription executor not wired: ${action}` };
+              const accepted = recordFailureEvent({ source: 'harness-run', kind: 'run-supervisor-wait-streak', ref: runId,
+                summary: `[implement aborted] run-supervisor wait streak ${String(handoff.waitCount ?? 'unknown')} · doctor reauthor handoff`,
+                goalText: feature, ...(opts.goalId ? { goalId: opts.goalId } : {}), ...(opts.goalFile ? { goalFile: opts.goalFile } : {}),
+                ...(opts.healCellKey ? { cellKey: opts.healCellKey } : {}), at: new Date().toISOString() });
+              return { outcome: accepted.folded ? 'heal-event-already-present' : 'heal-graph-requested',
+                detail: accepted.folded ? 'same-run heal event already recorded' : 'PR1 heal intake accepted the materialized reauthor action' };
+            },
+          }).then((result) => {
+            updateDelivery?.(result.status === 'acted' || result.status === 'already-acted' ? 'delivered' : 'not-delivered',
+              result.status === 'needs-human' ? result.outcome : result.status === 'missing-handoff' ? 'run-chart-handoff-missing' : undefined);
+          }).catch((error: unknown) => {
+            updateDelivery?.('not-delivered', error instanceof Error ? error.message.slice(0, 120) : String(error).slice(0, 120));
+          });
+          return;
+        }
         if (supervisorInputClosed) {
           recordUndeliveredSupervisorInput(normalized, 'late-supervisor-input');
           updateDelivery?.('not-delivered', 'late-supervisor-input');
@@ -7540,7 +7652,7 @@ async function runSelfImplementInner(
         supervisorDeliveryUpdates.push({ text: normalized, update: updateDelivery });
       },
       ...(escalateTier !== 'none' ? { escalateTier } : {}),
-      ...(opts.childLlm ? { childLlm: opts.childLlm } : {}),
+      ...(activeChildLlm ? { childLlm: activeChildLlm } : {}),
       ...(opts.documentReferences ? { documentReferences: opts.documentReferences } : {}),
     });
     } catch (error) {
@@ -7615,7 +7727,7 @@ async function runSelfImplementInner(
               ...(harnessSeededPaths.length ? { harnessSeededPaths } : {}),
               onSurfaceProgress: line => progress('implementing', line.trimEnd()),
               roundContext: { round: retryRound, effectiveMax, previousRoundFailure: retryNote },
-              ...(opts.childLlm ? { childLlm: opts.childLlm } : {}),
+              ...(activeChildLlm ? { childLlm: activeChildLlm } : {}),
               ...(opts.documentReferences ? { documentReferences: opts.documentReferences } : {}),
             }), T.implement, 'implement');
           } catch (error) {
@@ -7716,7 +7828,7 @@ async function runSelfImplementInner(
             ...(harnessSeededPaths.length ? { harnessSeededPaths } : {}),
             onSurfaceProgress: (line) => progress('implementing', line.trimEnd()),
             roundContext: { round: tddRetryRound, effectiveMax, previousRoundFailure: tddRetryNote },
-            ...(opts.childLlm ? { childLlm: opts.childLlm } : {}),
+            ...(activeChildLlm ? { childLlm: activeChildLlm } : {}),
             ...(opts.documentReferences ? { documentReferences: opts.documentReferences } : {}),
           }), T.implement, 'implement');
         } catch (error) {
@@ -7911,7 +8023,10 @@ async function runSelfImplementInner(
     }, { compact: { stringMax: Math.max(MAX_HARVESTED_EVIDENCE_CHARS, harvestObs.harvestedEvidence?.length ?? 0) } });
     if (impl.ok) completionDisposition = finishedChildCommitMissing || finishedChildCommitted ? undefined : impl.completionDisposition;
     const effectiveDisposition = impl.ok ? completionDisposition : impl.completionDisposition;
-    observe('implemented', { ok: impl.ok, round, ...(effectiveDisposition ? { completionDisposition: effectiveDisposition } : {}) });
+    let materializedPaths: readonly string[] | undefined;
+    try { materializedPaths = (s.changedFilesForGateRoute ?? changedFiles)(wt.path); } catch { /* unknown diff is not path evidence */ }
+    observe('implemented', { ok: impl.ok, round, ...(materializedPaths ? { materializedPaths: [...materializedPaths] } : {}),
+      ...(effectiveDisposition ? { completionDisposition: effectiveDisposition } : {}) });
     progress('implemented', impl.ok ? (round === 0 ? '구현 완료' : `rework ${round} 완료`) : impl.completionDisposition ? '변경 없이 완료 검증' : '구현 실패(worktree 보존)');
     if (!impl.ok) {
       finalizeSupervisorDeliveries('next-round-implement-not-ok');

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

@@ -38,6 +38,21 @@ export function parseConflictFiles(text: string): string[] {
 
 export type MergeFailureKind = 'base-modified' | 'head-moved' | 'conflict' | 'branch-policy' | 'other';
 
+export const HOST_REGATE_PR_HEAD_FAILURE_CONDITIONS = [
+  'head-unavailable', 'head-mismatch', 'state-unavailable', 'state-not-open',
+  'draft-status-unavailable', 'pr-is-draft', 'base-name-unavailable', 'base-oid-invalid',
+] as const;
+export type HostRegatePrHeadFailureCondition = typeof HOST_REGATE_PR_HEAD_FAILURE_CONDITIONS[number];
+
+export interface HostRegatePrHeadSnapshot {
+  headRefOid: string | null;
+  state: 'OPEN' | 'CLOSED' | 'MERGED' | 'OTHER' | null;
+  isDraft: boolean | null;
+  /** The only raw ref retained is the conventional base; all other non-empty values collapse to `other`. */
+  baseRefName: 'main' | 'other' | null;
+  baseRefOid: string | null;
+}
+
 /** Classify a `gh pr merge` failure so a reader can tell a race from a conflict from a policy block without the raw text. */
 export function classifyMergeFailure(detail: string, expectedHead?: string, actualHead?: string | null): MergeFailureKind {
   if (/base branch was modified/i.test(detail)) return 'base-modified';
@@ -48,12 +63,16 @@ export function classifyMergeFailure(detail: string, expectedHead?: string, actu
   return 'other';
 }
 
-/** One host-regate failure. The optional facts are filled for the pr-head, merge-conflict and merge steps. */
+/** One host-regate failure. The optional facts are filled for PR-head, merge-conflict and merge steps. */
 export interface HostRegateFailure {
   step: string;
   detail: string;
   expectedHead?: string;
   actualHead?: string | null;
+  /** Discrete clauses that failed the initial PR-head readiness check. */
+  failedConditions?: HostRegatePrHeadFailureCondition[];
+  /** Bounded structured facts from the same `gh pr view` used for the check. */
+  prHeadSnapshot?: HostRegatePrHeadSnapshot;
   conflictFiles?: string[];
   /** Number omitted from conflictFiles when the ledger's 200-path bound is reached. */
   conflictFilesOmitted?: number;
@@ -66,12 +85,30 @@ export function regateFailureFacts(failure: unknown): Omit<HostRegateFailure, 's
   const f = failure as Record<string, unknown>;
   const sha = (value: unknown): value is string => typeof value === 'string' && /^[0-9a-f]{40}$/i.test(value);
   const kinds: readonly MergeFailureKind[] = ['base-modified', 'head-moved', 'conflict', 'branch-policy', 'other'];
+  const headConditions: readonly HostRegatePrHeadFailureCondition[] = HOST_REGATE_PR_HEAD_FAILURE_CONDITIONS;
   const conflictFiles = Array.isArray(f.conflictFiles) ? f.conflictFiles.filter((p): p is string => typeof p === 'string') : undefined;
   const priorOmitted = Number.isSafeInteger(f.conflictFilesOmitted) && (f.conflictFilesOmitted as number) > 0 ? f.conflictFilesOmitted as number : 0;
   const conflictFilesOmitted = Math.max(0, (conflictFiles?.length ?? 0) - 200) + priorOmitted;
+  const failedConditions = Array.isArray(f.failedConditions)
+    ? [...new Set(f.failedConditions.filter((condition): condition is HostRegatePrHeadFailureCondition => typeof condition === 'string' && headConditions.includes(condition as HostRegatePrHeadFailureCondition)))].sort()
+    : undefined;
+  const snapshot = f.prHeadSnapshot && typeof f.prHeadSnapshot === 'object' ? f.prHeadSnapshot as Record<string, unknown> : undefined;
+  const states = ['OPEN', 'CLOSED', 'MERGED', 'OTHER'] as const;
+  const prHeadSnapshot = snapshot
+    && (sha(snapshot.headRefOid) || snapshot.headRefOid === null)
+    && ((typeof snapshot.state === 'string' && states.includes(snapshot.state as typeof states[number])) || snapshot.state === null)
+    && (typeof snapshot.isDraft === 'boolean' || snapshot.isDraft === null)
+    && ((snapshot.baseRefName === 'main' || snapshot.baseRefName === 'other') || snapshot.baseRefName === null)
+    && (sha(snapshot.baseRefOid) || snapshot.baseRefOid === null)
+    ? { headRefOid: snapshot.headRefOid as string | null, state: snapshot.state as HostRegatePrHeadSnapshot['state'],
+      isDraft: snapshot.isDraft as boolean | null, baseRefName: snapshot.baseRefName as HostRegatePrHeadSnapshot['baseRefName'],
+      baseRefOid: snapshot.baseRefOid as string | null }
+    : undefined;
   return {
     ...(sha(f.expectedHead) ? { expectedHead: f.expectedHead } : {}),
     ...(sha(f.actualHead) || f.actualHead === null ? { actualHead: f.actualHead as string | null } : {}),
+    ...(failedConditions?.length ? { failedConditions } : {}),
+    ...(prHeadSnapshot ? { prHeadSnapshot } : {}),
     ...(conflictFiles ? { conflictFiles: conflictFiles.slice(0, 200) } : {}),
     ...(conflictFilesOmitted > 0 ? { conflictFilesOmitted } : {}),
     ...(typeof f.mergeFailureKind === 'string' && kinds.includes(f.mergeFailureKind as MergeFailureKind) ? { mergeFailureKind: f.mergeFailureKind as MergeFailureKind } : {}),

package/src/self-implement/rework-child-provider.ts

@@ -0,0 +1,25 @@
+import type { ChildLlmSelection } from '../agent/run-context.js';
+
+export type ProviderAvailability = 'available' | 'unavailable' | 'unknown';
+export type ReworkChildProviderDecision =
+  | { action: 'keep'; selection: ChildLlmSelection; reason: 'not-grok' | 'quota-unknown' | 'quota-usable' | 'no-alternate' }
+  | { action: 'reselect'; selection: ChildLlmSelection; previous: ChildLlmSelection; reason: 'grok-quota-exhausted' | 'grok-credential-missing' };
+
+/** Re-evaluate Grok immediately before a supervisor rework relaunch; unknown quota is never treated as exhaustion. */
+export function reselectChildForRework(input: {
+  current: ChildLlmSelection;
+  grokQuota: 'usable' | 'exhausted' | 'unknown';
+  grokCredential: ProviderAvailability;
+  alternate?: ChildLlmSelection;
+  alternateCredential: ProviderAvailability;
+  alternateQuotaExhausted?: boolean;
+}): ReworkChildProviderDecision {
+  if (input.current.provider !== 'grok') return { action: 'keep', selection: input.current, reason: 'not-grok' };
+  const reason = input.grokQuota === 'exhausted' ? 'grok-quota-exhausted'
+    : input.grokCredential === 'unavailable' ? 'grok-credential-missing' : undefined;
+  if (!reason) return { action: 'keep', selection: input.current, reason: input.grokQuota === 'unknown' ? 'quota-unknown' : 'quota-usable' };
+  if (!input.alternate || input.alternateCredential !== 'available' || input.alternateQuotaExhausted === true) {
+    return { action: 'keep', selection: input.current, reason: 'no-alternate' };
+  }
+  return { action: 'reselect', selection: input.alternate, previous: input.current, reason };
+}