elanous 0.2.14 → 0.2.15

package/src/self-dev/draft-triage-rules.ts

@@ -38,6 +38,21 @@ const PROTECTED_LABELS: ReadonlySet<string> = new Set<string>([...PR_LABELS
 const goalId = (branch: string): string | undefined => /(?:^|[-/])goalid-([a-f0-9]+)(?=-|\/|$)/i.exec(branch)?.[1]?.toLowerCase();
 export const branchStem = (branch: string): string | undefined => /^self-impl\/(.+)-[a-f0-9]{8}-r[a-f0-9]+$/i.exec(branch)?.[1];
 const slot = (body?: string): string | undefined => /^칸:\s*(.+?)\s*$/m.exec(body ?? '')?.[1];
+const goalText = (body?: string): string | undefined => /^골:\s*(\S.*?)\s*$/m.exec(body ?? '')?.[1];
+// Auto titles name only files («src/harness: harness-queue.ts») — different goals share them, so they never identify a goal.
+export const isAutoTitle = (title: string): boolean =>
+  /^[\w./-]+:\s*[^\s,]+\.[a-z0-9]+(?:\s*,\s*[^\s,]+\.[a-z0-9]+)*$/i.test(title.trim());
+
+/** Same goal (TC 10-05): ① both carry a goal identifier → compare it ② otherwise exact title ⊕ both harness drafts ⊕ same branch stem, never an auto title ③ else false. */
+export function sameGoalPr(a: DraftTriagePr, b: DraftTriagePr): boolean {
+  const idA = goalId(a.branch), idB = goalId(b.branch);
+  if (idA && idB) return idA === idB;
+  const textA = goalText(a.body), textB = goalText(b.body);
+  if (textA && textB) return textA === textB;
+  if (!a.title || a.title !== b.title || isAutoTitle(a.title)) return false;
+  const stemA = branchStem(a.branch);
+  return Boolean(stemA && a.branch.startsWith('self-impl/') && b.branch.startsWith('self-impl/') && stemA === branchStem(b.branch));
+}
 const referencesDraft = (text: string, number: number): boolean =>
   new RegExp(`(?:\\(수확\\s*#${number}\\s*\\)|\\bsuperseded\\s*#${number}(?!\\d))`, 'i').test(text);
 const landingCommentReferencesDraft = (text: string, number: number): boolean =>
@@ -55,28 +70,30 @@ export function decideDraft({ draft, runStatus, mergedTwins, openDrafts, ageHour
     return { action: 'keep', reason: 'live' };
   }
   const lineage = goalId(draft.branch);
-  const twin = mergedTwins.find((pr) => pr.number !== draft.number && (
-    (draft.title && pr.title === draft.title) || (lineage && goalId(pr.branch) === lineage)
-  ));
-  if (twin) return { action: 'close', reason: `superseded-by #${twin.number}` };
+  const draftSlot = slot(draft.body);
   const stem = branchStem(draft.branch);
+  const compatible = (pr: DraftTriagePr): boolean =>
+    !(lineage && goalId(pr.branch) && goalId(pr.branch) !== lineage)
+    && !(draftSlot && slot(pr.body) && slot(pr.body) !== draftSlot);
+  const twin = mergedTwins.find((pr) => pr.number !== draft.number && compatible(pr) && sameGoalPr(draft, pr));
+  if (twin) return { action: 'close', reason: `superseded-by #${twin.number}` };
   const createdAt = Date.parse(draft.createdAt ?? '');
   const newer = stem && draft.title && Number.isFinite(createdAt) ? openDrafts
-    ?.filter((pr) => pr.number !== draft.number && pr.title === draft.title && branchStem(pr.branch) === stem
+    ?.filter((pr) => pr.number !== draft.number && pr.title === draft.title && branchStem(pr.branch) === stem && sameGoalPr(draft, pr)
       && Number.isFinite(Date.parse(pr.createdAt ?? '')) && Date.parse(pr.createdAt!) > createdAt)
     .sort((a, b) => Date.parse(b.createdAt!) - Date.parse(a.createdAt!) || b.number - a.number)[0] : undefined;
   if (newer) return { action: 'close', reason: `duplicate-of-open #${newer.number}` };
-  const harvest = mergedTwins.find((pr) => pr.number !== draft.number && (
+  const harvest = mergedTwins.find((pr) => pr.number !== draft.number && compatible(pr) && (
     [pr.mergeCommitMessage, pr.body].some((text) => text && referencesDraft(text, draft.number))
     || pr.landingVerifiedComments?.some((text) => landingCommentReferencesDraft(text, draft.number))
   ));
   if (harvest) return { action: 'close', reason: `superseded-by #${harvest.number} (harvest #${draft.number})` };
   const created = Date.parse(draft.createdAt ?? '');
   const files = draft.changedFiles;
-  const draftSlot = slot(draft.body);
   const later = mergedTwins.filter((pr) => pr.number !== draft.number && Number.isFinite(created)
     && Number.isFinite(Date.parse(pr.mergedAt ?? '')) && Date.parse(pr.mergedAt!) > created
-    && ((lineage && goalId(pr.branch) === lineage) || (draftSlot && slot(pr.body) === draftSlot)));
+    && compatible(pr) && ((lineage && goalId(pr.branch) === lineage)
+      || (draftSlot && slot(pr.body) === draftSlot) || (stem && branchStem(pr.branch) === stem)));
   if (files?.length && files.every((file) => {
     const changed = Date.parse(draft.latestFileChanges?.[file] ?? '');
     return Number.isFinite(changed) && changed >= created && later.some((pr) =>

package/src/self-dev/orchestrate.ts

@@ -260,12 +260,23 @@ export interface SelfDevJobResult {
    *  (merged / pr-opened / gate-failed / review-blocked / pr-declined). */
   stage?: string;
   branch?: string;
+  /** Child confirmed the finished implementation was pushed for manual harvest. */
+  harvestable?: true;
   worktreePath?: string;
   prUrl?: string;
   prNumber?: number;
   merged?: boolean;
   /** Child commit SHA, when observed by the Pod/host. */
   checkedHeadCommit?: string;
+  /**
+   * This run's own `--base` (not main). A non-main completion mode
+   * (worktree-only, draft, `--base` other than main) lands commits here.
+   */
+  base?: string;
+  /** Child finished with GOAL-COMPLETE (`ok=true`). Distinct from a main merge. */
+  ok?: boolean;
+  /** Commits this child added against its own `--base`. 0 is not completion progress. */
+  commitsAheadOfBase?: number;
   /** A dependency is done but its result is not on main; no child was launched. */
   blockReason?: 'parent-unlanded';
   parentPrNumber?: number;
@@ -405,6 +416,7 @@ export type ResumeDisposition = 'skip' | 'rerun' | 'rerun-duplicate-risk';
  */
 export function classifyResumeDisposition(result: SelfDevJobResult): ResumeDisposition {
   if (hasDelivered(result)) return 'skip';
+  if (result.harvestable === true && result.branch) return 'skip';
   if (result.stage === 'pr-opened') return 'rerun-duplicate-risk';
   if (result.merged === false) return 'rerun';
   if (result.status !== 'done') return 'rerun';
@@ -621,6 +633,7 @@ export function classifyFailure(
   ) {
     return 'awaiting-human';
   }
+  if (result.harvestable === true && result.branch) return 'main-sync-blocked';
   if (result.status === 'done' && !hasDelivered(result)) return convergedFailureKind();
   // ⭐ 상류가 죽어 «취소»된 조각 — 종전엔 status 가 failed 도 done 도 아니라 null 로 사라졌다.
   //   ⛔ 이것을 못 보면 「무엇이 상류를 기다리는가」를 슈퍼바이저가 영영 모른다.
@@ -1479,6 +1492,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
           ...(resumeDisposition ? { resumeDisposition } : {}),
           ...(disp?.stage ? { stage: disp.stage } : {}),
           ...(disp?.branch ? { branch: disp.branch } : {}),
+          ...(disp?.harvestable === true && disp.branch ? { harvestable: true } : {}),
           ...(disp?.worktreePath ? { worktreePath: disp.worktreePath } : {}),
           ...(disp?.prUrl ? { prUrl: disp.prUrl } : {}),
           ...(disp?.prNumber !== undefined ? { prNumber: disp.prNumber } : {}),
@@ -1526,7 +1540,7 @@ export function orchestrateSelfDev(opts: OrchestrateSelfDevOptions): Promise<Sel
         const rm = opts.removeWorktree ?? defaultRemoveWorktree;
         let removed = 0;
         for (const r of out) {
-          if (!r.worktreePath || r.prUrl) continue;
+          if (!r.worktreePath || r.prUrl || r.harvestable) continue;
           try { rm(r.worktreePath); removed++; } catch { /* fail-soft */ }
         }
         if (removed > 0) debug.log('self-dev.orchestrate', 'teardown', { removed });

package/src/self-dev/review-provider-fallback.ts

@@ -73,13 +73,18 @@ export function buildReviewProviderAttempts(
   const out: ReviewProviderAttempt[] = [primary];
   const seen = new Set([primary.model]);
   for (const f of fallbacks) {
-    if (!f.model.trim() || seen.has(f.model)) continue;
+    if (!f.model.trim() || seen.has(f.model) || (primary.provider && f.provider?.name === primary.provider.name)) continue;
     seen.add(f.model);
     out.push(f);
   }
   return out;
 }
 
+/** A distinct provider is available even when the optional config list is empty. */
+export function defaultReviewFallbackModel(primaryProvider?: string): string {
+  return resolveModelAlias(primaryProvider === 'grok' ? 'claude' : 'grok')!;
+}
+
 export interface ReviewFallbackObservation {
   readonly attempt: number;
   readonly total: number;

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

@@ -10,6 +10,14 @@ import { sweepFrozenMerges } from '../self-implement/frozen-merges.js';
 export interface SupervisorRound {
   round: number;
   landed: number;
+  /**
+   * Pieces that finished (`ok=true`) with at least one new commit against
+   * this run's own `--base` — not a main merge. Omitted on rounds that
+   * never measured it, so older history stays comparable.
+   */
+  baseCompleted?: number;
+  /** The run's own `--base` those completions were counted against. */
+  base?: string;
   actionable: number;
   reviewMustFixTrend?: SupervisorDecision['reviewMustFixTrend'];
 }
@@ -22,6 +30,7 @@ export type SupervisorStopReason =
   | 'parent-signals-red'
   | 'needs-human'
   | 'no-actionable-work'
+  | 'harvestable-awaiting-human'
   | 'handed-off-to-salvage'
   | 'max-rounds'
   | 'no-progress'
@@ -39,6 +48,7 @@ export const SUPERVISOR_STOP_REASONS = [
   'parent-signals-red',
   'needs-human',
   'no-actionable-work',
+  'harvestable-awaiting-human',
   'handed-off-to-salvage',
   'max-rounds',
   'no-progress',
@@ -105,9 +115,25 @@ export function countLanded(results: readonly SelfDevJobResult[]): number {
   return results.filter(hasDelivered).length;
 }
 
+/** One base label for the round. Mixed or missing bases stay unnamed. */
+export function roundBase(results: readonly SelfDevJobResult[]): string | undefined {
+  const bases = [...new Set(results.flatMap((result) => result.base === undefined ? [] : [result.base]))];
+  return bases.length === 1 ? bases[0] : undefined;
+}
+
+/**
+ * Finished pieces (`ok=true`) that added at least one commit against this
+ * run's own `--base`. A main merge is not required, and a commit without
+ * `ok=true` is not completion.
+ */
+export function countBaseCompleted(results: readonly SelfDevJobResult[]): number {
+  return results.filter((result) => result.ok === true && (result.commitsAheadOfBase ?? 0) >= 1).length;
+}
+
 export function madeProgress(prev: SupervisorRound | undefined, next: SupervisorRound): boolean {
   if (!prev) return true;
   if (next.landed > 0) return true;
+  if ((next.baseCompleted ?? 0) > (prev.baseCompleted ?? 0)) return true;
   if (next.actionable < prev.actionable) return true;
   return next.reviewMustFixTrend === 'improving';
 }
@@ -191,8 +217,16 @@ export function decideNextRun(input: {
   const t = triageRun(activeResults, deployFindings, observation === 'failed');
   const round = history.length;
   const landed = countLanded(results);
+  const baseCompleted = countBaseCompleted(results);
+  const completionBase = roundBase(results);
   const actionable = countActionable(t);
-  const thisRound: SupervisorRound = { round, landed, actionable, reviewMustFixTrend };
+  const thisRound: SupervisorRound = {
+    round,
+    landed,
+    ...(baseCompleted > 0 || completionBase !== undefined ? { baseCompleted, ...(completionBase === undefined ? {} : { base: completionBase }) } : {}),
+    actionable,
+    reviewMustFixTrend,
+  };
   const goalPlanRevisionObservation = formatGoalPlanRevisionObservation(results);
   const withGoalPlanRevisionObservation = (why: string): string => goalPlanRevisionObservation
     && goalPlanRevisionObservation !== GOAL_PLAN_REVISION_OBSERVATION_UNAVAILABLE
@@ -226,6 +260,16 @@ export function decideNextRun(input: {
     };
   }
 
+  const harvestable = results.filter((result) => result.harvestable === true && !!result.branch);
+  if (harvestable.length > 0) {
+    return {
+      ...base,
+      action: 'stop',
+      stopReason: 'harvestable-awaiting-human',
+      why: withGoalPlanRevisionObservation(`구현 완료 · 수확 대기 — ${harvestable.map((result) => result.branch).join(' · ')}`),
+    };
+  }
+
   if (deliverableMergeCompleteness === 'complete') {
     return {
       ...base,
@@ -364,7 +408,7 @@ export function decideNextRun(input: {
         ...base,
         action: 'stop',
         stopReason: 'no-progress',
-        why: withNoProgressGoalPlanRevisionObservation(`${stallRounds}라운드 연속 제자리 — 착지도 안 늘고 남은 조각도 안 줄었다(${actionable}). 골·불변식을 의심할 자리`),
+        why: withNoProgressGoalPlanRevisionObservation(`${stallRounds}라운드 연속 제자리 — base=${completionBase ?? 'main'} 기준 완료 ${baseCompleted} · 착지 ${landed} · 남은 조각도 안 줄었다(${actionable}). 골·불변식을 의심할 자리`),
       };
     }
   }
@@ -390,9 +434,12 @@ export function appendRound(
   reviewMustFixTrend?: SupervisorDecision['reviewMustFixTrend'],
 ): SupervisorRound[] {
   const t = triageRun(results.filter((result) => result.salvage !== 'launched'));
+  const baseCompleted = countBaseCompleted(results);
+  const base = roundBase(results);
   return [...history, {
     round: history.length,
     landed: countLanded(results),
+    ...(baseCompleted > 0 || base !== undefined ? { baseCompleted, ...(base === undefined ? {} : { base }) } : {}),
     actionable: countActionable(t),
     ...(reviewMustFixTrend === undefined ? {} : { reviewMustFixTrend }),
   }];

package/src/self-implement/frozen-merges.ts

@@ -7,7 +7,7 @@ import { debug } from '../debug/log.js';
 import { beginLandingMerge, readLandingFreeze, type LandingFreeze } from '../release-loop/landing-freeze.js';
 
 /** `manual`: the owning repository could not be determined — a sweep never resumes it; a person does. */
-export interface FrozenMerge { prNumber: number; headCommit: string; repoRoot: string; manual?: true }
+export interface FrozenMerge { prNumber: number; headCommit: string; repoRoot: string; manual?: true; /** Host goal document, so a resumed merge can still apply its «이 칸 완료» declaration (CL-AUTO). */ goalFile?: string }
 /** What a resume sweep hands its merge function: the held entry, marked as already claimed by this sweep. */
 export type ResumedMerge = FrozenMerge & { resumed: true };
 
@@ -65,7 +65,8 @@ function readQueue(root: string): FrozenMerge[] {
     Number.isSafeInteger(item.prNumber) && item.prNumber > 0 &&
     typeof item.headCommit === 'string' && /^[a-f0-9]{40}$/i.test(item.headCommit) &&
     typeof item.repoRoot === 'string' && item.repoRoot.length > 0 &&
-    (item.manual === undefined || item.manual === true))) throw new Error(`invalid frozen merge queue: ${path}`);
+    (item.manual === undefined || item.manual === true) &&
+    (item.goalFile === undefined || (typeof item.goalFile === 'string' && item.goalFile.length > 0)))) throw new Error(`invalid frozen merge queue: ${path}`);
   return data as FrozenMerge[];
 }
 

package/src/self-implement/goal-author.ts

@@ -6,6 +6,7 @@ import { dirname, isAbsolute, join, normalize, relative, resolve, sep } from 'no
 import { groundMissionInCodebase, isRepositoryImplementationCandidate, type CodebaseGrounding } from '../autopilot/mission-codebase-gate.js';
 import { extractSlugSource, generateMissionSlug, slugify } from '../autopilot/mission-registry.js';
 import { enhancePrompt, type EnhanceOpts, type EnhanceResult } from '../prompt-enhance/enhance.js';
+import type { LLMUsage } from '../prompt-cache/types.js';
 import { debug } from '../debug/log.js';
 
 function observeGoalAuthor(
@@ -324,9 +325,12 @@ function startGoalAuthorPhase(phase: GoalAuthorTimedPhase, authorRunId: string,
   return Date.now();
 }
 
-function endGoalAuthorPhase(phase: GoalAuthorTimedPhase, startedAt: number, authorRunId: string, onProgress?: GoalAuthorDeps['onProgress']): void {
+type GoalAuthorTokens = { inputTokens: number | null; outputTokens: number | null };
+const UNKNOWN_GOAL_AUTHOR_TOKENS: GoalAuthorTokens = { inputTokens: null, outputTokens: null };
+
+function endGoalAuthorPhase(phase: GoalAuthorTimedPhase, startedAt: number, authorRunId: string, onProgress?: GoalAuthorDeps['onProgress'], tokens: GoalAuthorTokens = UNKNOWN_GOAL_AUTHOR_TOKENS): void {
   const elapsedMs = Date.now() - startedAt;
-  observeGoalAuthor('goal-author', 'phase-end', { phase, authorRunId, elapsedMs });
+  observeGoalAuthor('goal-author', 'phase-end', { phase, authorRunId, elapsedMs, ...tokens });
   if (GOAL_AUTHOR_PHASES.includes(phase as GoalAuthorPhase)) {
     if (onProgress) onProgress(phase as GoalAuthorPhase, 'end');
     else process.stderr.write(`[goal-author] ${phase} ended in ${elapsedMs}ms\n`);
@@ -1156,6 +1160,21 @@ function observeAuthoredGroundingPathSections(document: string, paths: readonly
   }
 }
 
+function authoredGoalSectionChars(document: string): Record<string, number> {
+  const headings = linesOutsideFencedCode(document)
+    .filter(({ text }) => /^## (?:\S)/.test(text))
+    .map(({ text, start }) => ({ heading: text.slice(3).trim(), start }));
+  const sections: Record<string, number> = { preamble: [...document.slice(0, headings[0]?.start ?? document.length)].length };
+  for (let index = 0; index < headings.length; index += 1) {
+    const { heading, start } = headings[index];
+    sections[heading] = (sections[heading] ?? 0) + [...document.slice(start, headings[index + 1]?.start ?? document.length)].length;
+  }
+  for (const heading of ['PROBLEM', 'WHAT TO BUILD', 'ACCEPTANCE CRITERIA', 'TRACED PATHS', 'SCOPE BOUNDARY', 'STEPS', '답하지 못하는 것']) {
+    sections[heading] ??= 0;
+  }
+  return sections;
+}
+
 function canonicalBlocks(document: string): string[] {
   return linesOutsideFencedCode(document)
     .filter((line) => /^##(?:\s|$)/.test(line.text))
@@ -4906,6 +4925,13 @@ async function authorGoalWithSupersededRootIntent(
   }
   // ⭐ 이 저작 «한 번»의 id. goalId 보다 «먼저» 있어야 ground·enhance 의 소요를 그 골에 붙일 수 있다.
   const authorRunId = generateGoalId();
+  const authorStartedAt = Date.now();
+  const enhanceTokens: GoalAuthorTokens = { inputTokens: null, outputTokens: null };
+  const onEnhanceUsage = (usage: LLMUsage): void => {
+    if (usage.inputTokens !== undefined) enhanceTokens.inputTokens = (enhanceTokens.inputTokens ?? 0) + usage.inputTokens;
+    if (usage.outputTokens !== undefined) enhanceTokens.outputTokens = (enhanceTokens.outputTokens ?? 0) + usage.outputTokens;
+    try { deps.enhanceOpts?.onUsage?.(usage); } catch { /* usage observation is fail-soft */ }
+  };
   let facts: CodebaseGrounding | null = null;
   let groundingError = false;
   const persistentGrounding = resolveGoalAuthorPersistentGrounding('persistentGrounding' in deps ? deps.persistentGrounding : undefined);
@@ -4937,8 +4963,8 @@ async function authorGoalWithSupersededRootIntent(
       ? await deps.enhance(
         enhanceAsk,
         persistentFacts.length > 0
-          ? { ...deps.enhanceOpts, groundedFacts: persistentFacts }
-          : deps.enhanceOpts,
+          ? { ...deps.enhanceOpts, groundedFacts: persistentFacts, onUsage: onEnhanceUsage }
+          : { ...deps.enhanceOpts, onUsage: onEnhanceUsage },
       )
       : { original: ask, checklist: [], verbatimPreserved: true };
     // ⭐ goal-context 규범이 «어디에도 안 실린다»는 것을 관측으로 남긴다.
@@ -4956,7 +4982,7 @@ async function authorGoalWithSupersededRootIntent(
       placement: 'omitted',
     });
   } finally {
-    endGoalAuthorPhase('enhance', enhanceStartedAt, authorRunId, deps.onProgress);
+    endGoalAuthorPhase('enhance', enhanceStartedAt, authorRunId, deps.onProgress, enhanceTokens);
   }
   if (!enhancement.verbatimPreserved || (enhanceAsk && enhancement.original !== enhanceAsk)) {
     throw new Error('goal author refused an enhancement that does not preserve its input verbatim');
@@ -5431,6 +5457,18 @@ async function authorGoalWithSupersededRootIntent(
     } finally {
       endGoalAuthorPhase('lint', lintStartedAt, authorRunId, deps.onProgress);
     }
+    try {
+      observeGoalAuthor('goal-author', 'summary', {
+        authorRunId,
+        elapsedMs: Date.now() - authorStartedAt,
+        inputTokens: enhanceTokens.inputTokens,
+        outputTokens: enhanceTokens.outputTokens,
+        totalTokens: enhanceTokens.inputTokens === null || enhanceTokens.outputTokens === null
+          ? null : enhanceTokens.inputTokens + enhanceTokens.outputTokens,
+        goalChars: [...document].length,
+        sectionChars: authoredGoalSectionChars(document),
+      });
+    } catch { /* observation is fail-soft */ }
     return { document, facts, grounded: !groundingError && hasEvidence, authorRunId };
   } finally {
     endAssembleSubphase();

package/src/self-implement/goal-clarification-escalation.ts

@@ -35,6 +35,8 @@ type GoalClarificationAnsweredBy = 'human' | 'agent' | 'none' | 'mixed';
 
 export interface GoalClarificationEscalationInput {
   goalFile: string;
+  /** Explicit provenance for isolated test fixtures; never inferred from goalFile. */
+  testOrigin?: true;
   delivery?: GoalClarificationDelivery;
   resolvedDelivery?: GoalClarificationObservedDelivery;
   dispatch?: (
@@ -577,6 +579,9 @@ export async function escalateGoalDocumentClarifications(
                   }],
                 },
                 input.dispatchContext?.sessionId,
+                {},
+                undefined,
+                { testOrigin: input.testOrigin },
               );
               pendingQuestionPersistence.write(pending);
               pendingWritten += 1;

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

@@ -1,7 +1,10 @@
-import { appendFileSync, mkdirSync, readFileSync, rmdirSync, statSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
+import { getUserConfig } from '../user-config.js';
+import { psProcessStartMs, START_TOLERANCE_MS } from '../harness/harness-stop.js';
 
 export type FailureSource = 'release-run' | 'harness-run' | 'loop-tick' | 'cron';
 
@@ -14,6 +17,114 @@ export interface FailureEvent {
 }
 
 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 StartHealLoop = (file: string, options: HealLoopOptions) => Promise<unknown>;
+
+function healRunId(event: FailureEvent): string {
+  return `heal-${createHash('sha256').update(JSON.stringify([event.source, event.ref, event.at])).digest('hex')}`;
+}
+
+function maxConcurrentLoops(): number {
+  const raw = getUserConfig().raw.heal;
+  const cap = raw && typeof raw === 'object' && !Array.isArray(raw)
+    ? (raw as Record<string, unknown>).maxConcurrentLoops : undefined;
+  return typeof cap === 'number' && Number.isSafeInteger(cap) && cap > 0 ? cap : 2;
+}
+
+function ownerAlive(pid: unknown, pidStartedAt: unknown): boolean {
+  if (!Number.isSafeInteger(pid) || (pid as number) <= 0 || typeof pidStartedAt !== 'string') return false;
+  const started = Date.parse(pidStartedAt);
+  if (!Number.isFinite(started)) return false;
+  try {
+    const actual = psProcessStartMs(pid as number);
+    return actual !== null && Number.isFinite(actual) && Math.abs(actual - started) <= START_TOLERANCE_MS;
+  } catch { return false; }
+}
+
+function liveHealRuns(root: string): Set<string> {
+  const live = new Set<string>();
+  const dir = join(root, 'graph-runs', 'heal-loop');
+  let files: string[];
+  try { files = readdirSync(dir); }
+  catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return live;
+    throw error;
+  }
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue;
+    try {
+      const state = JSON.parse(readFileSync(join(dir, file), 'utf8')) as Record<string, unknown>;
+      if (state.graphId === 'heal-loop' && state.runId === file.slice(0, -5) &&
+          state.status === 'running' && ownerAlive(state.pid, state.pidStartedAt)) live.add(state.runId as string);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT' && !(error instanceof SyntaxError)) throw error;
+    }
+  }
+  return live;
+}
+
+/** 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> {
+  if (env.NODE_ENV === 'test' || env.ELANOUS_TEST_HOME) {
+    debug.log('heal.intake', 'loop-start-skipped-test', { runId: options.runId });
+    return undefined;
+  }
+  const root = options.deps.root;
+  const claimDir = join(root, 'heal', 'starts');
+  const selected = withInboxLock(inboxPath(root), () => {
+    mkdirSync(claimDir, { recursive: true });
+    const live = liveHealRuns(root);
+    const claimed = new Set<string>();
+    for (const name of readdirSync(claimDir)) {
+      if (!/^heal-[a-f0-9]{64}\.json$/.test(name)) continue;
+      const runId = name.slice(0, -5);
+      const path = join(claimDir, name);
+      const claim = JSON.parse(readFileSync(path, 'utf8')) as { active?: boolean; started?: boolean; pid?: number; pidStartedAt?: string };
+      const owner = claim.active && ownerAlive(claim.pid, claim.pidStartedAt);
+      if (!owner && !claim.started && !existsSync(join(root, 'graph-runs', 'heal-loop', `${runId}.json`))) {
+        unlinkSync(path);
+        continue;
+      }
+      claimed.add(runId);
+      if (owner && !live.has(runId)) live.add(runId);
+    }
+    const cap = maxConcurrentLoops();
+    if (live.size >= cap) {
+      debug.log('heal.intake', 'loop-start-deferred', { running: live.size, cap, runId: options.runId });
+      return undefined;
+    }
+    const next = readInbox(inboxPath(root)).find(event => !claimed.has(healRunId(event)) &&
+      !existsSync(join(root, 'graph-runs', 'heal-loop', `${healRunId(event)}.json`)));
+    if (!next) return undefined;
+    const runId = healRunId(next);
+    writeFileSync(join(claimDir, `${runId}.json`), JSON.stringify({ active: true, pid: process.pid,
+      pidStartedAt: new Date(Date.now() - process.uptime() * 1_000).toISOString() }), { flag: 'wx' });
+    return { event: next, runId };
+  });
+  if (!selected) return undefined;
+  let started = false;
+  try {
+    const result = await run(file, { runId: selected.runId, input: { failureEvent: selected.event }, deps: { root } });
+    started = true;
+    return result;
+  } finally {
+    withInboxLock(inboxPath(root), () => {
+      const claim = join(claimDir, `${selected.runId}.json`);
+      if (started || existsSync(join(root, 'graph-runs', 'heal-loop', `${selected.runId}.json`))) {
+        writeFileSync(claim, JSON.stringify({ active: false, started: true }));
+      } else {
+        unlinkSync(claim);
+      }
+    });
+    // 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 => {
+      debug.log('heal.intake', 'loop-start-failed', { runId: selected.runId, error: String(error) }, { level: 'error' });
+    });
+  }
+}
 
 function inboxPath(root: string): string {
   return join(root, 'heal', 'inbox.jsonl');
@@ -55,7 +166,7 @@ function withInboxLock<T>(file: string, work: () => T): T {
 }
 
 /** One durable JSON line per failure; repeat source+ref within an hour is folded. */
-export function recordFailureEvent(event: FailureEvent, root = effectiveInstanceRoot()): { folded: boolean } {
+export function recordFailureEvent(event: FailureEvent, root = effectiveInstanceRoot(), startLoop: StartHealLoop = startHealLoop): { folded: boolean } {
   if (!['release-run', 'harness-run', 'loop-tick', 'cron'].includes(event.source) ||
       !event.kind || !event.ref || !event.summary || !Number.isFinite(Date.parse(event.at))) {
     throw new Error('invalid heal failure event');
@@ -69,6 +180,13 @@ export function recordFailureEvent(event: FailureEvent, root = effectiveInstance
     return false;
   });
   debug.log('heal.intake', 'recorded', { source: event.source, kind: event.kind, ref: event.ref, folded });
+  if (!folded) {
+    const runId = healRunId(event);
+    void Promise.resolve().then(() => startLoop(HEAL_GRAPH, { runId, input: { failureEvent: event }, deps: { root } }))
+      .catch(error => {
+        debug.log('heal.intake', 'loop-start-failed', { source: event.source, kind: event.kind, ref: event.ref, runId, error: String(error) }, { level: 'error' });
+      });
+  }
   return { folded };
 }
 

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

@@ -20,7 +20,7 @@ export function needsPwaBuild(files: readonly string[]): boolean {
   return files.some((file) => file.startsWith('apps/pwa/') || (file.startsWith('src/') && !/\.test\.tsx?$/.test(file)));
 }
 
-export interface HostRegateInput { prNumber: number; headCommit: string; repoRoot: string; verifyOnly?: boolean; /** Called by a resume sweep that already holds this PR's claim. */ resumed?: true }
+export interface HostRegateInput { prNumber: number; headCommit: string; repoRoot: string; goalFile?: string; verifyOnly?: boolean; /** Called by a resume sweep that already holds this PR's claim. */ resumed?: true }
 export interface HostRegateResult { passed: boolean; failures: Array<{ step: string; detail: string }>; os: string; status?: 'passed' | 'failed' | 'unmeasured' | 'frozen'; /** verifyOnly: 실제로 얹어 잰 base 끝 */ baseCommit?: string }
 export type HostRegateDeps = {
   command?: (bin: string, args: readonly string[], cwd: string, env?: NodeJS.ProcessEnv) => { status: number | null; stdout: string; stderr: string };
@@ -31,6 +31,7 @@ export type HostRegateDeps = {
   log?: (event: 'passed' | 'failed' | 'unmeasured' | 'base-raced', data: Record<string, unknown>) => void;
   freezeRoot?: string;
   runExposeGate?: typeof runExposeGate;
+  syncMergedChecklist?: typeof import('../release-loop/merged-pr-checklist.js').syncMergedPrChecklist;
 };
 
 const SPAWN_MAX_BUFFER = 256 * 1024 * 1024;
@@ -240,7 +241,7 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     // --match-head-commit pins the head. gh has no base pin, so the base was re-read just
     // above; the seconds between that read and the merge are checked after the fact below.
     if (input.verifyOnly) return result('passed');
-    const landing = admitLandingMerge({ prNumber: input.prNumber, headCommit: input.headCommit, repoRoot: input.repoRoot }, deps.freezeRoot, {}, input.resumed ? undefined : { prNumber: input.prNumber, repoRoot: input.repoRoot, headCommit: input.headCommit });
+    const landing = admitLandingMerge({ prNumber: input.prNumber, headCommit: input.headCommit, repoRoot: input.repoRoot, ...(input.goalFile ? { goalFile: input.goalFile } : {}) }, deps.freezeRoot, {}, input.resumed ? undefined : { prNumber: input.prNumber, repoRoot: input.repoRoot, headCommit: input.headCommit });
     if (landing.kind !== 'merge') {
       debug.log('harness.merge', 'frozen', { pr: input.prNumber, ...(landing.kind === 'held' ? { reason: landing.freeze.reason, until: landing.freeze.until } : { resumedElsewhere: true }) });
       return { passed: true, failures: [], os: process.platform, status: 'frozen' };
@@ -255,6 +256,12 @@ export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps
     catch (e) { return result('unmeasured', 'merge-confirm', String(e)); }
     if (merged.state !== 'MERGED') return result('unmeasured', 'merge-confirm', `PR state after merge is ${merged.state ?? 'unknown'}`);
     landed = true;
+    try {
+      const sync = deps.syncMergedChecklist ?? (await import('../release-loop/merged-pr-checklist.js')).syncMergedPrChecklist;
+      sync(input.prNumber, input.repoRoot, input.goalFile);
+    } catch (error) {
+      debug.log('release.checklist', 'merged-pr-sync-failed', { pr: input.prNumber, error: String(error) });
+    }
     const mergeCommit = merged.mergeCommit?.oid ?? '';
     let mergedOnto = '';
     try {