elanous 0.2.14 → 0.2.16

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/heal-triage.ts

@@ -156,6 +156,50 @@ export interface HealTriageResult {
   readonly evidence: readonly string[];
 }
 
+/** 수리 한도를 다 쓴 런의 결함 셋. 힐 루프가 이 셋 중 하나만 고른다. */
+export type ReworkCapDefectClass = 'test-defect' | 'goal-defect' | 'code-defect';
+
+/** 분류 뒤 힐 루프가 고르는 다음 행동. */
+export type ReworkCapNextAction = 'harvest' | 'relaunch' | 'card';
+
+export interface ReworkCapHealInput {
+  /** 게이트가 이번 diff 가 들여온 실패 수. 없으면 0. */
+  readonly introduced?: readonly string[];
+  /** 마지막 리뷰 must-fix. 없으면 빈 목록. */
+  readonly mustFix?: readonly string[];
+  readonly summary?: string;
+}
+
+export interface ReworkCapHealDecision {
+  readonly defectClass: ReworkCapDefectClass;
+  readonly nextAction: ReworkCapNextAction;
+  readonly evidence: readonly string[];
+}
+
+const GOAL_DEFECT = /골|goal|acceptance|수용 기준|요구가 모순|스펙|경계:/i;
+
+/**
+ * 수리 한도 소진 런을 «시험 결함 · 골 결함 · 코드 결함» 중 하나로 가르고
+ * 수확·재발사·카드 중 하나를 고른다. 근거는 게이트 introduced 목록과 마지막 리뷰 지적이다.
+ * 도입 실패가 있으면 코드 결함(재발사). 리뷰가 골·수용 기준을 짚으면 골 결함(카드).
+ * 그 밖(리뷰만 있거나 근거가 비면)은 시험 결함(수확)이다.
+ */
+export function classifyReworkCapExhaustion(input: ReworkCapHealInput): ReworkCapHealDecision {
+  const introduced = (input.introduced ?? []).map((item) => item.trim()).filter(Boolean);
+  const mustFix = (input.mustFix ?? []).map((item) => item.trim()).filter(Boolean);
+  const evidence = [
+    ...introduced.map((item) => `gate introduced: ${item}`),
+    ...mustFix.map((item) => `review must-fix: ${item}`),
+  ];
+  if (introduced.length > 0) {
+    return { defectClass: 'code-defect', nextAction: 'relaunch', evidence };
+  }
+  if (mustFix.some((item) => GOAL_DEFECT.test(item)) || (input.summary ? GOAL_DEFECT.test(input.summary) : false)) {
+    return { defectClass: 'goal-defect', nextAction: 'card', evidence };
+  }
+  return { defectClass: 'test-defect', nextAction: 'harvest', evidence };
+}
+
 const UNTESTABLE_EXT = new Set(['.md', '.json', '.yaml', '.yml', '.txt']);
 const ENVIRONMENT_CLAIM = /할당량|자격|기판|quota|credential|substrate/i;
 

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 {

package/src/self-implement/l8-merge-queue.ts

@@ -8,6 +8,20 @@ import { getDefaultLogStore } from '../mss/logging/log-store.js';
 type Command = (bin: string, args: readonly string[], cwd: string) => { status: number | null; stdout: string; stderr: string };
 export type L8MergeQueueInput = { number: number; cwd: string; matchHeadCommit: string };
 export type L8MergeQueueResult = { merged: boolean; baseRefName?: string; mergeCommit?: string; detail?: string };
+/** Read-only integration report. Never a landing decision and never a remote write. */
+export type L8ChangedTestResult = { file: string; passed: boolean; pass: number; fail: number; detail?: string };
+export type L8IntegrationEvaluation = {
+  number: number;
+  head: string;
+  base?: string;
+  /** True only when the candidate integrates (next.md-only conflicts resolved) and every changed test passed. */
+  feasible: boolean;
+  conflictingFiles: string[];
+  /** True when there is no conflict, or every conflict path is exactly release/next.md. */
+  conflictsLimitedToNextMd: boolean;
+  changedTests: L8ChangedTestResult[];
+  detail?: string;
+};
 export type L8MergeQueueDeps = {
   command?: Command;
   /** Must identify the same shared repository across all harness processes. */
@@ -195,6 +209,124 @@ export async function acquireL8MergeQueue(cwd: string): Promise<() => void> {
   }
 }
 
+const TEST_PATH = /(?:^|\/)[^/]+\.(?:test|spec)\.(?:[cm]?[jt]sx?)$/;
+
+function parseChangedTestCounts(output: string): { pass: number; fail: number; ran: number; files: number } | null {
+  const counts = /\b(\d+) pass\b[\s\S]*?\b(\d+) fail\b[\s\S]*?Ran ([1-9]\d*) tests? across ([1-9]\d*) files?/.exec(output);
+  if (!counts) return null;
+  return { pass: Number(counts[1]), fail: Number(counts[2]), ran: Number(counts[3]), files: Number(counts[4]) };
+}
+
+/**
+ * Report whether one pinned PR can integrate onto freshly fetched main.
+ * Resolves an append-only release/next.md conflict in a disposable worktree only.
+ * Never pushes, never calls a merge API, and never moves a remote ref.
+ */
+export async function evaluateL8Integration(input: L8MergeQueueInput, deps: L8MergeQueueDeps = {}): Promise<L8IntegrationEvaluation> {
+  const report: L8IntegrationEvaluation = {
+    number: input.number,
+    head: input.matchHeadCommit,
+    feasible: false,
+    conflictingFiles: [],
+    conflictsLimitedToNextMd: false,
+    changedTests: [],
+  };
+  if (!Number.isSafeInteger(input.number) || input.number <= 0 || !/^[0-9a-f]{40}$/i.test(input.matchHeadCommit)) {
+    return { ...report, detail: 'invalid PR number or pinned head' };
+  }
+  const execute = deps.command ?? command;
+  const run = (bin: string, args: readonly string[], cwd: string): string => {
+    const result = execute(bin, args, cwd);
+    if (result.status !== 0) throw new Error(`${bin} ${args.join(' ')}: ${(result.stderr || result.stdout || `exit ${result.status}`).trim().slice(0, 500)}`);
+    return args.includes('-z') ? result.stdout : result.stdout.trim();
+  };
+  const refuseRemote = (bin: string, args: readonly string[]) => {
+    if (bin === 'git' && args.some((arg) => arg === 'push' || arg === 'update-ref')) throw new Error('evaluation must not push');
+    if (bin === 'gh' && args.some((arg) => arg === 'merge')) throw new Error('evaluation must not merge');
+  };
+  const guarded: Command = (bin, args, cwd) => {
+    refuseRemote(bin, args);
+    return execute(bin, args, cwd);
+  };
+  let temp: string | undefined;
+  let attached = false;
+  try {
+    type View = { headRefOid?: string; headRefName?: string; baseRefName?: string; state?: string; isDraft?: boolean; isCrossRepository?: boolean };
+    const view = JSON.parse(run('gh', ['pr', 'view', String(input.number), '--json', 'headRefOid,headRefName,baseRefName,state,isDraft,isCrossRepository'], input.cwd)) as View;
+    if (view.headRefOid !== input.matchHeadCommit || view.baseRefName !== 'main' || view.state !== 'OPEN' || view.isDraft !== false || view.isCrossRepository !== false) {
+      throw new Error('PR head, base, or ready/open state changed');
+    }
+    run('git', ['fetch', 'origin', 'refs/heads/main'], input.cwd);
+    const base = run('git', ['rev-parse', 'FETCH_HEAD'], input.cwd);
+    if (!/^[0-9a-f]{40}$/i.test(base)) throw new Error('main commit unavailable');
+    report.base = base;
+    run('git', ['fetch', 'origin', `refs/pull/${input.number}/head`], input.cwd);
+    if (run('git', ['rev-parse', 'FETCH_HEAD'], input.cwd) !== input.matchHeadCommit) throw new Error('fetched PR head changed');
+    temp = mkdtempSync(join(tmpdir(), 'elanous-l8-eval-'));
+    run('git', ['worktree', 'add', '--detach', temp, input.matchHeadCommit], input.cwd);
+    attached = true;
+    const fork = run('git', ['merge-base', base, input.matchHeadCommit], temp);
+    const paths = run('git', ['diff', '--name-only', '-z', fork, input.matchHeadCommit], temp).split('\0').filter(Boolean);
+    if (!paths.length) throw new Error('PR changed-file paths unavailable');
+    if (paths.some((path) => path.startsWith('-') || path.startsWith('/') || path.split('/').includes('..') || path.includes('\\'))) throw new Error('unsafe PR changed-file path');
+    const livePaths = run('git', ['diff', '--name-only', '-z', '--diff-filter=ACMRT', fork, input.matchHeadCommit], temp).split('\0').filter(Boolean);
+    const tests = livePaths.filter((path) => TEST_PATH.test(path));
+    const merge = guarded('git', ['-c', 'user.name=elanous merge queue', '-c', 'user.email=queue@localhost', 'merge', '--no-ff', '--no-edit', base], temp);
+    if (merge.status !== 0) {
+      const unresolved = run('git', ['diff', '--name-only', '--diff-filter=U'], temp).split('\n').filter(Boolean);
+      if (!unresolved.length) throw new Error(`git merge failed: ${(merge.stderr || `exit ${merge.status}`).trim()}`);
+      report.conflictingFiles = unresolved;
+      report.conflictsLimitedToNextMd = unresolved.length === 1 && unresolved[0] === NEXT_MD_PATH;
+      if (!report.conflictsLimitedToNextMd) {
+        report.detail = `merge conflicts: ${unresolved.join(', ')}`;
+        return report;
+      }
+      const stage = (n: number): string => {
+        const result = guarded('git', ['show', `:${n}:${NEXT_MD_PATH}`], temp!);
+        if (result.status !== 0) throw new Error(`release/next.md stage ${n} unavailable: ${result.stderr}`);
+        return result.stdout;
+      };
+      const resolved = resolveNextMdConflict(stage(1), stage(3), stage(2));
+      if (resolved === null) {
+        report.feasible = false;
+        report.detail = 'release/next.md conflict is not append-only';
+        return report;
+      }
+      writeFileSync(join(temp, NEXT_MD_PATH), resolved);
+      run('git', ['add', '--', NEXT_MD_PATH], temp);
+      run('git', ['-c', 'user.name=elanous merge queue', '-c', 'user.email=queue@localhost', 'commit', '-m', 'Integrate latest main for L8 evaluation'], temp);
+    } else {
+      report.conflictsLimitedToNextMd = true;
+    }
+    if (tests.length) {
+      const unavailable = tests.filter((path) => !existsSync(join(temp!, path)));
+      if (unavailable.length) throw new Error(`changed test paths unavailable: ${unavailable.join(', ')}`);
+      run('bun', ['install', '--frozen-lockfile'], temp);
+      for (const file of tests) {
+        const result = guarded('bun', ['test', file], temp);
+        const output = `${result.stdout}\n${result.stderr}`;
+        const counts = parseChangedTestCounts(output);
+        if (!counts || counts.pass + counts.fail !== counts.ran || counts.files !== 1 || (result.status !== 0 && counts.fail === 0)) {
+          throw new Error(`changed tests unmeasured: ${output.slice(-400)}`);
+        }
+        const passed = result.status === 0 && counts.fail === 0 && counts.pass > 0;
+        report.changedTests.push({ file, passed, pass: counts.pass, fail: counts.fail, ...(passed ? {} : { detail: output.slice(-400) }) });
+      }
+      if (report.changedTests.some((entry) => !entry.passed)) {
+        report.detail = 'changed tests failed';
+        return report;
+      }
+    }
+    report.feasible = true;
+    return report;
+  } catch (error) {
+    return { ...report, feasible: false, detail: String(error) };
+  } finally {
+    if (attached && temp) execute('git', ['worktree', 'remove', '--force', temp], input.cwd);
+    if (temp) rmSync(temp, { recursive: true, force: true });
+  }
+}
+
 /** One PR per shared git directory, integrated on a freshly fetched main in a disposable worktree. */
 export async function runL8MergeQueue(input: L8MergeQueueInput, deps: L8MergeQueueDeps = {}): Promise<L8MergeQueueResult> {
   if (!Number.isSafeInteger(input.number) || input.number <= 0 || !/^[0-9a-f]{40}$/i.test(input.matchHeadCommit)) {