elanous 0.2.28 → 0.2.31

package/src/dashboard/input/seat-autowake.ts

@@ -0,0 +1,318 @@
+// ── 턴 끝 자동 재개 `seat-autowake` (TUI-HOMEOSTASIS H3 · OPT-QUEUE-AUTOWAKE · 0.2.31 · 2026-10-16) ──────
+//
+// 🚨 무엇을 푸는가: 무인 자리 TUI(OPT 등)가 턴을 «✔ 완료»로 끝내면 그대로 멈춘다. 자리 큐
+//   (`seat-state/<자리>/queue.md` «## 대기»)와 안 읽은 우편이 남아 있어도 다음 턴이 안 열려,
+//   10-16 하루에 사람이 OPT 를 손으로 10회 넘게 깨웠다.
+// ⭐ 이 모듈은 «남은 일이 있나»를 턴 끝에 재고, 있으면 H2 내부 턴 문(`startTurnIfIdle`)으로 다음 턴을
+//   청한다. 문은 새로 짓지 않는다 — 거부 사유(NotIdle·HumanTyping …)는 H2 가 내고 여기선 그대로 남긴다.
+// ⛔ 입력칸 버퍼·`injectKey`·`hostControl.submit`·pty 주입 0(대표 비침투). 큐 파일은 읽기 전용.
+// ⛔ goal loop 에 얹지 않는다 — TUI 기본 엔진은 «보통 에이전트 턴»이고, 이어가기는 H2 위의 H3 다(OP #9347).
+//
+// 켜짐: 자리 TUI(`detectSeatTui`) ∧ `~/elanous-hq/seat-state/<자리>/autowake` 일반 파일(또는
+//   `~/elanous-hq/seats/<자리>/autowake`). 끄는 길 = 파일 삭제. 사람이 앉는 자리 기본 0.
+// 남은 일(OP #9349 계약): ⓐ 그 자리 안 읽은 우편 > 0 ⓑ queue.md «## 대기» 제목 아래 «- #N …» 줄 수 > 0
+//   (취소선 «- ~~#N~~» 줄·다음 «## …»(예: «## 끝») 아래 줄은 남은 일이 아니다 · 제목이 없거나 줄 꼴을
+//   못 알아보면 «모름» — 0 으로 읽지 않고 큐 쪽만 건너뛴다). 약속 시각은 H5 몫이라 여기 넣지 않는다.
+// 상한: 같은 오더(미읽음 최대 id ⊕ 큐 머리)로는 1회 · 사람 입력 없이 연속 K=5 · 마지막 사람 입력 뒤 N=30s 안이면 안 깨움.
+//
+// 세 얼굴:
+//   관측 = debug.log('tui.autowake', 'decided', { seat, unread, queue, opened|rejected, reason }) · 'cap'
+//   인지 = 남은 일 > 0 ∧ 유휴(턴 끝 ∧ 입력칸 마운트) ∧ 상한 안
+//   힐링 = H2 로 다음 턴(화면 «↻ 자동 재개(autowake): 우편 N통 · 큐 M건» 한 줄) · 상한 → 멈춤 ⊕ 'cap' ⊕
+//          화면 한 줄 «사람 확인 필요» · 실패 시 사유 로그(TF 가 본다)
+
+import { readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import type { TextInputInternalTurnYieldPort } from '../../chat/index.js';
+import { debug } from '../../debug/log.js';
+import { readUnreadSummary } from '../../msg/msg-store.js';
+import { lastHumanKeyAt as tuiLastHumanKeyAt } from '../../tui.js';
+import { detectSeatTui, type SeatDetection } from '../seat-boot-preamble.js';
+import type { StartTurnIfIdleOptions, StartTurnIfIdleResult } from './internal-turn.js';
+
+export const SEAT_AUTOWAKE_FILE = 'autowake';
+export const DEFAULT_AUTOWAKE_CONSECUTIVE_CAP = 5;
+export const DEFAULT_AUTOWAKE_HUMAN_QUIET_MS = 30_000;
+
+// ── 큐 파서 ──────────────────────────────────────────────────────────────────────────
+
+export type SeatQueueParse =
+  | { known: true; count: number; head: string | null }
+  | { known: false; reason: 'absent' | 'no-waiting-heading' | 'unrecognized-items' | 'unreadable' };
+
+const WAITING_HEADING = /^##\s+대기(?:\s|$)/;
+const ANY_H2 = /^##\s+\S/;
+/** 목록 줄(«-»·«*» 둘 다 잡되, 남은 일로 세는 것은 «- #N …» 뿐 — 나머지 꼴은 «모름»). */
+const LIST_ITEM = /^\s*([-*])\s+(.*)$/;
+/** «#N» 다음은 공백·줄끝·(유니코드) 글자·숫자 아닌 것 — «#12abc»·«#12한글» 은 «#12» 가 아니다. */
+const ITEM_ID = /^#(\d+)(?![\p{L}\p{N}_])/u;
+const STRUCK_ITEM = /^~~/;
+const NESTED_TASK = /^\s+(?:[-*+]|\d+[.)])\s+(?:~~)?#\d/;
+
+/** queue.md 에서 «## 대기» 아래 남은 항목(«- #N …»)을 센다. 형식을 모르면 known:false(0 이 아니다). */
+export function parseSeatQueue(text: string | null): SeatQueueParse {
+  if (text === null) return { known: false, reason: 'absent' };
+  const lines = text.split(/\r?\n/);
+  const start = lines.findIndex(line => WAITING_HEADING.test(line.trim()));
+  if (start < 0) return { known: false, reason: 'no-waiting-heading' };
+  let count = 0;
+  let head: string | null = null;
+  let unrecognized = 0;
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i]!;
+    if (ANY_H2.test(line.trim())) break; // 다음 절(«## 끝» 등) — 그 아래는 남은 일이 아니다.
+    if (!line.trim()) continue;
+    // 들여 쓴 줄 = 앞 항목의 이어쓰기 설명 — 단, 들여 쓴 «작업처럼 보이는» 줄(목록 기호 ⊕ #N)은 꼴 모름.
+    if (/^\s/.test(line)) {
+      if (NESTED_TASK.test(line)) unrecognized++;
+      continue;
+    }
+    const item = LIST_ITEM.exec(line);
+    // 들여 쓰지 않은 줄은 «- #N …» · «- ~~#N~~ …» 둘뿐이다 — 번호 목록·맨 #N·글줄은 꼴 모름.
+    if (!item) { unrecognized++; continue; }
+    const body = item[2]!.trim();
+    if (STRUCK_ITEM.test(body)) continue; // ~~#N~~ = 완료/폐기
+    const id = item[1] === '-' ? ITEM_ID.exec(body) : null;
+    if (!id) { unrecognized++; continue; }
+    count++;
+    head ??= `#${id[1]}`;
+  }
+  // «- #N» 꼴이 아닌 목록 줄이 하나라도 있으면 꼴을 모른다 — 세지 않고 «모름»(0 으로도, 일부 수로도 확정하지 않는다).
+  if (unrecognized > 0) return { known: false, reason: 'unrecognized-items' };
+  return { known: true, count, head };
+}
+
+// ── 순수 판정 ────────────────────────────────────────────────────────────────────────
+
+export type SeatAutowakeSkipReason =
+  | 'no-seat'
+  | 'disabled'
+  | 'not-turn-end'
+  | 'nothing-pending'
+  | 'human-recent'
+  | 'same-order'
+  | 'cap';
+
+export interface SeatAutowakeInput {
+  /** 자리 TUI 의 자리(대문자) — 자리 아님이면 null. */
+  seat: string | null;
+  /** autowake 파일이 있나. */
+  enabled: boolean;
+  /** 직전 확인 뒤 턴이 끝났나(턴 끝에서만 깨운다 — 부팅·화면 전환 재진입은 아니다). */
+  turnEnded: boolean;
+  /** 안 읽은 우편 수 ⊕ 최신 id. null = 원장 없음/못 읽음(«모름»). */
+  unread: { count: number; maxId: number | null } | null;
+  queue: SeatQueueParse;
+  now: number;
+  /** 마지막 사람 키 시각(ms · 0 = 없음). */
+  lastHumanKeyAt: number;
+  humanQuietMs?: number;
+  /** 마지막으로 «연» 자동 턴의 오더 지문. */
+  lastFingerprint: string | null;
+  /** 사람 입력 없이 연속으로 연 자동 턴 수. */
+  consecutive: number;
+  consecutiveCap?: number;
+}
+
+export type SeatAutowakeDecision =
+  | { action: 'start-turn'; fingerprint: string; unread: number | null; queue: number | null; prompt: string; reason: string }
+  | { action: 'skip'; reason: SeatAutowakeSkipReason; unread: number | null; queue: number | null; fingerprint?: string };
+
+/** 오더 지문 — 같은 미읽음 최대 id ⊕ 같은 큐 머리면 «같은 오더»다. */
+export function seatAutowakeFingerprint(unreadMaxId: number | null, queueHead: string | null): string {
+  return `msg:${unreadMaxId ?? '-'}|queue:${queueHead ?? '-'}`;
+}
+
+/** «우편 N통 · 큐 M건» — 모르는 쪽은 «모름»으로 남긴다(0 으로 단정하지 않는다). */
+export function formatSeatAutowakeReason(unread: number | null, queue: number | null): string {
+  return `${unread === null ? '우편 모름' : `우편 ${unread}통`} · ${queue === null ? '큐 모름' : `큐 ${queue}건`}`;
+}
+
+export function formatSeatAutowakePrompt(seat: string, unread: number | null, queue: number | null): string {
+  return `[자동 재개] 남은 일: ${formatSeatAutowakeReason(unread, queue)} — 이어서 처리 `
+    + `(eln msg list --to ${seat} · ~/elanous-hq/seat-state/${seat}/queue.md «## 대기» 맨 위부터)`;
+}
+
+export function decideSeatAutowake(input: SeatAutowakeInput): SeatAutowakeDecision {
+  const unread = input.unread ? input.unread.count : null;
+  const queue = input.queue.known ? input.queue.count : null;
+  const skip = (reason: SeatAutowakeSkipReason, fingerprint?: string): SeatAutowakeDecision =>
+    ({ action: 'skip', reason, unread, queue, ...(fingerprint ? { fingerprint } : {}) });
+  if (!input.seat) return skip('no-seat');
+  if (!input.enabled) return skip('disabled');
+  if (!input.turnEnded) return skip('not-turn-end');
+  const pendingUnread = unread ?? 0;
+  const pendingQueue = queue ?? 0;
+  if (pendingUnread <= 0 && pendingQueue <= 0) return skip('nothing-pending');
+  const fingerprint = seatAutowakeFingerprint(
+    pendingUnread > 0 ? input.unread!.maxId : null,
+    pendingQueue > 0 && input.queue.known ? input.queue.head : null,
+  );
+  const quiet = input.humanQuietMs ?? DEFAULT_AUTOWAKE_HUMAN_QUIET_MS;
+  if (input.lastHumanKeyAt > 0 && input.now - input.lastHumanKeyAt < quiet) return skip('human-recent', fingerprint);
+  if (input.consecutive >= (input.consecutiveCap ?? DEFAULT_AUTOWAKE_CONSECUTIVE_CAP)) return skip('cap', fingerprint);
+  if (input.lastFingerprint === fingerprint) return skip('same-order', fingerprint);
+  return {
+    action: 'start-turn',
+    fingerprint,
+    unread,
+    queue,
+    prompt: formatSeatAutowakePrompt(input.seat, unread, queue),
+    reason: formatSeatAutowakeReason(unread, queue),
+  };
+}
+
+// ── 배선 컨트롤러 ────────────────────────────────────────────────────────────────────
+
+export interface SeatAutowakeDeps {
+  /** H2 문 — 대시보드의 `internalTurnGate.startTurnIfIdle`. */
+  startTurnIfIdle: (input: string, opts: StartTurnIfIdleOptions) => StartTurnIfIdleResult;
+  getCwd: () => string;
+  home?: string;
+  detectSeat?: (cwd: string) => SeatDetection | null;
+  isRegularFile?: (path: string) => boolean;
+  readText?: (path: string) => string | null;
+  readUnread?: (seat: string) => { count: number; maxId: number | null } | null;
+  lastHumanKeyAt?: () => number;
+  now?: () => number;
+  humanQuietMs?: number;
+  consecutiveCap?: number;
+  /** 상한 도달 때 화면 한 줄(«사람 확인 필요»). */
+  notify?: (line: string) => void;
+  /** 입력칸이 마운트된 뒤 판정을 미루는 자리(기본 setTimeout 0 · unref). 시험은 즉시 실행을 넘긴다. */
+  defer?: (fn: () => void, ms: number) => void;
+  log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+export interface SeatAutowakeController {
+  /** 모델 턴이 끝났다(스트리밍 정리 지점) — 다음 입력칸 마운트에서 한 번 잰다. */
+  noteTurnEnded(): void;
+  /** 입력칸이 마운트됐다 — 턴 끝이 무장돼 있으면 판정하고, 남은 일이 있으면 H2 로 연다. */
+  check(): SeatAutowakeDecision & { opened?: boolean; rejected?: string };
+  /** H2 의 yield port 를 감싸 «마운트 = 판정 시점»으로 잇는다(입력칸 무접촉). */
+  wrapPort(port: TextInputInternalTurnYieldPort): TextInputInternalTurnYieldPort;
+}
+
+function defaultIsRegularFile(path: string): boolean {
+  try { return statSync(path).isFile(); } catch { return false; }
+}
+
+function defaultReadText(path: string): string | null {
+  try { return readFileSync(path, 'utf8'); } catch { return null; }
+}
+
+function defaultDefer(fn: () => void, ms: number): void {
+  const t = setTimeout(fn, ms);
+  (t as { unref?: () => void }).unref?.();
+}
+
+export function createSeatAutowake(deps: SeatAutowakeDeps): SeatAutowakeController {
+  const home = deps.home ?? homedir();
+  const detect = deps.detectSeat ?? ((cwd: string) => {
+    try { return detectSeatTui(cwd, { home }); } catch { return null; }
+  });
+  const isFile = deps.isRegularFile ?? defaultIsRegularFile;
+  const readText = deps.readText ?? defaultReadText;
+  const readUnread = deps.readUnread ?? ((seat: string) => {
+    try { return readUnreadSummary(seat); } catch { return null; }
+  });
+  const humanKeyAt = deps.lastHumanKeyAt ?? tuiLastHumanKeyAt;
+  const now = deps.now ?? Date.now;
+  const log = deps.log ?? ((c, e, d) => debug.log(c, e, d));
+  const defer = deps.defer ?? defaultDefer;
+  const quietMs = deps.humanQuietMs ?? DEFAULT_AUTOWAKE_HUMAN_QUIET_MS;
+
+  let turnEnded = false;
+  let lastFingerprint: string | null = null;
+  let consecutive = 0;
+  let lastOpenedAt = 0;
+  let capNotified = false;
+  let recheckArmed = false;
+
+  const check: SeatAutowakeController['check'] = () => {
+    const detection = detect(deps.getCwd());
+    const seat = detection?.seat ?? null;
+    const seatStateDir = seat ? join(home, 'elanous-hq', 'seat-state', seat) : null;
+    const enabled = seat !== null && (
+      isFile(join(seatStateDir!, SEAT_AUTOWAKE_FILE))
+      || isFile(join(home, 'elanous-hq', 'seats', seat, SEAT_AUTOWAKE_FILE))
+    );
+    // 자리가 아니거나 꺼져 있으면 아무것도 안 읽는다(사람 대화 TUI 비용 0 · 로그 0).
+    if (!seat || !enabled) {
+      turnEnded = false;
+      return decideSeatAutowake({
+        seat, enabled, turnEnded: false, unread: null, queue: { known: false, reason: 'absent' },
+        now: 0, lastHumanKeyAt: 0, lastFingerprint, consecutive,
+      });
+    }
+    const humanAt = humanKeyAt();
+    // 사람 키 하나가 연속 카운터를 0 으로 — 그 뒤엔 다시 열 수 있다.
+    if (humanAt > lastOpenedAt && consecutive > 0) { consecutive = 0; capNotified = false; }
+    const unread = readUnread(seat);
+    const queue = parseSeatQueue(readText(join(seatStateDir!, 'queue.md')));
+    const t = now();
+    const decision = decideSeatAutowake({
+      seat, enabled, turnEnded, unread, queue, now: t, lastHumanKeyAt: humanAt,
+      humanQuietMs: quietMs, lastFingerprint, consecutive, consecutiveCap: deps.consecutiveCap,
+    });
+    if (decision.action === 'skip' && decision.reason === 'not-turn-end') return decision;
+    const base = {
+      seat,
+      unread: decision.unread,
+      queue: decision.queue,
+      ...(queue.known ? {} : { queueUnknown: queue.reason }),
+      fingerprint: decision.fingerprint ?? null,
+      consecutive,
+    };
+    if (decision.action === 'skip') {
+      if (decision.reason === 'human-recent') {
+        // 조용창이 지나면 한 번 더 잰다(턴 끝 무장은 남긴다) — 그 사이 사람이 치면 그때 또 미뤄진다.
+        if (!recheckArmed) {
+          recheckArmed = true;
+          defer(() => { recheckArmed = false; check(); }, Math.max(0, quietMs - (t - humanAt)) + 50);
+        }
+        log('tui.autowake', 'decided', { ...base, rejected: true, reason: 'human-recent' });
+        return decision;
+      }
+      turnEnded = false;
+      if (decision.reason === 'cap') {
+        if (!capNotified) {
+          capNotified = true;
+          log('tui.autowake', 'cap', { ...base, cap: deps.consecutiveCap ?? DEFAULT_AUTOWAKE_CONSECUTIVE_CAP });
+          deps.notify?.(`⏸ 자동 재개 상한(${deps.consecutiveCap ?? DEFAULT_AUTOWAKE_CONSECUTIVE_CAP}회 연속) — 사람 확인 필요 · 키 하나면 다시 이어간다`);
+        }
+      }
+      log('tui.autowake', 'decided', { ...base, rejected: true, reason: decision.reason });
+      return decision;
+    }
+    const result = deps.startTurnIfIdle(decision.prompt, { origin: 'autowake', reason: decision.reason });
+    if (result.opened) {
+      turnEnded = false;
+      lastFingerprint = decision.fingerprint;
+      consecutive += 1;
+      lastOpenedAt = t;
+      log('tui.autowake', 'decided', { ...base, consecutive, opened: true, reason: decision.reason, turnId: result.turnId });
+      return { ...decision, opened: true };
+    }
+    // H2 거부 — 사유를 그대로 남긴다. 무장은 풀지 않는다(다음 마운트에서 다시 잰다).
+    log('tui.autowake', 'decided', { ...base, rejected: true, reason: result.reason, ...(result.detail ? { detail: result.detail } : {}) });
+    return { ...decision, opened: false, rejected: result.reason };
+  };
+
+  return {
+    noteTurnEnded() { turnEnded = true; },
+    check,
+    wrapPort(port) {
+      return {
+        attach(requestYield) {
+          port.attach(requestYield);
+          // 입력 루프가 첫 그림을 그린 뒤 잰다 — 마운트 «중»에 물러남을 청하지 않는다.
+          if (turnEnded) defer(() => { try { check(); } catch { /* fail-soft: 깨움은 입력을 막지 않는다 */ } }, 0);
+        },
+        detach(opts) { port.detach(opts); },
+        declined(detail) { port.declined?.(detail); },
+      };
+    },
+  };
+}

package/src/dashboard/input/turn-steer-bridge.ts

@@ -0,0 +1,164 @@
+// ── TUI typeahead 큐 ↔ 턴 «안» 주입 레지스트리 다리 (10-14 중복 수리) ────────────
+//
+// 🚨 무엇을 푸는가: 턴 중 Enter 한 발화는 ⓐ TUI 큐(턴 종료 뒤 새 프롬프트)와 ⓑ 레지스트리
+//   (다음 도구 경계에서 도는 턴 안으로) «두 곳»에 든다. 한쪽이 가져가면 다른 쪽에서도 지워야 하는데
+//   레지스트리 쪽 비우기 운영 호출이 0이라 같은 발화가 두 번 들어갔다:
+//     ① 마지막 바퀴에 도구 호출이 없어 배수 기회가 없으면 → 턴 종료 승격 ⊕ 다음 턴 둘째 바퀴 배수
+//     ② Ctrl+↑ 되꺼내기 → 고치기 전 문면이 레지스트리에 남아 모델로
+//     ③ Esc 중단 복원 → composer 로 돌아간 글이 다음 턴에 또
+//   그리고 배수 통지가 «앞에서부터 N개» 떨어내 같은 버킷의 남의 항목(goal-loop 메모)만큼 엉뚱한 대기 발화를 지웠다.
+// ⭐ 짝은 «레지스트리 id» 하나로 맞춘다 — 위치·문자열로 맞추지 않는다.
+// ⛔ 이 모듈은 상태 전이와 레지스트리 호출만 한다. 화면·로그는 호출측(대시보드)이 받는다.
+
+import {
+  attachTurnTypeaheadPendingId,
+  drainedIntoTurn,
+  drainTurnTypeaheadOnce,
+  isTurnTypeaheadSteerable,
+  markTurnTypeaheadPriority,
+  turnTypeaheadPendingIds,
+  type TurnTypeaheadState,
+} from '../../chat/turn-typeahead.js';
+import { canInterruptRunningTools } from '../../chat/tool-interrupt-behavior.js';
+import { debug } from '../../debug/log.js';
+import {
+  enqueuePendingUserInput,
+  prioritizePendingUserInput,
+  removePendingUserInput,
+  type PendingUserInputRemovalReason,
+} from '../../session/pending-input.js';
+
+export interface TurnTypeaheadRef {
+  state: TurnTypeaheadState;
+}
+
+export interface SteerDrainedEvent {
+  /** 이 TUI 큐에서 실제로 떨어낸(=턴 안으로 들어간) 발화 — 남의 항목은 빠진다. */
+  texts: string[];
+  remaining: number;
+}
+
+/**
+ * 큐 «마지막» 항목(방금 Enter 한 것)을 레지스트리에도 넣고 id 를 짝짓는다.
+ * 슬래시·빈 글·세션 없음이면 넣지 않는다(턴 종료 FIFO 로만 간다). 넣었으면 id 를 낸다.
+ */
+export function steerLastTurnTypeaheadSubmission(
+  ref: TurnTypeaheadRef,
+  sessionId: string | null | undefined,
+  onDrained: (event: SteerDrainedEvent) => void,
+): string | null {
+  const index = ref.state.queuedSubmissions.length - 1;
+  const text = ref.state.queuedSubmissions[index];
+  if (!sessionId || text === undefined || !isTurnTypeaheadSteerable(text)) return null;
+  const id = enqueuePendingUserInput(sessionId, text, (drained, items) => {
+    const result = drainedIntoTurn(ref.state, drained, items);
+    ref.state = result.state;
+    onDrained({ texts: result.matched, remaining: result.state.queuedSubmissions.length });
+  });
+  if (id) {
+    ref.state = attachTurnTypeaheadPendingId(ref.state, index, id);
+    debug.log('dashboard.turn-typeahead', 'queued', { id, length: text.length });
+  }
+  return id;
+}
+
+/**
+ * 큐를 «다른 길»로 떠난 항목(턴 종료 승격·되꺼내기·중단 복원)을 레지스트리에서도 떨어낸다.
+ * ⭐ 턴 종료 승격(`submitted-as-prompt`)은 «주입 한 번»이다 — 경계 배수(`llm.interjection drained {ids}`)와
+ *   합쳐 id 별 주입 횟수를 센다(RFC v2 P1 ⓒ). 그래서 그 id 를 따로 남긴다.
+ */
+export function releaseTurnTypeaheadPending(
+  ids: readonly string[] | undefined,
+  reason: PendingUserInputRemovalReason = 'unspecified',
+): number {
+  if (!ids || ids.length === 0) return 0;
+  if (reason === 'submitted-as-prompt') {
+    for (const id of ids) debug.log('dashboard.turn-typeahead', 'submitted-as-prompt', { id });
+  }
+  return removePendingUserInput(ids, reason);
+}
+
+/**
+ * 턴 종료 핸드오프 한 걸음 — 큐 드레인 → 레지스트리 해제 → (승격이면) Enter 주입.
+ * ⭐ 대시보드 inner-loop 가 «이 함수»를 부른다 — 시험이 같은 순서를 베끼지 않고 실제 경로를 문다.
+ *   ⛔ 해제는 Enter «전»이다: Enter 가 composer 를 거쳐 새 프롬프트로 나가는 순간 레지스트리에 남아 있으면
+ *   그 턴 둘째 바퀴 배수에 같은 발화가 «또» 들어간다.
+ */
+export function handoffTurnTypeaheadAtTurnEnd(
+  ref: TurnTypeaheadRef,
+  carriedInitial: string | null | undefined,
+  opts: { interrupted: boolean },
+  injectEnter: () => void,
+): ReturnType<typeof drainTurnTypeaheadOnce> {
+  const drained = drainTurnTypeaheadOnce(ref.state, carriedInitial, opts);
+  ref.state = drained.state;
+  releaseTurnTypeaheadPending(drained.releasedPendingIds, drained.injectEnter ? 'submitted-as-prompt' : 'restored-after-interrupt');
+  if (drained.injectEnter) injectEnter();
+  return drained;
+}
+
+export type PushNowDecision =
+  /** 대기 항목이 없다. */
+  | { kind: 'nothing' }
+  /** 도는 도구가 전부 끊어도 된다 — 턴만 끊고(자식은 산다) 턴 종료 FIFO 가 곧바로 그 발화로 잇는다. */
+  | { kind: 'interrupt'; runningTools: string[] }
+  /** 끊을 수 없는 도구가 돈다 — 다음 도구 경계에 최우선으로 넣는다. */
+  | { kind: 'priority'; blockingTools: string[] }
+  /** 끊을 수 없는 도구가 돌고, 대기 항목이 전부 경계에 못 들어간다(슬래시·세션 없음) — 응답 뒤에 나간다. */
+  | { kind: 'deferred'; blockingTools: string[] };
+
+/** «지금 밀어 넣기» 판정. 순수. */
+export function decidePushNow(
+  state: TurnTypeaheadState,
+  runningToolNames: readonly string[],
+): PushNowDecision {
+  if (state.queuedSubmissions.length === 0) return { kind: 'nothing' };
+  const { ok, blocking } = canInterruptRunningTools(runningToolNames);
+  if (ok) return { kind: 'interrupt', runningTools: [...new Set(runningToolNames)].sort() };
+  const steerable = turnTypeaheadPendingIds(state).some(id => typeof id === 'string');
+  return steerable ? { kind: 'priority', blockingTools: blocking } : { kind: 'deferred', blockingTools: blocking };
+}
+
+/** 큐의 레지스트리 항목을 버킷 맨 앞으로 옮기고 상태에 «최우선»을 적는다. 옮긴 수를 낸다. */
+export function prioritizeTurnTypeaheadPending(ref: TurnTypeaheadRef): number {
+  const ids = turnTypeaheadPendingIds(ref.state).filter((id): id is string => typeof id === 'string');
+  const moved = prioritizePendingUserInput(ids);
+  ref.state = markTurnTypeaheadPriority(ref.state);
+  return moved;
+}
+
+export interface PushNowDeps {
+  /** 지금 도는 도구 이름(중복 허용). */
+  runningToolNames: () => readonly string[];
+  /** 턴만 끊는다(자식은 산다) — 호출측이 «밀어 넣기 사유»를 적어 턴 종료가 복원 대신 제출하게 한다. */
+  interruptTurn: () => void;
+  pushNotice: (line: string) => void;
+}
+
+/** «지금 밀어 넣기» 한 번 — 판정하고 끊거나 최우선으로 올린다. 판정을 낸다. */
+export function runTurnTypeaheadPushNow(ref: TurnTypeaheadRef, deps: PushNowDeps): PushNowDecision {
+  const decision = decidePushNow(ref.state, deps.runningToolNames());
+  if (decision.kind === 'interrupt') {
+    deps.pushNotice('  ⚡ 지금 밀어 넣기 — 도는 응답을 끊고 바로 이어서 보냅니다.');
+    deps.interruptTurn();
+  } else if (decision.kind === 'priority') {
+    prioritizeTurnTypeaheadPending(ref);
+    deps.pushNotice(`  ⚡ 최우선 — ${decision.blockingTools.join(', ')} 은(는) 끊을 수 없어 끝나는 다음 도구 경계에 먼저 넣습니다.`);
+  } else if (decision.kind === 'deferred') {
+    deps.pushNotice(`  ⏳ 지금 넣을 수 있는 항목이 없습니다(슬래시 등) — ${decision.blockingTools.join(', ')} 은(는) 끊을 수 없어 응답 뒤에 보냅니다.`);
+  }
+  return decision;
+}
+
+/**
+ * 턴 종료 핸드오프가 이 턴을 «중단»(큐를 composer 로 복원)으로 읽을지. «지금 밀어 넣기»로 끊은 턴은
+ * 중단이 아니다 — 복원하지 않고 큐 머리를 곧바로 제출한다. 표지는 한 번 읽으면 지운다.
+ */
+export function consumeTurnEndInterrupted(
+  lastTurnFinalStatus: 'completed' | 'interrupted' | 'failed' | undefined,
+  steerInterruptRef: { pending: boolean },
+): boolean {
+  const steerInterrupted = steerInterruptRef.pending;
+  steerInterruptRef.pending = false;
+  return lastTurnFinalStatus === 'interrupted' && !steerInterrupted;
+}

package/src/dashboard/log-click-runtime.ts

@@ -39,7 +39,8 @@ export interface DashboardLogClickRuntimeDeps {
   pillRowGetter?: () => number | null;
   onPillClick?: () => void;
   /** When present, a click on a fold range toggles it (collapse only on
-   *  the expanded first line; otherwise `toggleAtLine` decides). Hosts
+   *  the expanded first/last line or the row that expanded it; otherwise
+   *  `toggleAtLine` decides). Hosts
    *  that omit it keep the legacy attachment/pill-only behavior. */
   foldStack?: FoldStack;
 }
@@ -96,11 +97,12 @@ export function createDashboardLogClickDeps(
       ? {
           tryFoldToggle: (absIdx: number): boolean => {
             const fold = deps.foldStack!;
-            // Collapse only from the first line of an expanded range.
+            // Collapse from the first/last line of an expanded range or
+            // the row whose click expanded it (#16 — same spot again folds).
             // Other lines of that range are rejected first so a body
             // click cannot fold the block under a reader. Folded
             // containment is left to toggleAtLine (false when none).
-            if (!fold.isExpandedFirstLine(absIdx)) {
+            if (!fold.isExpandedCollapseLine(absIdx)) {
               const targets = fold.snapshot();
               for (let i = targets.length - 1; i >= 0; i--) {
                 const t = targets[i]!;

package/src/dashboard/loop-scheduler.ts

@@ -0,0 +1,72 @@
+// TUI-LOOP-COMMAND — `/loop <간격> <프롬프트>` 의 idle-gated 루프 스케줄러.
+//
+// 칸 문면의 판정선(src/dashboard/loop-scheduler.test.ts 로 증명):
+//   idle 발사 1 — 간격 틱마다 대시보드가 «쉬는 동안»에만 프롬프트를 발사하고,
+//                 한 틱에 정확히 한 번만 발사한다.
+//   busy 미룸   — 틱이 바쁜 동안 오면 발사를 «버리지 않고» 한 개로 미뤄둔다
+//                 (적체가 쌓이지 않는다 · 쉼이 돌아온 틱에 정확히 한 번 발사).
+//   stop 0      — stop() 이후에는 어떤 틱도 발사하지 않는다.
+//
+// 호스트 의존이 없다 — isIdle · fire · schedule 만 주입받는다. 실제 타이머는
+// 기본 setInterval/clearInterval 이고, 테스트는 tick() 시임으로 결정적으로
+// 진행한다(가짜 타이머 불요).
+
+export interface LoopSchedulerOptions {
+  /** Interval between ticks. The /loop parser clamps this to ≥ 1s. */
+  intervalMs: number;
+  /** True when the dashboard is resting — the only state allowed to fire. */
+  isIdle: () => boolean;
+  /** The prompt launch action — called at most once per tick. */
+  fire: () => void;
+  /** Injectable tick scheduler; the default is setInterval/clearInterval. */
+  schedule?: (callback: () => void, intervalMs: number) => { unsubscribe(): void };
+}
+
+export interface LoopScheduler {
+  start(): void;
+  stop(): void;
+  isRunning(): boolean;
+  /** Fires deferred (not dropped) while busy — 0 or 1. */
+  pendingFireCount(): number;
+  /** One interval tick. The production timer and tests both call this. */
+  tick(): void;
+}
+
+export function createLoopScheduler(options: LoopSchedulerOptions): LoopScheduler {
+  const { isIdle, fire } = options;
+  const schedule = options.schedule ?? ((callback: () => void, intervalMs: number) => {
+    const timer = setInterval(callback, intervalMs);
+    return { unsubscribe: () => clearInterval(timer) };
+  });
+  let running = false;
+  let pending = false;
+  let handle: { unsubscribe(): void } | null = null;
+
+  const scheduler: LoopScheduler = {
+    start(): void {
+      if (running) return;
+      running = true;
+      pending = false;
+      handle = schedule(() => scheduler.tick(), options.intervalMs);
+    },
+    stop(): void {
+      if (!running) return;
+      running = false;
+      pending = false;
+      handle?.unsubscribe();
+      handle = null;
+    },
+    isRunning: () => running,
+    pendingFireCount: () => (running && pending ? 1 : 0),
+    tick(): void {
+      if (!running) return;
+      if (isIdle()) {
+        pending = false;
+        fire();
+      } else {
+        pending = true;
+      }
+    },
+  };
+  return scheduler;
+}

package/src/dashboard/running-build-status.ts

@@ -0,0 +1,74 @@
+// ── 상태줄 «실행 판» 값 — 이 TUI 프로세스가 실은 코드의 판 ⊕ 재기동 필요 여부 ──
+//
+// ⛔ 하단 `⌥ HEAD@<sha>` 는 세션 cwd 트리의 HEAD 다(실은 코드 아님). 이 값은 기동 판(`runningBuild`)을
+//    설치본 `current`(설치본으로 떴을 때) 또는 코드 뿌리 HEAD(체크아웃으로 떴을 때)와 비교한다.
+// 매 draw 마다 불리므로 비교 대상 판독은 `ttlMs` 로 묶는다(설치 갱신 감지는 분 단위면 충분하다).
+
+import type { RunningBuildState } from '../status/bar.js';
+import {
+  judgeBuildStaleness, readCheckoutHead, readCurrentInstallRecord, runningBuild,
+  type InstalledRecord,
+} from '../pty-shell/tui-run-state.js';
+import type { PtyBuildIdentity } from '../pty-shell/pty-manifest.js';
+import { debug } from '../debug/log.js';
+import { matchFailureEvent, recordFailureSignatureMatch } from '../self-health/signatures.js';
+
+export interface RunningBuildStatusDeps {
+  readonly build?: () => PtyBuildIdentity;
+  readonly readInstalled?: () => InstalledRecord;
+  readonly readCheckoutHead?: (codeRoot: string) => string | undefined;
+  readonly now?: () => number;
+  readonly ttlMs?: number;
+  readonly log?: (category: string, event: string, data: Record<string, unknown>) => void;
+}
+
+export function createRunningBuildStatus(deps: RunningBuildStatusDeps = {}): () => RunningBuildState {
+  const now = deps.now ?? Date.now;
+  const ttlMs = deps.ttlMs ?? 60_000;
+  let cached: RunningBuildState = { sha: '', stale: null };
+  let readAt = -Infinity;
+  let reportedStaleSha: string | undefined;
+  const log = deps.log ?? ((c: string, e: string, d: Record<string, unknown>) => debug.log(c, e, d));
+  // 옛 판(결함 #13)은 «넘어가는 순간» 한 번만 남긴다 — 매 판독(분 단위)마다 쌓지 않는다.
+  const reportStale = (state: RunningBuildState): void => {
+    if (state.stale !== true) {
+      // 해소되면 잊는다 — 같은 실행 판이 다시 옛 판이 되는 «두 번째 전환»도 센다.
+      if (state.stale === false) reportedStaleSha = undefined;
+      return;
+    }
+    if (reportedStaleSha === state.sha) return;
+    reportedStaleSha = state.sha;
+    try {
+      const data = { sha: state.sha, currentSha: state.currentSha ?? null };
+      log('tui.run-state', 'stale', data);
+      const signature = matchFailureEvent({ category: 'tui.run-state', event: 'stale', data });
+      if (signature) recordFailureSignatureMatch(signature, 'status-bar', log);
+    } catch { /* fail-soft — 관측이 상태줄을 막지 않는다 */ }
+  };
+  return () => {
+    const t = now();
+    if (t - readAt < ttlMs) return cached;
+    readAt = t;
+    // 판을 모르면 칸을 숨기지 않고 «▶ 실행 ?» 로 — 모른다는 것도 보여야 트리 HEAD 와 헷갈리지 않는다.
+    let build: PtyBuildIdentity;
+    try { build = (deps.build ?? runningBuild)(); } catch { cached = { sha: '', stale: null }; return cached; }
+    if (!build.sha) { cached = { sha: '', stale: null }; return cached; }
+    // 비교 대상 판독이 터져도 기동 판은 보인다 — «비교 불가(?)»로.
+    try {
+      const installed = build.source === 'installed' ? (deps.readInstalled ?? readCurrentInstallRecord)() : {};
+      const checkoutHead = build.source === 'checkout' && build.codeRoot
+        ? (deps.readCheckoutHead ?? readCheckoutHead)(build.codeRoot)
+        : undefined;
+      const verdict = judgeBuildStaleness({ build, installed, ...(checkoutHead ? { checkoutHead } : {}) });
+      cached = {
+        sha: build.sha,
+        stale: verdict.stale,
+        ...(verdict.stale === true ? { currentSha: build.source === 'installed' ? installed.sha : checkoutHead } : {}),
+      };
+      reportStale(cached);
+    } catch {
+      cached = { sha: build.sha, stale: null };
+    }
+    return cached;
+  };
+}