npm - coxpit - Versions diffs - 6.3.2 → 6.3.5 - Mend

coxpit 6.3.2 → 6.3.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/src/config.ts CHANGED Viewed

@@ -82,8 +82,15 @@ export const config = {
   portStrict: env.COXPIT_PORT_STRICT === '1' || (env.COXPIT_PORT_STRICT == null && stored.portStrict === true),
   dbPath,
   settingsPath,
+  // 소유자 UI 상태(열어둔 탭 등) — DB·settings 와 같은 데이터 폴더의 작은 JSON 한 장.
+  uiStatePath: path.join(path.dirname(path.resolve(dbPath)), 'ui-state.json'),
   // 단일 데몬 락 파일 — DB 와 같은 폴더(그 DB 를 지키는 락이므로)
   lockPath: path.join(path.dirname(path.resolve(dbPath)), 'daemon.lock.json'),
+  // 세션 tmux 의 PATH 맨 앞에 끼우는 얇은 심 폴더(부팅 때 `claude` 한 장을 쓴다).
+  // 사람이 세션에서 그냥 `claude` 를 쳐도 그 대화가 이 세션의 id 로 묶이게 하는 유일한 손잡이다.
+  // 이름이 'bin' 이면 안 된다 — 레거시 DB(cwd 의 ./coxpit.db)를 쓰는 개발 기동에서는 데이터 폴더가
+  // repo 루트가 되고, 그 repo 의 bin/ 은 package.json "files" 에 실려 npm 에 **발행된다**.
+  shimDir: path.join(path.dirname(path.resolve(dbPath)), 'shim'),
   // 원격 머신 SSH 개인키 경로(선택). 없으면 ssh 기본 키/에이전트 사용.
   sshKey: process.env.COXPIT_SSH_KEY ?? '',
   // run 정착 시 POST 할 웹훅(선택) — 텔레그램 브릿지 등 사용자 연결용.

package/src/db/index.ts CHANGED Viewed

@@ -127,6 +127,7 @@ export async function ensureSchema(): Promise<void> {
   try { await client.execute("ALTER TABLE repos ADD COLUMN kind TEXT NOT NULL DEFAULT 'git'"); } catch { /* exists */ }
   try { await client.execute("ALTER TABLE agent_runs ADD COLUMN title TEXT NOT NULL DEFAULT ''"); } catch { /* exists */ }
   try { await client.execute('ALTER TABLE agent_runs ADD COLUMN in_place INTEGER NOT NULL DEFAULT 0'); } catch { /* exists */ }
+  try { await client.execute("ALTER TABLE agent_runs ADD COLUMN claude_session_id TEXT NOT NULL DEFAULT ''"); } catch { /* exists */ }
   // DEFAULT 1 = 기존 run 은 real 로 남는다. 모르는 과거를 dry 로 칠하지 않기 위한 기본값이다(v5.28 H1).
   try { await client.execute('ALTER TABLE agent_runs ADD COLUMN real INTEGER NOT NULL DEFAULT 1'); } catch { /* exists */ }
   // 조인 키 인덱스(멱등) — 없으면 이 여섯 조회가 매번 테이블 전체를 훑는다.

package/src/db/schema.ts CHANGED Viewed

@@ -91,6 +91,11 @@ export const agentRuns = sqliteTable('agent_runs', {
   tmuxWindow: text('tmux_window').notNull().default(''),
   status: text('status').notNull().default('pending'), // pending | running | waiting | done | error
   sessionId: text('session_id').notNull().default(''), // 에이전트 세션(steer 용 --resume 키)
+  // 이 coxpit 세션이 쓰는 claude 대화 하나의 id(= ~/.claude/projects/<cwd-enc>/<id>.jsonl 파일명).
+  // 세션을 열 때 미리 정해 두고 `claude --session-id` 로 묶는다 — 한 폴더(워크스페이스 루트 등)에
+  // 세션 여럿이 살면 "가장 최근 .jsonl" 은 거의 항상 남의 대화라, 뷰어가 이름을 미리 알아야 한다.
+  // 태그 없이 이미 돌고 있던 세션은 화면 내용으로 찾아낸 뒤 여기에 적어 다시 찾지 않는다.
+  claudeSessionId: text('claude_session_id').notNull().default(''),
   prUrl: text('pr_url').notNull().default(''), // PR 모드로 올린 pull request URL
   model: text('model').notNull().default(''), // 런치별 모델 지정(빈값 = CLI 기본)
   // v5.28 Part H — 이 run 이 진짜 에이전트로 돌았나(real), 모의 스트림이었나(dry).

package/src/hud.ts CHANGED Viewed

@@ -5,10 +5,13 @@
 //   ① 알약으로 한눈에 본다(점 + 대기 수)  ② 펼쳐서 나를 기다리는 것부터 훑는다
 //   ③ 한 줄을 고르면 **목록 옆에** 상세가 열린다   ④ 대기 중인 에이전트에게 코크핏을 열지 않고 답한다
 //
-// [!] 이 실행분은 **서빙되는 페이지까지**다. 창(프레임리스·항상 위)·전역 단축키·크기 변경·
-// 드래그는 뒤따르는 데스크톱 작업(K1/K2)이다. 여기서는 원하는 크기 상태만
-// <html data-hud="pill|list|detail"> 에 적어 둔다 — 데스크톱이 나중에 그걸 읽어 창을 줄이고 늘린다.
-// 페이지 자신은 그 값으로 **안에서** 레이아웃만 바꾼다(브라우저에서 단독으로 돌아간다).
+// [!] 이 페이지는 **브라우저에서 단독으로 돈다**. 창(프레임리스·항상 위)·전역 단축키·크기 변경은
+// 데스크톱 쪽 일(K1/K2, desktop/main.cjs)이고, 여기는 그쪽을 한 줄도 모른다 —
+// 배치 상태를 <html data-hud="pill|list|detail"> 에 적고, 창이 붙어 있을 때만
+// window.coxpitHud.size({state,w,h}) 로 "이만큼 필요하다"고 말할 뿐이다(없으면 아무 일도 없다).
+// 창을 실제로 줄이고 늘리는 것도, 화면 밖으로 안 나가게 물리는 것도 전부 메인 프로세스다.
+// 보이는데 열리지 않는 알약은 없느니만 못하다 — 눌러서 펼쳐져야 하고 그러면서도 끌어 옮길 수 있어야 하니,
+// drag 영역과 클릭 대상은 같은 요소일 수 없다: 알약은 눌리고, 창은 알약 안의 홈(.pgrip)으로 옮긴다.
 //
 // 데이터는 전부 코크핏이 이미 읽는 것: GET /api/fleet(+ agentStates · real) 과 /ws 델타.
 // 새 창구는 하나뿐 — POST /api/runs/:id/input (살아 있는 tmux 에 한 줄 써 넣기, getScrollback 의 쓰기 쌍둥이).
@@ -52,11 +55,18 @@ export const HUD_HTML = /* html */ `<!doctype html>
   html[data-hud="pill"] body{align-items:flex-start}
   /* ── K3. 접힌 알약 — 이것이 평상시의 전부다 ───────────────────────────── */
-  .pill{display:inline-flex;align-items:center;gap:8px;height:26px;padding:0 11px;border-radius:999px;
+  .pill{display:inline-flex;align-items:center;gap:8px;height:26px;padding:0 11px 0 7px;border-radius:999px;
     background:var(--surface);border:1px solid var(--line);box-shadow:0 8px 28px rgba(0,0,0,.35);
-    font-family:var(--mono);font-size:11px;color:var(--muted);-webkit-app-region:drag}
+    font-family:var(--mono);font-size:11px;color:var(--muted)}
   .pill:hover{border-color:var(--line-hi);color:var(--ink)}
-  .pill>*{-webkit-app-region:no-drag}
+  /* app-region: 프레임 없는 창(K1)에서 drag 영역은 클릭을 **삼킨다** — 창이 대신 움직인다.
+     그래서 알약 자체는 no-drag(눌러서 펼치는 것이 알약의 일이고, 옮기는 일보다 훨씬 잦다)이고,
+     창을 옮기는 손잡이는 알약 안의 작은 홈 하나뿐이다. 브라우저에서는 둘 다 아무 뜻도 없다. */
+  .pill,.pill>*{-webkit-app-region:no-drag}
+  .pill>.pgrip{-webkit-app-region:drag}
+  .pgrip{flex:none;color:var(--faint);font-family:var(--mono);font-size:10px;line-height:1;
+    letter-spacing:-.06em;padding:0 2px;opacity:.65;cursor:grab}
+  .pill:hover .pgrip{opacity:1}
   .pdots{display:inline-flex;align-items:center;gap:4px}
   .pwait{color:var(--blocked);font-size:11px;letter-spacing:.02em}
   .pquiet{color:var(--faint);font-size:10.5px}
@@ -159,8 +169,10 @@ export const HUD_HTML = /* html */ `<!doctype html>
 </style>
 </head>
 <body>
-  <!-- K3 — 접힌 알약. 누르면 펼쳐진다(창 크기는 데스크톱이 나중에 data-hud 를 보고 맞춘다). -->
+  <!-- K3 — 접힌 알약. 누르면 펼쳐진다(창 크기는 데스크톱이 나중에 data-hud 를 보고 맞춘다).
+       맨 앞의 홈(.pgrip)만이 창을 끄는 손잡이다 — 나머지는 전부 눌리는 자리다. -->
   <button type="button" id="pill" class="pill" aria-label="coxpit fleet">
+    <span class="pgrip" id="pillGrip" aria-hidden="true" title="끌어서 창 옮기기">⠿</span>
     <span class="pdots" id="pillDots"></span>
     <span class="pwait" id="pillWait" hidden></span>
     <span class="pquiet" id="pillQuiet" hidden>quiet</span>
@@ -194,12 +206,28 @@ export const HUD_HTML = /* html */ `<!doctype html>
   }
   // ── 레이아웃 상태 = 데스크톱이 읽어 갈 자리 ────────────────────────────
-  // 창을 줄이고 늘리는 것은 **여기가 아니다**(K1, 데스크톱 작업). 이 페이지는 원하는 크기를
+  // 창을 줄이고 늘리는 것은 **여기가 아니다**(K1, 데스크톱 창). 이 페이지는 원하는 크기를
   // <html data-hud> 에 적어 두고, 자기 안에서는 그 값으로 배치만 바꾼다.
+  // 데스크톱 창에 실려 있으면 그 크기를 한 번 더 **말해 준다** — 창을 만지는 쪽은 언제나 저쪽이다.
+  // 알약 120x26 · 목록 250 · 상세 570 (+ 지면 여백 6px 양쪽). 창은 이 값을 화면 크기로 한 번 더 물린다.
+  var HUD_SIZE={ pill:{w:132,h:38}, list:{w:262,h:380}, detail:{w:582,h:440} };
+  function reportSize(next){
+    var api=window.coxpitHud;
+    if(!api||typeof api.size!=='function') return;   // 브라우저에서 단독으로 열린 경우 — 아무 일도 없다
+    var s=HUD_SIZE[next]||HUD_SIZE.pill;
+    var w=s.w, h=s.h;
+    // 알약만은 **재서** 말한다 — 폭이 점 수에 따라 달라져서 고정값이면 잘리거나 빈자리가 남는다.
+    if(next==='pill'){
+      var el=$('pill');
+      if(el&&el.offsetWidth){ w=Math.ceil(el.offsetWidth)+12; h=Math.ceil(el.offsetHeight)+12; }
+    }
+    try{ api.size({state:next, w:w, h:h}); }catch(e){}
+  }
   var layout='pill';
   function setLayout(next){
     layout=next;
     document.documentElement.setAttribute('data-hud', next);
+    reportSize(next);
     if(next==='pill'){ try{ $('pill').focus(); }catch(e){} }
   }
   function expand(){ if(layout==='pill'){ setLayout('list'); render(); } }
@@ -335,6 +363,8 @@ ${ACTIVITY_JS}
     if(b.wait.length){ w.hidden=false; w.textContent='\\u25d4 '+b.wait.length; q.hidden=true; }
     else { w.hidden=true; q.hidden=false; q.textContent=b.run.length?(b.run.length+' running'):'quiet'; }
     $('pill').title = b.wait.length ? (b.wait.length+' 개가 답을 기다립니다') : (b.run.length+' 개가 도는 중');
+    // 점이 늘고 줄면 알약의 폭도 달라진다 — 떠 있는 창이라면 그때마다 다시 말해 준다.
+    if(layout==='pill') reportSize('pill');
   }
   // ── K5. 상세 — 고른 행 하나. 목록은 그대로 옆에 남는다. ────────────────

package/src/index.ts CHANGED Viewed

@@ -1,5 +1,6 @@
 import { config } from './config';
 import { authMode, ensureSetupToken, isExposedBind } from './authkey';
+import { ensureClaudeShim } from './claudeshim';
 import { db, ensureSchema } from './db';
 import { machines } from './db/schema';
 import { acquireDaemonLock, updateLockPort } from './lock';
@@ -27,6 +28,13 @@ await acquireDaemonLock();
 await ensureSchema();
+// 세션마다 claude 대화를 정확히 묶기 위한 얇은 심(PATH 맨 앞) — 부팅 1회.
+// claude 가 없는 기계면 조용히 건너뛴다(세션은 지금까지와 같이 동작하고, 뷰어는 폴백으로 찾는다).
+{
+  const shim = ensureClaudeShim();
+  if (shim.real) console.log(`[coxpit] claude shim ready at ${shim.path} (tags each session's conversation with --session-id)`);
+}
 // 첫 실행 시 로컬 머신 시드(데몬이 도는 이 기계).
 if ((await db.select().from(machines)).length === 0) {
   await db.insert(machines).values({ slug: 'local', name: 'This machine', kind: 'local', online: true });

package/src/orchestrator.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { randomBytes } from 'node:crypto';
+import { randomBytes, randomUUID } from 'node:crypto';
 import { posix as ppath } from 'node:path';
 import { createInterface } from 'node:readline';
 import { existsSync, statSync, openSync, readSync, closeSync, mkdirSync } from 'node:fs';
@@ -6,6 +6,7 @@ import { mkdir, copyFile, readFile, writeFile, rm, unlink } from 'node:fs/promis
 import { homedir } from 'node:os';
 import type { ChildProcess } from 'node:child_process';
 import { eq, inArray, and, desc } from 'drizzle-orm';
+import { CLAUDE_SID_RE, claudeTagEnvArgs } from './claudeshim';
 import { config } from './config';
 import { db } from './db';
 import { agentRuns, agentEvents, tasks, repos, machines, designCaptures, docSnapshots, taskGroups, secrets } from './db/schema';
@@ -132,6 +133,45 @@ export async function secretEnvArgs(): Promise<string> {
   } catch { return ''; }
 }
+/** 이 머신이 데몬이 사는 그 기계인가(심 파일에 닿을 수 있나). */
+function isLocalMachine(m: MachineTarget): boolean {
+  return m.kind === 'local' || m.address === '';
+}
+/**
+ * 인터랙티브 세션(사람이 `claude` 를 쳐 넣는 자리)의 claude 대화 태그.
+ * 세션을 열기 전에 id 를 정해 run 에 적고, 그 세션 tmux 에는 심 폴더를 앞세운 PATH 와
+ * COXPIT_CLAUDE_SID 를 넣는다 — 그러면 사람이 그냥 `claude` 를 쳐도 그 대화가 이 id 로 묶이고,
+ * 뷰어는 대본 파일명을 추측하지 않는다(§getSessionChat ①).
+ * id 는 심이 없어도 적어 둔다: 그 이름의 파일이 실제로 있을 때만 쓰이므로 거짓이 새지 않고,
+ * 컬럼의 뜻이 "이 세션이 쓰기로 한 대화" 하나로 단순해진다.
+ */
+function sessionClaudeTag(machine: MachineTarget): { sid: string; env: string } {
+  const sid = randomUUID();
+  return { sid, env: claudeTagEnvArgs(sid, isLocalMachine(machine)) };
+}
+/**
+ * 죽은 세션을 그 자리에서 되살릴 때 다시 얹는 태깅 env(터미널 소생 경로 — server.ts).
+ * 셸이 exit 한 뒤 사람이 다시 들어와 `claude` 를 치는 자리가 정확히 여기라, 여기서 빠지면 태그가 끊긴다.
+ */
+export function claudeTagEnvForRun(machine: MachineTarget, sid: string): string {
+  return claudeTagEnvArgs(sid, isLocalMachine(machine));
+}
+/**
+ * coxpit 세션의 tmux 스크롤백 한도. tmux 기본값(2000줄)으로는 뷰어의 "터미널" 탭이 금방 잘린다.
+ * history-limit 은 **pane 이 만들어지는 순간**의 값이 적용된다(기존 pane 은 안 늘어난다) —
+ * new-session 뒤에 세션 옵션으로 올리면 첫 pane 에는 안 먹는다. 그래서 같은 tmux 호출 안에서
+ * 전역 옵션을 먼저 올리고 세션을 만든다(start-server 로 서버를 띄워 둬야 set -g 가 산다).
+ */
+export const TMUX_HISTORY_LIMIT = 100000;
+/** `tmux new-session <rest>` 대신 쓰는 셸 조각 — history-limit 을 올린 뒤 세션을 만든다. rest 는 호출부가 인용한다. */
+export function tmuxNewSession(rest: string): string {
+  return `tmux start-server \\; set-option -g history-limit ${TMUX_HISTORY_LIMIT} \\; new-session ${rest}`;
+}
 // 실행 중 run 의 자식 프로세스(stop 용). stoppedRuns = 사용자가 멈춘 run 표식.
 const liveChildren = new Map<number, ChildProcess>();
 const stoppedRuns = new Set<number>();
@@ -528,7 +568,7 @@ export async function launchRun(runId: number, real?: boolean): Promise<void> {
     // export LANG: 이 명령이 tmux 서버를 처음 띄우는 경우(특히 원격) C 로케일로 뜨면 CJK 가 깨진다.
     const runEnv = await secretEnvArgs();
     await runShellOn(ctx.machine,
-      `export LANG=${shq(config.lang)}; tmux kill-session -t ${shq('=' + session)} 2>/dev/null; tmux new-session -d${runEnv} -s ${shq(session)} -c ${shq(wtPath)} 2>/dev/null || true`, 8000);
+      `export LANG=${shq(config.lang)}; tmux kill-session -t ${shq('=' + session)} 2>/dev/null; ${tmuxNewSession(`-d${runEnv} -s ${shq(session)} -c ${shq(wtPath)}`)} 2>/dev/null || true`, 8000);
     await setRun(runId, { status: 'running' });
     await recordEvent(runId, 'meta', JSON.stringify({ branch, worktree: wtPath, real: useReal, ...(inPlace ? { inPlace: true } : {}) }));
@@ -788,9 +828,117 @@ export async function getRunTermInfo(runId: number): Promise<{ machine: MachineT
   return { machine: ctx.machine, session: run.tmuxWindow };
 }
+/** 대본 꼬리 상한 — runShellOn 의 maxBuffer(1MB)를 넘기면 읽기 자체가 실패한다. */
+const CHAT_TAIL_BYTES = 800000;
+/**
+ * 이름으로 대본 한 장 읽기 — 후보 폴더를 순서대로 보고 **처음 있는** `<sid>.jsonl` 의 꼬리.
+ * 없으면 빈 문자열(그러면 호출부가 다음 수단으로 내려간다).
+ */
+async function readTranscriptBySid(machine: MachineTarget, cands: string[], sid: string): Promise<string> {
+  const name = shq(`${sid}.jsonl`);
+  const cmd = `for d in ${cands.map((d) => shq(d)).join(' ')}; do f="$HOME/.claude/projects/$d/"${name};` +
+    ` if [ -f "$f" ]; then tail -c ${CHAT_TAIL_BYTES} "$f"; exit 0; fi; done`;
+  const r = await runShellOn(machine, cmd, 15000);
+  return r.ok ? r.stdout : '';
+}
+/**
+ * 페인 화면에서 "이 대화에만 있을 법한" 긴 조각 몇 개.
+ * TUI 테두리·불릿 같은 장식은 공백으로 벗기고, 대본(JSON) 안에서 **그대로** 찾을 수 있는 구간만 남긴다
+ * (따옴표·역슬래시는 JSON 에서 escape 되므로 조각에 넣지 않는다). 긴 것부터 앞에 온다.
+ */
+function paneNeedles(screen: string[], want = 4): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  for (const raw of screen) {
+    const t = raw.replace(/[\u2500-\u257F\u2022\u25A0-\u25FF]/g, ' ').replace(/\s+/g, ' ').trim();
+    if (t.length < 24) continue;
+    const piece = (t.match(/[^"\\]{24,}/g) ?? []).sort((a, b) => b.length - a.length)[0];
+    if (!piece) continue;
+    const s = piece.trim();
+    // 글자가 섞여 있어야 한다 — 기호만 남은 줄(프롬프트·구분선)은 아무 대본에나 걸린다.
+    if (s.length < 24 || seen.has(s) || !/[A-Za-z0-9\u3131-\uD79D\u3040-\u30FF\u4E00-\u9FFF]{4,}/.test(s)) continue;
+    seen.add(s);
+    out.push(s);
+  }
+  out.sort((a, b) => b.length - a.length);
+  return out.slice(0, want);
+}
+/**
+ * 태그 없이 이미 돌고 있는 세션의 대본 찾기 (best-effort) — **화면에 뜬 말**로 맞춰 본다.
+ * 사후에 페인↔.jsonl 을 잇는 파일시스템·프로세스 신호가 없기 때문에(열린 fd 도, argv 도 없다)
+ * 남는 단서는 그 페인이 지금 보여주고 있는 내용뿐이다.
+ * 규율: 페인이 claude 를 물고 있을 때만, 최신 25장만, 확실한 1등만.
+ *  - 동점이면 페인의 마지막 활동 시각에 mtime 이 가장 가까운 쪽을 고르고,
+ *  - 그래도 갈리면 답하지 않는다(찾지 못한 것을 찾았다고 하지 않는다).
+ * 다른 run 이 이미 자기 대화라고 적어 둔 id 는 후보에서 뺀다 — 남의 대본을 집지 않는 정확한 울타리다
+ * ("지금 가장 빨리 자라는 대본" 같은 추정보다 이게 싸고 확실하다).
+ */
+async function matchTranscriptByPane(
+  machine: MachineTarget, session: string, cands: string[], runId: number,
+): Promise<string> {
+  const t = shq(session);
+  const probe = await runShellOn(
+    machine,
+    `printf 'CMD:%s\\n' "$(tmux display -p -t ${t} '#{pane_current_command}' 2>/dev/null)"; ` +
+    `printf 'ACT:%s\\n' "$(tmux display -p -t ${t} '#{session_activity}' 2>/dev/null)"; ` +
+    `tmux capture-pane -t ${t} -p -J -S -200 2>/dev/null || true`,
+    12000,
+  );
+  if (!probe.ok) return '';
+  let cmd = '';
+  let act = 0;
+  const screen: string[] = [];
+  for (const l of probe.stdout.split('\n')) {
+    if (l.startsWith('CMD:')) { cmd = l.slice(4).trim(); continue; }
+    if (l.startsWith('ACT:')) { act = Number(l.slice(4).trim()) || 0; continue; }
+    screen.push(l);
+  }
+  // claude TUI 는 node 로 뜬다(래퍼에 따라 이름이 다르다) — 평범한 셸 페인에서 남의 대본을 집지 않기 위한 문지기.
+  if (!/claude|^(node|bun|deno)$/.test(cmd)) return '';
+  const needles = paneNeedles(screen);
+  if (needles.length < 2) return '';
+  const greps = needles.map((n) => `grep -qF ${shq(n)} "$f" 2>/dev/null && n=$((n+1));`).join(' ');
+  const scan = `for d in ${cands.map((d) => shq(d)).join(' ')}; do p="$HOME/.claude/projects/$d";` +
+    ` c=$(ls -t "$p"/*.jsonl 2>/dev/null | head -1); if [ -n "$c" ]; then cd "$p" || exit 0;` +
+    ` for f in $(ls -t *.jsonl 2>/dev/null | head -25); do n=0; ${greps}` +
+    ` m=$(date -r "$f" +%s 2>/dev/null || echo 0); printf '%s %s %s\\n' "$n" "$m" "$f"; done; exit 0; fi; done`;
+  const sc = await runShellOn(machine, scan, 20000);
+  if (!sc.ok) return '';
+  const claimed = await db.select({ id: agentRuns.id, sid: agentRuns.claudeSessionId }).from(agentRuns);
+  const exclude = new Set(claimed.filter((o) => o.id !== runId && o.sid).map((o) => o.sid));
+  const rows: Array<{ sid: string; score: number; mtime: number }> = [];
+  for (const l of sc.stdout.split('\n')) {
+    const m = /^(\d+) (\d+) (.+)\.jsonl$/.exec(l.trim());
+    if (!m) continue;
+    const sid = m[3]!;
+    if (exclude.has(sid) || !CLAUDE_SID_RE.test(sid)) continue;
+    rows.push({ sid, score: Number(m[1]), mtime: Number(m[2]) });
+  }
+  const best = rows.reduce((a, r) => Math.max(a, r.score), 0);
+  if (best < 1) return '';
+  const top = rows.filter((r) => r.score === best);
+  if (top.length === 1) return top[0]!.sid;
+  if (!act) return '';
+  top.sort((a, b) => Math.abs(a.mtime - act) - Math.abs(b.mtime - act));
+  return Math.abs(top[0]!.mtime - act) < Math.abs(top[1]!.mtime - act) ? top[0]!.sid : '';
+}
 /**
  * 세션의 Claude Code 대화 로그(JSONL)를 대화형으로 파싱 — 뷰어의 "대화" 모드.
- * cwd(worktreePath)를 [^a-zA-Z0-9]→'-' 로 바꾼 게 ~/.claude/projects/<...>/ 폴더명 → 최신 .jsonl.
+ * 대본은 claude 가 **자기 cwd** 를 [^a-zA-Z0-9]→'-' 로 인코딩한 ~/.claude/projects/<...>/ 밑에 쌓인다.
+ * worktreePath 를 기준으로 삼으면 빈손이 되는 경우가 둘이고, 폰에서 "대화 탭이 비어 있다"던 게 정확히 이것이다:
+ *  ① 루트·메인 세션은 worktreePath 가 아예 비어 있다(그래도 페인엔 멀쩡한 cwd 가 있다 — 그래서 여기서 포기하면 안 된다).
+ *  ② 사람이 페인에서 cd 한 뒤엔 worktree 루트가 claude 의 cwd 가 아니다.
+ * 그래서 기준은 **페인이 지금 서 있는 폴더**(tmux #{pane_current_path} — getRunPwd)이고, worktreePath 는 폴백이다.
+ *
+ * 폴더가 정해져도 그 안의 **어느 .jsonl 이냐**가 남는다. 한 폴더(워크스페이스 루트)에 세션이 여럿이면
+ * "가장 최근 파일"은 거의 항상 남의 대화다 — 그래서 셋을 순서대로 본다:
+ *  ① 이 세션에 태깅해 둔 id 의 파일(claudeSessionId, 정확) — §sessionClaudeTag 가 심어 둔 이름.
+ *  ② 없으면 화면 내용으로 찾아(best-effort) **한 번만** 찾고 그 id 를 적어 둔다.
+ *  ③ 그래도 못 찾으면 예전대로 최신 .jsonl (틀릴 수 있다는 것을 아는 폴백).
  * user/assistant turn 만 추출(tool_result 노이즈 제외, tool_use 는 칩으로).
  */
 export async function getSessionChat(runId: number, maxTurns = 200): Promise<{
@@ -799,12 +947,35 @@ export async function getSessionChat(runId: number, maxTurns = 200): Promise<{
   const info = await getRunTermInfo(runId);
   const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, runId)).limit(1);
   const run = rr[0];
-  if (!info || !run || !run.worktreePath) return { ok: false, turns: [], note: 'no session' };
-  const proj = run.worktreePath.replace(/[^a-zA-Z0-9]/g, '-');
-  const cmd = `d=${shq(proj)}; f=$(ls -t "$HOME/.claude/projects/$d"/*.jsonl 2>/dev/null | head -1); [ -n "$f" ] && tail -n 8000 "$f" || true`;
-  const r = await runShellOn(info.machine, cmd, 15000);
-  if (!r.ok) return { ok: true, turns: [], note: 'no transcript' };
-  if (!r.stdout.trim()) return { ok: true, turns: [], note: 'no Claude Code transcript for this folder' };
+  if (!info || !run) return { ok: false, turns: [], note: 'no session' };
+  const pwd = (await getRunPwd(runId)).pwd;   // tmux #{pane_current_path} — 대본의 진짜 기준
+  const encoded = [pwd, run.worktreePath || '']
+    .filter((p) => !!p)
+    .map((p) => p.replace(/[^a-zA-Z0-9]/g, '-'));
+  const cands = encoded.filter((d, i) => encoded.indexOf(d) === i);
+  if (!cands.length) return { ok: false, turns: [], note: 'no session' };
+  // ① 태깅된 대본 — 이름을 미리 정해 뒀으면 추측할 것이 없다.
+  const tagged = CLAUDE_SID_RE.test(run.claudeSessionId) ? run.claudeSessionId : '';
+  let raw = tagged ? await readTranscriptBySid(info.machine, cands, tagged) : '';
+  // ② 태그가 (아직) 실물과 안 맞는 세션 — 화면에 뜬 말로 찾고, 찾았으면 적어 둬 다시 찾지 않는다.
+  if (!raw.trim()) {
+    const found = await matchTranscriptByPane(info.machine, info.session, cands, runId);
+    if (found) {
+      raw = await readTranscriptBySid(info.machine, cands, found);
+      if (raw.trim()) await setRun(runId, { claudeSessionId: found });
+    }
+  }
+  // ③ 폴백 — 이 폴더의 최신 .jsonl (페인 cwd 우선, worktree 폴백). 여러 세션이 한 폴더를 쓰면 남의 것일 수 있다.
+  if (!raw.trim()) {
+    const cmd = `f=''; for d in ${cands.map((d) => shq(d)).join(' ')}; do c=$(ls -t "$HOME/.claude/projects/$d"/*.jsonl 2>/dev/null | head -1); if [ -n "$c" ]; then f="$c"; break; fi; done; [ -n "$f" ] && tail -c ${CHAT_TAIL_BYTES} "$f" || true`;
+    const fb = await runShellOn(info.machine, cmd, 15000);
+    if (!fb.ok) return { ok: true, turns: [], note: 'no transcript' };
+    raw = fb.stdout;
+  }
+  if (!raw.trim()) return { ok: true, turns: [], note: 'no Claude Code transcript for this folder' };
   const userText = (content: unknown): string => {
     if (typeof content === 'string') return content;
     if (!Array.isArray(content)) return '';
@@ -823,7 +994,7 @@ export async function getSessionChat(runId: number, maxTurns = 200): Promise<{
     return { text: text.join('\n'), tools };
   };
   const turns: Array<{ role: string; text: string; tools?: string[] }> = [];
-  for (const line of r.stdout.split('\n')) {
+  for (const line of raw.split('\n')) {
     if (!line.trim()) continue;
     let j: { type?: string; message?: { content?: unknown } };
     try { j = JSON.parse(line); } catch { continue; }
@@ -840,16 +1011,25 @@ export async function getSessionChat(runId: number, maxTurns = 200): Promise<{
 /**
  * tmux 페인 스크롤백 스냅샷 — 모바일 "위 내용 읽기"(뷰어의 터미널 모드)용.
- * capture-pane -S -N 으로 N 줄 위부터 현재까지 텍스트를 통째로 반환(읽기 전용).
+ * capture-pane -S - 로 **히스토리 전체**(맨 처음 줄부터 현재 화면까지)를 떠서, 꼬리 N 줄만 돌려준다(읽기 전용).
+ * 예전엔 -S -N 이었는데, 세션이 tmux 기본 history-limit(2000) 으로 떠 있어 N 을 아무리 키워도 소용없었다
+ * → 세션 생성 때 한도를 올리고(tmuxNewSession), 여기선 범위를 잘라 묻지 않는다.
+ * -J 는 화면 폭에서 접힌 줄을 **논리적 한 줄로 도로 붙인다**. 이게 없으면 캡처가 디스플레이 행 그대로 와서
+ * 폰에서 긴 경로·명령어가 단어 중간에서 끊겼다("Internal Solutio / n %") — 읽기도 집기도 안 되던 원인.
+ * 한계 둘(버그 아님):
+ *  - 전체 화면 TUI(claude CLI·vim·less 등)는 tmux 의 **대체 화면**을 쓴다. 대체 화면엔 스크롤백이 없어서
+ *    TUI 가 떠 있는 동안 캡처되는 건 지금 보이는 화면뿐이다(뷰어 터미널 탭이 그렇게 말해 준다). 일반 셸 출력은 전부 남는다.
+ *  - 헤드리스 에이전트 run 은 tmux 밖에서 돈다 — 그 tmux 는 빈 worktree 셸이 정상이고, 볼 곳은 "대화" 탭이다.
  */
 export async function getScrollback(runId: number, lines: number): Promise<{ ok: boolean; text: string }> {
   const info = await getRunTermInfo(runId);
   if (!info) return { ok: false, text: 'no terminal session' };
-  const n = Math.max(50, Math.min(20000, Math.floor(lines) || 3000));
+  const n = Math.max(50, Math.min(TMUX_HISTORY_LIMIT, Math.floor(lines) || TMUX_HISTORY_LIMIT));
   // capture-pane 은 '=' 접두사(정확일치) 를 pane 타깃으로 못 받는다 → 세션명 그대로(존재 시 정확일치 우선).
-  const r = await runShellOn(info.machine, `tmux capture-pane -t ${shq(info.session)} -p -S -${n}`, 15000);
+  const r = await runShellOn(info.machine, `tmux capture-pane -t ${shq(info.session)} -p -J -S -`, 15000);
   if (!r.ok) return { ok: false, text: (r.stderr || r.stdout).trim().slice(0, 500) };
-  return { ok: true, text: r.stdout };
+  const all = r.stdout.split('\n');
+  return { ok: true, text: all.length > n ? all.slice(-n).join('\n') : r.stdout };
 }
 /**
@@ -882,7 +1062,7 @@ export async function sendRunInput(runId: number, text: string): Promise<{ ok: b
 export async function getRunPwd(runId: number): Promise<{ ok: boolean; pwd: string }> {
   const info = await getRunTermInfo(runId);
   if (!info) return { ok: false, pwd: '' };
-  const t = shq('=' + info.session);
+  const t = shq(info.session);
   const cmd = `tmux display -p -t ${t} '#{pane_current_path}' 2>/dev/null || tmux list-panes -s -t ${t} -F '#{pane_current_path}' 2>/dev/null | head -1`;
   const r = await runShellOn(info.machine, cmd, 8000);
   const pwd = ((r.stdout || '').split('\n')[0] || '').trim();
@@ -1226,9 +1406,10 @@ export async function openWorkbench(repoId: number, title: string, root = false)
   //            branch='' 로 남겨 merge 는 자동 거부(=이미 base). cleanup 도 worktree remove 를 건너뛴다.
   // root=false: 기존 workbench — 격리 worktree + 브랜치(수동 변경 후 Review 에서 merge).
   const agent = root ? 'session' : 'workbench';
+  const tag = sessionClaudeTag(machine);   // 이 작업방의 claude 대화 id(뷰어가 대본을 정확히 찾는 근거)
   const tIns = await db.insert(tasks).values({ repoId, title: title || (root ? 'Session' : 'Workbench'), prompt: root ? '(root session)' : '(interactive workbench)' }).returning();
   const task = tIns[0]!;
-  const rIns = await db.insert(agentRuns).values({ taskId: task.id, machineId: m.id, agent, status: 'pending' }).returning();
+  const rIns = await db.insert(agentRuns).values({ taskId: task.id, machineId: m.id, agent, status: 'pending', claudeSessionId: tag.sid }).returning();
   const run = rIns[0]!;
   const runId = run.id;
   broadcast({ type: 'run', runId, taskId: task.id, status: 'pending', agent, branch: '', filesChanged: 0 });
@@ -1240,15 +1421,16 @@ export async function openWorkbench(repoId: number, title: string, root = false)
   // export LANG: tmux 서버 첫 기동이 C 로케일이면 세션 셸의 CJK 입력·표시가 깨진다.
   // 동명 세션 잔재(DB 리셋 등으로 run id 재사용) 선제 정리 — '=' 정확 일치만.
-  const wbEnv = await secretEnvArgs();   // 시크릿 볼트 → env 주입
+  // 태깅 env 는 시크릿 뒤에 둔다 — 볼트에 PATH 가 들어 있어도 심이 앞을 잡아야 태깅이 산다.
+  const wbEnv = (await secretEnvArgs()) + tag.env;   // 시크릿 볼트 + claude 태깅 → env 주입
   const prep = await runShellOn(
     machine,
     root
       ? `export LANG=${shq(config.lang)}; { tmux kill-session -t ${shq('=' + session)} 2>/dev/null || true; }` +
-        ` && tmux new-session -d${wbEnv} -s ${shq(session)} -c ${shq(repo.path)}`
+        ` && ${tmuxNewSession(`-d${wbEnv} -s ${shq(session)} -c ${shq(repo.path)}`)}`
       : `export LANG=${shq(config.lang)}; mkdir -p ${shq(wtParent)} && git -C ${shq(repo.path)} worktree add -b ${shq(branch)} ${shq(wtPath)} ${shq(repo.defaultBranch)}` +
         ` && { tmux kill-session -t ${shq('=' + session)} 2>/dev/null || true; }` +
-        ` && tmux new-session -d${wbEnv} -s ${shq(session)} -c ${shq(wtPath)}`,
+        ` && ${tmuxNewSession(`-d${wbEnv} -s ${shq(session)} -c ${shq(wtPath)}`)}`,
     20000,
   );
   if (!prep.ok) {
@@ -1289,19 +1471,21 @@ export async function openSessionAt(machineSlug: string, path: string, title: st
   const bucket = await ensureSessionsRepo(m.id);
   const name = title || dir.split('/').filter(Boolean).pop() || dir;
+  const tag = sessionClaudeTag(machine);   // 이 세션의 claude 대화 id
   const tIns = await db.insert(tasks).values({ repoId: bucket.id, title: name, prompt: '(session)' }).returning();
   const task = tIns[0]!;
-  const rIns = await db.insert(agentRuns).values({ taskId: task.id, machineId: m.id, agent: 'session', status: 'pending' }).returning();
+  const rIns = await db.insert(agentRuns).values({ taskId: task.id, machineId: m.id, agent: 'session', status: 'pending', claudeSessionId: tag.sid }).returning();
   const run = rIns[0]!;
   const runId = run.id;
   broadcast({ type: 'run', runId, taskId: task.id, status: 'pending', agent: 'session', branch: '', filesChanged: 0 });
   const session = `coxpit-r${runId}`;
-  const sEnv = await secretEnvArgs();   // 시크릿 볼트 → env 주입
+  // 태깅 env 는 시크릿 뒤에(위 openWorkbench 와 같은 이유 — 심이 PATH 앞을 잡아야 한다).
+  const sEnv = (await secretEnvArgs()) + tag.env;   // 시크릿 볼트 + claude 태깅 → env 주입
   const prep = await runShellOn(
     machine,
     `export LANG=${shq(config.lang)}; { tmux kill-session -t ${shq('=' + session)} 2>/dev/null || true; }` +
-    ` && tmux new-session -d${sEnv} -s ${shq(session)} -c ${shq(dir)}`,
+    ` && ${tmuxNewSession(`-d${sEnv} -s ${shq(session)} -c ${shq(dir)}`)}`,
     15000,
   );
   if (!prep.ok) {

package/src/server.ts CHANGED Viewed

@@ -17,11 +17,12 @@ import {
 } from './authkey';
 import { config } from './config';
 import { readSettings, writeSettings } from './settings';
+import { readOpenTabs, writeOpenTabs, sanitizeOpenTabs } from './uistate';
 import { db } from './db';
 import { machines, repos, tasks, agentRuns, agentEvents, designCaptures, shareLinks, taskGroups, secrets } from './db/schema';
 import { BOOKMARKLET_JS } from './design';
 import { runShellOn, shq } from './exec';
-import { launchRun, cleanupRun, stopRun, getRunDiff, loadRunDocs, mergeRun, getRunTermInfo, steerRun, exportRun, prRun, integrateRuns, planFanout, reviewTask, syncRun, openWorkbench, spawnSubtasks, listSubtasks, resolveAgentToken, taskCloseRisk, launchGroupTask, isRunLive, liveInPlaceRun, askGroupCoordinator, computeRunOutputs, normalizeOutputs, listReclaimableWorktrees, pruneWorktrees, worktreeDisk, listOrphanTmux, killTmuxSessions, noopSignal, groupOverlap, landTarget, mergePreview, startLandResolve, listDocuments, verifyRun, verifyBase, openSessionAt, deleteSession, getScrollback, sendRunInput, getRunPwd, getSessionChat } from './orchestrator';
+import { launchRun, cleanupRun, stopRun, getRunDiff, loadRunDocs, mergeRun, getRunTermInfo, steerRun, exportRun, prRun, integrateRuns, planFanout, reviewTask, syncRun, openWorkbench, spawnSubtasks, listSubtasks, resolveAgentToken, taskCloseRisk, launchGroupTask, isRunLive, liveInPlaceRun, askGroupCoordinator, computeRunOutputs, normalizeOutputs, listReclaimableWorktrees, pruneWorktrees, worktreeDisk, listOrphanTmux, killTmuxSessions, noopSignal, groupOverlap, landTarget, mergePreview, startLandResolve, listDocuments, verifyRun, verifyBase, openSessionAt, deleteSession, getScrollback, sendRunInput, getRunPwd, getSessionChat, tmuxNewSession, claudeTagEnvForRun } from './orchestrator';
 import { openTerm } from './term';
 import { attach as agentAttach, feed as agentFeed, input as agentInput, onExit as agentExit, detach as agentDetach, allAgentStates, spottedPorts } from './agentstate';
 import { scanListeners, scanPort, killPid, dropCache as dropListenerCache } from './procscan';
@@ -254,13 +255,19 @@ export async function buildServer(): Promise<FastifyInstance> {
     };
   });
+  // 서빙되는 한 장짜리 페이지는 **절대 캐시하지 않는다**. 세 페이지 전부 HTML 안에 JS 가 들어 있어서,
+  // 브라우저·PWA 가 옛 문서를 물고 있으면 고친 코드가 기기에 아예 도착하지 않는다(폰에서 "고쳤는데
+  // 그대로"의 진짜 원인). 버전이 박힌 /vendor/*·/brand/* 정적 자산은 그대로 캐시한다 — 여기만 no-store.
+  const freshPage = (reply: FastifyReply): FastifyReply =>
+    reply.header('cache-control', 'no-store').header('pragma', 'no-cache');
   // 플릿 보드(단일 페이지). 인증 게이트 적용됨(무인증 요청은 게이트가 login/setup 페이지로 응답).
-  app.get('/', async (_req, reply) => reply.type('text/html').send(BOARD_HTML));
+  app.get('/', async (_req, reply) => freshPage(reply).type('text/html').send(BOARD_HTML));
   // 터미널 우선 셸(병행 개발) — 백엔드는 보드와 공유. Phase 5에서 데스크톱 기본을 여기로 플립 예정.
-  app.get('/cockpit', async (_req, reply) => reply.type('text/html').send(COCKPIT_PAGE));
+  app.get('/cockpit', async (_req, reply) => freshPage(reply).type('text/html').send(COCKPIT_PAGE));
   // HUD(v5.28 K) — 플릿을 작게 다시 내놓는 한 장. 데스크톱의 떠 있는 작은 창이 이걸 띄운다.
   // 서빙되는 **페이지**라 /cockpit 과 같은 게이트 뒤다(무인증 예외 아님 — 헬스가 아니다).
-  app.get('/hud', async (_req, reply) => reply.type('text/html').send(HUD_PAGE));
+  app.get('/hud', async (_req, reply) => freshPage(reply).type('text/html').send(HUD_PAGE));
   // ─── 접근키 인증(access-key) ────────────────────────────────────
   // 요청이 tunnel/https 를 탔나 — Secure 쿠키 여부 결정용.
@@ -503,6 +510,19 @@ export async function buildServer(): Promise<FastifyInstance> {
     return { ok: true };
   });
+  // ── 소유자 UI 상태 — 열어둔 탭 (ui-state.json) ───────────────────
+  // 탭 바를 **데몬**이 기억한다. 브라우저 저장소는 캐시 비우기·기기 교체·옛 페이지에 쉽게 날아가는데,
+  // 그동안 tmux 세션은 살아 있다 — 새로고침이 돌고 있는 일을 닫아버려선 안 된다.
+  app.get('/api/ui/opentabs', async () => readOpenTabs());
+  app.put('/api/ui/opentabs', async (req, reply) => {
+    try {
+      return { ok: true, ...writeOpenTabs(sanitizeOpenTabs(req.body)) };
+    } catch (e) {
+      // 디스크에 못 썼으면 조용히 성공한 척하지 않는다 — 클라이언트는 localStorage 사본으로 버틴다.
+      return reply.code(500).send({ error: `could not persist ui state: ${(e as Error).message}` });
+    }
+  });
   // 아카이브 — 닫힌 태스크 목록(최신순, 페이지네이션·필터). 카드가 아니라 한 줄 행.
   app.get('/api/archive', async (req) => {
     const q = (req.query ?? {}) as { offset?: string; limit?: string; q?: string; repo?: string; status?: string };
@@ -1302,7 +1322,7 @@ export async function buildServer(): Promise<FastifyInstance> {
     const q = (req.query ?? {}) as { lines?: string };
     const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, id)).limit(1);
     if (!rr[0]) return reply.code(404).send({ error: 'not found' });
-    const res = await getScrollback(id, Number(q.lines) || 3000);
+    const res = await getScrollback(id, Number(q.lines) || 0);   // lines 없으면 히스토리 전체
     if (!res.ok) return reply.code(422).send(res);
     return res;
   });
@@ -1905,8 +1925,10 @@ export async function buildServer(): Promise<FastifyInstance> {
     if (!has.ok) {
       const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, id)).limit(1);
       const wt = rr[0]?.worktreePath ?? '';
+      // 소생한 페인에서도 `claude` 가 이 세션의 대화로 묶이게 태깅 env 를 다시 얹는다(없으면 빈 문자열).
+      const tagEnv = claudeTagEnvForRun(info.machine, rr[0]?.claudeSessionId ?? '');
       const revive = wt
-        ? await runShellOn(info.machine, `export LANG=${shq(config.lang)}; test -d ${shq(wt)} && tmux new-session -d -s ${shq(info.session)} -c ${shq(wt)}`, 10000)
+        ? await runShellOn(info.machine, `export LANG=${shq(config.lang)}; test -d ${shq(wt)} && ${tmuxNewSession(`-d${tagEnv} -s ${shq(info.session)} -c ${shq(wt)}`)}`, 10000)
         : { ok: false } as { ok: boolean };
       if (!revive.ok) {
         socket.send(JSON.stringify({ t: 'err', d: `tmux session '${info.session}' gone and could not be revived (worktree missing?)` }));

package/src/uistate.ts ADDED Viewed

@@ -0,0 +1,65 @@
+import fs from 'node:fs';
+import { config } from './config';
+// 소유자 UI 상태 — 데이터 폴더(~/.coxpit)의 ui-state.json 한 장.
+// 왜 데몬이 기억하나: 열어둔 탭을 브라우저(localStorage)에만 두면 캐시를 비우거나, 기기를 바꾸거나,
+// 오래된 페이지가 떠 있기만 해도 통째로 사라진다 — tmux 세션은 멀쩡히 살아 있는데도.
+// 스키마를 늘리지 않는다: settings.json·auth.json 과 같은 자리의 작은 JSON 파일(선례 그대로).
+// 소유자 1인 도구라 사용자 구분은 없다.
+/** 탭 바에 열려 있던 run 탭 집합 + 마지막으로 보던 탭. */
+export interface OpenTabs {
+  ids: number[];
+  active: number | null;
+}
+export interface UiState {
+  openTabs?: OpenTabs;
+}
+/** 폰 DOM·복원 시간 보호 상한. 넘치면 **최근 것**을 남긴다. */
+export const MAX_OPEN_TABS = 24;
+function readUiState(): UiState {
+  try {
+    const raw = JSON.parse(fs.readFileSync(config.uiStatePath, 'utf8'));
+    return raw && typeof raw === 'object' ? (raw as UiState) : {};
+  } catch {
+    return {};   // 파일 없음·깨짐 = 빈 상태(기억해둔 게 없다)
+  }
+}
+/** 신뢰할 수 없는 입력(클라이언트 PUT·디스크 파일)을 정수 id 목록으로 정리한다. */
+export function sanitizeOpenTabs(raw: unknown): OpenTabs {
+  const o = (raw ?? {}) as { ids?: unknown; active?: unknown };
+  const ids: number[] = [];
+  if (Array.isArray(o.ids)) {
+    for (const v of o.ids) {
+      const n = Number(v);
+      if (Number.isInteger(n) && n > 0 && !ids.includes(n)) ids.push(n);
+    }
+  }
+  const a = Number(o.active);
+  return {
+    ids: ids.slice(-MAX_OPEN_TABS),
+    active: Number.isInteger(a) && a > 0 ? a : null,
+  };
+}
+/**
+ * `stored` = 데몬이 **한 번이라도** 탭 집합을 받아 적었는가.
+ * 빈 집합("전부 닫았다")과 미기록("아직 아무 말도 못 들었다")은 다르다 — 클라이언트는 후자일 때만
+ * 브라우저 사본을 씨앗으로 쓴다(1회 이관). 이 구분이 없으면 owner 가 닫은 탭이 되살아난다.
+ */
+export function readOpenTabs(): OpenTabs & { stored: boolean } {
+  const st = readUiState();
+  if (!st.openTabs) return { ids: [], active: null, stored: false };
+  return { ...sanitizeOpenTabs(st.openTabs), stored: true };
+}
+/** 부분 병합 저장 — 다른 UI 상태가 생겨도 이 쓰기가 덮지 않는다. */
+export function writeOpenTabs(next: OpenTabs): OpenTabs {
+  const clean = sanitizeOpenTabs(next);
+  const cur = readUiState();
+  fs.writeFileSync(config.uiStatePath, JSON.stringify({ ...cur, openTabs: clean }, null, 2) + '\n');
+  return clean;
+}