elanous 0.2.35 → 0.2.36

package/src/onboarding/web-first.ts

@@ -7,6 +7,7 @@ import { runBgLaunch, type BgLaunchResult } from '../cli/bg-launch.js';
 import { joinRestHealthUrl, runNexusShow, type NexusShowResult } from '../cli/nexus-show.js';
 import { issueSetupLinkToken } from '../auth/setup-link-tokens.js';
 import { debug } from '../debug/log.js';
+import { detectLocale, type Locale } from '../expression/locale.js';
 import { browserUnavailableReason } from '../oauth/browser-availability.js';
 import type { UserConfig } from '../user-config.js';
 
@@ -18,6 +19,8 @@ export interface WebFirstSetupDeps {
   /** Bare first run never starts or waits for a missing daemon; explicit setup retains web launch. */
   startIfMissing?: boolean;
   startedAt?: number;
+  /** Locale for user-facing wording; defaults to the shared ambient decision (detectLocale). */
+  locale?: Locale;
   showNexus?: () => Promise<NexusShowResult>;
   startDaemon?: () => Promise<BgLaunchResult>;
   probeHealth?: (url: string, timeoutMs: number) => Promise<boolean>;
@@ -37,6 +40,34 @@ export interface WebFirstSetupDeps {
 
 const STARTUP_TIMEOUT_MS = 12_000;
 
+/** User-facing web-first fallback wording, routed by the shared locale decision (detectLocale). */
+const WEB_FIRST_TEXT = {
+  ko: {
+    unavailable: (reason: string) => `웹 셋업을 사용할 수 없습니다 (${reason}). 터미널 설정으로 전환합니다.`,
+    offline: '오프라인 모드',
+    startingDaemon: '웹 셋업을 위해 데몬을 시작합니다.',
+    continueInBrowser: '브라우저에서 셋업을 이어가세요',
+    phoneOnSameWifi: (link: string) => `같은 와이파이의 폰이면: ${link}`,
+    linkSingleUse: '이 링크는 10분 안에 한 번만 열 수 있습니다',
+    sameWifiRestart: '같은 와이파이에서 열려면 `elanous nexus run` 을 루프백 없이 다시 띄우세요',
+    scanTailnet: '같은 와이파이·tailnet 의 폰 카메라로 스캔하세요',
+    scanSameWifi: '같은 와이파이의 폰 카메라로 스캔하세요',
+    terminalInstead: '터미널에서 하려면: `elanous setup --terminal`',
+  },
+  en: {
+    unavailable: (reason: string) => `web setup is unavailable (${reason}); switching to terminal setup.`,
+    offline: 'offline mode',
+    startingDaemon: 'starting the daemon for web setup.',
+    continueInBrowser: 'continue setup in your browser',
+    phoneOnSameWifi: (link: string) => `on a phone on the same wifi: ${link}`,
+    linkSingleUse: 'this link can be opened only once within 10 minutes',
+    sameWifiRestart: 'to open it from the same wifi, restart `elanous nexus run` without a loopback-only bind',
+    scanTailnet: 'scan with a phone camera on the same wifi/tailnet',
+    scanSameWifi: 'scan with a phone camera on the same wifi',
+    terminalInstead: 'to use the terminal instead: `elanous setup --terminal`',
+  },
+} as const;
+
 async function probeHealth(url: string, timeoutMs: number): Promise<boolean> {
   try {
     const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
@@ -53,12 +84,13 @@ function setupUrl(pwa: string, token: string): string {
 export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-shown' | 'fallback'> {
   const startedAt = deps.startedAt ?? Date.now();
   const print = deps.print ?? console.log;
+  const text = WEB_FIRST_TEXT[(deps.locale ?? detectLocale()) === 'en' ? 'en' : 'ko'];
   const observe = (event: 'link-shown' | 'fallback', reason?: string, qr = false, browserOpened = false, remote: 'loopback' | 'tailnet' = 'loopback', ms?: number, lan?: 'shown' | 'loopback-bind' | 'no-address', ssh?: boolean) => {
     try { debug.log('onboarding.web-first', event, { ...(reason ? { reason } : {}), qr, browserOpened, remote, ...(ms !== undefined ? { ms } : {}), ...(lan ? { lan, ssh } : {}) }); }
     catch { /* Observability must not block onboarding. */ }
   };
   const fallback = (reason: string): 'fallback' => {
-    print(`웹 셋업을 사용할 수 없습니다 (${reason}). 터미널 설정으로 전환합니다.`);
+    print(text.unavailable(reason));
     observe('fallback', reason);
     return 'fallback';
   };
@@ -70,7 +102,7 @@ export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-s
   try { shown = await show(); } catch { /* A missing daemon may make inspection fail. */ }
   const running = shown?.status === 'unregistered' || (shown?.status === 'registered' && shown.instance?.alive === true);
   if (deps.startIfMissing === false && !running) {
-    print('오프라인 모드');
+    print(text.offline);
     observe('fallback', 'offline');
     return 'fallback';
   }
@@ -85,11 +117,11 @@ export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-s
   const deadline = Date.now() + STARTUP_TIMEOUT_MS;
   if (!running || !shown?.urls?.pwa.loopback) {
     if (deps.startIfMissing === false) {
-      print('오프라인 모드');
+      print(text.offline);
       observe('fallback', 'offline');
       return 'fallback';
     }
-    print('웹 셋업을 위해 데몬을 시작합니다.');
+    print(text.startingDaemon);
     let launch: BgLaunchResult;
     try {
       launch = await (deps.startDaemon ?? (() => runBgLaunch({ out: { log: () => {}, error: () => {} } })))();
@@ -115,7 +147,7 @@ export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-s
     if (remaining > 0) await Bun.sleep(Math.min(200, remaining));
   }
   if (!healthy && deps.startIfMissing === false) {
-    print('오프라인 모드');
+    print(text.offline);
     observe('fallback', 'offline');
     return 'fallback';
   }
@@ -154,13 +186,13 @@ export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-s
   const lan: 'shown' | 'loopback-bind' | 'no-address' = !confirmedBind ? 'no-address' : !reachable ? 'loopback-bind' : lanAddress ? 'shown' : 'no-address';
   const lanLink = lanAddress ? setupUrl(`http://${lanAddress}:${port}/app/`, token) : undefined;
   const phoneLink = shown.urls.pwa.tailnet ? setupUrl(shown.urls.pwa.tailnet, token) : lanLink;
-  print('브라우저에서 셋업을 이어가세요');
+  print(text.continueInBrowser);
   print(link);
   if (lanLink) {
-    print(`같은 와이파이의 폰이면: ${lanLink}`);
-    print('이 링크는 10분 안에 한 번만 열 수 있습니다');
+    print(text.phoneOnSameWifi(lanLink));
+    print(text.linkSingleUse);
   } else if (lan === 'loopback-bind') {
-    print('같은 와이파이에서 열려면 `elanous nexus run` 을 루프백 없이 다시 띄우세요');
+    print(text.sameWifiRestart);
   }
   const linkShownMs = Date.now() - startedAt;
   let qr = false;
@@ -172,12 +204,12 @@ export async function runWebFirstSetup(deps: WebFirstSetupDeps): Promise<'link-s
       }))(phoneLink);
       if (rendered) {
         print(rendered);
-        print(shown.urls.pwa.tailnet ? '같은 와이파이·tailnet 의 폰 카메라로 스캔하세요' : '같은 와이파이의 폰 카메라로 스캔하세요');
+        print(shown.urls.pwa.tailnet ? text.scanTailnet : text.scanSameWifi);
         qr = true;
       }
     } catch { /* QR is optional. */ }
   }
-  print('터미널에서 하려면: `elanous setup --terminal`');
+  print(text.terminalInstead);
   let browserOpened = false;
   const env = deps.browserEnv ?? process.env;
   const ssh = !!(env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY);

package/src/ops/overview-collect.ts

@@ -234,6 +234,16 @@ export interface CollectDeps {
   gitLog?: (sinceIso: string) => { lines: string[]; observedAt: string } ;
 }
 
+/** Production schedule.run ledger reader; dbPath is explicit so replays never open the operating ledger. */
+export async function readSchedulerExecutionRows(dbPath: string, sinceMs: number, untilMs: number): Promise<SchedulerExecutionObservation[]> {
+  const { LogStore } = await import('../mss/logging/log-store.js');
+  const store = LogStore.openReadOnly(dbPath);
+  try {
+    return store.queryAll({ exactCategories: ['schedule.run'], sinceMs, untilMs })
+      .map(({ ts_ms, data }) => ({ ts_ms, data }));
+  } finally { store.close(); }
+}
+
 async function defaultDeps(root: string): Promise<Required<CollectDeps>> {
   const [{ listSchedules }, { listChecklist }, { readReleaseRuns }, { readTaskAgentState, taskAgentStatePath }, { ResourceLedger }, { getUserConfig }] = await Promise.all([
     import('../release-loop/release-schedule.js'), import('../release-loop/checklist.js'), import('../nexus/api/ops-api.js'),
@@ -242,12 +252,8 @@ async function defaultDeps(root: string): Promise<Required<CollectDeps>> {
   return {
     listSchedules: () => listSchedules(),
     readSchedulerRuns: async (sinceMs, untilMs) => {
-      const { LogStore, logsDbPath } = await import('../mss/logging/log-store.js');
-      const store = LogStore.openReadOnly(logsDbPath());
-      try {
-        return store.queryAll({ exactCategories: ['schedule.run'], sinceMs, untilMs })
-          .map(({ ts_ms, data }) => ({ ts_ms, data }));
-      } finally { store.close(); }
+      const { logsDbPath } = await import('../mss/logging/log-store.js');
+      return readSchedulerExecutionRows(logsDbPath(), sinceMs, untilMs);
     },
     listChecklist: (v) => listChecklist(v),
     readRuns: (dir) => readReleaseRuns(null, dir),

package/src/ops/overview.ts

@@ -141,17 +141,17 @@ export function bindingResource(s: OverviewSnapshot): ResourceBinding | null {
   for (const host of s.machines.hosts) {
     const l = host.load.value;
     if (!l) continue;
-    if (l.totalGb > 0) {
+    if (Number.isFinite(l.freeGb) && Number.isFinite(l.totalGb) && 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) {
+    if (Number.isFinite(l.load5) && Number.isFinite(l.cpuCount) && 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 io = l.ioPressure;
-    if (io) {
+    if (io && Number.isFinite(io.someAvg10) && Number.isFinite(io.fullAvg10)) {
       const remaining = Math.max(0, 100 - io.someAvg10);
       candidates.push({ kind: 'io', label: `${host.name} I/O`, remainingRatio: ratio01(remaining / 100), remainingText: `${remainingAmount(remaining)}/100(압박 ${remainingAmount(io.someAvg10)}% · full ${remainingAmount(io.fullAvg10)}% · 10초 평균)` });
     }

package/src/persona/loader.ts

@@ -154,6 +154,16 @@ export function validatePersonaShape(
     todo = obj['todo'];
   }
 
+  // 🗣️ 말투(speech style) — TUI-SPEECH-STYLE-CHARACTER. ⛔ 위 `actionHosts` 주석이
+  //    못 박은 그 이유로 ***여기에 명시로 옮긴다*** — 타입에만 더하면 YAML 의 그 줄은 영영 안 읽힌다.
+  let speechStyle: string | undefined;
+  if (Object.hasOwn(obj, 'speechStyle')) {
+    if (typeof obj['speechStyle'] !== 'string' || !obj['speechStyle'].trim()) {
+      return err(path, 'speechStyle must be a non-empty string');
+    }
+    speechStyle = obj['speechStyle'];
+  }
+
   let mentionPatterns: readonly string[] | undefined;
   if (obj['mentionPatterns'] !== undefined) {
     if (!Array.isArray(obj['mentionPatterns'])
@@ -169,6 +179,7 @@ export function validatePersonaShape(
     ...(todo !== undefined ? { todo } : {}),
     ...(description.value !== undefined ? { description: description.value } : {}),
     ...(systemPrompt.value !== undefined ? { systemPrompt: systemPrompt.value } : {}),
+    ...(speechStyle !== undefined ? { speechStyle } : {}),
     ...(brand !== undefined ? { brand } : {}),
     ...(models !== undefined ? { models } : {}),
     ...(mentionPatterns !== undefined ? { mentionPatterns } : {}),

package/src/persona/types.ts

@@ -30,6 +30,14 @@ export interface PersonaProfile {
    *  v1 = no resolution, raw passthrough). */
   readonly systemPrompt?: string;
 
+  /**
+   * 🗣️ **말투(speech style)** — 이 페르소나가 «어떻게» 말하는가(TUI-SPEECH-STYLE-CHARACTER).
+   *
+   * ⛔ 안 적으면 «없다» — 기본 말투를 조용히 채우지 않는다(`actionHosts`·`capabilities`
+   *    와 같은 규율: 관측이 「선언이 없다」고 말한다).
+   */
+  readonly speechStyle?: string;
+
   /**
    * 🚧 **이 봇이 «손을 쓸 수 있는» 호스트들** — 되돌릴 수 없는 브라우저 조작의 «경계».
    *

package/src/prompt-library/session-guidance.ts

@@ -33,6 +33,11 @@ function hasTool(enabled: ReadonlySet<string>, ...names: string[]): boolean {
   return false;
 }
 
+/** One working tab per site: each one-shot `aside repl "<js>"` call starts a new REPL
+ *  session, so `page` from the previous call is gone — reattach, don't reopen. */
+export const ASIDE_BROWSER_GUIDANCE =
+  'When you drive a browser with `aside repl "<js>"`: each call is a new REPL session, so reuse ONE working tab instead of opening a new one per step (extra tabs of the same app trigger «open in another tab» locks and lost connections). Start every script by reattaching: `const t1=(await listBrowserTabs()).find(t=>t.url.startsWith(\'<origin+path>\')); if (t1) await attachBrowserTab(t1.targetId); else await openTab(\'<url>\');` then use `page`. Call `openTab()` only when no matching tab exists or the user asks for a new page. Always pass the script as the argument — a bare `aside repl` waits for input until the shell timeout. A REPL call may run up to 120s, so give long browser steps a shell timeout above that (e.g. 150000 ms) and split very long flows into several calls.';
+
 /** Build the session guidance addendum. Returns 0 or 1 system message
  *  containing per-tool one-liner directives, gated on what's active.
  *  When `enabledTools` is undefined or every relevant tool is absent,
@@ -114,6 +119,15 @@ export function buildSessionGuidanceAddendum(
     );
   }
 
+  // Browser via Aside (ASIDE-TAB-REUSE · 10-22). Observed in the n8n lecture
+  // session: every step ran `aside repl "var p=await openTab('<same url>')…"`.
+  // A one-shot `aside repl` is a fresh REPL session, so each call opened another
+  // tab → n8n «Editing in another tab» lock → lost connection → the step repeated.
+  // A bare `aside repl` (no script) also hung until the shell timeout.
+  if (hasTool(active, 'Bash', 'bash', 'RunShell', 'run_shell', 'aside.repl', 'aside_repl')) {
+    items.push(ASIDE_BROWSER_GUIDANCE);
+  }
+
   if (items.length === 0) return [];
   // B4 — 파일 수 규칙. 명령을 실제로 돌릴 도구(Bash·PtyShellStart·WebTerminal*)가 있을 때만 `git ls-files` 로 세라고 하고,
   // Read 만 켜진 세션에선 셀 수 없으니 추측하지 말고 확인 불가라고 답하게 한다(EVAL q09 «959» vs 실측 778 · 리뷰 3라운드 must-fix).

package/src/provider-summary.ts

@@ -17,6 +17,7 @@ import { loadTokens, isExpiringSoon } from './oauth/store.js';
 import { CODEX_REFRESH_BUFFER_MS } from './oauth/codex.js';
 import { findCodexModel } from './codex/models.js';
 import { getLocalLLMUrl } from './config.js';
+import { zaiCodingPlanAvailable } from './llm/zai-coding-plan.js';
 
 export type AuthKind = 'oauth' | 'apikey' | 'local' | 'none';
 
@@ -105,6 +106,13 @@ function authDetailForDecision(
       ? llm.apiKey ? 'API key (config)' : 'API key (~/.cache/openrouter_api_key · env OPENROUTER_API_KEY)'
       : 'not configured — bash scripts/add-api-key.sh OPENROUTER_API_KEY';
   }
+  // GLM-NO-CREDENTIAL-FALLBACK (OP #28375 · 🩸 run-6c85c69f) — 종전엔 glm 칸이 없어 자격이 «있어도» 아래 일반 문면
+  //   「no provider configured」가 찍혔고(자식 PTY 첫 줄), 부검이 그 줄을 «자격 결손» 원인으로 읽었다. 판정은 glm 직결이 서는 조건 그 함수다.
+  if (provider === 'glm') {
+    return zaiCodingPlanAvailable()
+      ? 'GLM Coding Plan 키 (~/.cache/zai_api_key · env ZAI_API_KEY)'
+      : 'not configured — ZAI_API_KEY 없음 (~/.cache/zai_api_key · env ZAI_API_KEY)';
+  }
   if (provider === 'local') {
     const url = llm.baseUrl || getLocalLLMUrl();
     return auth === 'local' && url ? `OpenAI-compat endpoint — ${url}` : 'not configured — set llm.baseUrl';

package/src/pty-shell/herdr-agent-report.ts

@@ -3,7 +3,10 @@
 // `herdr agent list` 에 안 잡힌다 — pane CLI 로 생애·세션을 직접 알린다.
 //
 // 활성은 HERDR_ENV=1 ⊕ HERDR_PANE_ID ⊕ 킬스위치가 아닐 때뿐.
-// 실패(rc≠0·timeout·spawn·ENOENT)는 던지지 않고 한 번 로그한 뒤 그 신고기를 끈다.
+// 실패(rc≠0·spawn·ENOENT·오류 봉투)는 던지지 않고 한 번 로그한 뒤 그 신고기를 끈다.
+// 단 turn 신고의 timeout 은 끄지 않는다(TUI-HERDR-STATUS-STALE · 10-22 n8n): herdr 가 바쁜 한 번의 2s 초과로
+// 신고기가 꺼져 턴 끝 idle 이 영영 안 나가 herdr 가 1.9h 동안 working 을 보였다. timeout 은 «결과 모름»이라
+// 마지막 턴 상태를 잠시 뒤 다시 신고하고(새 seq · 더 새 턴이 오면 그만) 이후 턴 신고도 그대로 보낸다.
 //
 // herdr 는 같은 pane·source 에서 «직전보다 큰 seq» 만 받는다(작으면 rc0 인데 무시).
 // 같은 pane 에서 TUI 를 다시 띄워도 신고가 살도록 seq 는 max(직전+1 · 시각 · pane 기록+1) 이다.
@@ -15,6 +18,8 @@
 // 실패로 꺼지는 것은 «이후 turn» 뿐이다. release(권한 반납)는 start 실패가 «확인»됐을 때만 건너뛴다.
 // start 의 비동기 신고가 아직 안 끝났으면(결과 모름) 반납을 미루지 않고 바로 동기로 시도한다(관측 `release-start-pending`) —
 // 종료 경로에서 미루면 exit 뒤 반납이 영영 안 나간다. 반납 실패(rc≠0 등)는 `release-failed` 로 늘 남긴다.
+// 그때 반납 직전에 더 큰 seq 로 동기 재등록한다(TUI-HERDR-EXIT-RACE) — 미등록 반납은 seq 를 안 남겨
+// 늦게 닿은 비동기 등록이 유령이 되던 경합을 «동기 재등록 → 동기 반납» 순서로 닫는다.
 
 import { spawn, spawnSync } from 'node:child_process';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
@@ -29,6 +34,8 @@ export type HerdrTurn = 'busy' | 'idle';
 export interface HerdrRunResult {
   readonly ok: boolean;
   readonly stderr?: string;
+  /** 시간 안에 답을 못 받았다 — herdr 가 이미 적용했을 수도 있는 «결과 모름»(TUI-HERDR-STATUS-STALE). */
+  readonly timedOut?: boolean;
 }
 
 export interface HerdrRunOpts {
@@ -50,8 +57,15 @@ export interface HerdrAgentReporterDeps {
   readonly now?: () => number;
   /** pane 별 마지막 seq 기록. 기본 = tmpdir 파일(`createFileSeqStore`). */
   readonly seqStore?: HerdrSeqStore;
+  /** 재신고 타이머 — 기본 setTimeout(unref). 시험이 가짜 시계를 준다. */
+  readonly schedule?: (fn: () => void, ms: number) => void;
 }
 
+const defaultSchedule = (fn: () => void, ms: number): void => {
+  const t = setTimeout(fn, ms);
+  (t as unknown as { unref?: () => void }).unref?.();
+};
+
 /** 같은 pane 에서 마지막으로 낸 seq — 프로세스 사이 단조를 잇는다. 실패는 던져도 된다(신고기가 삼킨다). */
 export interface HerdrSeqStore {
   read(): number | undefined;
@@ -89,6 +103,10 @@ export interface HerdrAgentReporterLike {
 }
 
 const ASYNC_TIMEOUT_MS = 2000;
+/** turn 신고가 timeout 이면 이만큼 뒤에 마지막 상태를 다시 신고한다. */
+export const HERDR_TURN_RETRY_DELAY_MS = 3000;
+/** 같은 턴 상태의 재신고 상한 — 넘으면 `report-gave-up` 을 남기고 다음 턴 신고를 기다린다(신고기는 켜 둔다). */
+export const HERDR_TURN_RETRY_MAX = 3;
 const SYNC_TIMEOUT_MS = 300;
 const STDERR_HEAD = 240;
 const STDOUT_CAP = 4096;
@@ -149,7 +167,10 @@ export function defaultHerdrRunner(env: NodeJS.ProcessEnv): HerdrRunner {
     if (opts.sync) {
       try {
         const r = spawnSync(bin, argv, { timeout: cap, encoding: 'utf8', windowsHide: true });
-        if (r.error) return { ok: false, stderr: r.error.message };
+        if (r.error) {
+          const timedOut = (r.error as NodeJS.ErrnoException).code === 'ETIMEDOUT';
+          return { ok: false, stderr: r.error.message, ...(timedOut ? { timedOut: true } : {}) };
+        }
         const out = typeof r.stdout === 'string' ? r.stdout : '';
         const overflow = Buffer.byteLength(out, 'utf8') > STDOUT_CAP;
         return judgeHerdr(r.status, overflow ? '' : out, typeof r.stderr === 'string' ? r.stderr : '', overflow);
@@ -178,7 +199,7 @@ export function defaultHerdrRunner(env: NodeJS.ProcessEnv): HerdrRunner {
       };
       const timer = setTimeout(() => {
         try { child.kill(); } catch { /* already gone */ }
-        finish({ ok: false, stderr: stderr || 'timeout' });
+        finish({ ok: false, stderr: stderr || 'timeout', timedOut: true });
       }, cap);
       child.stderr?.on('data', (chunk: Buffer | string) => {
         if (stderr.length < STDERR_HEAD) stderr += String(chunk);
@@ -201,6 +222,43 @@ export function defaultHerdrRunner(env: NodeJS.ProcessEnv): HerdrRunner {
   };
 }
 
+/** 신호 지킴이가 쓰는 process 의 좁은 면 — 시험이 가짜를 준다. */
+export interface HerdrSignalTarget {
+  readonly pid: number;
+  on(sig: NodeJS.Signals, fn: (sig: NodeJS.Signals) => void): unknown;
+  removeListener(sig: NodeJS.Signals, fn: (sig: NodeJS.Signals) => void): unknown;
+  listenerCount(sig: NodeJS.Signals): number;
+  kill(pid: number, sig?: string | number): unknown;
+}
+
+const RELEASE_SIGNALS: readonly NodeJS.Signals[] = ['SIGINT', 'SIGTERM'];
+
+/**
+ * SIGINT·SIGTERM 기본 죽음에도 반납한다(TUI-HERDR-EXIT-RACE).
+ * 대시보드가 raw 모드에 들기 «전»의 ctrl+c 는 SIGINT 기본 동작으로 프로세스를 죽여(rc130) 'exit' 훅이 안 돈다 —
+ * 10-22 격리 세션 실측: 반납 0 · `agent list` 에 elanous idle 이 남았다.
+ * 신호가 오면 반납(동기) → 자기 리스너를 걷고, 이제 아무도 안 들으면 같은 신호를 다시 올려 기본 죽음을 지킨다.
+ * 다른 리스너가 있으면 그쪽이 같은 신호를 이미 받았다 — 다시 올리지 않는다.
+ * @returns 해제(정상 종료 경로에서 부른다).
+ */
+export function guardHerdrReleaseOnSignal(release: () => void, proc: HerdrSignalTarget = process): () => void {
+  let off = false;
+  const remove = (): void => {
+    if (off) return;
+    off = true;
+    for (const sig of RELEASE_SIGNALS) { try { proc.removeListener(sig, onSignal); } catch { /* 종료 경로를 깨지 않는다 */ } }
+  };
+  function onSignal(sig: NodeJS.Signals): void {
+    try { release(); } catch { /* 신호 경로를 깨지 않는다 */ }
+    remove();
+    let alone = true;
+    try { alone = proc.listenerCount(sig) === 0; } catch { alone = true; }
+    if (alone) { try { proc.kill(proc.pid, sig); } catch { /* 이미 끝나는 중 */ } }
+  }
+  for (const sig of RELEASE_SIGNALS) proc.on(sig, onSignal);
+  return remove;
+}
+
 /**
  * herdr pane 안에서만 신고기. 비활성이면 null (skipped 로그 한 번).
  * 반환 메서드는 실패해도 던지지 않는다.
@@ -219,7 +277,7 @@ export function createHerdrAgentReporter(deps: HerdrAgentReporterDeps = {}): Her
   }
   const run = deps.run ?? defaultHerdrRunner(env);
   const sessionId = deps.sessionId ?? '';
-  return new Reporter(paneId, sessionId, run, log, deps.now ?? Date.now, deps.seqStore ?? createFileSeqStore(paneId));
+  return new Reporter(paneId, sessionId, run, log, deps.now ?? Date.now, deps.seqStore ?? createFileSeqStore(paneId), deps.schedule ?? defaultSchedule);
 }
 
 type IssueResult = boolean | Promise<boolean>;
@@ -256,8 +314,14 @@ class Reporter implements HerdrAgentReporterLike {
     private readonly log: (event: string, data: Record<string, unknown>) => void,
     private readonly now: () => number,
     private readonly seqStore: HerdrSeqStore,
+    private readonly schedule: (fn: () => void, ms: number) => void,
   ) {}
 
+  /** 마지막으로 요청된 턴 상태와 그 세대 — 재신고는 세대가 그대로일 때만(더 새 턴이 오면 그만). */
+  private lastTurn: HerdrTurn | null = null;
+  private turnGen = 0;
+  private turnRetries = 0;
+
   start(): void {
     if (this.startState !== 'none') return;
     try { this.storedSeq = this.seqStore.read(); } catch (error) { this.seqStoreFail(error); }
@@ -314,6 +378,13 @@ class Reporter implements HerdrAgentReporterLike {
   turn(t: HerdrTurn): void {
     // 반납 뒤 신고는 반납한 에이전트를 더 큰 seq 로 다시 등록한다 — 막는다.
     if (this.disabled || this.released) return;
+    this.lastTurn = t;
+    this.turnGen += 1;
+    this.turnRetries = 0;
+    this.issueTurn(t);
+  }
+
+  private issueTurn(t: HerdrTurn): void {
     const state = t === 'busy' ? 'working' : 'idle';
     this.issue([
       'pane', 'report-agent',
@@ -328,11 +399,24 @@ class Reporter implements HerdrAgentReporterLike {
     if (this.released) return;
     // idle 등록 실패가 확인됐거나 start 전이면 건너뛴다. pending = 결과 모름 → 반납을 시도한다.
     if (this.startState === 'none' || this.startState === 'failed' || this.idleFailed) return;
+    this.released = true;
     if (this.startState === 'pending') {
       this.log('release-start-pending', {});
       this.releasedWhilePending = true;
+      // 즉시 종료 경합(TUI-HERDR-EXIT-RACE): 비동기 idle 등록은 herdr 자식 프로세스라 부모가 죽어도 간다.
+      //   herdr 0.9.1 실측 — 미등록 에이전트 반납은 rc0 인데 seq 를 안 남긴다 ⇒ 반납 «뒤에» 닿은 작은 seq 등록이
+      //   유령으로 남는다(10-22 격리 세션 tf-exit-race). 기다릴 수 없으니(동기 ≤300ms) 순서를 동기로 고정한다:
+      //   더 큰 seq 로 동기 재등록 → 동기 반납. 반납이 «등록된» 에이전트를 지우며 seq 를 남기므로
+      //   늦게 닿는 앞 등록(작은 seq)은 herdr 가 버린다. 재등록 실패여도 반납은 그대로 시도한다(결과 모름).
+      this.issue([
+        'pane', 'report-agent',
+        '--source', HERDR_SOURCE, '--agent', HERDR_AGENT,
+        '--state', 'idle',
+        '--agent-session-id', this.sessionId,
+        '--seq', this.nextSeq(),
+        this.paneId,
+      ], true, 'release');
     }
-    this.released = true;
     const seq = this.nextSeq();
     // pane 기록 쓰기는 여기(동기 종료 경로)뿐이다.
     try { this.seqStore.write(this.seq); } catch (error) { this.seqStoreFail(error); }
@@ -346,6 +430,27 @@ class Reporter implements HerdrAgentReporterLike {
     ], true, 'release');
   }
 
+  /**
+   * turn 신고 timeout — 신고기를 끄지 않고 마지막 턴 상태를 잠시 뒤 다시 신고한다(TUI-HERDR-STATUS-STALE).
+   * herdr 가 그 신고를 이미 적용했어도(답만 늦었다) 다시 보내는 것은 무해하다 — 더 큰 seq 의 같은 상태다.
+   */
+  private retryTurnAfterTimeout(argv: string[], stderr: string | undefined): void {
+    const gen = this.turnGen;
+    const state = this.lastTurn;
+    const attempt = this.turnRetries + 1;
+    if (state === null) return;
+    if (attempt > HERDR_TURN_RETRY_MAX) {
+      this.log('report-gave-up', { cmd: argv[1] ?? '', state: state === 'busy' ? 'working' : 'idle', attempts: HERDR_TURN_RETRY_MAX, stderrHead: stderrHead(stderr) });
+      return;
+    }
+    this.turnRetries = attempt;
+    this.log('report-timeout-retry', { cmd: argv[1] ?? '', state: state === 'busy' ? 'working' : 'idle', attempt, delayMs: HERDR_TURN_RETRY_DELAY_MS, stderrHead: stderrHead(stderr) });
+    this.schedule(() => {
+      if (this.disabled || this.released || this.turnGen !== gen) return;
+      this.issueTurn(state);
+    }, HERDR_TURN_RETRY_DELAY_MS);
+  }
+
   private seqStoreFail(error: unknown): void {
     if (this.seqStoreFailed) return;
     this.seqStoreFailed = true;
@@ -388,7 +493,7 @@ class Reporter implements HerdrAgentReporterLike {
       const judged = (result as Promise<HerdrRunResult>).then(
         (r) => {
           if (r.ok) return true;
-          this.fail(argv, phase, r.stderr);
+          this.fail(argv, phase, r.stderr, r.timedOut === true);
           return false;
         },
         (error: unknown) => {
@@ -401,7 +506,7 @@ class Reporter implements HerdrAgentReporterLike {
     }
     const syncResult = result as HerdrRunResult;
     if (!syncResult.ok) {
-      this.fail(argv, phase, syncResult.stderr);
+      this.fail(argv, phase, syncResult.stderr, syncResult.timedOut === true);
       return false;
     }
     return true;
@@ -419,7 +524,7 @@ class Reporter implements HerdrAgentReporterLike {
     try {
       const r = await this.run(argv, opts);
       if (r.ok) return true;
-      this.fail(argv, phase, r.stderr);
+      this.fail(argv, phase, r.stderr, r.timedOut === true);
       return false;
     } catch (error) {
       this.fail(argv, phase, error instanceof Error ? error.message : String(error));
@@ -427,7 +532,11 @@ class Reporter implements HerdrAgentReporterLike {
     }
   }
 
-  private fail(argv: string[], phase: 'start' | 'session' | 'turn' | 'release', stderr: string | undefined): void {
+  private fail(argv: string[], phase: 'start' | 'session' | 'turn' | 'release', stderr: string | undefined, timedOut = false): void {
+    if (phase === 'turn' && timedOut && !this.disabled) {
+      this.retryTurnAfterTimeout(argv, stderr);
+      return;
+    }
     if (phase === 'start') this.idleFailed = true;
     // 반납 실패는 신고기가 이미 꺼졌어도 늘 남긴다(종료 경로의 유일한 흔적).
     if (phase === 'release') {