elanous 0.2.0 → 0.2.5

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

@@ -21,6 +21,7 @@ import {
   resolveChildLivenessHeartbeatPath,
 } from '../core-turn/child-liveness-heartbeat.js';
 import { resolveNexusPwa, type NexusPwaResolution } from '../cli/nexus-show.js';
+import { ptyWebAddress } from '../cli/pty-web-address.js';
 import { startPty, mintPtyId, ptyAvailable } from '../pty-shell/registry.js';
 import { probeControlStance, stanceBlocksWrite } from '../pty-shell/pty-control-stance.js';
 import { externalWriteProvenance } from '../pty-shell/pty-write-provenance.js';
@@ -49,6 +50,7 @@ import { brainTrigger } from './brain-consultation.js';
 import { decideAutoAssist, decideAutoStop, decideBoundaryApproval, decideScreenStallSilenceTermination, hasNovelCompletionSignal, NO_STALL, parseBoundaryApprovalRequest, UNKNOWN_OBSERVED_RAW_SHELL_METACHARACTERS, type AutoAssistInput, type AutoStopInput, type AutoStopVerdict, type BoundaryApprovalRequestKind, type DeterministicCompletionState, type ScreenStallSilenceInput } from './auto-intervene.js';
 import { decideByRecipe, missingStateKeys, parseRecipe, type Recipe, type RecipeDecision } from '../decide/recipe.js';
 import { callJev, gateAnswer, probeKey, type JevAnswer } from '../decide/jev.js';
+import { shadowBoundaryDecision, type BoundaryShadowConfig, type BoundaryShadowDeps } from '../decide/boundary-shadow.js';
 import { decideOutputArtifactWatchdog, type OutputArtifactSnapshot, type OutputWatchdogPolicy } from './output-artifact-watchdog.js';
 import { mapBrainAction, mapControlStance, supervisionObservationFields } from './supervision-vocabulary.js';
 import { decideInterventionStep, type InterventionStep } from './intervention-step.js';
@@ -61,6 +63,8 @@ import { childPtyIdentityEnv } from '../agent/pty-identity.js';
 import { elanousTuiSpawnOptions } from './elanous-tui-spawn.js';
 import { describeGrokCredentialFreshness, readGrokTokenFreshness, type GrokCredentialFreshnessSnapshot } from '../acp/grok-auth.js';
 import { debug } from '../debug/log.js';
+import { sendOutbound } from '../domains/outbound-alert.js';
+import { formatPtyLinkMessage, readReportOrigin } from './report-origin.js';
 import { DETACHED_PROGRESS_FRAME_PREFIX, decodeDetachedProgressFrame } from '../harness/dispatch-detached.js';
 import { setEventLoopActivity } from '../debug/event-loop-watchdog.js';
 import { resolveEscalateTarget, resolveExplicitChildEscalateTarget } from './rework-policy.js';
@@ -151,17 +155,14 @@ export function formatWaitSupervisionBatchReason(waitCount: number, latestJudgme
   return `waitCount=${waitCount} latestJudgment=${singleLineBoundarySurfaceValue(latestJudgment ?? 'wait')}`;
 }
 
-/** Renders the spawned child's PWA terminal link or the typed reason it is unavailable. */
 /** The child's terminal URL, or `null` when no PWA base is resolvable.
  *  ⛔⭐ Reads `url` (what the resolver ALREADY chose), never `loopback` — the resolver may have
  *  picked a tailnet base, and reading `loopback` silently discarded that choice (`GOAL-T80`).
  *  ⛔ Exists so the structured observation is built from the SAME value the human line shows,
  *  instead of string-slicing that line (which glued ` source=…` into the URL). */
 export function surfaceLinkUrlFor(ptyId: string, pwa: NexusPwaResolution): string | null {
-  if (!('url' in pwa)) return null;
-  const url = new URL('term', pwa.url);
-  url.search = new URLSearchParams({ pty: ptyId }).toString();
-  return url.toString();
+  // 링크 모양은 한 곳(`src/cli/pty-web-address.ts`)에서만 만든다 — agent-mission `watch=` 줄·`pty list` 와 같은 값.
+  return ptyWebAddress(ptyId, pwa).webUrl;
 }
 
 /** Renders the spawned child's PWA terminal link or the typed reason it is unavailable. */
@@ -271,6 +272,9 @@ export interface BoundaryRequestWatchOptions {
   onCommandStart?: (commandFirstToken: string) => void;
   /** Test seam for the behavior-axis shadow. Default reads recipes/tool-guard.json and calls Jev. */
   behaviorAxis?: BoundaryBehaviorAxis;
+  /** Test seam for the Jev boundary shadow; production reads raw.decide.boundaryShadow. */
+  boundaryShadow?: BoundaryShadowConfig;
+  boundaryShadowDeps?: BoundaryShadowDeps;
 }
 
 const BEHAVIOR_AXIS_QUESTIONS = ['irreversible', 'outside_workdir', 'reaches_network'] as const;
@@ -519,6 +523,13 @@ export function watchHarnessBoundaryRequests(
                   try {
                     observeBoundaryBehaviorAxis(request, verdict, context, options.behaviorAxis);
                   } catch (error) { observeFailure(error); }
+                  try {
+                    const rawDecide = getUserConfig().raw.decide;
+                    const config = options.boundaryShadow ?? (rawDecide && typeof rawDecide === 'object'
+                      ? (rawDecide as { boundaryShadow?: BoundaryShadowConfig }).boundaryShadow
+                      : undefined);
+                    void shadowBoundaryDecision(request, verdict, config, options.boundaryShadowDeps).catch(observeFailure);
+                  } catch (error) { observeFailure(error); }
                 });
               }
             }
@@ -948,6 +959,8 @@ export interface HeadlessGoalLoopPtyOptions {
   onSurfaceProgress?: (line: string) => void;
   /** Current worktree's PWA resolver seam; it is resolved once after the child is spawned. */
   resolveNexusPwa?: (opts: { cwd: string }) => NexusPwaResolution;
+  /** Outbound seam; the default retains quiet hours and origin routing. */
+  sendOutbound?: typeof sendOutbound;
   /** Queues an argv child supervisor input for the orchestrator's next-round prompt; never writes stdin. */
   onSupervisorInput?: (text: string, updateDelivery: (delivery: SupervisorDeliveryState, reason?: string) => void) => void;
   /** ★ 턴 abort 신호(#21) — /cancel 이 이 신호를 abort 하면 호스팅 PTY 를 즉시 kill + 폴 루프 조기 종료
@@ -1377,6 +1390,15 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
   // ⛔ 사람이 읽는 줄을 «잘라서» 구조화 값을 만들지 않는다 — 줄 형식이 바뀌면 값이 조용히 오염된다
   //   (실제로 `source=` 를 더하자 그 슬라이스가 URL 에 그것을 붙였다). 같은 순수 함수에서 «둘 다» 뽑는다.
   const surfaceLinkUrl = surfaceLinkUrlFor(ptyId, pwa);
+  const reportOrigin = readReportOrigin(process.env);
+  if (surfaceLinkUrl !== null && reportOrigin?.channel === 'telegram') {
+    try {
+      const accepted = (opts.sendOutbound ?? sendOutbound)(formatPtyLinkMessage({ webUrl: surfaceLinkUrl, ptyId }), 'report', reportOrigin);
+      debug.log('self-implement.surface-link', accepted ? 'reported' : 'report-failed', { ptyId, chatId: reportOrigin.chatId });
+    } catch (error) {
+      try { debug.log('self-implement.surface-link', 'report-failed', { ptyId, error: errorMessage(error) }, { level: 'warn' }); } catch { /* fail-soft */ }
+    }
+  }
   const surfaceLinkObservation: Record<string, string> = surfaceLinkUrl !== null && 'source' in pwa
     ? { surfaceLinkUrl, surfaceLinkSource: pwa.source }
     : { surfaceLinkUnavailableReason: 'reason' in pwa ? pwa.reason : 'pwa-url-unknown' };
@@ -1753,7 +1775,9 @@ export async function runHeadlessGoalLoopPty(opts: HeadlessGoalLoopPtyOptions):
                     const deliveryReason = input && !opts.onSupervisorInput ? 'next-round-callback-unwired' : undefined;
                     emitSurfaceProgress(formatSupervisionProgressLine({
                       action: decision.action,
-                      reason: decision.action === 'input' ? decision.text : decision.reason,
+                      reason: decision.action === 'input' ? decision.text
+                        : 'reason' in decision ? decision.reason
+                        : `${decision.action} ${JSON.stringify({ ...decision, action: undefined })}`,
                       ...(delivery ? { delivery } : {}),
                       ...(deliveryReason ? { deliveryReason } : {}),
                       ...(inputInstructionOccurrence ? { inputInstructionOccurrence } : {}),

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,244 @@
+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 SPAWN_MAX_BUFFER = 256 * 1024 * 1024;
+
+const defaultCommand: NonNullable<HostRegateDeps['command']> = (bin, args, cwd, env) => {
+  // bun ≥1.4 applies Node's 1MB default maxBuffer and silently truncates — test output here is often larger.
+  const r = spawnSync(bin, [...args], { cwd, env: env ?? process.env, encoding: 'utf8', timeout: 600_000, maxBuffer: SPAWN_MAX_BUFFER });
+  const overflow = (r.error as NodeJS.ErrnoException | undefined)?.code === 'ENOBUFS';
+  return { status: overflow ? null : r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? `${r.error.message} (${overflow ? `output exceeded ${SPAWN_MAX_BUFFER} bytes` : '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;
+}