elanous 0.2.0 → 0.2.4

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

@@ -0,0 +1,229 @@
+/** 결정론 트리아지 — 실패 서명과 이미 거친 역할만으로 다음 갈래를 고른다. */
+
+export type HealTriageOutcome =
+  | 'environment-claimed'
+  | 'untestable'
+  | 'harness-fixable'
+  | 'child-fixable'
+  | 'needs-deeper-observation'
+  | 'needs-grounding'
+  | 'rework-with-citations'
+  | 'exhausted';
+
+export interface HealCitation {
+  readonly title: string;
+  readonly url: string;
+  readonly snippet: string;
+}
+
+export interface HealFailureSignature {
+  readonly errorText?: string;
+  readonly citations?: readonly HealCitation[];
+  readonly failedTests?: number;
+  readonly introduced?: number;
+  readonly unknown?: number;
+  readonly timedOut?: number;
+  readonly unverified?: readonly string[];
+  readonly importerUnrunTests?: number;
+  readonly environmentClaim?: string;
+  readonly namedSource?: string;
+}
+
+/** 게이트 사실로 채울 수 있는 칸. 없는 칸만 채운다. */
+export const HEAL_GATE_FACT_FIELDS = ['introduced', 'unknown', 'timedOut', 'failedTests', 'unverified', 'errorText'] as const;
+export type HealGateFactField = (typeof HEAL_GATE_FACT_FIELDS)[number];
+
+export type PathExists = boolean | 'unknown';
+
+export interface HealFactFill {
+  readonly signature: HealFailureSignature;
+  readonly added: readonly HealGateFactField[];
+}
+
+export interface HealSignatureMerge {
+  readonly signature: HealFailureSignature;
+  readonly evidence: readonly string[];
+}
+
+const NUMBER_GATE_FIELDS = ['introduced', 'unknown', 'timedOut', 'failedTests'] as const;
+
+function isMarkedDeleted(path: string): boolean {
+  return path.startsWith('-') || path.includes('(deleted)');
+}
+
+/** 없는 경로만 `-<path>` 로 표시한다. 이미 표시된 것은 그대로 두고, `unknown` 은 표시하지 않는다. */
+export function markDeletedUnverified(paths: readonly string[], exists: (path: string) => PathExists): string[] {
+  return paths.map((path) => {
+    if (isMarkedDeleted(path)) return path;
+    const present = exists(path);
+    if (present === false) return `-${path}`;
+    return path;
+  });
+}
+
+function numberField(record: Record<string, unknown>, field: (typeof NUMBER_GATE_FIELDS)[number]): number | undefined {
+  const value = record[field];
+  return typeof value === 'number' ? value : undefined;
+}
+
+function stringList(value: unknown): readonly string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const items = value.filter((item): item is string => typeof item === 'string');
+  return items.length ? items : undefined;
+}
+
+/** 원장 항목들에서 마지막 게이트 사실을 고른다. 칸마다 가장 뒤의 값만 남긴다. */
+export function lastGateFacts(entries: readonly { readonly data?: unknown }[]): Partial<HealFailureSignature> {
+  const facts: {
+    introduced?: number;
+    unknown?: number;
+    timedOut?: number;
+    failedTests?: number;
+    unverified?: readonly string[];
+    errorText?: string;
+  } = {};
+  for (const entry of entries) {
+    const data = entry.data && typeof entry.data === 'object' && !Array.isArray(entry.data)
+      ? entry.data as Record<string, unknown>
+      : undefined;
+    if (!data) continue;
+    for (const field of NUMBER_GATE_FIELDS) {
+      const value = numberField(data, field);
+      if (value !== undefined) facts[field] = value;
+    }
+    const unverified = stringList(data.unverified);
+    if (unverified) facts.unverified = unverified;
+    if (typeof data.errorText === 'string') facts.errorText = data.errorText;
+  }
+  return facts;
+}
+
+/** 서명에 없는 칸만 마지막 게이트 사실에서 복사한다. 더한 칸이 없으면 added 가 빈다. */
+export function fillMissingGateFacts(signature: HealFailureSignature, ledgerEntries: readonly { readonly data?: unknown }[]): HealFactFill {
+  const facts = lastGateFacts(ledgerEntries);
+  const added: HealGateFactField[] = [];
+  const next: {
+    introduced?: number;
+    unknown?: number;
+    timedOut?: number;
+    failedTests?: number;
+    unverified?: readonly string[];
+    errorText?: string;
+  } = {};
+  for (const field of NUMBER_GATE_FIELDS) {
+    if (signature[field] === undefined && facts[field] !== undefined) {
+      next[field] = facts[field];
+      added.push(field);
+    }
+  }
+  if (signature.unverified === undefined && facts.unverified !== undefined) {
+    next.unverified = facts.unverified;
+    added.push('unverified');
+  }
+  if (signature.errorText === undefined && facts.errorText !== undefined) {
+    next.errorText = facts.errorText;
+    added.push('errorText');
+  }
+  return { signature: { ...signature, ...next }, added };
+}
+
+const MERGE_FACT_FIELDS = [...HEAL_GATE_FACT_FIELDS, 'importerUnrunTests', 'environmentClaim', 'namedSource', 'citations'] as const;
+
+function definedFields(signature: HealFailureSignature): string[] {
+  return MERGE_FACT_FIELDS.filter((field) => signature[field] !== undefined);
+}
+
+/** 나중 오버레이가 이긴다. 기여한 칸마다 evidence 한 줄. */
+export function mergeHealSignatures(base: HealFailureSignature, overlays: readonly { readonly source: string; readonly signature: HealFailureSignature }[]): HealSignatureMerge {
+  let signature: HealFailureSignature = { ...base };
+  const evidence: string[] = [];
+  for (const overlay of overlays) {
+    const contributed = definedFields(overlay.signature);
+    if (contributed.length === 0) continue;
+    signature = { ...signature, ...overlay.signature };
+    for (const field of contributed) evidence.push(`${field} ← ${overlay.source}`);
+  }
+  return { signature, evidence };
+}
+
+export interface HealTriageHistory {
+  /** 이 판에서 이미 방문한 노드 id. */
+  readonly visited?: readonly string[];
+}
+
+export interface HealTriageResult {
+  readonly outcome: HealTriageOutcome;
+  readonly evidence: readonly string[];
+}
+
+const UNTESTABLE_EXT = new Set(['.md', '.json', '.yaml', '.yml', '.txt']);
+const ENVIRONMENT_CLAIM = /할당량|자격|기판|quota|credential|substrate/i;
+
+function extOf(path: string): string {
+  const base = path.split('/').pop() ?? path;
+  const dot = base.lastIndexOf('.');
+  return dot <= 0 ? '' : base.slice(dot).toLowerCase();
+}
+
+function deletedOrUntestable(path: string): boolean {
+  return path.startsWith('-') || path.includes('(deleted)') || UNTESTABLE_EXT.has(extOf(path.replace(/^\-/, '')));
+}
+
+function visited(history: HealTriageHistory | undefined, nodeId: string): boolean {
+  return (history?.visited ?? []).includes(nodeId);
+}
+
+export function triageFailure(signature: HealFailureSignature, history?: HealTriageHistory): HealTriageResult {
+  const failed = signature.failedTests ?? 0;
+  const introduced = signature.introduced ?? 0;
+  const unverified = signature.unverified ?? [];
+  const importer = signature.importerUnrunTests ?? 0;
+  const claim = signature.environmentClaim?.trim() ?? '';
+
+  if (claim && ENVIRONMENT_CLAIM.test(claim) && !visited(history, 'verify-evidence')) {
+    return {
+      outcome: 'environment-claimed',
+      evidence: [`환경 분류를 주장한다: ${claim}`, 'verify-evidence 를 아직 거치지 않았다'],
+    };
+  }
+  if (failed === 0 && unverified.length > 0 && unverified.every(deletedOrUntestable)) {
+    return {
+      outcome: 'untestable',
+      evidence: [`실패 시험 0`, `미검증이 전부 지운 파일 또는 시험 불가 확장자다: ${unverified.join(', ')}`],
+    };
+  }
+  if (failed === 0 && importer > 0) {
+    return {
+      outcome: 'harness-fixable',
+      evidence: [`실패 시험 0`, `importer 미실행 시험 ${importer}`],
+    };
+  }
+  if (introduced > 0 || (signature.namedSource?.trim() ?? '') !== '') {
+    const why = introduced > 0
+      ? `도입 실패 introduced=${introduced}`
+      : `이름이 짚이는 미검증 소스: ${signature.namedSource}`;
+    return { outcome: 'child-fixable', evidence: [why] };
+  }
+  if (!visited(history, 'observe-deeper')) {
+    return {
+      outcome: 'needs-deeper-observation',
+      evidence: ['결정론 갈래에 안 맞는다', 'observe-deeper 를 아직 거치지 않았다'],
+    };
+  }
+  if (!visited(history, 'ground-external')) {
+    return {
+      outcome: 'needs-grounding',
+      evidence: ['observe-deeper 를 거쳤다', 'ground-external 을 아직 거치지 않았다'],
+    };
+  }
+  if (signature.citations?.length) {
+    return {
+      outcome: 'rework-with-citations',
+      evidence: ['ground-external 인용으로 재작업한다', ...signature.citations.map((citation) => citation.url)],
+    };
+  }
+  return {
+    outcome: 'exhausted',
+    evidence: ['observe-deeper 와 ground-external 을 둘 다 거쳤다', '더 올릴 해상도가 없다'],
+  };
+}

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

@@ -0,0 +1,240 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { detectTestInterference, parseFailureCount, runBunTest } from '../../scripts/detect-test-interference.js';
+import { runTestInterferenceGate } from '../../scripts/ci-test-interference-gate.js';
+
+/**
+ * The PWA's static build type-checks every `src/**` file it imports, under Next's stricter
+ * `ProcessEnv` — a change that only touches `src/**` can break it while tsc and bun test stay
+ * green (2026-09-27: two such changes kept main's PWA build red for two hours). Build whenever
+ * app code or non-test source changed; test files are never imported by the PWA.
+ */
+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 }
+export interface HostRegateResult { passed: boolean; failures: Array<{ step: string; detail: string }>; os: string; status?: 'passed' | 'failed' | 'unmeasured'; /** 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 };
+  interference?: (files: readonly string[], cwd: string) => Promise<{ passed: boolean; detail?: string; unmeasured?: boolean }>;
+  makeTemp?: () => string;
+  removeTemp?: (path: string) => void;
+  acquire?: (repoRoot: string) => Promise<() => void>;
+  log?: (event: 'passed' | 'failed' | 'unmeasured' | 'base-raced', data: Record<string, unknown>) => void;
+};
+
+const defaultCommand: NonNullable<HostRegateDeps['command']> = (bin, args, cwd, env) => {
+  const r = spawnSync(bin, [...args], { cwd, env: env ?? process.env, encoding: 'utf8', timeout: 600_000 });
+  return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? `${r.error.message} (command unavailable)` : '') };
+};
+
+/** The informational pr-land gate always returns zero; enforce its measured report and the combined test result instead. */
+async function defaultInterference(files: readonly string[], cwd: string, opts: { neighbors?: boolean } = {}): Promise<{ passed: boolean; detail?: string; unmeasured?: boolean }> {
+  const tests = files.filter((file) => /\.test\.tsx?$/.test(file));
+  const neighbors = new Set<string>(tests);
+  // verifyOnly(승인 탭)는 «이 PR 이 바꾼 시험»만 잰다 — 이웃 시험을 넣으면 간섭 관문의 상한(8)에 잘려 영영 «측정 불가»가 되고,
+  //   이웃의 기존 실패가 이 PR 을 막는다(2026-09-28 #21239 실측: scripts/lib 이웃 9 → 상한 8 · nl-routing-measurement 기존 1 fail).
+  if (opts.neighbors !== false) for (const file of tests) {
+    for (const sibling of readdirSync(join(cwd, dirname(file)))) {
+      if (/\.test\.tsx?$/.test(sibling)) neighbors.add(join(dirname(file), sibling));
+    }
+  }
+  const selected = [...neighbors].sort();
+  if (!selected.length) return { passed: true };
+  // 간섭 관문은 시험 파일이 둘 이상일 때만 잰다 — 하나면 간섭이라는 말이 없으니 그 파일을 한 번 돌려 실패 수로 본다.
+  if (selected.length === 1) {
+    const run = await runBunTest(selected, undefined, cwd);
+    const fail = run.signal || run.exitCode === null ? null : parseFailureCount(`${run.stdout}${run.stderr}`);
+    if (fail === null) return { passed: false, unmeasured: true, detail: `single test run unmeasured: ${selected[0]}` };
+    return fail === 0 ? { passed: true } : { passed: false, detail: `${selected[0]} — ${fail} fail` };
+  }
+  // The informational pr-land gate always returns zero; its measured report is the verdict.
+  let report: Awaited<ReturnType<typeof detectTestInterference>> | undefined;
+  await runTestInterferenceGate({
+    args: ['--changed-files', ...selected], log: () => {},
+    detect: async (paths) => (report = await detectTestInterference(paths, (batch) => runBunTest(batch, undefined, cwd))),
+  });
+  if (!report || report.status === 'unmeasurable' || selected.length > report.order.length) return { passed: false, unmeasured: true, detail: 'test interference measurement unavailable or truncated' };
+  if (report.isolatedFailures !== 0 || report.combinedFailures !== 0 || report.status === 'interference') {
+    return { passed: false, detail: `isolated=${report.isolatedFailures}, combined=${report.combinedFailures}, interference=${report.status}` };
+  }
+  return { passed: true };
+}
+
+const SLOT_WAIT_MS = 30 * 60_000;
+
+function slotOwnerAlive(slot: string): boolean {
+  try {
+    const pid = Number(readFileSync(join(slot, 'pid'), 'utf8').trim());
+    if (!Number.isSafeInteger(pid) || pid <= 0) return false;
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    // EPERM: the process exists but belongs to someone else.
+    return (error as NodeJS.ErrnoException).code === 'EPERM';
+  }
+}
+
+export async function acquireSlot(repoRoot: string, opts: { waitMs?: number; pollMs?: number; now?: () => number } = {}): Promise<() => void> {
+  const gitDir = spawnSync('git', ['rev-parse', '--path-format=absolute', '--git-common-dir'], { cwd: repoRoot, encoding: 'utf8' });
+  if (gitDir.status !== 0 || !gitDir.stdout.trim()) throw new Error('git common directory unavailable for host regate lock');
+  const root = join(gitDir.stdout.trim(), 'elanous-host-regate');
+  mkdirSync(root, { recursive: true });
+  const now = opts.now ?? Date.now;
+  const deadline = now() + (opts.waitMs ?? SLOT_WAIT_MS);
+  for (;;) {
+    for (let i = 0; i < 2; i++) {
+      const slot = join(root, `slot-${i}`);
+      try {
+        mkdirSync(slot);
+        writeFileSync(join(slot, 'pid'), String(process.pid));
+        return () => rmSync(slot, { recursive: true, force: true });
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
+        // A slot left by a crashed host process would otherwise block every later run.
+        // A slot without a pid file yet may be mid-acquire; only reclaim once its owner is known dead.
+        if (existsSync(join(slot, 'pid')) && !slotOwnerAlive(slot)) {
+          rmSync(slot, { recursive: true, force: true });
+          debug.log('harness.host-regate', 'slot-reclaimed', { slot: `slot-${i}` });
+        }
+      }
+    }
+    if (now() >= deadline) throw new Error(`host regate slots busy for ${Math.round((opts.waitMs ?? SLOT_WAIT_MS) / 60_000)}m`);
+    await new Promise((resolve) => setTimeout(resolve, opts.pollMs ?? 250));
+  }
+}
+
+export async function runHostRegate(input: HostRegateInput, deps: HostRegateDeps = {}): Promise<HostRegateResult> {
+  const command = deps.command ?? defaultCommand;
+  const log = deps.log ?? ((event: 'passed' | 'failed' | 'unmeasured' | 'base-raced', data: Record<string, unknown>) => debug.log('harness.host-regate', event, data));
+  const failures: HostRegateResult['failures'] = [];
+  let files: string[] = [];
+  let base = '';
+  let worktree: string | undefined;
+  let attached = false;
+  let release: (() => void) | undefined;
+  let verifiedBase: string | undefined;
+  const result = (event: 'passed' | 'failed' | 'unmeasured', step?: string, detail?: string): HostRegateResult => {
+    if (step) failures.push({ step, detail: detail ?? 'unknown' });
+    log(event, { pr: input.prNumber, files, os: process.platform, ...(step ? { failedStep: step } : {}) });
+    return { passed: event === 'passed', failures, os: process.platform, ...(input.verifyOnly ? { status: event, ...(verifiedBase ? { baseCommit: verifiedBase } : {}) } : {}) };
+  };
+  const run = (bin: string, args: readonly string[], cwd: string, env?: NodeJS.ProcessEnv): string => {
+    const r = command(bin, args, cwd, env);
+    if (r.status !== 0) throw new Error((r.stderr || r.stdout || `${bin} exited ${r.status}`).trim().slice(0, 300));
+    return r.stdout.trim();
+  };
+  try {
+    if (!Number.isSafeInteger(input.prNumber) || input.prNumber <= 0 || !/^[0-9a-f]{40}$/i.test(input.headCommit)) return result('unmeasured', 'input', 'invalid PR number or checked head SHA');
+    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));
+    let view: PrView;
+    try { view = readPr(); }
+    catch (e) { return result('unmeasured', 'pr-view', String(e)); }
+    if (view.headRefOid !== input.headCommit || view.state !== 'OPEN' || view.isDraft !== false || !view.baseRefName || !/^[0-9a-f]{40}$/i.test(view.baseRefOid ?? '')) return result('unmeasured', 'pr-head', 'PR head, base commit, ready state or open state unavailable or changed');
+    const baseRefName = view.baseRefName;
+    // verifyOnly(승인 탭): PR 에 기록된 base(baseRefOid)는 main 의 «지금 끝»보다 늙을 수 있다 — 지금 끝에 얹어 잰다.
+    let baseCommit = view.baseRefOid!;
+    try {
+      run('git', ['fetch', 'origin', `refs/heads/${baseRefName}`], input.repoRoot);
+      const fetchedBase = run('git', ['rev-parse', 'FETCH_HEAD'], input.repoRoot);
+      if (input.verifyOnly) { baseCommit = fetchedBase; verifiedBase = fetchedBase; }
+      else if (fetchedBase !== baseCommit) throw new Error('fetched PR base differs from checked SHA');
+      run('git', ['fetch', 'origin', `refs/pull/${input.prNumber}/head`], input.repoRoot);
+      if (run('git', ['rev-parse', 'FETCH_HEAD'], input.repoRoot) !== input.headCommit) throw new Error('fetched PR head differs from checked SHA');
+      worktree = (deps.makeTemp ?? (() => mkdtempSync(join(tmpdir(), 'elanous-host-regate-'))))();
+      run('git', ['worktree', 'add', '--detach', worktree, baseCommit], input.repoRoot);
+      attached = true;
+      if (run('git', ['rev-parse', 'HEAD'], worktree) !== baseCommit) throw new Error('worktree base HEAD mismatch');
+      base = run('git', ['merge-base', baseCommit, input.headCommit], worktree);
+      files = run('git', ['diff', '--name-only', base, input.headCommit], worktree).split('\n').filter(Boolean);
+      if (!files.length) throw new Error('changed files unavailable');
+      // Materialize the proposed merge of this exact PR head into the observed base.
+      // A clean head checkout cannot expose integration breaks introduced by the base.
+      try { run('git', ['merge', '--no-ff', '--no-commit', input.headCommit], worktree); }
+      catch (e) { return result('failed', 'merge-conflict', String(e)); }
+      run('git', ['-c', 'user.name=elanous host regate', '-c', 'user.email=regate@localhost', 'commit', '-m', 'host regate integration candidate'], worktree);
+      if (run('git', ['rev-parse', 'HEAD^1'], worktree) !== baseCommit || run('git', ['rev-parse', 'HEAD^2'], worktree) !== input.headCommit) throw new Error('integration parents do not match PR base and checked head');
+      if (!deps.command && !existsSync(join(worktree, 'scripts/ci-typecheck-changed.ts'))) throw new Error('typecheck gate unavailable in checked worktree');
+      // Borrow the source checkout's dependencies only when they are really installed. The daemon's install source can be
+      // a temporary checkout whose node_modules is empty or purged; linking it turned every gate into
+      // «Cannot find package 'typescript'» (unmeasured · 2026-09-29 #21239). Install into the candidate instead.
+      const candidate = worktree;
+      const provide = (dir: string, marker: string): void => {
+        if (existsSync(join(candidate, dir, 'node_modules'))) return;
+        if (existsSync(join(input.repoRoot, dir, 'node_modules', marker, 'package.json'))) {
+          symlinkSync(join(input.repoRoot, dir, 'node_modules'), join(candidate, dir, 'node_modules'), 'dir');
+        } else run('bun', ['install', '--frozen-lockfile'], join(candidate, dir));
+      };
+      provide('', 'typescript');
+      if (needsPwaBuild(files) && existsSync(join(worktree, 'apps/pwa'))) provide('apps/pwa', 'next');
+    } catch (e) { return result('unmeasured', 'worktree', String(e)); }
+    try {
+      const interference = await (deps.interference ?? ((f: readonly string[], c: string) => defaultInterference(f, c, { neighbors: !input.verifyOnly })))(files, worktree);
+      if (!interference.passed) return result(interference.unmeasured ? 'unmeasured' : 'failed', 'test-interference', interference.detail);
+    } catch (e) { return result('unmeasured', 'test-interference', String(e)); }
+    // verifyOnly: 통합 후보는 «지금 main 끝»(baseCommit)에 얹은 것이다 — 옛 merge-base 로 비교하면 그사이 main 착지분
+    //   수백 파일이 «이 PR 의 변경»으로 잡혀 저장소 전체 검사로 승격된다(2026-09-28 #21239 실측: 456파일 · PWA 636건).
+    try { run('bun', ['scripts/ci-typecheck-changed.ts'], worktree, { ...process.env, TSC_BASE_REF: input.verifyOnly ? baseCommit : base }); }
+    catch (e) { return result(String(e).includes('error TS') ? 'failed' : 'unmeasured', 'typecheck', String(e)); }
+    // ⛔ 2026-09-28: a Pod landing brought `join(home, '.elanous', …)` into main without this gate, and every human
+    //    `pr land` after it failed the isolation gate regardless of its own files (#21336 → #21343).
+    if (deps.command || existsSync(join(worktree, 'scripts/ci-isolation-hardcode-gate.ts'))) {
+      try { run('bun', ['scripts/ci-isolation-hardcode-gate.ts', '--changed-files', ...files], worktree); }
+      catch (e) { return result(/\[isolation-gate\] FAIL/.test(String(e)) ? 'failed' : 'unmeasured', 'isolation-gate', String(e)); }
+    }
+    if (needsPwaBuild(files)) {
+      try { run('bun', ['bin/elanous.mjs', '--test', 'nexus', 'build'], worktree); }
+      catch (e) { return result(String(e).includes('command unavailable') ? 'unmeasured' : 'failed', 'nexus-build', String(e)); }
+    }
+    let current: PrView;
+    try { current = readPr(); }
+    catch (e) { return result('unmeasured', 'pr-view', String(e)); }
+    if (current.headRefOid !== input.headCommit || current.baseRefName !== baseRefName || (!input.verifyOnly && current.baseRefOid !== baseCommit) || current.state !== 'OPEN' || current.isDraft !== false) {
+      return result('unmeasured', 'pr-base-changed', 'PR head or base changed during host regate; rerun against the new base');
+    }
+    // --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');
+    try { run('gh', ['pr', 'merge', String(input.prNumber), '--squash', '--match-head-commit', input.headCommit], input.repoRoot); }
+    catch (e) { return result('failed', 'merge', String(e)); }
+    type MergedView = { state?: string; mergeCommit?: { oid?: string } | null };
+    let merged: MergedView;
+    try { merged = JSON.parse(run('gh', ['pr', 'view', String(input.prNumber), '--json', 'state,mergeCommit'], input.repoRoot)); }
+    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'}`);
+    const mergeCommit = merged.mergeCommit?.oid ?? '';
+    let mergedOnto = '';
+    try {
+      run('git', ['fetch', 'origin', mergeCommit], input.repoRoot);
+      mergedOnto = run('git', ['rev-parse', `${mergeCommit}^1`], input.repoRoot);
+    } catch (e) {
+      // Merged, but the parent could not be read: "unknown" is not "raced".
+      log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'merge-parent', mergeCommit: mergeCommit || null, detail: String(e).slice(0, 200) });
+    }
+    if (mergedOnto && mergedOnto !== baseCommit) {
+      log('base-raced', { pr: input.prNumber, files, os: process.platform, checkedBase: baseCommit, mergedOnto, mergeCommit });
+    }
+    return result('passed');
+  } catch (e) {
+    return result('unmeasured', 'host-regate', String(e));
+  } finally {
+    try { if (attached && worktree) run('git', ['worktree', 'remove', '--force', worktree], input.repoRoot); }
+    catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'cleanup', detail: String(e) }); }
+    try { if (worktree) (deps.removeTemp ?? ((path) => rmSync(path, { recursive: true, force: true })))(worktree); }
+    catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'cleanup', detail: String(e) }); }
+    try { release?.(); }
+    catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'lock', detail: String(e) }); }
+    if (failures.length) {
+      const { step, detail } = failures[0]!;
+      const body = `호스트 재게이트 실패(${process.platform}): ${step} — ${detail.replace(/\s+/g, ' ').slice(0, 180)}`;
+      try { run('gh', ['pr', 'comment', String(input.prNumber), '--body', body], input.repoRoot); }
+      catch (e) { log('unmeasured', { pr: input.prNumber, files, os: process.platform, failedStep: 'comment', detail: String(e) }); }
+    }
+  }
+}

package/src/self-implement/non-git-consent.ts

@@ -0,0 +1,23 @@
+import { debug } from '../debug/log.js';
+
+export interface NonGitInitOptions {
+  target: string;
+  interactive: boolean;
+  assumeYes: boolean;
+  ask: (prompt: string) => Promise<string | undefined>;
+}
+
+/** Explicitly authorize creating a local Git repository and its initial commit. */
+export async function decideNonGitInit({ target, interactive, assumeYes, ask }: NonGitInitOptions): Promise<'init' | 'refused' | 'non-interactive-refused'> {
+  let decision: 'init' | 'refused' | 'non-interactive-refused';
+  if (assumeYes) {
+    decision = 'init';
+  } else if (!interactive) {
+    decision = 'non-interactive-refused';
+  } else {
+    const answer = await ask(`${target} 는 git 저장소가 아닙니다. 여기서 \`git init\` 하고 첫 커밋을 만들까요? 되돌리려면 \`.git\` 을 지우면 됩니다. [y/N] `);
+    decision = /^(?:y|yes)$/i.test(answer?.trim() ?? '') ? 'init' : 'refused';
+  }
+  debug.log('harness.non-git', 'decided', { target, decision, interactive });
+  return decision;
+}