elanous 0.2.31 → 0.2.32

package/src/mss/logging/render-categories.ts

@@ -79,6 +79,11 @@ export const RENDER_CATEGORY_EXEMPTIONS: ReadonlyMap<string, string> = new Map([
   //   ⛔ 접두 전체(`dashboard`)를 풀지 «않는다» — 그러면 진짜 렌더 소음이 되살아난다. 이 둘만 뗀다.
   ['dashboard.turn-typeahead', 'Mid-turn input queueing decisions — which key was consumed, what was queued, and when it drains. Turn-control judgment, not frame noise.'],
   ['dashboard.streaming-key', 'Streaming-window key ownership — whether a key reached the streaming dispatcher at all. This is the probe that answers "is the ladder live?", so it must survive render mute.'],
+  // ⛔ 2026-10-17 (`TUI-H8-SEAT-BOOT-LOG-MUTED`) — 자리 부트 카드는 «항상성» 이벤트다(렌더 소음 아님).
+  //   `/session new` 뒤 카드가 실렸는지를 `logs --all --include-test` 로도 0행으로 만들어
+  //   «카드가 빠졌다»와 «음소거됐다»를 가를 수 없었다. 접두 전체는 풀지 않고 이것만 뗀다.
+  //   (`tui.autoturn`·`tui.wakeup`·`tui.autowake` 는 `tui` 가 렌더 접두가 아니라 애초에 안 잘린다.)
+  ['dashboard.seat-boot', 'Seat boot card lifecycle — conversation-start, card-injected, card-skipped. Homeostasis evidence that the seat card reached the turn, not frame noise.'],
 ]);
 
 /** Reject an exemption without its required, human-readable rationale. */

package/src/ops/overview.ts

@@ -96,6 +96,62 @@ export interface VerdictResult { verdict: Verdict; reasons: string[]; nextAction
 /** 부하/코어가 이 값을 넘으면 «기계 압박»(흐름 저하의 사유). 디스크 I/O 신호는 OVW-MACHINE-HB 전까지 없다. */
 export const LOAD_PER_CORE_PRESSURE = 3;
 
+/** 자원 지도의 축 어휘(닫힌 집합 · RES-FLOOR-BINDING). I/O·게이트 예약은 이 칸에 원천이 없어 늘 제외다. */
+export type ResourceKind = 'memory' | 'cpu' | 'io' | 'slots' | 'gate';
+
+/** 구속 조건 — 남은 비율이 최소인 축. 남은 비율 = 남은 양/전체 양(CPU 는 압박선 LOAD_PER_CORE_PRESSURE×코어를 전체로 본다). */
+export interface ResourceBinding {
+  kind: ResourceKind;
+  label: string;
+  remainingRatio: number;
+  /** 남은 양/전체 양의 사람 표기 — `5/64GB` · `0/54코어(압박선 3/코어)` · `0/46자리`. */
+  remainingText: string;
+}
+
+function ratio01(n: number): number {
+  return Math.min(1, Math.max(0, n));
+}
+
+function remainingAmount(n: number): string {
+  return Number.isInteger(n) ? n.toFixed(0) : String(Number(n.toPrecision(3)));
+}
+
+/**
+ * 구속 조건 규칙(RES-FLOOR-BINDING) — 메모리·CPU·I/O·슬롯·게이트 예약 중 «남은 비율 최소»인 축이 흐름을 묶는다.
+ * 못 잰 축(하트비트 없는 호스트 · 용량 못 잼 · 원천 없는 I/O·게이트 예약)은 후보에서 뺀다 — «넉넉»으로도 «바닥»으로도 읽지 않는다.
+ * 측정 축이 하나도 없으면 null. 동율은 정해진 순서(호스트 순 메모리→CPU, 그 다음 슬롯)의 첫 축이 이긴다.
+ */
+export function bindingResource(s: OverviewSnapshot): ResourceBinding | null {
+  const candidates: ResourceBinding[] = [];
+  for (const host of s.machines.hosts) {
+    const l = host.load.value;
+    if (!l) continue;
+    if (l.totalGb > 0) {
+      const remaining = Math.max(0, l.freeGb);
+      candidates.push({ kind: 'memory', label: `${host.name} 메모리`, remainingRatio: ratio01(remaining / l.totalGb), remainingText: `${remainingAmount(remaining)}/${l.totalGb.toFixed(0)}GB` });
+    }
+    if (l.cpuCount > 0) {
+      const cpuCap = l.cpuCount * LOAD_PER_CORE_PRESSURE;
+      const remaining = Math.max(0, cpuCap - l.load5);
+      candidates.push({ kind: 'cpu', label: `${host.name} CPU`, remainingRatio: ratio01(remaining / cpuCap), remainingText: `${remainingAmount(remaining)}/${cpuCap.toFixed(0)}코어(압박선 ${LOAD_PER_CORE_PRESSURE}/코어)` });
+    }
+  }
+  const capacity = s.tasks.capacity.value;
+  if (capacity && capacity.podTarget + capacity.localMax > 0) {
+    const total = capacity.podTarget + capacity.localMax;
+    candidates.push({ kind: 'slots', label: '슬롯', remainingRatio: ratio01(capacity.free / total), remainingText: `${capacity.free}/${total}자리` });
+  }
+  let binding: ResourceBinding | null = null;
+  for (const c of candidates) if (binding === null || c.remainingRatio < binding.remainingRatio) binding = c;
+  return binding;
+}
+
+/** 판정 띠 문구 — 측정된 축 중 «무엇이 흐름을 묶고 있나»를 이름으로 단다. 측정 축이 없으면 null. */
+export function bindingPhrase(b: ResourceBinding | null): string | null {
+  if (!b) return null;
+  return `구속 자원 ${b.label} — 남은 비율 최소 ${Math.round(b.remainingRatio * 100)}% (${b.remainingText})`;
+}
+
 export function computeVerdict(s: OverviewSnapshot): VerdictResult {
   const hits = new Map<Verdict, { reasons: string[]; actions: string[] }>();
   const hit = (v: Verdict, reason: string, action?: string): void => {
@@ -155,14 +211,15 @@ export function computeVerdict(s: OverviewSnapshot): VerdictResult {
     }
   }
 
+  const phrase = bindingPhrase(bindingResource(s));
   for (const v of VERDICTS) {
     const row = hits.get(v);
     if (!row) continue;
     // 이유 사슬: 이긴 판정의 사유 먼저, 그 밑에 진 판정들의 사유도 «부가»로 남긴다(한 사슬에 두 원인이 보이게).
     const rest = VERDICTS.filter((o) => o !== v && hits.has(o)).flatMap((o) => hits.get(o)!.reasons.map((r) => `(+${VERDICT_LABEL[o]}) ${r}`));
-    return { verdict: v, reasons: [...row.reasons, ...rest], nextActions: row.actions };
+    return { verdict: v, reasons: [...row.reasons, ...(phrase ? [phrase] : []), ...rest], nextActions: row.actions };
   }
-  return { verdict: 'flowing', reasons: [], nextActions: [] };
+  return { verdict: 'flowing', reasons: phrase ? [phrase] : [], nextActions: [] };
 }
 
 /** exit code — flowing·degraded 0 · 그 밖의 판정 3(수집기 자체 실패 1 은 호출자 몫). */

package/src/pr-tool/census.ts

@@ -28,7 +28,9 @@ export type Census = { status: 'checked'; total: number; rows: readonly CensusRo
   | { status: 'unknown'; reason: string };
 export interface DiffHunk { path: string; start: number; end: number }
 export type GuardCode = 'inventory-unknown' | 'candidate-unknown' | 'goal-only' | 'file-overlap' | 'hunk-overlap' | 'same-cell' | 'seat-cap' | 'seat-unattributed';
-export interface GuardReason { code: GuardCode; detail: string; prs?: readonly number[] }
+export interface GuardReason { code: GuardCode; detail: string; prs?: readonly number[]; files?: readonly string[] }
+/** PR-GUARD-HUNK-WARN (대표 10-17): 줄 겹침은 기본 경고 — 착지 쪽 스마트 머지가 푼다. 'refuse' = 옛 거부 동작. */
+export type HunkOverlapMode = 'refuse' | 'warn';
 export interface GuardVerdict { status: 'allow' | 'refuse' | 'unknown'; reasons: readonly GuardReason[]; warnings: readonly GuardReason[] }
 
 const SEATS = ['OP', 'TC', 'MK', 'UX'] as const;
@@ -209,7 +211,7 @@ export function censusOpenPrs(inventory: Inventory, now = Date.now()): Census {
   return result;
 }
 
-export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat | null; seatCap?: number; cellId?: string | null; hunks?: readonly DiffHunk[] }, inventory: Inventory): GuardVerdict {
+export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat | null; seatCap?: number; cellId?: string | null; hunks?: readonly DiffHunk[]; hunkOverlap?: HunkOverlapMode }, inventory: Inventory): GuardVerdict {
   if (!input.files || input.files.length === 0 || input.files.some(file => !file || file.startsWith('/') || file.includes('..'))) {
     const reasons: GuardReason[] = [{ code: 'candidate-unknown', detail: '새 PR 변경 파일을 확인할 수 없음' }];
     debug.log('pr.tool', 'guard-refuse', { status: 'unknown', reasons });
@@ -226,8 +228,21 @@ export function guardNewPr(input: { files: readonly string[] | null; seat?: Seat
   const sameCell = input.cellId ? inventory.prs.filter(pr => pr.cellId === input.cellId) : [];
   if (sameCell.length) reasons.push({ code: 'same-cell', detail: `같은 칸 ${input.cellId} OPEN PR이 있음`, prs: sameCell.map(pr => pr.number) });
   const overlaps = inventory.prs.filter(pr => pr.files.some(file => candidate.has(file)));
-  const sameHunk = overlaps.filter(pr => pr.hunks?.some(other => input.hunks?.some(own => own.path === other.path && own.start <= other.end && other.start <= own.end)));
-  if (sameHunk.length) reasons.push({ code: 'hunk-overlap', detail: '같은 파일의 수정 줄 범위가 겹침', prs: sameHunk.map(pr => pr.number) });
+  const hunkFiles = new Set<string>();
+  const sameHunk = overlaps.filter(pr => {
+    const paths = (pr.hunks ?? []).filter(other => input.hunks?.some(own => own.path === other.path && own.start <= other.end && other.start <= own.end)).map(other => other.path);
+    for (const path of paths) hunkFiles.add(path);
+    return paths.length > 0;
+  });
+  if (sameHunk.length) {
+    const refuseHunk = input.hunkOverlap === 'refuse';
+    (refuseHunk ? reasons : warnings).push({
+      code: 'hunk-overlap',
+      detail: refuseHunk ? '같은 파일의 수정 줄 범위가 겹침' : '같은 파일의 수정 줄 범위가 겹침 · 착지 때 머지로 푼다',
+      prs: sameHunk.map(pr => pr.number),
+      files: [...hunkFiles],
+    });
+  }
   if (overlaps.length) warnings.push({ code: 'file-overlap', detail: '같은 파일의 OPEN PR이 있음 · 줄 겹침은 별도 판정', prs: overlaps.map(pr => pr.number) });
   const seat = seatValue(input.seat);
   if (input.seat !== undefined && input.seat !== null && !seat) reasons.push({ code: 'candidate-unknown', detail: '호출자 자리 값 오류' });

package/src/pr-tool/inflight-registry.ts

@@ -0,0 +1,143 @@
+/**
+ * INFLIGHT-REGISTRY — 비행 중 등록부(대표 10-17 «출발 때 맥락 남기고 머지 때 참조 · 착지하면 지움 · 폭증 막기»).
+ *
+ * 발사하는 런이 runId·칸·한 줄 의도·대상 파일을 한 줄 등록하고, 머지 순간(스마트 머지 LLM)에 같은 파일을
+ * 만지는 줄들의 의도를 읽는다. 착지하면 지운다. 정본은 PR 본문이고 이것은 «색인»이다 — 못 읽으면 빈 목록
+ * (머지는 종전 그대로 간다), 못 쓰면 발사·착지를 막지 않는다(호출부가 fail-soft).
+ *
+ * 폭증 막기: 런당 1줄(같은 칸 재발사는 덮어씀) · 의도 ≤300자 · 파일 ≤20 · 48h 지난 줄은 읽을 때 거르고 쓸 때 걷는다.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { withFileLockSync } from '../storage/file-lock.js';
+
+export const INFLIGHT_INTENT_MAX_CHARS = 300;
+export const INFLIGHT_FILES_MAX = 20;
+export const INFLIGHT_TTL_MS = 48 * 60 * 60 * 1000;
+export const INFLIGHT_REGISTRY_FILE = 'inflight-registry.json';
+
+export interface InflightEntry {
+  runId: string;
+  /** 칸 id(없으면 카드 id) — 같은 칸 재발사는 이 키로 덮어쓴다. */
+  cell: string;
+  intent: string;
+  files: string[];
+  registeredAt: string;
+  cardId?: string;
+}
+
+export interface InflightOptions {
+  path?: string;
+  now?: () => Date;
+}
+
+/** 기본 자리 — 과제 카드 상태(`task-agent-actions.json`)와 같은 우주 뿌리. */
+export function inflightRegistryPath(): string {
+  return join(effectiveInstanceRoot(), INFLIGHT_REGISTRY_FILE);
+}
+
+function readEntries(path: string): InflightEntry[] {
+  if (!existsSync(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8')) as { entries?: unknown };
+    return Array.isArray(parsed.entries) ? parsed.entries.filter(isEntry) : [];
+  } catch { return []; }
+}
+
+function isEntry(value: unknown): value is InflightEntry {
+  const entry = value as Partial<InflightEntry> | null;
+  return !!entry && typeof entry.runId === 'string' && typeof entry.cell === 'string' && typeof entry.intent === 'string'
+    && Array.isArray(entry.files) && typeof entry.registeredAt === 'string';
+}
+
+function isExpired(entry: InflightEntry, now: Date): boolean {
+  const at = Date.parse(entry.registeredAt);
+  return !Number.isFinite(at) || now.getTime() - at > INFLIGHT_TTL_MS;
+}
+
+/** 잠금 안에서 읽고 고쳐 쓴다 — 48h 지난 줄은 쓸 때 걷는다(`expire` 관측). */
+function mutate(opts: InflightOptions, update: (entries: InflightEntry[]) => InflightEntry[]): void {
+  const path = opts.path ?? inflightRegistryPath();
+  const now = (opts.now ?? (() => new Date()))();
+  withFileLockSync(`${path}.lock`, () => {
+    const all = readEntries(path);
+    const live = all.filter((entry) => !isExpired(entry, now));
+    if (live.length < all.length) {
+      try { debug.log('pr-tool.inflight', 'expire', { phase: 'write', runIds: all.filter((entry) => isExpired(entry, now)).map((entry) => entry.runId) }); } catch { /* fail-soft */ }
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({ entries: update(live) }));
+  });
+}
+
+/** 한 줄 등록 — 같은 runId 또는 같은 칸의 옛 줄을 덮어쓴다. 의도·파일은 상한에서 자른다. */
+export function registerInflight(input: { runId: string; cell: string; intent: string; files: readonly string[]; cardId?: string }, opts: InflightOptions = {}): InflightEntry {
+  const now = (opts.now ?? (() => new Date()))();
+  const files = [...new Set(input.files.map((file) => file.trim()).filter(Boolean))];
+  // 한 줄 칸만 — 줄바꿈·제어 문자는 공백으로(머지 프롬프트 인용 블록을 깨지 못하게 · 프롬프트 쪽도 따로 무력화한다).
+  const oneLine = (value: string) => value.replace(/[\p{Cc}\s]+/gu, ' ').trim();
+  const entry: InflightEntry = {
+    runId: oneLine(input.runId),
+    cell: oneLine(input.cell),
+    intent: oneLine(input.intent).slice(0, INFLIGHT_INTENT_MAX_CHARS),
+    files: files.slice(0, INFLIGHT_FILES_MAX),
+    registeredAt: now.toISOString(),
+    ...(input.cardId ? { cardId: input.cardId } : {}),
+  };
+  let replaced: string[] = [];
+  mutate(opts, (entries) => {
+    replaced = entries.filter((old) => old.runId === entry.runId || old.cell === entry.cell).map((old) => old.runId);
+    return [...entries.filter((old) => old.runId !== entry.runId && old.cell !== entry.cell), entry];
+  });
+  try { debug.log('pr-tool.inflight', 'register', { runId: entry.runId, cell: entry.cell, files: entry.files.length, filesDropped: files.length - entry.files.length, intentChars: entry.intent.length, replaced }); } catch { /* fail-soft */ }
+  return entry;
+}
+
+/** 줄을 지운다 — runId 또는 카드 id 로. 지운 수를 돌려준다(0 = 그런 줄 없음). */
+export function removeInflight(key: { runId: string } | { cardId: string }, reason: string, opts: InflightOptions = {}): number {
+  let removed: string[] = [];
+  const matches = (entry: InflightEntry): boolean => 'runId' in key ? entry.runId === key.runId : entry.cardId === key.cardId;
+  mutate(opts, (entries) => {
+    removed = entries.filter(matches).map((entry) => entry.runId);
+    return entries.filter((entry) => !matches(entry));
+  });
+  try { debug.log('pr-tool.inflight', 'remove', { ...key, reason, removed }); } catch { /* fail-soft */ }
+  return removed.length;
+}
+
+/** 살아 있는 줄 — `files` 를 주면 그중 하나라도 만지는 줄만. 48h 지난 줄은 거른다(읽기는 쓰지 않는다). */
+export function listInflight(filter: { files?: readonly string[] } = {}, opts: InflightOptions = {}): InflightEntry[] {
+  const now = (opts.now ?? (() => new Date()))();
+  const all = readEntries(opts.path ?? inflightRegistryPath());
+  const live = all.filter((entry) => !isExpired(entry, now));
+  if (live.length < all.length) {
+    try { debug.log('pr-tool.inflight', 'expire', { phase: 'read', count: all.length - live.length }); } catch { /* fail-soft */ }
+  }
+  if (!filter.files) return live;
+  const wanted = new Set(filter.files);
+  return live.filter((entry) => entry.files.some((file) => wanted.has(file)));
+}
+
+/**
+ * 착지한 PR 의 줄을 지운다 — 그 PR 을 연 과제 카드(`card.pr`)의 카드 id·runId 로 찾는다.
+ * 카드가 없으면 디스크를 건드리지 않는다(사람 PR · 다른 우주 카드 = 지울 줄 없음).
+ */
+export function removeInflightForPr(
+  pr: number,
+  cards: Iterable<{ id: string; runId?: string; pr?: number | { number: number } }>,
+  opts: InflightOptions = {},
+): number {
+  const owners = [...cards].filter((card) => (typeof card.pr === 'number' ? card.pr : card.pr?.number) === pr);
+  if (owners.length === 0) {
+    try { debug.log('pr-tool.inflight', 'remove', { pr, reason: 'pr-landed', removed: [], cards: 0 }); } catch { /* fail-soft */ }
+    return 0;
+  }
+  let removed = 0;
+  for (const card of owners) {
+    removed += removeInflight({ cardId: card.id }, `pr-landed:${pr}`, opts);
+    if (card.runId) removed += removeInflight({ runId: card.runId }, `pr-landed:${pr}`, opts);
+  }
+  return removed;
+}

package/src/pty-shell/pty-manifest.ts

@@ -277,6 +277,9 @@ export function upsertPtyManifest(row: {
   };
 }): void {
   try {
+    // 행을 (다시) 세우면 snapshot·frame 칸이 비워진다 — 같은 프로세스의 쓰기 스로틀도 비워 다음 쓰기가 바로 닿게 한다.
+    _lastSnapshotAt.delete(row.id);
+    _lastFrameAt.delete(row.id);
     const d = db(); if (!d) return;
     const runId = getHarnessRunId(process.env);
     const runIdSource = getHarnessRunIdSource();
@@ -800,12 +803,18 @@ export function listPtyManifestByRun(runId: string): PtyManifestRow[] {
   }
 }
 
-export function getPtyManifest(id: string): PtyManifestRow | null {
+/** `strict` — 조회 실패(db 못 엶·질의 오류)를 «행 없음»(null)과 가르도록 던진다. 기본은 둘 다 null(fail-soft). */
+export function getPtyManifest(id: string, opts: { readonly strict?: boolean } = {}): PtyManifestRow | null {
   try {
-    const d = db(); if (!d) return null;
+    const d = db();
+    if (!d) {
+      if (opts.strict) throw new Error('pty-manifest-db-unavailable');
+      return null;
+    }
     const row = d.query('SELECT * FROM pty_manifest WHERE id=?').get(id) as Record<string, unknown> | null;
     return row ? mapRow(row) : null;
-  } catch {
+  } catch (error) {
+    if (opts.strict) throw error;
     return null;
   }
 }

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

@@ -176,10 +176,9 @@ export function describePtyRunState(
     ...(checkoutHead ? { checkoutHead } : {}),
     ...(row && row.kind === 'tui' ? { startedAt: row.startedAt } : {}),
   });
-  const turn: PtyTurnView = row?.alive && row.turnState ? row.turnState : 'unknown';
+  const turnView = ptyTurnViewOfRow(row);
   return {
-    turn,
-    ...(turn !== 'unknown' && row?.turnAt ? { turnAt: row.turnAt } : {}),
+    ...turnView,
     build: build ?? null,
     installed: installed.sha ?? null,
     stale: staleness.stale,
@@ -191,6 +190,38 @@ export function shortSha(sha: string | null | undefined): string {
   return sha ? sha.slice(0, 7) : '-';
 }
 
+/** 행의 자기보고 턴만 — 설치본·git 판독과 «무관»하다(판독이 실패해도 기록된 턴은 그대로 읽힌다). 죽은 행·기록 없음 = unknown. */
+export function ptyTurnViewOfRow(row: Pick<PtyManifestRow, 'alive' | 'turnState' | 'turnAt'> | null | undefined): Pick<PtyRunStateView, 'turn' | 'turnAt'> {
+  const turn: PtyTurnView = row?.alive && row.turnState ? row.turnState : 'unknown';
+  return { turn, ...(turn !== 'unknown' && row?.turnAt ? { turnAt: row.turnAt } : {}) };
+}
+
+// ── 턴 칸(H10 · `pty list` 가 화면 긁기 없이 «지금 턴 중인가·얼마나 됐나»를 낸다) ──
+
+export interface PtyTurnCell {
+  readonly state: PtyTurnView;
+  /** 지금 턴 상태로 바뀐 시각(epoch ms) — 모르면 null. */
+  readonly at: number | null;
+  /** 지금 턴 상태에 머문 초(busy 면 «이 턴 경과»). ⛔ 모르면 null — 「0초」와 「못 잼」은 다른 값이다. */
+  readonly sinceSec: number | null;
+}
+
+export const UNKNOWN_TURN_CELL: PtyTurnCell = { state: 'unknown', at: null, sinceSec: null };
+
+/** `turnAt` 은 턴 값이 «바뀔 때만» 적힌다(`reportTuiTurn` 이 같은 값을 거른다) ⇒ now−turnAt = 그 상태의 경과. */
+export function describeTurnCell(view: Pick<PtyRunStateView, 'turn' | 'turnAt'>, now: number): PtyTurnCell {
+  if (view.turn === 'unknown' || view.turnAt === undefined || !Number.isFinite(view.turnAt) || view.turnAt <= 0) {
+    return { state: view.turn, at: null, sinceSec: null };
+  }
+  return { state: view.turn, at: view.turnAt, sinceSec: Math.max(0, Math.floor((now - view.turnAt) / 1000)) };
+}
+
+/** 표 한 칸 값: `busy,42s` · `idle,300s` · 시각 모름 `busy,?s` · 턴 모름 `?`. */
+export function formatTurnCell(cell: PtyTurnCell): string {
+  if (cell.state === 'unknown') return '?';
+  return `${cell.state},${cell.sinceSec === null ? '?' : cell.sinceSec}s`;
+}
+
 // ── 기록(TUI) ──
 
 export interface TuiRunStateRecorderDeps {

package/src/seat-loop/traffic-signal.ts

@@ -18,7 +18,8 @@ export function classifySeatTrafficProposal(message: string): 'hold' | 'UNHOLD'
   return null;
 }
 
-const defaultPath = (name: string): string => join(homedir(), 'elanous-hq', 'seat-state', 'OP', name);
+export const opSeatStatePath = (name: string): string => join(homedir(), 'elanous-hq', 'seat-state', 'OP', name);
+const defaultPath = opSeatStatePath;
 const missing = (error: unknown): boolean => (error as NodeJS.ErrnoException).code === 'ENOENT';
 
 /** A missing installation has no signal; an invalid or unreadable one cannot authorize a checklist launch. */

package/src/self-dev/ask-launch-flow.ts

@@ -13,6 +13,7 @@
 import { linesOutsideFencedCode } from '../self-implement/goal-author.js';
 import { existsSync } from 'node:fs';
 import { debug } from '../debug/log.js';
+import { appendRunLedgerEntry, runLedgerDir } from '../self-implement/run-ledger.js';
 import { recordAuthoredGoal } from './authored-goal-trace.js';
 import { findAskPathCandidates, type AskPathCandidateOptions } from './ask-path-candidates.js';
 import { retiredEntranceNotice, type EntranceDeclaration } from './entrance-registry.js';
@@ -849,6 +850,15 @@ export async function runAskLaunchFlow(
   const entrance = input.entrance;
   const askStartedAt = deps.now();
   const selfResolveClarifications = resolveSelfResolveClarifications(input.selfResolveClarifications);
+  // The Pod's logs.db disappears with the Job. Journal the two auto-authoring boundaries in its
+  // existing run ledger so the host's terminal collection can reemit them even on a failed Job.
+  const recordPodAuthoring = (event: 'ask-auto-target-candidates' | 'ask-auto-reauthor', data: Record<string, unknown>): void => {
+    if (process.env.ELANOUS_SUBSTRATE !== 'pod') return;
+    const runId = process.env.ELANOUS_RUN_ID ?? input.runId;
+    if (!runId) return;
+    try { appendRunLedgerEntry({ runId, event, data }, runLedgerDir()); }
+    catch (error) { deps.log('ask-auto-author-ledger-unavailable', { event, reason: error instanceof Error ? error.message : String(error) }, 'warn'); }
+  };
   deps.log('harness.entrance', {
     entrance: entrance.id,
     entranceStatus: entrance.status,
@@ -1082,6 +1092,7 @@ export async function runAskLaunchFlow(
         selection: { path: selectedPath ?? null, reason: selectionReason },
         ...(candidates.error === undefined ? {} : { error: candidates.error }),
       }, candidates.error === undefined && selectedPath ? 'info' : 'warn');
+      recordPodAuthoring('ask-auto-target-candidates', { candidatePathCount: candidates.paths.length, selected: Boolean(selectedPath), outcome: selectionReason });
     }
     const selectedPaths = candidates.selection?.path
       ? [candidates.selection.path]
@@ -1093,6 +1104,7 @@ export async function runAskLaunchFlow(
     } else {
       deps.print('[ask] ⑴ ⚠️ 자동 재저작에 넣을 대상 경로 후보가 없다. 대상 경로를 확인해야 한다');
     }
+    recordPodAuthoring('ask-auto-reauthor', { candidatePathCount: candidates.paths.length, firstPathCount: first.decision.result.paths.length, outcome: 'started' });
     authored = await authorAndPreflight(selectedPaths.length > 0
       ? `대상 경로: ${selectedPaths.join(' · ')}\n${input.askText}`
       : input.askText, selectedPaths);
@@ -1104,6 +1116,7 @@ export async function runAskLaunchFlow(
       secondPathCount: authored.decision.result.paths.length,
       helped: authored.decision.shouldLaunch,
     }, authored.decision.shouldLaunch ? 'info' : 'warn');
+    recordPodAuthoring('ask-auto-reauthor', { candidatePathCount: candidates.paths.length, firstPathCount: first.decision.result.paths.length, secondPathCount: authored.decision.result.paths.length, helped: authored.decision.shouldLaunch });
   }
 
   const { goalFile: effectiveGoalFile, decision } = authored;