elanous 0.2.29 → 0.2.32

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

@@ -15,11 +15,15 @@ import {
   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';
@@ -92,3 +96,69 @@ export function handoffTurnTypeaheadAtTurnEnd(
   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

@@ -1,6 +1,6 @@
 import type { Attachment, ContextRegistry } from '../context.js';
 import { debug } from '../debug/log.js';
-import type { FoldStack } from '../fold-stack.js';
+import type { FoldStack, FoldTarget } from '../fold-stack.js';
 import type { AttachmentRowMap } from '../log-pane/attachment-row-map.js';
 import type { LogClickDispatchDeps } from '../log-pane/click-dispatch.js';
 import type { AttachmentPopupAction } from '../log-pane/attachment-popup.js';
@@ -43,6 +43,113 @@ export interface DashboardLogClickRuntimeDeps {
    *  `toggleAtLine` decides). Hosts
    *  that omit it keep the legacy attachment/pill-only behavior. */
   foldStack?: FoldStack;
+  /** Keeps the viewport where the click happened while a click toggles a
+   *  fold (#81). Hosts that omit it keep FoldStack's own scroll policy. */
+  foldClickAnchor?: FoldClickScrollAnchor;
+}
+
+/** Scroll state the fold-click anchor reads and writes. Offsets are the
+ *  log pane's visual-row offsets (`-1` = pinned to the tail). */
+export interface FoldClickScrollState {
+  getScrollOffset: () => number;
+  setScrollOffset: (offset: number) => void;
+  /** Max visual-row offset for the current chatLines (after a splice). */
+  maxScroll: () => number;
+  getFrozenTail: () => number | null;
+  setFrozenTail: (index: number | null) => void;
+  /** chatLines length — tells new output from the fold's own splice. */
+  lineCount: () => number;
+}
+
+export interface FoldClickScrollAnchor {
+  /** Current top visual row and raw offset — the click's frame. */
+  viewport(): { top: number; scrollOffset: number };
+  /** Run a click toggle with the viewport top held in place. */
+  run<T>(toggle: () => T): T;
+  /** FoldStack `onAfterToggle` hook: inside `run` it keeps the top row;
+   *  outside (the `f` key, bulk toggles) it falls back to `otherwise`. */
+  onAfterToggle(target: FoldTarget, delta: number): void;
+  /** Call before each paint: a pane that was following the tail when the
+   *  click expanded a block goes back to the tail as soon as new output
+   *  arrives (the click must not leave the pane stuck off the tail). */
+  reconcile(): void;
+}
+
+/** #81 — the old `onAfterToggle` pinned every toggle to the tail, so a
+ *  click that expanded a block near the bottom pushed its header up the
+ *  screen and a second click on the same spot landed in the body (rejected
+ *  as `expanded-body`). A click toggle now keeps the top row; it only
+ *  returns to the tail when the kept top would be past the new bottom. */
+export function createFoldClickScrollAnchor(
+  state: FoldClickScrollState,
+  otherwise: (target: FoldTarget, delta: number) => void,
+): FoldClickScrollAnchor {
+  let heldTop: number | null = null;
+  // Set when a click moved a tail-following pane off the tail: the offset
+  // it set and the line count right after the splice.
+  let followTail: { offset: number; lineCount: number } | null = null;
+  const viewport = (): { top: number; scrollOffset: number } => {
+    const scrollOffset = state.getScrollOffset();
+    const max = state.maxScroll();
+    return { top: scrollOffset < 0 ? max : Math.min(scrollOffset, max), scrollOffset };
+  };
+  return {
+    viewport,
+    run<T>(toggle: () => T): T {
+      const prev = heldTop;
+      heldTop = viewport().top;
+      try {
+        return toggle();
+      } finally {
+        heldTop = prev;
+      }
+    },
+    onAfterToggle(target, delta) {
+      if (heldTop === null) {
+        otherwise(target, delta);
+        return;
+      }
+      // The splice moved every line after the block; a frozen tail past it
+      // must move with them or the pane would cut the expanded rows short.
+      const frozen = state.getFrozenTail();
+      if (frozen !== null && target.kind === 'static' && target.lineStart < frozen) {
+        state.setFrozenTail(frozen + delta);
+      }
+      const offsetBefore = state.getScrollOffset();
+      const wasFollowing = offsetBefore < 0 || followTail?.offset === offsetBefore;
+      const max = state.maxScroll();
+      const next = heldTop >= max ? -1 : heldTop;
+      state.setScrollOffset(next);
+      if (next < 0) state.setFrozenTail(null);
+      // No freeze here: the pane still follows the tail (see reconcile).
+      followTail = next >= 0 && wasFollowing ? { offset: next, lineCount: state.lineCount() } : null;
+      debug.log('log.fold', 'fold-click-anchor', {
+        lineStart: target.kind === 'static' ? target.lineStart : null,
+        delta,
+        topBefore: heldTop,
+        scrollOffsetAfter: next,
+        maxScrollAfter: max,
+        followTail: followTail !== null,
+      });
+    },
+    reconcile() {
+      if (followTail === null) return;
+      // Someone else moved the pane (scroll keys, search, tail pin) — theirs.
+      if (state.getScrollOffset() !== followTail.offset) {
+        followTail = null;
+        return;
+      }
+      if (state.lineCount() <= followTail.lineCount) return;
+      debug.log('log.fold', 'fold-click-follow-tail', {
+        offset: followTail.offset,
+        lineCountBefore: followTail.lineCount,
+        lineCountNow: state.lineCount(),
+      });
+      followTail = null;
+      state.setScrollOffset(-1);
+      state.setFrozenTail(null);
+    },
+  };
 }
 
 export function createDashboardLogClickDeps(
@@ -97,6 +204,13 @@ export function createDashboardLogClickDeps(
       ? {
           tryFoldToggle: (absIdx: number): boolean => {
             const fold = deps.foldStack!;
+            const anchor = deps.foldClickAnchor;
+            // Screen frame of the click — lets the log tell «same spot again»
+            // from «a different row» (#81 had no way to).
+            const frame = anchor ? (() => {
+              const v = anchor.viewport();
+              return { screenRow: absIdx - v.top, top: v.top, scrollOffset: v.scrollOffset };
+            })() : {};
             // 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
@@ -114,6 +228,7 @@ export function createDashboardLogClickDeps(
                       reason: 'expanded-body',
                       lineStart: t.lineStart,
                       lineEnd: t.lineEnd,
+                      ...frame,
                     });
                     return false;
                   }
@@ -121,7 +236,8 @@ export function createDashboardLogClickDeps(
                 }
               }
             }
-            const toggled = fold.toggleAtLine(absIdx);
+            const toggle = (): boolean => fold.toggleAtLine(absIdx, frame);
+            const toggled = anchor ? anchor.run(toggle) : toggle();
             if (toggled) deps.draw();
             return toggled;
           },

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/seat-boot-preamble.ts

@@ -35,6 +35,24 @@ export function detectSeat(cwd: string, env: NodeJS.ProcessEnv = process.env): S
   return null;
 }
 
+/** 자리(무인) TUI 판정 — `detectSeat` ⊕ `~/elanous-hq/seat-state/<자리>` 가 실재(부트 카드와 같은 기준).
+ *  TUI 라우팅(TUI-H1-SEAT-GOALLOOP)이 «자리면 운영 지시를 goal loop 로» 가를 때 쓴다. 자리가 아니면 null(사람 대화 TUI) · 조회 실패는 throw. */
+export function detectSeatTui(
+  cwd: string,
+  deps: { home?: string; env?: NodeJS.ProcessEnv; stat?: (path: string) => { isDirectory(): boolean } } = {},
+): SeatDetection | null {
+  const detection = detectSeat(cwd, deps.env ?? process.env);
+  if (!detection) return null;
+  try {
+    return (deps.stat ?? statSync)(join(deps.home ?? homedir(), 'elanous-hq', 'seat-state', detection.seat)).isDirectory() ? detection : null;
+  } catch (error) {
+    // «없다»(ENOENT·ENOTDIR)만 «자리 아님»이다. 권한 오류 등 조회 실패는 던진다 — 호출부(bridge)가 seatKnown:false 로 남긴다.
+    const code = (error as NodeJS.ErrnoException | null)?.code;
+    if (code === 'ENOENT' || code === 'ENOTDIR') return null;
+    throw error;
+  }
+}
+
 export interface SeatBootDeps {
   home?: string;
   msgPath?: string;

package/src/dashboard/skill-runtime.ts

@@ -1,4 +1,5 @@
 import { C } from '../tui.js';
+import { logTurnThrew } from './turn-busy-teardown.js';
 import { startThinking } from '../thinking-line.js';
 import type { ContextRegistry } from '../context.js';
 import { loadAllAttachments } from '../extractors.js';
@@ -261,6 +262,7 @@ export async function runDashboardSkillByName(
   } catch (err: any) {
     skillStatus = 'failed';
     skillError = err?.message || String(err);
+    logTurnThrew('skill-run', err);
     deps.pushDebugLine(C.error(`Error: ${err?.message || err}`));
   } finally {
     cleanupEsc?.();