elanous 0.2.42 → 0.2.44

package/scripts/demo/demo1104-stage.ts

@@ -0,0 +1,316 @@
+import { DEMO1104_STAGE_CONFIG, type DemoActId, type DemoLaneId } from './demo1104-stage.config.js';
+
+type Act = typeof DEMO1104_STAGE_CONFIG.acts[number];
+type Lane = typeof DEMO1104_STAGE_CONFIG.lanes[number];
+type ActStatus = 'pending' | 'running' | 'live' | 'failed' | 'video';
+type TimerHandle = ReturnType<typeof setTimeout>;
+type TimerScheduler = {
+  setTimeout(callback: () => void, delayMs: number): TimerHandle;
+  clearTimeout(handle: TimerHandle): void;
+};
+type LaneStatus = 'pending' | 'running' | 'started' | 'failed';
+type VideoTrigger = 'failure' | 'deadline' | 'manual';
+type VideoTransition = { actId: DemoActId; videoId: string; trigger: VideoTrigger; failedAt: number; requestedAt: number; completedAt: number | null; latencyMs: number | null; status: 'shown' | 'failed' | 'superseded'; error: string | null };
+
+export type StageAdapters = {
+  startLane(lane: Lane): Promise<void>;
+  runAct(act: Act, signal: AbortSignal): Promise<void>;
+  showVideo(videoId: string, act: Act, signal: AbortSignal): Promise<void>;
+};
+
+export type StageSnapshot = {
+  startedAt: number | null;
+  elapsedMs: number;
+  lanes: Array<{ id: DemoLaneId; title: string; startsAtAct: DemoActId; status: LaneStatus; startedAt: number | null }>;
+  acts: Array<{ id: DemoActId; title: string; targetStartSec: number; targetEndSec: number; videoId: string | null; status: ActStatus }>;
+  transitions: VideoTransition[];
+};
+
+export function createDemoStageConsole(options: {
+  adapters: StageAdapters;
+  now?: () => number;
+  timers?: TimerScheduler;
+}): {
+  start(): Promise<void>;
+  runActNow(id: DemoActId): Promise<void>;
+  switchToVideo(id: DemoActId): Promise<void>;
+  snapshot(): StageSnapshot;
+} {
+  const now = options.now ?? Date.now;
+  const timers: TimerScheduler = options.timers ?? {
+    setTimeout: (callback, delayMs) => setTimeout(callback, delayMs) as TimerHandle,
+    clearTimeout: handle => clearTimeout(handle),
+  };
+  const startedAt = { value: null as number | null };
+  const laneStarts = new Map<DemoLaneId, number>();
+  const laneStatuses = new Map<DemoLaneId, LaneStatus>(
+    DEMO1104_STAGE_CONFIG.lanes.map(lane => [lane.id, 'pending']),
+  );
+  const actStatuses = new Map<DemoActId, ActStatus>(DEMO1104_STAGE_CONFIG.acts.map(act => [act.id, 'pending']));
+  const actGenerations = new Map<DemoActId, number>();
+  const actControllers = new Map<DemoActId, { generation: number; controller: AbortController }>();
+  const videoControllers = new Map<DemoActId, { generation: number; controller: AbortController }>();
+  const transitions: VideoTransition[] = [];
+  const abortActWork = (id: DemoActId): void => {
+    actControllers.get(id)?.controller.abort();
+    videoControllers.get(id)?.controller.abort();
+  };
+  const nextActGeneration = (id: DemoActId): number => {
+    abortActWork(id);
+    const next = (actGenerations.get(id) ?? 0) + 1;
+    actGenerations.set(id, next);
+    return next;
+  };
+  const isCurrentActGeneration = (id: DemoActId, generation: number): boolean => actGenerations.get(id) === generation;
+
+  const actFor = (id: DemoActId): Act => {
+    const act = DEMO1104_STAGE_CONFIG.acts.find(candidate => candidate.id === id);
+    if (!act) throw new Error(`Unknown demo act: ${id}`);
+    return act;
+  };
+
+  const switchToVideo = async (id: DemoActId, failedAt: number, trigger: VideoTrigger, generation: number): Promise<void> => {
+    const act = actFor(id);
+    if (!act.highlightVideoId) throw new Error(`${id} has no configured highlight video`);
+    if (!isCurrentActGeneration(id, generation)) return;
+    const requestedAt = now();
+    const transition: VideoTransition = { actId: id, videoId: act.highlightVideoId, trigger, failedAt, requestedAt, completedAt: null, latencyMs: null, status: 'failed', error: null };
+    transitions.push(transition);
+    const controller = new AbortController();
+    videoControllers.set(id, { generation, controller });
+    const remainingMs = DEMO1104_STAGE_CONFIG.failoverDeadlineMs - (requestedAt - failedAt);
+    if (remainingMs <= 0) {
+      transition.error = `video display exceeded ${DEMO1104_STAGE_CONFIG.failoverDeadlineMs}ms`;
+      if (isCurrentActGeneration(id, generation)) actStatuses.set(id, 'failed');
+      controller.abort();
+      videoControllers.delete(id);
+      throw new Error(`${id} video transition failed: ${transition.error}`);
+    }
+    let timeout: TimerHandle | undefined;
+    let timedOut = false;
+    let removeAbortListener = () => {};
+    const aborted = new Promise<never>((_resolve, reject) => {
+      const onAbort = () => reject(new Error('video transition superseded'));
+      if (controller.signal.aborted) onAbort();
+      else {
+        controller.signal.addEventListener('abort', onAbort, { once: true });
+        removeAbortListener = () => controller.signal.removeEventListener('abort', onAbort);
+      }
+    });
+    const deadline = new Promise<never>((_resolve, reject) => {
+      timeout = timers.setTimeout(() => {
+        timedOut = true;
+        reject(new Error(`video display exceeded ${DEMO1104_STAGE_CONFIG.failoverDeadlineMs}ms`));
+      }, remainingMs);
+    });
+    const display = Promise.resolve()
+      .then(() => options.adapters.showVideo(act.highlightVideoId!, act, controller.signal))
+      .then(() => {
+        transition.completedAt = now();
+        transition.latencyMs = transition.completedAt - failedAt;
+      });
+    try {
+      await Promise.race([display, deadline, aborted]);
+      if (transition.latencyMs! > DEMO1104_STAGE_CONFIG.failoverDeadlineMs) {
+        timedOut = true;
+        throw new Error(`video display exceeded ${DEMO1104_STAGE_CONFIG.failoverDeadlineMs}ms`);
+      }
+      if (!isCurrentActGeneration(id, generation)) {
+        transition.status = 'superseded';
+        transition.error = 'video transition superseded';
+        return;
+      }
+      transition.status = 'shown';
+      actStatuses.set(id, 'video');
+    } catch (error) {
+      if (!isCurrentActGeneration(id, generation)) {
+        transition.status = 'superseded';
+        transition.error = 'video transition superseded';
+        return;
+      }
+      transition.error = timedOut ? `video display exceeded ${DEMO1104_STAGE_CONFIG.failoverDeadlineMs}ms` : error instanceof Error ? error.message : String(error);
+      if (isCurrentActGeneration(id, generation)) actStatuses.set(id, 'failed');
+      controller.abort();
+      throw new Error(`${id} video transition failed: ${transition.error}`);
+    } finally {
+      removeAbortListener();
+      if (timeout) timers.clearTimeout(timeout);
+      if (videoControllers.get(id)?.generation === generation) videoControllers.delete(id);
+    }
+  };
+
+  return {
+    async start() {
+      if (startedAt.value !== null) throw new Error('Demo stage already started');
+      startedAt.value = now();
+      // Invoke both lanes before awaiting either one so the two story lines start together.
+      const launches = DEMO1104_STAGE_CONFIG.lanes.map(lane => {
+        laneStatuses.set(lane.id, 'running');
+        const laneStartedAt = now();
+        laneStarts.set(lane.id, laneStartedAt);
+        return options.adapters.startLane(lane).then(
+          () => { laneStatuses.set(lane.id, 'started'); },
+          error => { laneStatuses.set(lane.id, 'failed'); throw error; },
+        );
+      });
+      await Promise.all(launches);
+    },
+
+    async runActNow(id) {
+      if (startedAt.value === null) throw new Error('Start the demo stage before running an act');
+      const act = actFor(id);
+      const generation = nextActGeneration(id);
+      const controller = new AbortController();
+      actControllers.set(id, { generation, controller });
+      actStatuses.set(id, 'running');
+      let timeout: TimerHandle | undefined;
+      let failedAt: number | undefined;
+      let trigger: VideoTrigger = 'failure';
+      let removeAbortListener = () => {};
+      const timeoutMs = DEMO1104_STAGE_CONFIG.failoverDeadlineMs;
+      const aborted = new Promise<never>((_resolve, reject) => {
+        const onAbort = () => reject(new Error('act execution superseded'));
+        if (controller.signal.aborted) onAbort();
+        else {
+          controller.signal.addEventListener('abort', onAbort, { once: true });
+          removeAbortListener = () => controller.signal.removeEventListener('abort', onAbort);
+        }
+      });
+      const deadline = new Promise<never>((_resolve, reject) => {
+        timeout = timers.setTimeout(() => {
+          failedAt = now();
+          trigger = 'deadline';
+          reject(new Error(`Act exceeded ${timeoutMs}ms`));
+        }, timeoutMs);
+      });
+      try {
+        await Promise.race([options.adapters.runAct(act, controller.signal), deadline, aborted]);
+        if (!isCurrentActGeneration(id, generation)) return;
+        actStatuses.set(id, 'live');
+      } catch {
+        if (!isCurrentActGeneration(id, generation)) return;
+        failedAt ??= now();
+        actStatuses.set(id, 'failed');
+        if (!act.highlightVideoId) throw new Error(`${id} failed and has no configured highlight video`);
+        controller.abort();
+        if (actControllers.get(id)?.generation === generation) actControllers.delete(id);
+        await switchToVideo(id, failedAt, trigger, generation);
+      } finally {
+        removeAbortListener();
+        if (timeout) timers.clearTimeout(timeout);
+        if (actControllers.get(id)?.generation === generation) actControllers.delete(id);
+      }
+    },
+
+    switchToVideo(id) {
+      if (startedAt.value === null) throw new Error('Start the demo stage before switching to video');
+      if (!actFor(id).highlightVideoId) throw new Error(`${id} has no configured highlight video`);
+      const generation = nextActGeneration(id);
+      return switchToVideo(id, now(), 'manual', generation);
+    },
+
+    snapshot() {
+      const current = now();
+      return {
+        startedAt: startedAt.value,
+        elapsedMs: startedAt.value === null ? 0 : Math.max(0, current - startedAt.value),
+        lanes: DEMO1104_STAGE_CONFIG.lanes.map(lane => ({
+          id: lane.id,
+          title: lane.title,
+          startsAtAct: lane.startsAtAct,
+          status: laneStatuses.get(lane.id) ?? 'pending',
+          startedAt: laneStarts.get(lane.id) ?? null,
+        })),
+        acts: DEMO1104_STAGE_CONFIG.acts.map(act => ({
+          id: act.id,
+          title: act.title,
+          targetStartSec: act.targetStartSec,
+          targetEndSec: act.targetEndSec,
+          videoId: act.highlightVideoId,
+          status: actStatuses.get(act.id) ?? 'pending',
+        })),
+        transitions: transitions.map(transition => ({ ...transition })),
+      };
+    },
+  };
+}
+
+type CliOptions = { mock: boolean; help?: boolean; runAct?: DemoActId; failAct?: DemoActId; hangAct?: DemoActId; switchToVideo?: DemoActId };
+
+const HELP = 'Usage: bun scripts/demo/demo1104-stage.ts --mock [--run-act <act> [--fail-act <act>|--hang-act <act>]] [--switch-to-video <act>]';
+
+export function parseStageArgs(argv: string[]): CliOptions {
+  if (argv.includes('--help')) return { mock: false, help: true };
+  let mock = false;
+  let runAct: DemoActId | undefined;
+  let failAct: DemoActId | undefined;
+  let hangAct: DemoActId | undefined;
+  let switchToVideo: DemoActId | undefined;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--mock') { mock = true; continue; }
+    if (arg === '--run-act' || arg === '--fail-act' || arg === '--hang-act' || arg === '--switch-to-video') {
+      const value = argv[++index];
+      if (!value) throw new Error(`${arg} needs an act id`);
+      const act = DEMO1104_STAGE_CONFIG.acts.find(candidate => candidate.id === value);
+      if (!act) throw new Error(`Unknown act id: ${value}`);
+      if (arg !== '--run-act' && !act.highlightVideoId) throw new Error(`${value} has no configured highlight video`);
+      if (arg === '--run-act') runAct = act.id;
+      else if (arg === '--fail-act') failAct = act.id;
+      else if (arg === '--hang-act') hangAct = act.id;
+      else switchToVideo = act.id;
+      continue;
+    }
+    throw new Error(`Unknown option: ${arg}`);
+  }
+  if (!mock) throw new Error('This first-stage console is mock-only; pass --mock');
+  if (failAct && failAct !== runAct) throw new Error('--fail-act must match --run-act');
+  if (hangAct && hangAct !== runAct) throw new Error('--hang-act must match --run-act');
+  if (hangAct && failAct) throw new Error('--hang-act cannot be combined with --fail-act');
+  if (switchToVideo && (runAct || failAct)) throw new Error('--switch-to-video cannot be combined with act execution');
+  if (switchToVideo && hangAct) throw new Error('--switch-to-video cannot be combined with --hang-act');
+  return { mock, ...(runAct ? { runAct } : {}), ...(failAct ? { failAct } : {}), ...(hangAct ? { hangAct } : {}), ...(switchToVideo ? { switchToVideo } : {}) };
+}
+
+export async function runMockStage(args: CliOptions, stageOptions: { now?: () => number; timers?: TimerScheduler } = {}): Promise<StageSnapshot> {
+  const adapters: StageAdapters = {
+    async startLane(lane) { console.log(`시작: ${lane.title}`); },
+    async runAct(act) {
+      console.log(`지금 실행: ${act.title}`);
+      if (args.failAct === act.id) throw new Error('mock failure injected');
+      if (args.hangAct === act.id) return new Promise<void>(() => {});
+    },
+    async showVideo(videoId, act) { console.log(`영상 전환: ${act.title} → ${videoId}`); },
+  };
+  const stage = createDemoStageConsole({ adapters, ...stageOptions });
+  await stage.start();
+  if (args.runAct) {
+    await stage.runActNow(args.runAct);
+    const transition = stage.snapshot().transitions.at(-1);
+    if (transition?.status === 'shown') {
+      const cause = transition.trigger === 'deadline' ? '정체' : transition.trigger === 'failure' ? '실패' : '수동';
+      console.log(`씬 ${cause} · 영상 전환 완료: ${transition.actId} → ${transition.videoId} · ${transition.latencyMs}ms`);
+    }
+  }
+  if (args.switchToVideo) {
+    await stage.switchToVideo(args.switchToVideo);
+    const transition = stage.snapshot().transitions.at(-1);
+    if (transition?.status === 'shown') console.log(`수동 영상 전환 완료: ${transition.actId} → ${transition.videoId} · ${transition.latencyMs}ms`);
+  }
+  return stage.snapshot();
+}
+
+if (import.meta.main) {
+  try {
+    const args = parseStageArgs(process.argv.slice(2));
+    if (args.help) {
+      console.log(HELP);
+      process.exit(0);
+    }
+    const snapshot = await runMockStage(args);
+    console.log(JSON.stringify(snapshot, null, 2));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 2;
+  }
+}

package/scripts/goal-method-audit.ts

@@ -107,6 +107,22 @@ export function collectSlotLoads(lines: readonly string[]): readonly SlotLoad[]
   return out;
 }
 
+/** §6 머리말이 선언한 「사람 몫」 — 매뉴얼이 canonical 이므로 «수»를 이 파일에 박지 않는다.
+ *  🩸 계기(2026-10-31): `«여섯»` 이 여기 박혀 있었고 매뉴얼 §6 이 `«둘»` 로 바뀐 뒤에도 그 수를 계속 찍었다. */
+const HUMAN_SLOT_DECLARATION = /사람\s*(?:몫|칸)\s*«([^»]+)»/u;
+
+export function declaredHumanSlots(lines: readonly string[]): string | null {
+  const start = lines.findIndex(l => /^##\s*6\./u.test(l));
+  if (start < 0) return null;
+  const rel = lines.slice(start + 1).findIndex(l => /^##\s/u.test(l));
+  const end = rel < 0 ? lines.length : start + 1 + rel;
+  for (const line of lines.slice(start, end)) {
+    const match = HUMAN_SLOT_DECLARATION.exec(line);
+    if (match) return match[1]!;
+  }
+  return null;
+}
+
 export interface NarrativeCount { readonly name: string; readonly lines: number }
 
 /** 머리말이 「여기 없다」고 선언한 것들이 실제로 몇 줄인가. */
@@ -135,7 +151,7 @@ function report(path = MANUAL): number {
   console.log('');
   const slots = collectSlotLoads(lines);
   const mapped = new Set(slots.flatMap(s => s.clauses));
-  console.log(`축② 사람 칸 — §6 선언 «여섯» ↔ 조항 ${clauses.length} · 칸에 «걸린» 조항 ${mapped.size}`);
+  console.log(`축② 사람 칸 — §6 선언 «${declaredHumanSlots(lines) ?? '없음'}» ↔ 조항 ${clauses.length} · 칸에 «걸린» 조항 ${mapped.size}`);
   for (const { slot, clauses: c } of slots) {
     console.log(`   ${slot.padEnd(3)} ${String(c.length).padStart(2)}개  ${c.join(' ')}`);
   }

package/scripts/graph-units/land-enqueue.ts

@@ -2,6 +2,7 @@ import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { isAbsolute } from 'node:path';
 import { debug } from '../../src/debug/log.js';
+import { parseGraphTemplateYaml, type LandUnitTrainPolicySpec } from '../../src/self-implement/graph-yaml.js';
 
 type RecordValue = Record<string, unknown>;
 type EnqueueResult = {
@@ -10,6 +11,93 @@ type EnqueueResult = {
   evidence: RecordValue;
 };
 
+/** Facts collected by the train runner for one landing batch. Keep this input explicit:
+ * the graph unit enqueues one PR and cannot infer batch/theme/scenario facts itself. */
+export type LandTrainObservation = {
+  readonly express: boolean;
+  readonly waitedForBatch: boolean;
+  readonly batchSize: number;
+  readonly groupBy: readonly string[];
+  readonly waitMinutes: number;
+  readonly scenarioSource: string;
+  readonly mockUsed: boolean;
+  readonly gateRuns: number;
+  readonly land: {
+    readonly perPr: string;
+    readonly pinnedHead: boolean;
+    readonly ejectOnFail: boolean;
+    readonly integrationPr: boolean;
+  };
+};
+
+export type LandPolicyDrift = {
+  readonly field: string;
+  readonly expected: unknown;
+  readonly observed: unknown;
+};
+
+function sameMembers(actual: readonly string[], expected: readonly string[]): boolean {
+  return actual.length === expected.length && expected.every((value) => actual.includes(value));
+}
+
+/** Compare runner-measured facts with the declared policy. Missing/invalid facts are drift,
+ * never an implicit pass. Express work bypasses batch size/theme waiting as declared. */
+export function compareLandTrainPolicy(
+  policy: LandUnitTrainPolicySpec,
+  observed: LandTrainObservation,
+): LandPolicyDrift[] {
+  const drift: LandPolicyDrift[] = [];
+  const check = (field: string, expected: unknown, actual: unknown, matches: boolean): void => {
+    if (!matches) drift.push({ field, expected, observed: actual ?? null });
+  };
+  if (typeof observed.express !== 'boolean') {
+    check('/express', 'boolean', observed.express, false);
+  } else if (observed.express) {
+    check('/express/waitsForBatch', policy.express.waitsForBatch, observed.waitedForBatch, observed.waitedForBatch === policy.express.waitsForBatch);
+  } else {
+    const validSize = Number.isSafeInteger(observed.batchSize)
+      && observed.batchSize >= policy.batch.min && observed.batchSize <= policy.batch.max;
+    check('/batch/size', `${policy.batch.min}..${policy.batch.max}`, observed.batchSize, validSize);
+    check('/batch/groupBy', policy.batch.groupBy, observed.groupBy,
+      Array.isArray(observed.groupBy) && sameMembers(observed.groupBy, policy.batch.groupBy));
+    check('/batch/waitMinutes', `<=${policy.batch.maxWaitMin}`, observed.waitMinutes,
+      Number.isFinite(observed.waitMinutes) && observed.waitMinutes >= 0 && observed.waitMinutes <= policy.batch.maxWaitMin);
+  }
+  check('/scenarioPrebuild/source', policy.scenarioPrebuild.source, observed.scenarioSource,
+    policy.scenarioPrebuild.source.includes(observed.scenarioSource as typeof policy.scenarioPrebuild.source[number]));
+  check('/scenarioPrebuild/mock', policy.scenarioPrebuild.mock, observed.mockUsed,
+    observed.mockUsed === (policy.scenarioPrebuild.mock === 'required'));
+  check('/gate/runs', policy.gate.oncePerBatch ? 1 : 'unspecified', observed.gateRuns,
+    !policy.gate.oncePerBatch || observed.gateRuns === 1);
+  check('/land/perPr', policy.land.perPr, observed.land?.perPr, observed.land?.perPr === policy.land.perPr);
+  check('/land/pinnedHead', policy.land.pinnedHead, observed.land?.pinnedHead, observed.land?.pinnedHead === policy.land.pinnedHead);
+  check('/land/ejectOnFail', policy.land.ejectOnFail, observed.land?.ejectOnFail, observed.land?.ejectOnFail === policy.land.ejectOnFail);
+  check('/land/integrationPr', policy.land.integrationPr, observed.land?.integrationPr, observed.land?.integrationPr === policy.land.integrationPr);
+  return drift;
+}
+
+/** Runtime contract for the OP train runner: emit only on measured drift; tests inject the sink. */
+export function observeLandPolicyDrift(
+  policy: LandUnitTrainPolicySpec,
+  observed: LandTrainObservation,
+  emit: (event: 'land.policy-drift', payload: { drift: readonly LandPolicyDrift[] }) => void = (_event, payload) => {
+    debug.log('land', 'policy-drift', payload, { level: 'warn' });
+  },
+): LandPolicyDrift[] {
+  const drift = compareLandTrainPolicy(policy, observed);
+  if (drift.length > 0) emit('land.policy-drift', { drift });
+  return drift;
+}
+
+function observeEnvelopePolicy(context: RecordValue, emit?: Parameters<typeof observeLandPolicyDrift>[2]): void {
+  if (context.landTrainObservation === undefined) return;
+  const parsed = parseGraphTemplateYaml(readFileSync(new URL('../../graphs/units/land/land.yaml', import.meta.url), 'utf8'), 'land.yaml');
+  const policy = parsed.template?.policy;
+  if (!policy) throw new Error(`land policy unavailable: ${parsed.errors.map((issue) => issue.message).join('; ')}`);
+  // Runtime envelopes are untrusted; the comparator treats absent fields as drift evidence.
+  observeLandPolicyDrift(policy, record(context.landTrainObservation) as unknown as LandTrainObservation, emit);
+}
+
 function record(value: unknown): RecordValue {
   return value !== null && typeof value === 'object' && !Array.isArray(value) ? value as RecordValue : {};
 }
@@ -29,8 +117,10 @@ export function runLandEnqueue(
   envelope: unknown,
   executable = process.env.ELANOUS_LAND_ENQUEUE,
   spawn: typeof spawnSync = spawnSync,
+  emitPolicyDrift?: Parameters<typeof observeLandPolicyDrift>[2],
 ): EnqueueResult {
   const context = record(record(envelope).context);
+  observeEnvelopePolicy(context, emitPolicyDrift);
   const rawPr = context.pr;
   const pr = typeof rawPr === 'number' ? rawPr : typeof rawPr === 'string' && /^\d+$/.test(rawPr) ? Number(rawPr) : NaN;
   const expectedHead = text(context.expectedHead);

package/scripts/hooks/codex-notify.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+# ── Codex CLI notify hook — 손(hand) progress 전달 (HAND-HOOKS-NEXUS-STATUS · 2026-10-30) ──
+#
+# OP #54582 승인 · TC #54571 계약 기반. Codex notify 실행 시 알림 JSON 을 기존 계약
+# `POST /v1/missions/{missionId}/line`(src/agent-mission/mission-line.ts · postMissionLineEvent)로
+# **type:progress** 한 건만 보낸다. final 은 명시적 `mission reply --done` 전용,
+# ask/answer/correct 는 예약 — 이 훅은 progress 만 보낸다.
+#
+# 인증: missionId+attemptId+손별 Bearer. token 은 child env 에만 둔다:
+#   ELANOUS_HAND_TOKEN  — 손별 Bearer token(인자·파일 저장 금지)
+#   ELANOUS_MISSION_ID · ELANOUS_ATTEMPT_ID — 현재 미션/시도
+#   ELANOUS_NEXUS_URL — (선택) 계약 endpoint base
+# 자격이 없으면 조용히 exit 0(fail-soft — 훅이 Codex 를 막지 않는다).
+# PWA 손 카드 제외(TC graphEvents node-added kind=hand · DEMO1104-ARG-ADAPTIVE-VIEW가 렌더).
+# OSC 는 폴백이며 화면 scraping 은 하지 않는다. 병렬 송신 없음(Pod concurrency=1).
+#
+# 인자/stdin: Codex 가 주는 notify JSON {tool_name, cwd, ...} — Codex 는 notify JSON 을
+# 인자 하나(argv[1])로 넘기고, stdin 은 폴백이다.
+
+set -uo pipefail
+# Codex notify 프로그램 규약: JSON 을 argv[1] 로 받는다 — 인자가 없으면 stdin 을 읽는다.
+if [ "$#" -gt 0 ]; then INPUT="$1"; else INPUT="$(cat)"; fi
+
+HAND_CLI="$(cd "$(dirname "$0")/../.." && pwd)/src/agent-mission/hand-hooks.ts"
+
+if [ -n "${ELANOUS_HAND_TOKEN:-}" ] && [ -n "${ELANOUS_MISSION_ID:-}" ] && [ -n "${ELANOUS_ATTEMPT_ID:-}" ] \
+  && command -v bun >/dev/null 2>&1 && [ -f "$HAND_CLI" ]; then
+  # 논블로킹(백그라운드 &)·출력 버림 — notify 경로를 지연시키지 않는다.
+  printf '%s' "$INPUT" | bun "$HAND_CLI" codex-notify >/dev/null 2>&1 &
+fi
+
+exit 0

package/scripts/install.sh

@@ -154,7 +154,6 @@ missing_prerequisites() {
     command -v curl >/dev/null 2>&1 || MISSING+=(curl)
     command -v unzip >/dev/null 2>&1 || MISSING+=(unzip)   # bun 공식 설치기가 쓴다
   fi
-  command -v git >/dev/null 2>&1 || MISSING+=(git)
 }
 missing_prerequisites
 INSTALLED_DEPS=''
@@ -192,8 +191,9 @@ if ! command -v bun >/dev/null 2>&1 && [ "$BOOTSTRAP_BUN" -eq 1 ]; then
   fi
 fi
 
-# Keep this explicit set aligned with catalog/external-commands.yaml required entries.
-REQUIRED_COMMANDS=(git bun)
+# Git enables repository/worktree features but is not needed to boot the installed TUI.
+# Keep this set aligned with the runtime-required entries in catalog/external-commands.yaml.
+REQUIRED_COMMANDS=(bun)
 HARNESS_COMMANDS=(gh rg codex)
 for command in "${REQUIRED_COMMANDS[@]}"; do
   if ! command -v "$command" >/dev/null 2>&1; then
@@ -379,27 +379,23 @@ if [ ! -f "$VERSION_DIR/package.json" ]; then
 fi
 # 🩸 2026-09-24 빈 GCP VM 실측: `--offline` 만 쓰면 bun 캐시가 빈 새 기계에서 의존성이 «전부» failed to resolve — 어떤
 #    새 기계에서도 설치가 안 됐다(이 맥은 캐시가 차 있어 가려졌다). ⇒ 캐시로 먼저(빠르고 네트워크 없음) ⊕ 실패하면 레지스트리.
-# 🩸 2026-09-24 빈 VM 실측: apt `nodejs npm` 이 있으면 PATH 의 node(v18)·node-gyp(9.3.0)가 node-pty 를 빌드해
-#    bun 이 불러오는 순간 panic(uv_version_string)으로 죽었다. ⇒ 빌드 동안만 node=bun · node-gyp=최신 심을 PATH 앞에
-#    (src/native/native-build-env.ts 와 같은 심).
-NATIVE_SHIM="$(mktemp -d "${TMPDIR:-/tmp}/elanous-native-build.XXXXXX")"
-ln -s "$BUN_EXEC" "$NATIVE_SHIM/node"
-printf '#!/bin/sh\nexec "%s" x node-gyp@latest "$@"\n' "$BUN_EXEC" > "$NATIVE_SHIM/node-gyp"
-chmod +x "$NATIVE_SHIM/node-gyp"
-if ! (cd "$VERSION_DIR" && PATH="$NATIVE_SHIM:$PATH" bun add --no-save --offline "$INSTALL_TARBALL" >/dev/null 2>&1); then
+# Bun is the only runtime prerequisite. Skip lifecycle scripts: Bun otherwise runs optional
+# utf-8-validate native builds on bare Ubuntu and fails without Python/compiler. Optional prebuilt
+# packages (for example sharp) remain in the dependency graph.
+if ! (cd "$VERSION_DIR" && bun add --no-save --ignore-scripts --offline "$INSTALL_TARBALL" >/dev/null 2>&1); then
   echo "dependencies not in the local bun cache — fetching them from the npm registry" >&2
   # bun prints «Blocked N postinstalls» and progress noise here — keep it out of the screen unless this step fails.
   ADD_LOG="$(mktemp "${TMPDIR:-/tmp}/elanous-bun-add.XXXXXX")"
   ADD_RC=0
-  (cd "$VERSION_DIR" && PATH="$NATIVE_SHIM:$PATH" bun add --no-save "$INSTALL_TARBALL") >"$ADD_LOG" 2>&1 || ADD_RC=$?
+  (cd "$VERSION_DIR" && bun add --no-save --ignore-scripts "$INSTALL_TARBALL") >"$ADD_LOG" 2>&1 || ADD_RC=$?
   if [ "$ADD_RC" -ne 0 ]; then
     tail -n 20 "$ADD_LOG" >&2
-    rm -f "$ADD_LOG"; rm -rf "$NATIVE_SHIM"
+    rm -f "$ADD_LOG"
     exit "$ADD_RC"
   fi
   rm -f "$ADD_LOG"
 fi
-rm -rf "$NATIVE_SHIM"
+echo "If an optional native feature is unavailable, run 'elanous doctor --fix --yes' for repair guidance. The Bun TUI needs no system Node.js, Python, or compiler." >&2
 ln -sfn "versions/$VERSION_NAME" "$PREFIX/current"
 mkdir -p "$PREFIX/bin"
 # 절대 bun 경로를 설치 때 박고 엔트리는 current 를 거친다 — cron/systemd 의 짧은 PATH 와 판 전환 모두 지원.
@@ -478,30 +474,6 @@ if [ "$START_SETUP" -eq 0 ]; then
 fi
 # 🆕 2026-09-24 빈 VM 실측: 하니스(codex 백엔드)는 Codex CLI 를 자식으로 띄우는데 빈 기계엔 codex·node 가 «둘 다» 없었다.
 #    ⚠️ 아래 설치 줄은 빈 기계에서 아직 «안 쟀다» — `elanous doctor` 의 codex 줄이 판정한다.
-# C++20 toolchain must precede node-pty's rebuild; only suggest missing prerequisites.
-if ! command -v make >/dev/null 2>&1 || ! command -v c++ >/dev/null 2>&1; then
-  case "$(uname -s)" in
-    Darwin) BUILD_HINT='xcode-select --install' ;;
-    Linux)
-      OS_ID='' OS_LIKE=''
-      if [ -r "${ELANOUS_INSTALL_OS_RELEASE_FILE:-/etc/os-release}" ]; then
-        while IFS='=' read -r key value; do
-          value="${value#\"}"; value="${value%\"}"
-          case "$key" in ID) OS_ID="$value" ;; ID_LIKE) OS_LIKE="$value" ;; esac
-        done < "${ELANOUS_INSTALL_OS_RELEASE_FILE:-/etc/os-release}"
-      fi
-      BUILD_HINT=''
-      case " $OS_ID $OS_LIKE " in
-        *' debian '*|*' ubuntu '*) BUILD_HINT='sudo apt-get install -y build-essential' ;;
-        *' fedora '*) BUILD_HINT='sudo dnf groupinstall -y "Development Tools"' ;;
-      esac ;;
-    *) BUILD_HINT='' ;;
-  esac
-  if [ -n "$BUILD_HINT" ]; then
-    echo "  $STEP) $BUILD_HINT"; STEP=$((STEP + 1))
-  fi
-  echo "  $STEP) elanous doctor --fix --yes       # $(t 'rebuild node-pty after installing build tools' '빌드 도구를 깐 뒤 node-pty 다시 빌드')"; STEP=$((STEP + 1))
-fi
 if ! command -v rg >/dev/null 2>&1; then
   if [ -z "${OS_ID:-}" ] && [ -r "${ELANOUS_INSTALL_OS_RELEASE_FILE:-/etc/os-release}" ]; then
     while IFS='=' read -r key value; do

package/scripts/landing-heal/land-plan.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env bun
+import { existsSync, readFileSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+import { planTrain, type TrainCandidate, type TrainDeferred } from '../../src/self-implement/merge-train.js';
+import type { L8ShadowQueueState } from '../../src/self-implement/l8-merge-queue.js';
+
+export const LAND_PLAN_MAX_BATCH = 8;
+
+type LandPlan = { batch: TrainCandidate[]; deferred: TrainDeferred[] };
+
+function inputPath(args: readonly string[]): string {
+  if (args.length !== 2 || args[0] !== '--input') throw new Error('usage: land-plan.ts --input <absolute-json-path>');
+  const path = args[1];
+  if (!path || !isAbsolute(path)) throw new Error('--input requires an absolute path');
+  if (!existsSync(path)) throw new Error('input file missing');
+  return path;
+}
+
+function isQueueState(value: unknown): value is L8ShadowQueueState {
+  if (!value || typeof value !== 'object' || !('pending' in value) || !Array.isArray(value.pending)
+    || !value.pending.every((item) => item && typeof item === 'object'
+      && Number.isSafeInteger(item.number) && item.number > 0
+      && typeof item.head === 'string' && /^[0-9a-f]{40}$/i.test(item.head)
+      && (item.files === undefined || Array.isArray(item.files) && item.files.every((file: unknown) => typeof file === 'string'))
+      && (item.filesUnmeasured === undefined || item.filesUnmeasured === true))
+    || !('verdicts' in value) || !Array.isArray(value.verdicts)
+    || !('deferred' in value ? Array.isArray(value.deferred) : true)) return false;
+  return true;
+}
+
+function candidates(state: L8ShadowQueueState): TrainCandidate[] {
+  return state.pending.map(({ number, head, files, filesUnmeasured }) => ({
+    number,
+    head,
+    ...(files === undefined ? {} : { files }),
+    ...(filesUnmeasured === undefined ? {} : { filesUnmeasured }),
+  }));
+}
+
+export function planLandQueue(state: unknown): LandPlan {
+  if (!isQueueState(state)) throw new Error('invalid shadow queue ledger');
+  return planTrain(candidates(state), { maxBatch: LAND_PLAN_MAX_BATCH });
+}
+
+export function runLandPlan(args: readonly string[]): LandPlan {
+  const state: unknown = JSON.parse(readFileSync(inputPath(args), 'utf8'));
+  return planLandQueue(state);
+}
+
+if (import.meta.main) {
+  try {
+    process.stdout.write(`${JSON.stringify(runLandPlan(process.argv.slice(2)))}\n`);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exitCode = 1;
+  }
+}

package/scripts/public-leak-baseline.txt

@@ -794,7 +794,6 @@
 2	runtime-path-outside-export	src/self-implement/project-scaffold.test.ts
 3	runtime-path-outside-export	src/self-implement/run-ledger-cli.test.ts
 1	runtime-path-outside-export	src/workflow-runtime/discovery.ts
-1	runtime-path-outside-export	test/anatomy-doc-source-citations.test.ts
 1	runtime-path-outside-export	test/dev-help-concise.test.ts
 1	runtime-path-outside-export	test/dispatch/authored-goal-queue.test.ts
 1	runtime-path-outside-export	test/federation-guard-f11-paint-cache-opt-in.test.ts

package/scripts/release-loop/auto-approve-node.ts

@@ -86,7 +86,7 @@ export function runAutoApprove(context: GraphContext = readGraphContext(), deps:
   writeFileSync(report, lines.join('\n'));
   const tuiSubcheck = { runId: context.runId ?? null, level: regressStatus.level,
     fail: failedCheckIds?.length ?? null, failedCheckIds, approvalRequired: regressNeedsApproval };
-  debug.log('release-loop.approve', 'auto-decision', { version, outcome, metrics, tuiSubcheck });
+  debug.log('release-loop.approve', 'auto-decision', { version, outcome, metrics, runId: context.runId ?? null, tuiSubcheck });
   return { outcome, verdict: outcome === 'ok' ? 'pass' as const : 'fail' as const,
     summary: `auto approval ${outcome}: ${metrics.filter((metric) => !WARNING_ONLY.has(metric.name) && metric.verdict === 'pass').length}/8${regressNeedsApproval ? ` · tui-regress ${regressStatus.level} failed ${failedLabel} → HITL` : ''}`,
     runId: context.runId ?? null, tuiSubcheck, ...(outcome === 'ok' ? { decidedBy: 'release-loop metrics' as const } : {}), metrics, report };