coxpit 5.27.6 → 6.0.0

package/src/db/index.ts

@@ -113,4 +113,6 @@ export async function ensureSchema(): Promise<void> {
   try { await client.execute("ALTER TABLE agent_runs ADD COLUMN verify_status TEXT NOT NULL DEFAULT ''"); } catch { /* exists */ }
   try { await client.execute("ALTER TABLE agent_runs ADD COLUMN verify_output TEXT NOT NULL DEFAULT ''"); } catch { /* exists */ }
   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 */ }
 }

package/src/db/schema.ts

@@ -82,8 +82,12 @@ export const agentRuns = sqliteTable('agent_runs', {
   taskId: integer('task_id').notNull(),
   machineId: integer('machine_id').notNull(),
   agent: text('agent').notNull().default('claude-code'),
+  title: text('title').notNull().default(''), // v6.0 — 작업 안에서의 역할 이름(예: 구현·기타). 빈값 = 프로바이더 이름/main 으로 표시
   worktreePath: text('worktree_path').notNull().default(''),
   branch: text('branch').notNull().default(''),
+  // v6.0 Part P — 격리 없이 repo 체크아웃에서 그대로 도는 에이전트(worktree·브랜치 없음).
+  // 결과물은 루트 세션 마커와 같다(worktree_path=repo.path, branch=''); 이 플래그는 "그렇게 띄워라"는 의도다.
+  inPlace: integer('in_place', { mode: 'boolean' }).notNull().default(false),
   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 키)

package/src/files.ts

@@ -28,6 +28,12 @@ function startDir(root: string): string {
   return (HOME === root || HOME.startsWith(root + '/')) ? HOME : root;
 }
 
+// 어떤 절대경로가 지금의 뷰어 루트 안인가 — 호출자가 "평소 파일 뷰어로 열면 되는지"를
+// 미리 물어보는 창구(v6.0 W2: WORK.md 는 ~/.coxpit 아래라 기본 루트(홈) 안이다).
+export function withinFilesRoot(p: string): boolean {
+  return withinRoot(presolve(p), currentRoot());
+}
+
 export type FileKind = 'md' | 'html' | 'pdf' | 'image' | 'text' | 'binary';
 
 const IMAGE_EXT = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg', '.bmp', '.ico', '.avif']);

package/src/orchestrator.ts

@@ -12,6 +12,7 @@ import { agentRuns, agentEvents, tasks, repos, machines, designCaptures, docSnap
 import { runShellOn, spawnShellOn, shq, type MachineTarget } from './exec';
 import { broadcast } from './hub';
 import { getProvider, type Provider } from './providers';
+import { workContextBlock, removeWorkDoc } from './workdoc';
 
 // ── 산출물 계약(deliverable contract) ─────────────────────────
 /** 산출물 타입 5종 — 태스크가 선언할 수 있는 계약 항목. */
@@ -223,6 +224,35 @@ export function isRunLive(runId: number): boolean {
   return liveChildren.has(runId) || adoptedRuns.has(runId);
 }
 
+/**
+ * 발사 창 — launchRun 이 착수했지만 아직 자식 프로세스가 안 생긴 구간.
+ * launchRun 의 첫 문장이라 요청 핸들러가 응답을 돌려주기 **전에** 동기적으로 들어간다.
+ * 메모리에만 있어 데몬이 죽으면 같이 사라진다(= 재시작 후 유령이 체크아웃을 물고 있는 일이 없다).
+ */
+const launching = new Set<number>();
+
+/**
+ * v6.0 P3 — 이 repo 체크아웃에서 지금 일하고 있는 in-place **에이전트** run 이 있으면 그 id.
+ * 한 체크아웃에 에이전트 둘은 서로의 편집을 덮어쓴다 → 발사 전에 이걸로 막는다(409).
+ *
+ * 살아있음 = 자식 보유/재-adopt(isRunLive) **또는** 발사 창(launching). 후자가 없으면
+ * 연달아 들어온 두 요청이 둘 다 통과한다 — launchRun 은 fire-and-forget 이라
+ * 두 번째 검사 시점엔 첫 run 의 자식이 아직 안 생겼기 때문.
+ * 손 터미널(agent='session'·'workbench')은 세지 않는다 — 사람이 자기 체크아웃에
+ * 터미널을 몇 개 열든 그건 사람의 선택이다(D3).
+ */
+export async function liveInPlaceRun(repoId: number): Promise<number | null> {
+  const repoTasks = await db.select({ id: tasks.id }).from(tasks).where(eq(tasks.repoId, repoId));
+  if (!repoTasks.length) return null;
+  const ids = repoTasks.map((t) => t.id);
+  const rs = (await db.select().from(agentRuns).where(inArray(agentRuns.taskId, ids)))
+    .filter((r) => r.inPlace && r.agent !== 'session' && r.agent !== 'workbench');
+  for (const r of rs) {
+    if (isRunLive(r.id) || launching.has(r.id)) return r.id;
+  }
+  return null;
+}
+
 /** 에이전트 프롬프트에 붙는 능력 고지 — 독립 하위작업을 병렬 서브런으로 뺄 수 있다.
  * 파일 기반: 기본 권한(claude acceptEdits · codex workspace-write)이 네트워크를 막아도
  * 파일 쓰기는 되므로, spawn 요청을 워크트리의 .coxpit/spawn.json 으로 받는다. */
@@ -362,6 +392,7 @@ function remoteKillScript(worktreePath: string): string {
 
 interface RunContext {
   runId: number;
+  taskId: number;
   machine: MachineTarget;
   machineId: number;
   repoId: number;
@@ -371,6 +402,7 @@ interface RunContext {
   real: boolean;
   agent: string;
   model: string;
+  inPlace: boolean;   // v6.0 P1 — 격리 worktree 없이 repo 체크아웃에서 그대로 돈다
 }
 
 async function loadContext(runId: number): Promise<RunContext | null> {
@@ -405,8 +437,15 @@ async function loadContext(runId: number): Promise<RunContext | null> {
   const declared = parseOutputs(task.outputs);
   if (declared.length) prompt += deliverablesNote(declared);
 
+  // v6.0 W3 — 작업의 공유 컨텍스트(WORK.md). 격리된 run 은 과거에서 갈라져 나오지만,
+  // 여기 적힌 결정은 이 작업 아래 모든 세션에 따라붙는다(파일 컨텍스트는 Part P 의 몫,
+  // 결정 컨텍스트는 이쪽 몫). 디자인 캡처·산출물 계약과 같은 시임이라 발사 경로 전부가 덮인다.
+  // ⚠️ 편집은 **다음 발사·steer** 부터 닿는다 — 돌고 있는 턴에 끼어드는 마법은 없다.
+  prompt += workContextBlock(task.id);
+
   return {
     runId,
+    taskId: task.id,
     machine: { slug: m.slug, kind: m.kind, address: m.address, sshUser: m.sshUser },
     machineId: m.id,
     repoId: repo.id,
@@ -416,6 +455,7 @@ async function loadContext(runId: number): Promise<RunContext | null> {
     real: config.agent.real,
     agent: run.agent,
     model: run.model,
+    inPlace: run.inPlace,
   };
 }
 
@@ -423,30 +463,41 @@ async function loadContext(runId: number): Promise<RunContext | null> {
  * 한 AgentRun 실행: worktree 생성 → tmux 창(best-effort) → 에이전트 spawn →
  * stdout 라인 파싱하며 이벤트 적재 → 종료 시 files_changed 집계 + status 전이.
  * fire-and-forget. 실패는 status='error' 로 봉인.
+ *
+ * v6.0 P1 — in-place run 은 1) 을 통째로 건너뛴다: worktree 도 브랜치도 만들지 않고
+ * repo 체크아웃(ctx.repoPath)에서 그대로 돈다. 남는 자국은 **루트 세션 마커 그대로**
+ * (branch='' · worktreePath=repo.path) 라 merge/PR/sync/cleanup 은 이미 있는 판정이
+ * 알아서 비껴간다 — 새 개념이 아니라 이미 있던 표식의 재사용이다.
  */
 export async function launchRun(runId: number, real?: boolean): Promise<void> {
+  // 발사 창 진입 — 이 한 줄은 호출 즉시(첫 await 전에) 실행되므로, 뒤이어 들어온
+  // in-place 요청이 아직 자식이 없는 이 run 을 "없는 것"으로 볼 수 없다(P3 가드).
+  launching.add(runId);
   const ctx = await loadContext(runId);
-  if (!ctx) return;
+  if (!ctx) { launching.delete(runId); return; }
   const useReal = real ?? ctx.real;
 
-  const branch = `coxpit/r${runId}`;
+  const inPlace = ctx.inPlace;
+  const branch = inPlace ? '' : `coxpit/r${runId}`;
   const wtParent = ppath.join(ppath.dirname(ctx.repoPath), '.coxpit-worktrees');
-  const wtPath = ppath.join(wtParent, `r${runId}`);
+  const wtPath = inPlace ? ctx.repoPath : ppath.join(wtParent, `r${runId}`);
   const session = `coxpit-r${runId}`;
 
   try {
     await setRun(runId, { status: 'preparing', branch, worktreePath: wtPath, tmuxWindow: session, startedAt: new Date() });
 
-    // 1) worktree 생성(격리 브랜치)
-    const prep = await runShellOn(
-      ctx.machine,
-      `mkdir -p ${shq(wtParent)} && git -C ${shq(ctx.repoPath)} worktree add -b ${shq(branch)} ${shq(wtPath)} ${shq(ctx.baseBranch)}`,
-      20000,
-    );
-    if (!prep.ok) {
-      await recordEvent(runId, 'error', (prep.stderr || prep.stdout).trim().slice(0, 500));
-      await setRun(runId, { status: 'error', endedAt: new Date(), exitSummary: 'worktree add failed' });
-      return;
+    // 1) worktree 생성(격리 브랜치) — in-place 는 건너뛴다(격리가 없는 것이 요점).
+    if (!inPlace) {
+      const prep = await runShellOn(
+        ctx.machine,
+        `mkdir -p ${shq(wtParent)} && git -C ${shq(ctx.repoPath)} worktree add -b ${shq(branch)} ${shq(wtPath)} ${shq(ctx.baseBranch)}`,
+        20000,
+      );
+      if (!prep.ok) {
+        await recordEvent(runId, 'error', (prep.stderr || prep.stdout).trim().slice(0, 500));
+        await setRun(runId, { status: 'error', endedAt: new Date(), exitSummary: 'worktree add failed' });
+        return;
+      }
     }
 
     // 2) tmux 창(사람이 attach 해 개입할 수 있게) — best-effort. 동명 잔재는 선제 정리('=' 정확 일치).
@@ -456,7 +507,7 @@ export async function launchRun(runId: number, real?: boolean): Promise<void> {
       `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);
 
     await setRun(runId, { status: 'running' });
-    await recordEvent(runId, 'meta', JSON.stringify({ branch, worktree: wtPath, real: useReal }));
+    await recordEvent(runId, 'meta', JSON.stringify({ branch, worktree: wtPath, real: useReal, ...(inPlace ? { inPlace: true } : {}) }));
 
     // 3) 에이전트 spawn(스트리밍)
     // 원격은 ssh 채널이 죽어도 프로세스가 남을 수 있어 pid 파일을 남긴다(stop 시 원격 kill).
@@ -490,6 +541,8 @@ export async function launchRun(runId: number, real?: boolean): Promise<void> {
   } catch (e) {
     await recordEvent(runId, 'error', String(e).slice(0, 500));
     await setRun(runId, { status: 'error', endedAt: new Date(), exitSummary: 'orchestrator error' });
+  } finally {
+    launching.delete(runId);   // 발사 창 해제 — 여기까지 오면 살아있음 판정은 liveChildren 이 이어받는다
   }
 }
 
@@ -645,9 +698,11 @@ export async function steerRun(runId: number, message: string, mode: 'work' | 'a
   await recordEvent(runId, mode === 'ask' ? 'ask' : 'steer', message.slice(0, 2000));
 
   // Ask 모드 — 세션에 질문만: 파일 수정 없이 답변만 하도록 래핑
-  const finalMessage = mode === 'ask'
+  // 뒤에 붙는 WORK CONTEXT(W3): 작업 중간에 steer 를 받는 에이전트도 그동안 적힌 결정을 본다.
+  // 여기서도 편집은 **이 steer 부터** 닿는다(이미 돌고 있던 턴은 건드리지 않는다).
+  const finalMessage = (mode === 'ask'
     ? `Question about your work in this session (do NOT modify any files, do NOT run write commands — answer concisely):\n${message}`
-    : message;
+    : message) + workContextBlock(ctx.taskId);
 
   const isRemote = ctx.machine.kind !== 'local' && ctx.machine.address !== '';
   const pidPrefix = isRemote ? `printf '%s' "$$" > .coxpit-agent.pid && ` : '';
@@ -1175,7 +1230,8 @@ export async function deleteSession(runId: number): Promise<{ ok: boolean; detai
   await db.delete(agentRuns).where(eq(agentRuns.id, runId));
   // 세션 task 는 run 과 1:1 — 남은 run 이 없으면 task 도 제거해 트리에서 사라지게.
   const siblings = await db.select().from(agentRuns).where(eq(agentRuns.taskId, run.taskId));
-  if (task && siblings.length === 0) await db.delete(tasks).where(eq(tasks.id, task.id));
+  // 작업이 사라지면 그 작업의 WORK.md 도 같이 사라진다(W1 — 정본은 task 수명에 매인다).
+  if (task && siblings.length === 0) { await db.delete(tasks).where(eq(tasks.id, task.id)); removeWorkDoc(task.id); }
   broadcast({ type: 'run', runId, deleted: true });   // 모든 콘솔이 재하이드레이트 → 행 제거
   return { ok: true, detail: 'session deleted (folder preserved)' };
 }
@@ -2087,3 +2143,78 @@ export async function pruneWorktrees(runIds?: number[]): Promise<{
 
   return { removed, count: removed.length };
 }
+
+// ── 고아 tmux 세션 수거(reaper) ─────────────────────────────────
+// run 을 지워도 tmux 세션은 남는다(데몬 재시작·DB 초기화·수동 삭제). 2026-09-17 에 손으로
+// 13개를 걷어낸 그 일을 제품의 동작으로 만든다. 규칙 셋만 지키면 안전하다:
+//   ① DB 에 **없는** run id 의 `coxpit-r<N>` 만 후보다(살아 있는 run 의 세션은 목록에 아예 안 든다)
+//   ② 페인이 빈 셸 이상을 돌리고 있으면 **표시만** 하고 절대 미리 고르지 않는다
+//   ③ 죽일 때도 '=' 정확 일치 — coxpit-r5 가 coxpit-r50 을 물면 안 된다(전에 물었다)
+
+/** tmux 이름에서 run id 를 읽는 유일한 형태. 숫자가 아니면 우리 것으로 치지 않는다. */
+const ORPHAN_SESSION_RE = /^coxpit-r(\d+)$/;
+/** "빈 셸" 로 볼 pane_current_command 들 — 이 밖이면 뭔가 돌고 있는 것으로 본다. */
+const IDLE_SHELLS = new Set(['sh', 'bash', 'zsh', 'fish', 'dash', 'ksh', 'csh', 'tcsh', 'login', '-sh', '-bash', '-zsh']);
+const LOCAL_MACHINE: MachineTarget = { slug: 'local', kind: 'local', address: '', sshUser: '' };
+
+export interface OrphanTmuxSession {
+  name: string;      // coxpit-r<N>
+  runId: number;     // 이름에서 읽은 id (DB 에는 없다 — 그래서 고아다)
+  command: string;   // 페인에서 지금 돌고 있는 것(빈 셸이면 셸 이름)
+  idle: boolean;     // 모든 페인이 빈 셸인가 = 미리 체크해도 되는가
+}
+
+/**
+ * 로컬 머신의 고아 tmux 세션 목록. `tmux list-panes -a` 한 번으로 세션별 페인 명령까지 읽고,
+ * DB 에 run 레코드가 있는 이름은 전부 빼고 돌려준다(= 살아 있는 세션은 절대 제안되지 않는다).
+ * tmux 서버가 안 떠 있으면 빈 배열.
+ */
+export async function listOrphanTmux(): Promise<OrphanTmuxSession[]> {
+  const r = await runShellOn(
+    LOCAL_MACHINE,
+    `tmux list-panes -a -F '#{session_name}\t#{pane_current_command}' 2>/dev/null || true`,
+    8000,
+  ).catch(() => ({ stdout: '' as string }));
+
+  const panes = new Map<string, string[]>();
+  for (const line of String(r.stdout || '').split('\n')) {
+    const [name, cmd] = line.split('\t');
+    if (!name || !ORPHAN_SESSION_RE.test(name)) continue;
+    const arr = panes.get(name) ?? [];
+    arr.push((cmd ?? '').trim());
+    panes.set(name, arr);
+  }
+  if (!panes.size) return [];
+
+  const known = new Set((await db.select().from(agentRuns)).map((x) => x.id));
+  const out: OrphanTmuxSession[] = [];
+  for (const [name, cmds] of panes) {
+    const runId = Number(ORPHAN_SESSION_RE.exec(name)![1]);
+    if (known.has(runId)) continue;            // 기록이 있는 run = 고아가 아니다
+    const busy = cmds.find((c) => c && !IDLE_SHELLS.has(c));
+    out.push({ name, runId, command: busy || cmds[0] || '', idle: !busy });
+  }
+  out.sort((a, b) => a.runId - b.runId);
+  return out;
+}
+
+/**
+ * 선택한 고아 세션 종료. 클라이언트가 보낸 이름을 믿지 않고 **지금 다시 고아 목록을 떠서**
+ * 그 안에 있는 것만 죽인다(그 사이 run 이 생겼거나 이름이 지어졌으면 건너뛴다).
+ * 타깃은 언제나 '=' 정확 일치.
+ */
+export async function killTmuxSessions(names: string[]): Promise<{
+  killed: string[]; skipped: Array<{ name: string; reason: string }>; count: number;
+}> {
+  const allowed = new Set((await listOrphanTmux()).map((o) => o.name));
+  const killed: string[] = [];
+  const skipped: Array<{ name: string; reason: string }> = [];
+  for (const raw of names) {
+    const name = String(raw).trim();
+    if (!allowed.has(name)) { skipped.push({ name, reason: 'not an orphan session (live run, or already gone)' }); continue; }
+    await runShellOn(LOCAL_MACHINE, `tmux kill-session -t ${shq('=' + name)} 2>/dev/null || true`, 8000)
+      .catch(() => { /* best-effort — 이미 사라졌을 수 있다 */ });
+    killed.push(name);
+  }
+  return { killed, skipped, count: killed.length };
+}

package/src/server.ts

@@ -13,6 +13,7 @@ import { loginPageHTML } from './login';
 import {
   authMode, authIsOpen, verifyKey, storeKey, clearStored, isExposedBind, signSession, SESSION_COOKIE,
   clientKey, rateCheck, rateFail, rateReset, setupAllowed,
+  captureKey, captureKeyIsFixed, rotateCaptureKey, verifyCaptureKey,
 } from './authkey';
 import { config } from './config';
 import { readSettings, writeSettings } from './settings';
@@ -20,14 +21,16 @@ 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, askGroupCoordinator, computeRunOutputs, normalizeOutputs, listReclaimableWorktrees, pruneWorktrees, noopSignal, groupOverlap, landTarget, mergePreview, startLandResolve, listDocuments, verifyRun, openSessionAt, deleteSession, getScrollback, 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, listOrphanTmux, killTmuxSessions, noopSignal, groupOverlap, landTarget, mergePreview, startLandResolve, listDocuments, verifyRun, openSessionAt, deleteSession, getScrollback, getSessionChat } from './orchestrator';
 import { openTerm } from './term';
+import { attach as agentAttach, feed as agentFeed, input as agentInput, onExit as agentExit, detach as agentDetach, allAgentStates } from './agentstate';
 import { addSink, removeSink, broadcast } from './hub';
 import { getProvider, listProviders } from './providers';
 import { remoteState, setServe, setFunnel } from './remote';
 import { BOARD_HTML } from './board';
 import { COCKPIT_HTML } from './cockpit';
-import { listDir as fsListDir, readForView as fsReadForView, readRaw as fsReadRaw, writeText as fsWriteText, findFiles as fsFindFiles, uploadFile as fsUploadFile } from './files';
+import { listDir as fsListDir, readForView as fsReadForView, readRaw as fsReadRaw, writeText as fsWriteText, findFiles as fsFindFiles, uploadFile as fsUploadFile, withinFilesRoot } from './files';
+import { ensureWorkDoc, readWorkDoc, writeWorkDoc, removeWorkDoc, workDocPath, workDocSize } from './workdoc';
 
 const require_ = createRequire(import.meta.url);
 
@@ -201,7 +204,14 @@ function ptyMax(): number | null {
 }
 
 export async function buildServer(): Promise<FastifyInstance> {
-  const app = Fastify({ logger: true });
+  // 로거: 쿼리스트링의 캡처 키(?k=…)가 데몬 로그에 평문으로 남지 않게 가린다(issue #13).
+  // (프록시/엣지 로그는 데몬이 못 막지만, 캡처 키는 저가치·회전가능이라 감수 가능.)
+  const app = Fastify({ logger: {
+    redact: {
+      paths: ['req.url'],
+      censor: (v: unknown) => (typeof v === 'string' ? v.replace(/([?&]k=)[^&]*/g, '$1REDACTED') : v),
+    },
+  } });
   // 살아있는 웹 터미널 수 — pty 압력 조기경보(/api/health)용. openTerm 성공 시 +1, 소켓 close 시 -1.
   // 누수가 재발하면 이 값이 실제 열린 탭보다 커지지 않아도(닫을 때 감소), machine-wide ptmx 대비
   // 이 데몬의 부하를 노출한다. leak 재발 자체는 회귀 테스트(test/pty-fd.mjs)가 잡는다.
@@ -368,6 +378,9 @@ export async function buildServer(): Promise<FastifyInstance> {
         return { ...r, events: (byRun.get(r.id) ?? []).slice(-EVENT_CAP), noop: sig.noop, noopReason: sig.reason };
       }),
       counts: { activeTasks: activeTasks.length, closedTasks: closedCount },
+      // 지금 터미널이 붙어 있는 run 의 에이전트 상태(runId → {state,detail,ts}).
+      // 하이드레이션용 — 새로 뜬 코크핏이 다음 agentstate 델타를 기다리지 않게. 붙어 있는 동안만 존재한다.
+      agentStates: allAgentStates(),
       // 보드 헤더 "어느 데몬에 붙어 있나" 표시용 (인증 뒤라 dbPath 노출 가능)
       // authOpen = 비밀번호 미설정 → Funnel(공개) 가드가 켜져야 함(원격접근 카드용)
       daemon: {
@@ -503,6 +516,17 @@ export async function buildServer(): Promise<FastifyInstance> {
     return pruneWorktrees(runIds);
   });
 
+  // v6.0 T6 — 고아 tmux 세션(위 worktree 회수와 같은 유지보수 가족). DB 에 run 기록이 없는 `coxpit-r*` 만 목록에 든다.
+  // 살아 있는 run 의 세션은 애초에 나오지 않고, 빈 셸이 아닌 것은 idle:false 로 표시만 된다.
+  app.get('/api/tmux/orphans', async () => ({ sessions: await listOrphanTmux() }));
+
+  // 선택 종료 — 이름 배열만 받는다. 서버가 고아 목록을 다시 떠서 그 안의 것만, '=' 정확 일치로 죽인다.
+  app.post('/api/tmux/orphans/kill', async (req, reply) => {
+    const b = (req.body ?? {}) as { sessions?: unknown };
+    if (!Array.isArray(b.sessions)) return reply.code(400).send({ error: 'sessions must be an array of session names' });
+    return killTmuxSessions(b.sessions.map((s) => String(s)));
+  });
+
   // ─── 머신 레지스트리 ────────────────────────────────────────────
   app.get('/api/machines', async () => ({ machines: await db.select().from(machines) }));
 
@@ -822,14 +846,13 @@ export async function buildServer(): Promise<FastifyInstance> {
   });
 
   // ─── Design Mode ───────────────────────────────────────────────
-  // 캡처 키: 인증 off 면 자유, on 이면 ?k=<COXPIT_AUTH_PASS> (북마클릿은 basic 헤더 불가)
+  // 캡처 키 = 마스터 접근키와 분리된 저가치 전용 키(issue #13). 오직 이 캡처 엔드포인트만 허가한다.
+  // 인증 꺼짐이면 자유, 아니면 ?k=<capture key> 를 검증(마스터 접근키가 아니라 캡처 키로).
+  // setup(마스터 키 미설정) 상태여도 캡처 키는 독립적으로 존재하므로 캡처는 동작한다.
   const captureKeyOk = (req: { query?: unknown }): boolean => {
-    const m = authMode();
-    // 인증 꺼짐 → 자유. 아직 키 미설정(setup) → 캡처 불가(키가 없으니 증명 수단 없음).
-    if (m.mode === 'disabled') return true;
-    if (m.mode === 'setup') return false;
+    if (authMode().mode === 'disabled') return true;
     const k = ((req.query ?? {}) as { k?: string }).k ?? '';
-    return verifyKey(k, m);
+    return verifyCaptureKey(k);
   };
   const cors = (reply: { header: (k: string, v: string) => unknown }) => {
     reply.header('access-control-allow-origin', '*');
@@ -856,6 +879,11 @@ export async function buildServer(): Promise<FastifyInstance> {
 
   app.get('/api/design', async () => ({ captures: await db.select().from(designCaptures) }));
 
+  // 캡처 키 조회/회전 — 인증 게이트 뒤(EXEMPT 아님)라 인증된 보드 사용자만 접근한다.
+  // 보드가 이걸로 북마클릿 href(?k=…)를 만들고, 회전 버튼으로 새 키를 발급한다.
+  app.get('/api/design/capture-key', async () => ({ key: captureKey(), fixed: captureKeyIsFixed() }));
+  app.post('/api/design/capture-key/rotate', async () => ({ key: rotateCaptureKey(), fixed: captureKeyIsFixed() }));
+
   app.delete('/api/design/:id', async (req, reply) => {
     const id = Number((req.params as { id: string }).id);
     await db.delete(designCaptures).where(eq(designCaptures.id, id));
@@ -925,24 +953,100 @@ export async function buildServer(): Promise<FastifyInstance> {
     return { task: tr[0], runs };
   });
 
-  // 태스크 이름 변경(=세션 이름 변경). title 만 갱신.
+  // 태스크 이름 변경(=세션 이름 변경) + v6.0 S2 승격(repoId 재부모화).
+  // 둘 다 선택 — title 만 보내던 기존 호출은 그대로 동작한다. repoId 는 "이 작업이 어느
+  // 프로젝트 것인가"만 바꾼다: run 의 worktreePath 는 손대지 않으므로 터미널은 제 폴더에서 계속 돈다.
   app.patch('/api/tasks/:id', async (req, reply) => {
     const id = Number((req.params as { id: string }).id);
-    const b = (req.body ?? {}) as { title?: string };
+    const b = (req.body ?? {}) as { title?: string; repoId?: unknown };
+    const wantTitle = b.title !== undefined;
+    const wantRepo = b.repoId !== undefined && b.repoId !== null;
+    if (!wantTitle && !wantRepo) return reply.code(400).send({ error: 'title or repoId required' });
+
     const title = (b.title ?? '').trim();
-    if (!title) return reply.code(400).send({ error: 'title required' });
-    if (title.length > 140) return reply.code(400).send({ error: 'title too long (max 140)' });
+    if (wantTitle) {
+      if (!title) return reply.code(400).send({ error: 'title required' });
+      if (title.length > 140) return reply.code(400).send({ error: 'title too long (max 140)' });
+    }
     const tr = await db.select().from(tasks).where(eq(tasks.id, id)).limit(1);
-    if (!tr[0]) return reply.code(404).send({ error: 'not found' });
-    await db.update(tasks).set({ title }).where(eq(tasks.id, id));
-    broadcast({ type: 'task', taskId: id, title });
-    return { ok: true, title };
+    const task = tr[0];
+    if (!task) return reply.code(404).send({ error: 'not found' });
+
+    let repoId: number | undefined;
+    if (wantRepo) {
+      const wanted = Number(b.repoId);
+      if (!Number.isInteger(wanted)) return reply.code(400).send({ error: 'repoId must be an integer' });
+      const rr = await db.select().from(repos).where(eq(repos.id, wanted)).limit(1);
+      const repo = rr[0];
+      if (!repo) return reply.code(404).send({ error: 'repo not found' });
+      // 승격은 한 방향이다 — 프로젝트로 나가는 길만 있고, Scratch 버킷으로 밀어 넣는 길은 없다.
+      if (repo.kind === 'sessions') {
+        return reply.code(400).send({
+          error: 'cannot re-parent into the scratch bucket',
+          code: 'SCRATCH_BUCKET',
+          detail: 'the sessions bucket is not a project — pick a registered repo',
+        });
+      }
+      repoId = repo.id;
+    }
+    const patch: { title?: string; repoId?: number } = {};
+    if (wantTitle) patch.title = title;
+    if (repoId !== undefined) patch.repoId = repoId;
+    await db.update(tasks).set(patch).where(eq(tasks.id, id));
+    const outTitle = wantTitle ? title : task.title;
+    const outRepo = repoId ?? task.repoId;
+    broadcast({ type: 'task', taskId: id, title: outTitle, repoId: outRepo });
+    return { ok: true, title: outTitle, repoId: outRepo };
+  });
+
+  // ─── v6.0 Part W — WORK.md (작업의 공유 컨텍스트) ───────────────
+  // 정본은 데몬 데이터 디렉터리(~/.coxpit/work/<taskId>.md)에 산다 — git 트리 밖이라
+  // 어떤 worktree 의 diff 에도 뜨지 않고 브랜치가 갈려도 내용이 갈라지지 않는다.
+  // 읽기·쓰기는 **기존 파일 뷰어**(/api/fs/read·write)가 그대로 맡는 것이 기본이다:
+  // ~/.coxpit 은 기본 뷰어 루트(홈) 안이라 이미 통과한다(새 파일 창구를 만들지 않는다).
+  // 여기 셋은 그 앞뒤만 맡는다 — ① 처음 열 때 빈 파일을 만들어 주고(POST),
+  // ② COXPIT_DB/COXPIT_FILES_ROOT 조합 때문에 그 길이 막힌 경우의 대체 경로(GET/PUT).
+  const WORK_DOC_MAX = 512 * 1024;
+  const workTask = async (id: number) => (await db.select().from(tasks).where(eq(tasks.id, id)).limit(1))[0];
+
+  app.post('/api/tasks/:id/work', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    if (!(await workTask(id))) return reply.code(404).send({ error: 'task not found' });
+    try {
+      const path = ensureWorkDoc(id);
+      // inRoot=true 면 클라이언트는 평소 쓰던 파일 뷰어 페인으로 그냥 연다.
+      return { ok: true, path, inRoot: withinFilesRoot(path), size: workDocSize(id) };
+    } catch (e: any) { return reply.code(500).send({ error: String(e?.message || e) }); }
+  });
+
+  app.get('/api/tasks/:id/work', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    if (!(await workTask(id))) return reply.code(404).send({ error: 'task not found' });
+    const path = workDocPath(id);
+    const text = readWorkDoc(id);
+    // 뷰어가 /api/fs/read 에서 받던 모양 그대로 — 같은 렌더러가 손 안 대고 붙는다.
+    return { path, name: 'WORK.md', kind: 'md', size: Buffer.byteLength(text, 'utf8'), editable: true, text };
+  });
+
+  app.put('/api/tasks/:id/work', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    const b = (req.body ?? {}) as { content?: string };
+    if (typeof b.content !== 'string') return reply.code(400).send({ error: 'content required' });
+    if (Buffer.byteLength(b.content, 'utf8') > WORK_DOC_MAX) return reply.code(400).send({ error: 'content exceeds edit cap (512KB)' });
+    if (!(await workTask(id))) return reply.code(404).send({ error: 'task not found' });
+    try {
+      const { path, size } = writeWorkDoc(id, b.content);
+      return { ok: true, path, name: 'WORK.md', size };
+    } catch (e: any) { return reply.code(500).send({ error: String(e?.message || e) }); }
   });
 
+  // 역할 이름(run.title) 상한 — 탭 한 칸에 들어가는 길이. 작업 이름(140)보다 짧게 둔다.
+  const RUN_TITLE_MAX = 60;
+
   // N개의 에이전트 run 을 만들고 각자 오케스트레이션 시작(fire-and-forget).
   app.post('/api/tasks/:id/run', async (req, reply) => {
     const id = Number((req.params as { id: string }).id);
-    const b = (req.body ?? {}) as { agent?: string; count?: number; real?: boolean; model?: string };
+    const b = (req.body ?? {}) as { agent?: string; count?: number; real?: boolean; model?: string; title?: string; inPlace?: boolean };
     const tr = await db.select().from(tasks).where(eq(tasks.id, id)).limit(1);
     const task = tr[0];
     if (!task) return reply.code(404).send({ error: 'task not found' });
@@ -957,16 +1061,36 @@ export async function buildServer(): Promise<FastifyInstance> {
     if (model && (model.length > 64 || !/^[\w.\-:/]*$/.test(model))) {
       return reply.code(400).send({ error: 'invalid model name' });
     }
+    // v6.0 T4 — 역할 이름(선택). 작업 안에서 이 run 이 무엇인지(구현·기타). 빈값 = 프로바이더 이름으로 표시.
+    const title = (b.title ?? '').trim().slice(0, RUN_TITLE_MAX);
+    // v6.0 P — 격리는 선택이다. in-place = repo 체크아웃 공유(순차) · worktree = 병렬(나중에 머지).
+    const inPlace = b.inPlace === true;
+    if (inPlace && count > 1) {
+      return reply.code(400).send({
+        error: 'IN_PLACE_FANOUT',
+        detail: 'in-place is sequential — one agent per checkout (count must be 1). launch in a worktree to fan out.',
+      });
+    }
+    // P3 — 한 체크아웃에 에이전트 둘은 서로를 덮어쓴다. 만들기 **전에** 막고 이유를 말한다.
+    if (inPlace) {
+      const busy = await liveInPlaceRun(task.repoId);
+      if (busy !== null) {
+        return reply.code(409).send({
+          error: 'IN_PLACE_BUSY',
+          detail: `r${busy} is already working in this checkout — steer it, or launch in a worktree`,
+        });
+      }
+    }
     const created: Array<typeof agentRuns.$inferSelect> = [];
     for (let i = 0; i < count; i++) {
       const ins = await db.insert(agentRuns)
-        .values({ taskId: id, machineId: rp[0].machineId, agent, model, status: 'pending' })
+        .values({ taskId: id, machineId: rp[0].machineId, agent, model, title, inPlace, status: 'pending' })
         .returning();
       created.push(ins[0]!);
     }
     // 보드가 taskId 를 알도록 생성 브로드캐스트 후 백그라운드 시작.
     for (const r of created) {
-      broadcast({ type: 'run', runId: r.id, taskId: id, status: 'pending', agent, branch: '', filesChanged: 0 });
+      broadcast({ type: 'run', runId: r.id, taskId: id, status: 'pending', agent, title, inPlace, branch: '', filesChanged: 0 });
       void launchRun(r.id, b.real);
     }
     return reply.code(202).send({ ok: true, runs: created.map((r) => ({ id: r.id, status: r.status })) });
@@ -1021,6 +1145,8 @@ export async function buildServer(): Promise<FastifyInstance> {
     for (const r of trs) cleanups.push({ runId: r.id, ...(await cleanupRun(r.id)) });
 
     await db.update(tasks).set({ status: 'closed', closedAt: new Date() }).where(eq(tasks.id, id));
+    // 작업이 닫히면 그 작업의 WORK.md 도 같이 사라진다(W1) — 공유 컨텍스트는 작업의 수명을 산다.
+    removeWorkDoc(id);
     broadcast({ type: 'task', taskId: id, status: 'closed' });
     return { ok: true, taskId: id, cleanups };
   });
@@ -1034,6 +1160,22 @@ export async function buildServer(): Promise<FastifyInstance> {
     return { run: rr[0], events };
   });
 
+  // v6.0 T4 — run 의 역할 이름 변경(탭 더블클릭). title 만 받는다.
+  // (세션 버킷 run 은 지금까지처럼 태스크 이름을 바꾼다 — 클라이언트가 갈라 부른다.)
+  app.patch('/api/runs/:id', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    const b = (req.body ?? {}) as { title?: unknown };
+    const title = typeof b.title === 'string' ? b.title.trim() : '';
+    if (!title) return reply.code(400).send({ error: 'title required' });
+    if (title.length > RUN_TITLE_MAX) return reply.code(400).send({ error: `title too long (max ${RUN_TITLE_MAX})` });
+    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' });
+    await db.update(agentRuns).set({ title }).where(eq(agentRuns.id, id));
+    // status 를 싣지 않는다 — 이름 변경은 정착 이벤트가 아니다(보드의 settle 알림을 깨우지 않게).
+    broadcast({ type: 'run', runId: id, taskId: rr[0].taskId, title });
+    return { ok: true, title };
+  });
+
   app.post('/api/runs/:id/cleanup', async (req, reply) => {
     const id = Number((req.params as { id: string }).id);
     const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, id)).limit(1);
@@ -1643,10 +1785,12 @@ export async function buildServer(): Promise<FastifyInstance> {
       return;
     }
     liveTerminals++;   // pty 압력 지표(/api/health) — close 에서 정확히 1회 감소
+    agentAttach(id);   // 에이전트 상태 추적 시작(refcount — 같은 run 에 여러 클라이언트가 붙어도 tracker 는 하나)
     let closed = false;
     // 백프레셔 — WS 송신 버퍼가 차면 pty 를 잠시 멈춰 폭주 방지
     let paused = false;
     term.onData((d) => {
+      agentFeed(id, d);
       try {
         socket.send(JSON.stringify({ t: 'o', d }));
         if (!paused && socket.bufferedAmount > 800_000) { paused = true; try { term.pause(); } catch { /* n/a */ } }
@@ -1657,16 +1801,16 @@ export async function buildServer(): Promise<FastifyInstance> {
     }, 200);
     const keepalive = setInterval(() => { try { socket.ping(); } catch { /* closed */ } }, 30_000);
 
-    term.onExit(() => { try { socket.send(JSON.stringify({ t: 'exit' })); socket.close(); } catch { /* closed */ } });
+    term.onExit(() => { agentExit(id); try { socket.send(JSON.stringify({ t: 'exit' })); socket.close(); } catch { /* closed */ } });
     socket.on('message', (raw: Buffer) => {
       try {
         const m = JSON.parse(raw.toString()) as { t?: string; d?: string; cols?: number; rows?: number };
-        if (m.t === 'i' && typeof m.d === 'string') term.write(m.d);
+        if (m.t === 'i' && typeof m.d === 'string') { agentInput(id); term.write(m.d); }
         else if (m.t === 'r' && m.cols && m.rows) term.resize(Math.max(20, Math.min(500, m.cols)), Math.max(5, Math.min(200, m.rows)));
       } catch { /* ignore */ }
     });
     socket.on('close', () => {
-      if (!closed) { closed = true; liveTerminals = Math.max(0, liveTerminals - 1); }
+      if (!closed) { closed = true; liveTerminals = Math.max(0, liveTerminals - 1); agentDetach(id); }
       clearInterval(drain); clearInterval(keepalive);
       try { term.kill(); } catch { /* gone */ }
     });