elanous 0.2.40 → 0.2.42

package/src/pty-shell/tui-run-state.ts

@@ -12,7 +12,7 @@
 // 판독(CLI 쪽): `describePtyRunState` 가 행 ⊕ 설치본 기록 ⊕ (체크아웃이면) 그 뿌리의 HEAD 로 판정한다.
 
 import { spawn } from 'node:child_process';
-import { readFileSync } from 'node:fs';
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -30,6 +30,7 @@ import {
   updatePtyManifestAbortRequested, updatePtyManifestBuild, updatePtyManifestProgress, updatePtyManifestTurn,
   type PtyBuildIdentity, type PtyManifestRow, type PtyTurnState,
 } from './pty-manifest.js';
+import { ptyEventLogDbPath, readPtyEventsAfterAt } from './pty-event-log.js';
 
 const CODE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
 
@@ -496,6 +497,139 @@ export function judgeTurnProgress(input: TurnProgressInput): TurnProgressJudgmen
   return 'progressing';
 }
 
+// ── TUI-SEAT-PILOT-2H-COMPARE — 좌석 대조 판정 신호 한 줄 ──
+//
+// 완료 경계는 «실행 명령·runId·시작/끝 시각·두 표면의 원장 행·산출 바이트·오류 수·결과» 를
+// `seat-state/OP/tools/sim-log.sh` 한 줄로 남기라고 한다. 그 한 줄의 «형식» 은 순수 함수가 정하고,
+// 두 표면의 원장 행은 각자의 생산 원장에서 읽는다 — tui-run-state 는 pty_manifest 행, pty-event-log 는
+// `pty_events` 의 그 표면 행이다. ⛔ 재지 못한 항목은 «미측정» 으로 남긴다 — 측정된 `0` 과 섞지 않는다(null ≠ 0).
+
+/** 재지 못한 항목의 직렬화 값. 측정된 `0`·빈 문자열과 구별된다. */
+export const SEAT_COMPARE_UNMEASURED = '미측정';
+
+/** 한 표면의 원장 요약. `rows === null` 은 «못 읽었다» 이지 «0행» 이 아니다. */
+export interface SeatCompareLedgerSummary {
+  readonly surface: string;
+  readonly rows: number | null;
+  readonly lastSeq: number | null;
+  readonly lastState: string | null;
+}
+
+/** 판정 신호 입력 — 완료 경계가 이름으로 요구한 항목 그대로. */
+export interface SeatCompareSignalInput {
+  readonly runId: string | null;
+  readonly command: string | null;
+  readonly startedAt: number | null;
+  readonly endedAt: number | null;
+  /** 이 TUI 좌석 표면의 원장 행 요약(pty_manifest 턴 행). */
+  readonly tuiRunState: SeatCompareLedgerSummary;
+  /** 비교 상대 표면의 원장 행 요약(`pty_events`). */
+  readonly ptyEventLog: SeatCompareLedgerSummary;
+  readonly outputBytes: number | null;
+  readonly errors: number | null;
+  readonly result: string | null;
+}
+
+function seatCompareText(value: string | null | undefined): string {
+  if (value === null || value === undefined) return SEAT_COMPARE_UNMEASURED;
+  // 한 줄 계약 — 값 안의 개행·연속 공백은 접어서 줄을 쪼개지 못하게 한다.
+  const flat = value.replace(/\s+/g, ' ').trim();
+  return flat.length > 0 ? flat : SEAT_COMPARE_UNMEASURED;
+}
+
+function seatCompareCount(value: number | null | undefined): string {
+  if (value === null || value === undefined || !Number.isFinite(value)) return SEAT_COMPARE_UNMEASURED;
+  return String(value);
+}
+
+function seatCompareAt(ms: number | null | undefined): string {
+  if (ms === null || ms === undefined || !Number.isFinite(ms)) return SEAT_COMPARE_UNMEASURED;
+  return new Date(ms).toISOString();
+}
+
+function seatCompareLedger(summary: SeatCompareLedgerSummary): string {
+  return [
+    `ledger:${seatCompareText(summary.surface)}`,
+    `rows=${seatCompareCount(summary.rows)}`,
+    `lastSeq=${seatCompareCount(summary.lastSeq)}`,
+    `lastState=${seatCompareText(summary.lastState)}`,
+  ].join(' ');
+}
+
+/** 판정 신호 한 줄 — 새 줄 없이 ` · ` 로 잇는다. 못 잰 항목은 «미측정» 으로 남는다. */
+export function buildSeatCompareSignalLine(input: SeatCompareSignalInput): string {
+  return [
+    `run=${seatCompareText(input.runId)}`,
+    `cmd=${seatCompareText(input.command)}`,
+    `start=${seatCompareAt(input.startedAt)}`,
+    `end=${seatCompareAt(input.endedAt)}`,
+    seatCompareLedger(input.tuiRunState),
+    seatCompareLedger(input.ptyEventLog),
+    `bytes=${seatCompareCount(input.outputBytes)}`,
+    `errors=${seatCompareCount(input.errors)}`,
+    `result=${seatCompareText(input.result)}`,
+  ].join(' · ');
+}
+
+/** 생산 이음매 — `pty_events` 원장에서 이 표면의 행을 실제로 읽어 요약한다. 못 읽으면 rows=null(미측정). */
+export function readPtyEventLogLedger(surfaceId: string, dbPath: string = ptyEventLogDbPath()): SeatCompareLedgerSummary {
+  const surface = 'pty-event-log';
+  const read = readPtyEventsAfterAt(dbPath, 0, { surfaceId });
+  if (read.status !== 'ok') return { surface, rows: null, lastSeq: null, lastState: null };
+  const last = read.rows.length > 0 ? read.rows[read.rows.length - 1] : undefined;
+  return { surface, rows: read.rows.length, lastSeq: last ? last.seq : 0, lastState: last?.state ?? null };
+}
+
+/** 기본 기록 위치 — 셸 도구와 같은 파일(`seat-state/OP/tools/sim-log.log`). `ELANOUS_SEAT_COMPARE_LOG` 로 바꾼다. */
+export const SEAT_COMPARE_LOG_PATH = join(CODE_ROOT, 'seat-state', 'OP', 'tools', 'sim-log.log');
+
+export interface SeatCompareWriteDeps {
+  readonly path?: string;
+  /** append 이음매 — 시험이 임시 파일·메모리로 바꾼다. */
+  readonly append?: (path: string, line: string) => void;
+}
+
+/** 판정 신호 한 줄을 sim-log 에 append 한다. 실패(권한 등)는 false — 종료 경로를 깨지 않는다. */
+export function appendSeatCompareSignalLine(line: string, deps: SeatCompareWriteDeps = {}): boolean {
+  const path = deps.path ?? (process.env.ELANOUS_SEAT_COMPARE_LOG?.trim() || SEAT_COMPARE_LOG_PATH);
+  try {
+    if (deps.append) {
+      deps.append(path, line);
+    } else {
+      mkdirSync(dirname(path), { recursive: true });
+      appendFileSync(path, `${line}\n`, 'utf8');
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 생산 진입점 스위치 — `ELANOUS_SEAT_COMPARE_RUN_ID` 가 있을 때만 좌석 대조 원장을 켠다.
+ * 없으면 `null` = 녹음기가 그 한 줄을 안 남긴다(«미실행은 미측정»).
+ */
+export function seatCompareDepsFromEnv(env: NodeJS.ProcessEnv = process.env): TuiSeatCompareDeps | null {
+  const runId = env.ELANOUS_SEAT_COMPARE_RUN_ID?.trim();
+  if (!runId) return null;
+  const command = env.ELANOUS_SEAT_COMPARE_COMMAND?.trim() || [process.execPath, ...process.argv.slice(1)].join(' ');
+  return { runId, command };
+}
+
+/** 좌석 대조 판정 신호를 켜는 손잡이 — 주면 녹음기 종료 경로가 두 표면 원장을 읽어 한 줄을 남긴다. */
+export interface TuiSeatCompareDeps {
+  readonly runId: string | null;
+  readonly command?: string | null;
+  /** 산출 바이트 — 녹음기가 못 재면 생략(«미측정»). */
+  readonly outputBytes?: number | null;
+  /** 결과 판정 문구 — 생략하면 종료 시 마지막 턴 상태. */
+  readonly result?: string | null;
+  /** 원장 요약 읽기 이음매(시험: 가짜 원장). 생략하면 실 `pty_events`. */
+  readonly readLedger?: (surfaceId: string) => SeatCompareLedgerSummary;
+  /** 기록 이음매(시험: 메모리). 생략하면 sim-log 파일 append. */
+  readonly write?: (line: string) => boolean;
+}
+
 // ── 기록(TUI) ──
 
 export interface TuiRunStateRecorderDeps {
@@ -524,6 +658,11 @@ export interface TuiRunStateRecorderDeps {
    * 생략하면 감시를 안 건다 — 이 축을 켜는 것은 호출자(생산 진입점)의 결정이다.
    */
   readonly selfRestart?: TuiSelfRestartDeps;
+  /**
+   * TUI-SEAT-PILOT-2H-COMPARE 좌석 대조 판정 신호. 주면 종료 경로가 두 표면(pty_manifest 턴 행 ⊕
+   * `pty_events`)의 원장행을 읽어 «한 줄» 을 sim-log 에 남긴다. 생략하면 아무것도 안 남긴다(미실행=미측정).
+   */
+  readonly seatCompare?: TuiSeatCompareDeps;
 }
 
 interface ActiveRecorder {
@@ -550,9 +689,29 @@ const defaultLog = (event: string, data: Record<string, unknown>): void => { deb
 export function startTuiRunStateRecorder(surfaceId: string, deps: TuiRunStateRecorderDeps = {}): () => void {
   const now = deps.now ?? Date.now;
   const log = deps.log ?? defaultLog;
-  const writeTurn = deps.writeTurn ?? updatePtyManifestTurn;
+  const writeTurnBase = deps.writeTurn ?? updatePtyManifestTurn;
   const writeProgress = deps.writeProgress ?? updatePtyManifestProgress;
   const writeAbortRequested = deps.writeAbortRequested ?? updatePtyManifestAbortRequested;
+  // 좌석 대조 신호가 켜졌을 때만 턴 행 수·쓰기 실패를 센다 — 꺼져 있으면 판정 신호 비용 0.
+  const seatCompare = deps.seatCompare ?? null;
+  // 시작 시각도 신호가 켜졌을 때만 잰다 — 꺼져 있으면 종전과 같이 now() 를 한 번도 더 부르지 않는다.
+  const seatCompareStartedAt = seatCompare ? now() : 0;
+  let seatCompareTurnRows = 0;
+  let seatCompareWriteFailures = 0;
+  const writeTurn = seatCompare
+    ? (id: string, turn: PtyTurnState, at: number): boolean => {
+      let ok = false;
+      try {
+        ok = writeTurnBase(id, turn, at);
+      } catch (error) {
+        seatCompareWriteFailures += 1;
+        throw error;
+      }
+      if (ok) seatCompareTurnRows += 1;
+      else seatCompareWriteFailures += 1;
+      return ok;
+    }
+    : writeTurnBase;
   // 기본 신고기는 기본 manifest 쓰기와 짝일 때만. writeTurn 주입(시험)은 herdr 를 안 만든다.
   const herdr = deps.herdr !== undefined
     ? deps.herdr
@@ -564,6 +723,7 @@ export function startTuiRunStateRecorder(surfaceId: string, deps: TuiRunStateRec
   if (build) {
     const ok = (() => { try { return (deps.writeBuild ?? updatePtyManifestBuild)(surfaceId, build); } catch { return false; } })();
     log(ok ? 'build-recorded' : 'build-write-failed', { ptyId: surfaceId, sha: build.sha, version: build.version, source: build.source });
+    if (!ok) seatCompareWriteFailures += 1;
   }
   // 기동 순서: 판 → manifest 초기 idle → herdr 신고. herdr start 가 idle 을 신고하므로 초기 idle 을 turn 으로 다시 안 보낸다.
   const recorder: ActiveRecorder = { surfaceId, now, writeTurn, writeProgress, writeAbortRequested, log, herdr, herdrLast: herdr ? 'idle' : undefined };
@@ -662,6 +822,32 @@ export function startTuiRunStateRecorder(surfaceId: string, deps: TuiRunStateRec
     try { unwatch(); } catch { /* 종료 경로를 깨지 않는다 */ }
     try { unguard(); } catch { /* 종료 경로를 깨지 않는다 */ }
     if (herdr) { try { herdr.release(); } catch { /* 종료 경로를 깨지 않는다 */ } }
+    // 좌석 대조 판정 신호 — 두 표면의 원장 행을 «여기서» 읽어 한 줄로 남긴다.
+    if (seatCompare) {
+      try {
+        const readLedger = seatCompare.readLedger ?? readPtyEventLogLedger;
+        const line = buildSeatCompareSignalLine({
+          runId: seatCompare.runId,
+          command: seatCompare.command ?? null,
+          startedAt: seatCompareStartedAt,
+          endedAt: now(),
+          tuiRunState: {
+            surface: 'tui-run-state',
+            rows: seatCompareTurnRows,
+            lastSeq: null,
+            lastState: recorder.last ?? null,
+          },
+          ptyEventLog: readLedger(surfaceId),
+          outputBytes: seatCompare.outputBytes ?? null,
+          errors: seatCompareWriteFailures,
+          result: seatCompare.result ?? recorder.last ?? null,
+        });
+        const written = (seatCompare.write ?? appendSeatCompareSignalLine)(line);
+        log(written ? 'seat-compare-signal' : 'seat-compare-signal-write-failed', { ptyId: surfaceId, line });
+      } catch (error) {
+        log('seat-compare-signal-failed', { ptyId: surfaceId, error: error instanceof Error ? error.message : String(error) });
+      }
+    }
     if (active === recorder) active = null;
   };
 }

package/src/release-loop/checklist-target-path-hint.ts

@@ -0,0 +1,13 @@
+export interface TargetPathHintLine {
+  readonly fragments: readonly string[];
+  readonly labelMissing: boolean;
+}
+
+/** Parse the first declared target-path line shared by checklist storage and ask preflight. */
+export function parseTargetPathHintLine(text: string): TargetPathHintLine {
+  const firstLine = text.split(/\r?\n/).find((line) => line.trim() !== '');
+  if (firstLine === undefined) return { fragments: [], labelMissing: true };
+  const match = /^\s*(?:대상\s*경로|target\s*paths?)\s*[:：]\s*(.*)$/i.exec(firstLine);
+  if (!match) return { fragments: [], labelMissing: true };
+  return { fragments: match[1]!.split(/[·,;]/), labelMissing: false };
+}

package/src/release-loop/checklist.ts

@@ -5,6 +5,9 @@ import { isAbsolute, join } from 'node:path';
 import * as store from './feature-store.js';
 import { debug } from '../debug/log.js';
 import { CliUserError } from '../cli/cli-user-error.js';
+import { parseTargetPathHintLine } from './checklist-target-path-hint.js';
+export { parseTargetPathHintLine } from './checklist-target-path-hint.js';
+export type { TargetPathHintLine } from './checklist-target-path-hint.js';
 
 export type ChecklistStatus = 'green' | 'yellow' | 'red' | 'done';
 export type ChecklistDisposition = 'move' | 'known-issue' | 'block';
@@ -248,6 +251,11 @@ export function isMergeOrTypecheckOnlyEvidence(value: string): boolean {
   return signal;
 }
 
+/** Parsed target path fragments, preserving order and raw path spelling while trimming separator whitespace. */
+export function parseChecklistTargetPaths(text: string): string[] {
+  return parseTargetPathHintLine(text).fragments.map((fragment) => fragment.trim().replace(/^`+|`+$/g, ''));
+}
+
 /** Shadow check at checklist authorship. Callers supply the origin/main file probe and merged-PR file reader. */
 export function inspectChecklistTargetPaths(input: {
   title: string; evidence?: string; refs?: readonly string[]; dispatchKind?: ChecklistDispatchKind;
@@ -256,7 +264,7 @@ export function inspectChecklistTargetPaths(input: {
 } {
   const lines = input.title.split(/\r?\n/);
   const first = /^대상 경로:\s*(.*)$/.exec(lines[0] ?? '');
-  const rawTargets = first?.[1]?.split(' · ').map((path) => path.trim()) ?? [];
+  const rawTargets = parseChecklistTargetPaths(lines[0] ?? '');
   const validPath = (path: string): boolean => path.length > 0 && path.length < 4096
     && !path.startsWith('/') && !path.includes('\\') && !/[\u0000-\u001f\u007f]/u.test(path)
     && path.split('/').every((segment) => segment !== '' && segment !== '.' && segment !== '..');

package/src/release-loop/gate-host-reservation.ts

@@ -1,9 +1,12 @@
 import { randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { psProcessStartMs } from '../harness/harness-stop.js';
 import { debug } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { psProcessStart, type HostLeaseRecord, type PendingJobIdentity } from '../pod-lease/host-lease.js';
+import { parsePodPool, podPoolHostLease, resolvePodPoolSpec, type PodPoolMember } from '../task-orchestrator/surfaces/pod-pool.js';
 
 interface GateHostClaim {
   token: string;
@@ -19,6 +22,147 @@ export type GateHostReservation =
   | { status: 'free' }
   | { status: 'reserved' | 'unknown'; reason: string; runId?: string; reservedAt?: number };
 
+/** Read-only snapshots used to decide whether the resource pool behind a gate host is occupied. */
+export interface GateHostResourceSnapshot {
+  /** null means the lease ledger was unreadable; [] is a measured empty ledger. */
+  leases: readonly HostLeaseRecord[] | null;
+  /** Active Pending/Running Jobs from the configured Pod pool; null means not measurable. */
+  activeJobs: readonly PendingJobIdentity[] | null;
+}
+
+export type GateHostResourceReading =
+  | { status: 'measured'; empty: boolean; reservations: number; authoringLeases: number; waitingJobs: number; activeJobs: number }
+  | { status: 'unmeasurable'; empty: null; reason: 'lease-ledger-unavailable' | 'lease-ledger-invalid' | 'pod-list-unavailable' | 'pod-list-invalid' | 'pod-pool-invalid' };
+
+const unavailable = (reason: Extract<GateHostResourceReading, { status: 'unmeasurable' }>['reason']): GateHostResourceReading => ({ status: 'unmeasurable', empty: null, reason });
+
+/** Read leases and active harness Pods from the configured pool without creating, pruning, or updating any ledger. */
+export function readGateHostResourcesForHost(host: string, env: NodeJS.ProcessEnv = process.env,
+  deps: { members?: readonly PodPoolMember[]; kubectl?: (args: readonly string[]) => { status: number | null; stdout: string };
+    processStart?: (pid: number) => string | null } = {}): GateHostResourceReading {
+  let members: readonly PodPoolMember[];
+  try {
+    const spec = resolvePodPoolSpec(undefined, env, () => {
+      try {
+        // The gate path resolves its pool from harness.podPool, unlike generic Pod launches.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        return (require('../user-config.js') as typeof import('../user-config.js')).getUserConfig().harness?.podPool;
+      } catch { return undefined; }
+    });
+    members = deps.members ?? (spec ? parsePodPool(spec) : []);
+  } catch { return unavailable('pod-pool-invalid'); }
+  if (!members.length) return unavailable('pod-list-unavailable');
+  const selectedHost = host.split('@').at(-1)!;
+  const selectedMembers = members.filter(member => member.sshHost === selectedHost);
+  if (!selectedMembers.length) return unavailable('pod-list-unavailable');
+  const selectedContexts = new Set(selectedMembers.map(member => member.context));
+
+  const leasePool = podPoolHostLease(members);
+  let leases: HostLeaseRecord[];
+  try {
+    let names: string[];
+    try { names = readdirSync(leasePool.dir).filter(name => name.endsWith('.json')); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') names = [];
+      else return unavailable('lease-ledger-unavailable');
+    }
+    leases = [];
+    const processStart = deps.processStart ?? psProcessStart;
+    for (const name of names) {
+      if (!/^[A-Za-z0-9._-]+\.json$/.test(name)) return unavailable('lease-ledger-invalid');
+      let lease: HostLeaseRecord;
+      try { lease = JSON.parse(readFileSync(join(leasePool.dir, name), 'utf8')) as HostLeaseRecord; }
+      catch { return unavailable('lease-ledger-invalid'); }
+      if (!lease || !Number.isSafeInteger(lease.pid) || lease.pid <= 0 || typeof lease.startedAt !== 'string' || !lease.startedAt ||
+        typeof lease.at !== 'string' || (lease.stage !== undefined && lease.stage !== 'authoring' && lease.stage !== 'job') ||
+        (lease.stage === 'job' && (!lease.job || !lease.context || !lease.namespace))) return unavailable('lease-ledger-invalid');
+      try { process.kill(lease.pid, 0); }
+      catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ESRCH') continue;
+        // EPERM means the PID may still be alive; the start-time comparison below is still read-only.
+      }
+      const startedAt = processStart(lease.pid);
+      if (startedAt === null) return unavailable('lease-ledger-unavailable');
+      if (startedAt !== lease.startedAt) continue;
+      if (lease.stage !== 'job' || selectedContexts.has(lease.context!)) leases.push(lease);
+    }
+  } catch { return unavailable('lease-ledger-unavailable'); }
+
+  const kubectl = deps.kubectl ?? ((args: readonly string[]) => {
+    const result = spawnSync('kubectl', [...args], { encoding: 'utf8', timeout: 15_000, maxBuffer: 64 * 1024 * 1024 });
+    return { status: result.status, stdout: result.stdout ?? '' };
+  });
+  const activeJobs = new Map<string, PendingJobIdentity>();
+  for (const member of selectedMembers) {
+    let result: { status: number | null; stdout: string };
+    try { result = kubectl(['--context', member.context, '--request-timeout=10s', 'get', 'pods', '--all-namespaces', '-l', 'elanous.substrate=pod', '-o', 'json']); }
+    catch { return unavailable('pod-list-unavailable'); }
+    if (result.status !== 0) return unavailable('pod-list-unavailable');
+    let items: unknown;
+    try { items = (JSON.parse(result.stdout) as { items?: unknown }).items; }
+    catch { return unavailable('pod-list-invalid'); }
+    if (!Array.isArray(items)) return unavailable('pod-list-invalid');
+    for (const item of items) {
+      if (!item || typeof item !== 'object') return unavailable('pod-list-invalid');
+      const pod = item as { metadata?: { name?: unknown; namespace?: unknown; deletionTimestamp?: unknown; labels?: Record<string, unknown>; ownerReferences?: Array<{ kind?: unknown; name?: unknown }> }; status?: { phase?: unknown } };
+      const phase = pod.status?.phase;
+      if (phase === 'Succeeded' || phase === 'Failed') continue;
+      if (phase !== 'Pending' && phase !== 'Running') return unavailable('pod-list-invalid');
+      // Deleting Pods are already leaving the pool and must not keep the selected host occupied.
+      if (pod.metadata?.deletionTimestamp != null) continue;
+      const context = member.context;
+      const namespace = pod.metadata?.namespace;
+      const owner = pod.metadata?.ownerReferences?.find(ref => ref.kind === 'Job')?.name;
+      const job = owner ?? pod.metadata?.labels?.['job-name'];
+      if (typeof namespace !== 'string' || !namespace || typeof job !== 'string' || !job) return unavailable('pod-list-invalid');
+      const identity = { context, namespace, job };
+      activeJobs.set(`${context}\0${namespace}\0${job}`, identity);
+    }
+  }
+  const reading = readGateHostResources({ leases, activeJobs: [...activeJobs.values()] });
+  debug.log('release-loop.gate', 'host-resource-probe', { host: selectedHost, poolContexts: selectedMembers.map(member => member.context), ...reading });
+  return reading;
+}
+
+function activeJobKey(job: PendingJobIdentity): string | null {
+  return typeof job?.context === 'string' && job.context.length > 0 &&
+    typeof job.namespace === 'string' && job.namespace.length > 0 &&
+    typeof job.job === 'string' && job.job.length > 0
+    ? `${job.context}\0${job.namespace}\0${job.job}` : null;
+}
+
+/**
+ * Read the resource ledgers as the authority for host occupancy. Process argv is deliberately not an input:
+ * unrelated commands that happen to contain `bun test` do not reserve a gate host.
+ * A Job-backed lease and its active Job are one reservation; a lease without an observed Job remains reserved.
+ */
+export function readGateHostResources(snapshot: GateHostResourceSnapshot): GateHostResourceReading {
+  if (snapshot.leases === null) return { status: 'unmeasurable', empty: null, reason: 'lease-ledger-unavailable' };
+  if (snapshot.activeJobs === null) return { status: 'unmeasurable', empty: null, reason: 'pod-list-unavailable' };
+  if (!Array.isArray(snapshot.leases) || snapshot.leases.some((lease) => !lease ||
+    !Number.isSafeInteger(lease.pid) || lease.pid <= 0 || typeof lease.startedAt !== 'string' || !lease.startedAt || typeof lease.at !== 'string' ||
+    (lease.stage !== undefined && lease.stage !== 'authoring' && lease.stage !== 'job') ||
+    (lease.stage === 'job' && (!lease.job || !lease.context || !lease.namespace)))) {
+    return { status: 'unmeasurable', empty: null, reason: 'lease-ledger-invalid' };
+  }
+  if (!Array.isArray(snapshot.activeJobs) || snapshot.activeJobs.some((job) => !job || activeJobKey(job) === null)) {
+    return { status: 'unmeasurable', empty: null, reason: 'pod-list-invalid' };
+  }
+
+  const jobs = new Set(snapshot.activeJobs.map(activeJobKey) as string[]);
+  // Authoring leases have no host/context yet, so they conservatively occupy each selected host in the shared pool.
+  let authoringLeases = 0;
+  let waitingJobs = 0;
+  for (const lease of snapshot.leases) {
+    if (lease.stage !== 'job') { authoringLeases++; continue; }
+    const key = lease.job && lease.context && lease.namespace
+      ? activeJobKey({ job: lease.job, context: lease.context, namespace: lease.namespace }) : null;
+    if (!key || !jobs.has(key)) waitingJobs++;
+  }
+  const reservations = authoringLeases + waitingJobs + jobs.size;
+  return { status: 'measured', empty: reservations === 0, reservations, authoringLeases, waitingJobs, activeJobs: jobs.size };
+}
+
 const hostName = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
 const claimsDir = (root: string) => join(root, 'release', 'gate-host-reservations');
 

package/src/release-loop/release-schedule.ts

@@ -1,10 +1,99 @@
+import { createHash } from 'node:crypto';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { CliUserError } from '../cli/cli-user-error.js';
 import { debug } from '../debug/log.js';
-import { readSchedule, readSchedules, writeSchedule, type ScheduleRow } from './feature-store.js';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import { readSchedule, readSchedules, releasedVersion, writeSchedule, type ScheduleRow } from './feature-store.js';
 import { checkScheduleCeoLoad } from './placement.js';
 
 export type ReleaseSchedule = ScheduleRow;
 
+export interface ReleaseCutDueEvent {
+  id: string;
+  type: 'release.cut.due';
+  version: string;
+  cutAt: string;
+  at: string;
+}
+
+function newerVersion(version: string, published: string): boolean {
+  if (!published) return true;
+  const left = version.split('.').map(Number), right = published.split('.').map(Number);
+  for (let index = 0; index < 3; index++) {
+    if (left[index]! !== right[index]!) return left[index]! > right[index]!;
+  }
+  return false;
+}
+
+/** A scheduler tick observes due cuts; it does not directly start a release run. */
+export function dueReleaseCutEvents(now: string, root = releaseLedgerRoot()): ReleaseCutDueEvent[] {
+  const at = Date.parse(now);
+  if (!Number.isFinite(at)) throw new Error(`invalid schedule tick time: ${now}`);
+  const published = releasedVersion(root);
+  return readSchedules(root).filter(row => {
+    const cut = Date.parse(row.cutAt);
+    return newerVersion(row.version, published) && cut <= at && at - cut < 24 * 3_600_000;
+  }).map(row => ({ id: `release.cut.due:${row.version}:${row.cutAt}`, type: 'release.cut.due' as const,
+    version: row.version, cutAt: row.cutAt, at: new Date(at).toISOString() }));
+}
+
+function hasReleaseRunForEvent(root: string, eventId: string): boolean {
+  const dir = join(root, 'graph-runs', 'release-loop');
+  if (!existsSync(dir)) return false;
+  for (const name of readdirSync(dir)) {
+    if (!name.endsWith('.json')) continue;
+    try {
+      const run = JSON.parse(readFileSync(join(dir, name), 'utf8')) as { input?: { triggerEvent?: { id?: string } } };
+      if (run.input?.triggerEvent?.id === eventId) return true;
+    } catch { /* Ignore a partially written run; the next scheduler tick retries. */ }
+  }
+  return false;
+}
+
+/** Claim each version+cut only once across scheduler processes; a dead pending owner can be retried. */
+export async function emitDueReleaseCutEvents(now: string, emit: (event: ReleaseCutDueEvent) => Promise<void>,
+  root = releaseLedgerRoot(), subscriptionId = 'graph:release-loop'): Promise<ReleaseCutDueEvent[]> {
+  const emitted: ReleaseCutDueEvent[] = [];
+  for (const event of dueReleaseCutEvents(now, root)) {
+    const hash = createHash('sha256').update(`${subscriptionId}\0${event.id}`).digest('hex').slice(0, 16);
+    const path = join(root, 'release', 'cut-events', `${event.version}-${hash}.json`);
+    mkdirSync(dirname(path), { recursive: true });
+    let fd: number;
+    try { fd = openSync(path, 'wx', 0o600); }
+    catch (cause) {
+      if ((cause as NodeJS.ErrnoException).code !== 'EEXIST') throw cause;
+      let prior: { status?: string; pid?: number } = {};
+      try { prior = JSON.parse(readFileSync(path, 'utf8')) as typeof prior; } catch { /* pending write */ }
+      if (prior.status !== 'pending' || !Number.isInteger(prior.pid)) {
+        // A crash between O_EXCL creation and the first write leaves an empty claim.
+        if (Date.now() - statSync(path).mtimeMs < 60_000 || prior.status === 'emitted') continue;
+      } else {
+        try { process.kill(prior.pid!, 0); continue; }
+        catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ESRCH') continue; }
+      }
+      if (hasReleaseRunForEvent(root, event.id)) {
+        writeFileSync(path, JSON.stringify({ ...event, subscriptionId, status: 'emitted', recovered: true }) + '\n', { mode: 0o600 });
+        continue;
+      }
+      try { unlinkSync(path); fd = openSync(path, 'wx', 0o600); }
+      catch (error) { if ((error as NodeJS.ErrnoException).code === 'EEXIST') continue; throw error; }
+    }
+    closeSync(fd);
+    writeFileSync(path, JSON.stringify({ ...event, subscriptionId, status: 'pending', pid: process.pid }) + '\n', { mode: 0o600 });
+    try {
+      await emit(event);
+      writeFileSync(path, JSON.stringify({ ...event, subscriptionId, status: 'emitted', pid: process.pid }) + '\n', { mode: 0o600 });
+      debug.log('release.schedule', 'cut-due', { version: event.version, cutAt: event.cutAt, eventId: event.id, subscriptionId });
+      emitted.push(event);
+    } catch (error) {
+      if (existsSync(path)) unlinkSync(path);
+      throw error;
+    }
+  }
+  return emitted;
+}
+
 /** A release landing and its representative work share the same KST day boundary. */
 export function kstDay(utc: string): string {
   return new Date(Date.parse(utc) + 9 * 3_600_000).toISOString().slice(0, 10);

package/src/repl/index.ts

@@ -41,6 +41,8 @@ import {
   type UserConfig,
 } from '../user-config.js';
 import { setAmbientSessionId, debug } from '../debug/log.js';
+import { buildInstalledSkillCatalogMessage, type InstalledSkillSummary } from '../dashboard/skill-catalog-preamble.js';
+import { resolveModelContextWindow } from '../models/context-window.js';
 import { decideSigintAction } from './sigint.js';
 import { decideSessionStart, observeSessionStart } from '../session/session-start.js';
 import { buildReplayTurnsFromSession } from './replay.js';
@@ -275,13 +277,39 @@ export function buildReplSystemPrompt(ctx: {
   sessionId?: string | undefined;
   /** 시험·임베디드 호출부용 시임 — 기본은 실제 홈·msg 원장·process.env. */
   seatBootDeps?: SeatBootDeps | undefined;
+  /** Installed skill summaries are injectable for deterministic prompt tests. */
+  skillCatalog?: readonly InstalledSkillSummary[] | undefined;
+  skillCatalogContextWindow?: number | null | undefined;
 }): string | undefined {
   const base = ctx.enabledToolNames === undefined
     ? undefined
     : buildAgentSystemPrompt(ctx.cfg, ctx.enabledToolNames);
+  const skillToolsEnabled = ctx.enabledToolNames?.includes('skill_exec') === true
+    && ctx.enabledToolNames.includes('elanous_skills_list');
+  let skillCatalogText = '';
+  if (skillToolsEnabled) {
+    try {
+      const catalog = ctx.skillCatalog ?? (() => {
+        const skills = require('../skills/index.js') as typeof import('../skills/index.js');
+        return skills.applySkillFilter(skills.getSkillIndex(), ctx.cfg.skills)
+          .map(({ name, description }) => ({ name, description }));
+      })();
+      const built = buildInstalledSkillCatalogMessage(
+        catalog,
+        ctx.skillCatalogContextWindow ?? resolveModelContextWindow(ctx.cfg.llm.model),
+      );
+      skillCatalogText = built.message?.content ?? '';
+      debug.log('repl.skill-catalog', 'built', {
+        skillCount: built.skillCount, estimatedTokens: built.estimatedTokens,
+        budgetTokens: built.budgetTokens, mode: built.mode,
+      });
+    } catch (error) {
+      debug.log('repl.skill-catalog', 'failed', { reason: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+    }
+  }
   const card = buildSeatBootCardText(ctx);
-  if (card.length === 0) return base;
-  return base === undefined || base.length === 0 ? card : `${base}\n\n${card}`;
+  const parts = [skillCatalogText, base ?? '', card].filter(part => part.length > 0);
+  return parts.length > 0 ? parts.join('\n\n') : undefined;
 }
 
 /** 자리 부트 카드 문면(system 메시지 0~1개를 이어 붙인 것). 자리가 아니면 ''. */
@@ -344,6 +372,7 @@ async function runOneTurn(
   nextTuiDelivery?: { pending: PendingTaskNotification[] },
   onJsonDelta?: (delta: string) => void,
   onJsonStatus?: (line: string) => void,
+  onJsonReplace?: (fullText: string) => void,
 ): Promise<{ reply: string; provider: string; model: string | null; durationMs: number; logPath: string | null }> {
   const startedAt = Date.now();
   const replyChunks: string[] = [];
@@ -374,6 +403,7 @@ async function runOneTurn(
     userConfig: cfg,
     sessionId,
     userText,
+    utteranceSurface: 'tui',
     systemPrompt,
     userImages: userImages.length > 0 ? userImages : undefined,
     ...(process.env.ELANOUS_TEST_FAKE_LLM === '1' && Number.isFinite(Number(process.env.ELANOUS_TEST_FAKE_LLM_IDLE_TIMEOUT_MS))
@@ -387,6 +417,14 @@ async function runOneTurn(
       }
       else process.stdout.write(d);
     },
+    onReplaceText: (fullText) => {
+      if (jsonOutput) {
+        replyChunks.splice(0, replyChunks.length, fullText);
+        onJsonReplace?.(fullText);
+      } else {
+        process.stdout.write(`\n\n  [근거 반영된 답변]\n  ${fullText}\n`);
+      }
+    },
     onStatusLine: (line) => { onJsonStatus?.(line); },
     tools: replToolSpecs,
     dispatchTool: tools?.dispatch,
@@ -795,6 +833,9 @@ export async function runRepl(opts: ReplOpts): Promise<number> {
           process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
             ? (text) => { process.stdout.write(`${JSON.stringify({ event: 'status', turnId: turn.id, text })}\n`); }
             : undefined,
+          process.env.ELANOUS_NEXT_TUI_STREAM === '1' && typeof turn.id === 'string'
+            ? (text) => { process.stdout.write(`${JSON.stringify({ event: 'replace', turnId: turn.id, text })}\n`); }
+            : undefined,
         );
       } catch (error) {
         if (!backgroundBridge) throw error;