coxpit 6.2.0 → 6.3.2

package/src/orchestrator.ts

@@ -5,7 +5,7 @@ import { existsSync, statSync, openSync, readSync, closeSync, mkdirSync } from '
 import { mkdir, copyFile, readFile, writeFile, rm, unlink } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import type { ChildProcess } from 'node:child_process';
-import { eq, inArray, and } from 'drizzle-orm';
+import { eq, inArray, and, desc } from 'drizzle-orm';
 import { config } from './config';
 import { db } from './db';
 import { agentRuns, agentEvents, tasks, repos, machines, designCaptures, docSnapshots, taskGroups, secrets } from './db/schema';
@@ -104,8 +104,17 @@ async function recordEvent(runId: number, kind: string, payload: string): Promis
   broadcast({ type: 'event', runId, kind, payload });
 }
 
+/**
+ * run 레코드가 움직인 횟수. 오케스트레이션 워처(1.5초 간격)가 "다시 읽을 일이 생겼나"를
+ * 쿼리 없이 O(1) 로 판단하는 데 쓴다. setRun 은 run 의 수명 전환에서만 불린다(줄당이 아니다)
+ * — 그래서 이 카운터는 드물게 움직이고, 조용한 틱은 DB 를 아예 건드리지 않는다.
+ * 부모별로 좁히지 않고 하나로 두는 건 의도다: 넘치게 칠해 한 번 더 읽는 쪽이 놓치는 쪽보다 낫다.
+ */
+let runRev = 0;
+
 async function setRun(runId: number, patch: Partial<typeof agentRuns.$inferInsert>): Promise<void> {
   await db.update(agentRuns).set(patch).where(eq(agentRuns.id, runId));
+  runRev++;
   broadcast({ type: 'run', runId, ...patch });
 }
 
@@ -277,14 +286,17 @@ export function startOrchWatch(runId: number, wtPath: string, real: boolean): No
   const dir = ppath.join(wtPath, '.coxpit');
   let last = '';
   let busy = false;
+  let seenRev = -1; // 현황을 마지막으로 읽은 시점의 runRev. -1 = 아직 한 번도 안 읽음(첫 틱은 읽는다)
   return setInterval(() => {
     if (busy) return;
     busy = true;
     void (async () => {
+      let consumed = false;
       try {
         const spawnPath = ppath.join(dir, 'spawn.json');
         const txt = await readFile(spawnPath, 'utf8').catch(() => null);
         if (txt !== null) {
+          consumed = true;
           await rm(spawnPath).catch(() => { /* consumed */ });
           try {
             const req = JSON.parse(txt) as unknown;
@@ -298,14 +310,22 @@ export function startOrchWatch(runId: number, wtPath: string, real: boolean): No
             await recordEvent(runId, 'error', 'spawn.json was not valid JSON — nothing spawned');
           }
         }
-        // 현황 파일 — 내용이 바뀔 때만 다시 쓴다
-        const subs = await listSubtasks(runId);
-        if (subs.length) {
-          const j = JSON.stringify(subs, null, 2);
-          if (j !== last) {
-            last = j;
-            await mkdir(dir, { recursive: true });
-            await writeFile(ppath.join(dir, 'subtasks.json'), j);
+        // 현황 파일 — **이번 틱에 뭔가 실제로 벌어졌을 때만** 읽고 쓴다.
+        // 조건 둘: spawn.json 을 소비했거나(위), run 레코드가 움직였거나(runRev).
+        // 조용한 틱(대부분)에는 쿼리조차 돌지 않는다 — 1.5초마다 도는 워처라 이 절약이
+        // run 이 사는 동안 계속 쌓인다. rev 를 **읽기 전에 떠 두고 성공 후에 저장**하는 건 의도다:
+        // 실패하면 여전히 더러운 상태로 남아 다음 틱에 재시도되고, 읽는 동안 생긴 변화도 안 놓친다.
+        const rev = runRev;
+        if (consumed || rev !== seenRev) {
+          const subs = await listSubtasks(runId);
+          seenRev = rev;
+          if (subs.length) {
+            const j = JSON.stringify(subs, null, 2);
+            if (j !== last) {
+              last = j;
+              await mkdir(dir, { recursive: true });
+              await writeFile(ppath.join(dir, 'subtasks.json'), j);
+            }
           }
         }
       } catch { /* 워처 오류는 조용히 — 다음 틱에 재시도 */ }
@@ -344,13 +364,15 @@ export async function spawnSubtasks(parentRunId: number, title: string, prompt:
   const runIds: number[] = [];
   for (let i = 0; i < n; i++) {
     const rIns = await db.insert(agentRuns).values({
-      taskId: task.id, machineId: pr.machineId, agent: pr.agent, model: pr.model, status: 'pending',
+      taskId: task.id, machineId: pr.machineId, agent: pr.agent, model: pr.model, status: 'pending', real,
     }).returning();
     const run = rIns[0]!;
-    broadcast({ type: 'run', runId: run.id, taskId: task.id, status: 'pending', agent: run.agent, branch: '', filesChanged: 0 });
+    broadcast({ type: 'run', runId: run.id, taskId: task.id, status: 'pending', agent: run.agent, real, branch: '', filesChanged: 0 });
     void launchRun(run.id, real);
     runIds.push(run.id);
   }
+  // 새 자식이 생겼다 — 부모 워처가 다음 틱에 현황을 다시 읽도록 표시한다(HTTP 쌍둥이 경로 포함).
+  runRev++;
   await recordEvent(parentRunId, 'meta', JSON.stringify({ subtask: task.id, title: task.title, runs: runIds }));
   return { ok: true, detail: `spawned task #${task.id} (${runIds.length} run(s))`, taskId: task.id, runIds };
 }
@@ -484,7 +506,9 @@ export async function launchRun(runId: number, real?: boolean): Promise<void> {
   const session = `coxpit-r${runId}`;
 
   try {
-    await setRun(runId, { status: 'preparing', branch, worktreePath: wtPath, tmuxWindow: session, startedAt: new Date() });
+    // real 은 여기서 각인한다 — 명령을 고르는 그 값이 곧 run 의 사실이다(v5.28 H1).
+    // 'preparing' 에 실어 두면 worktree 단계에서 넘어져도 "이 run 은 모의였다"가 남는다.
+    await setRun(runId, { status: 'preparing', real: !!useReal, branch, worktreePath: wtPath, tmuxWindow: session, startedAt: new Date() });
 
     // 1) worktree 생성(격리 브랜치) — in-place 는 건너뛴다(격리가 없는 것이 요점).
     if (!inPlace) {
@@ -607,6 +631,17 @@ async function runAgentChild(runId: number, machine: MachineTarget, wtPath: stri
   void notifySettle(runId, status, filesChanged, exitSummary);
 }
 
+/**
+ * verify 러너 — 명령 한 번, 꼬리 한 줌. 어디서 돌리든 판정 규칙은 하나여야 해서
+ * verifyRun(run 의 worktree)·verifyBase(머지된 base)가 이 함수를 같이 쓴다.
+ */
+async function runVerifyCmd(cmd: string, cwd: string, machine: MachineTarget): Promise<{ status: string; output: string }> {
+  const r = await runShellOn(machine, `cd ${shq(cwd)} && ( ${cmd} )`, 180000);
+  const merged = [r.stdout, r.stderr].filter(Boolean).join('\n').trim();
+  const output = merged.length > 6000 ? '…' + merged.slice(-6000) : merged;
+  return { status: r.ok ? 'pass' : r.code === -1 ? 'error' : 'fail', output };
+}
+
 /**
  * Verify in-loop — repo.verifyCmd 를 run 의 worktree 에서 실행해 pass/fail 을 기록.
  * verifyCmd 미설정이면 상태를 비우고 no-op. 정착 훅이 자동 호출(done+변경), 수동 재검증도 지원.
@@ -626,12 +661,34 @@ export async function verifyRun(runId: number): Promise<{ ok: boolean; status: s
     return { ok: false, status: 'error', detail: 'worktree missing' };
   }
   await setRun(runId, { verifyStatus: 'running', verifyOutput: '' });
-  const r = await runShellOn(ctx.machine, `cd ${shq(run.worktreePath)} && ( ${cmd} )`, 180000);
-  const merged = [r.stdout, r.stderr].filter(Boolean).join('\n').trim();
-  const tail = merged.length > 6000 ? '…' + merged.slice(-6000) : merged;
-  const status = r.ok ? 'pass' : r.code === -1 ? 'error' : 'fail';
-  await setRun(runId, { verifyStatus: status, verifyOutput: tail });
-  return { ok: true, status };
+  const v = await runVerifyCmd(cmd, run.worktreePath, ctx.machine);
+  await setRun(runId, { verifyStatus: v.status, verifyOutput: v.output });
+  return { ok: true, status: v.status };
+}
+
+/**
+ * 머지된 base 검증(v5.28 J1) — repo.verifyCmd 를 **repo.path**(머지가 막 내려앉은 기본 브랜치)에서
+ * 돌린다. 승자가 내려앉은 그 호흡에 같은 명령을 돌려 pass/fail 을 그 자리에서 말하기 위한 것이라,
+ * 지나간 worktree 가 아니라 base 를 본다.
+ * - verifyCmd 가 비어 있으면 아무 명령도 추측하지 않고 no-op(status '').
+ * - best-effort — 실패는 보고일 뿐, 머지를 되돌리지 않는다.
+ */
+export async function verifyBase(repoId: number): Promise<{ status: string; output: string }> {
+  const none = { status: '', output: '' };
+  const rp = await db.select().from(repos).where(eq(repos.id, repoId)).limit(1);
+  const repo = rp[0];
+  if (!repo) return none;
+  const cmd = (repo.verifyCmd ?? '').trim();
+  if (!cmd) return none;
+  const mr = await db.select().from(machines).where(eq(machines.id, repo.machineId)).limit(1);
+  const m = mr[0];
+  if (!m) return none;
+  const machine: MachineTarget = { slug: m.slug, kind: m.kind, address: m.address, sshUser: m.sshUser };
+  try {
+    return await runVerifyCmd(cmd, repo.path, machine);
+  } catch (e) {
+    return { status: 'error', output: String(e).slice(0, 300) };
+  }
 }
 
 /**
@@ -795,6 +852,25 @@ export async function getScrollback(runId: number, lines: number): Promise<{ ok:
   return { ok: true, text: r.stdout };
 }
 
+/**
+ * 살아 있는 tmux 페인에 한 줄 써 넣기 (v5.28 K) — getScrollback 의 **쓰기 쌍둥이**.
+ * HUD 가 코크핏을 열지 않고 "대기 중인 에이전트"에게 답하는 유일한 길이다(steer 는 정착한 run 전용).
+ * 타깃 규율은 capture-pane 과 똑같이 맞춘다: send-keys 도 '=' 접두사를 못 받는 tmux 가 있어
+ * 세션명을 그대로 쓴다. 사람이 친 것과 같게 하려고 Enter 를 따로 한 번 더 보낸다.
+ * 세션이 없거나(정리됨) 죽었으면 ok:false — 라우트가 409 로 돌려준다. 지어내지 않는다.
+ */
+export async function sendRunInput(runId: number, text: string): Promise<{ ok: boolean; detail: string }> {
+  const info = await getRunTermInfo(runId);
+  if (!info) return { ok: false, detail: 'no terminal session' };
+  const r = await runShellOn(
+    info.machine,
+    `tmux send-keys -t ${shq(info.session)} ${shq(text)} Enter`,
+    10000,
+  );
+  if (!r.ok) return { ok: false, detail: (r.stderr || r.stdout).trim().slice(0, 300) || 'send-keys failed' };
+  return { ok: true, detail: 'sent' };
+}
+
 /**
  * 이 run 의 페인이 **지금 서 있는 폴더** (v5.28 D-fix).
  * 터미널이 찍은 상대경로를 열려면 worktree 루트가 아니라 페인의 cwd 가 기준이어야 한다 —
@@ -911,11 +987,16 @@ interface OutputsManifestItem { path?: string; type?: string; title?: string }
 
 /** run 의 최종 답변 텍스트 — result 이벤트(payload JSON) 우선, 없으면 exitSummary. */
 async function runAnswerText(run: typeof agentRuns.$inferSelect): Promise<string> {
-  const evs = await db.select().from(agentEvents).where(eq(agentEvents.runId, run.id));
-  for (let i = evs.length - 1; i >= 0; i--) {
-    if (evs[i]!.kind !== 'result') continue;
+  // result 이벤트만, 최신 순으로 — 전량 로드 후 뒤에서 훑던 것과 결과는 같고 읽는 행은 훨씬 적다
+  // (run 당 result 는 보통 한 줄, resume 한 run 이면 몇 줄). LIMIT 1 을 쓰지 않는 건 의도다:
+  // 가장 최신 result 의 payload 에 쓸 만한 result 문자열이 없으면 예전 result 로 내려가야 하고,
+  // 그게 원래 동작이다 — 같은 답을 내는 것이 이 변경의 조건이다.
+  const evs = await db.select().from(agentEvents)
+    .where(and(eq(agentEvents.runId, run.id), eq(agentEvents.kind, 'result')))
+    .orderBy(desc(agentEvents.id));
+  for (const e of evs) {
     try {
-      const o = JSON.parse(evs[i]!.payload) as { result?: string };
+      const o = JSON.parse(e.payload) as { result?: string };
       if (typeof o.result === 'string' && o.result.trim()) return o.result.trim();
     } catch { /* 비-JSON result — exitSummary 로 폴백 */ }
   }
@@ -1267,9 +1348,9 @@ export async function launchGroupTask(
   const machineId = rp[0]!.machineId;
   const tIns = await db.insert(tasks).values({ repoId, title: title.slice(0, 140), prompt, groupId }).returning();
   const task = tIns[0]!;
-  const rIns = await db.insert(agentRuns).values({ taskId: task.id, machineId, agent: 'claude-code', status: 'pending' }).returning();
+  const rIns = await db.insert(agentRuns).values({ taskId: task.id, machineId, agent: 'claude-code', status: 'pending', real }).returning();
   const run = rIns[0]!;
-  broadcast({ type: 'run', runId: run.id, taskId: task.id, status: 'pending', agent: run.agent, branch: '', filesChanged: 0 });
+  broadcast({ type: 'run', runId: run.id, taskId: task.id, status: 'pending', agent: run.agent, real, branch: '', filesChanged: 0 });
   void launchRun(run.id, real);
   return { id: task.id, title: task.title, runId: run.id };
 }
@@ -1512,6 +1593,8 @@ export interface IntegrateResult {
   detail?: string;
   integrationTaskId?: number;
   integrationRunId?: number;
+  /** 머지된 건에 한해 base 검증 결과(v5.28 J1). verifyCmd 가 없으면 status ''. */
+  verify?: { status: string; output: string };
 }
 
 /**
@@ -1529,7 +1612,13 @@ export async function integrateRuns(runIds: number[], real?: boolean): Promise<I
     if (run.status === 'merged') { results.push({ runId: id, status: 'skipped', detail: 'already merged' }); continue; }
 
     const m = await mergeRun(id);
-    if (m.ok) { results.push({ runId: id, status: 'merged' }); continue; }
+    if (m.ok) {
+      // 내려앉은 그 호흡에 base 를 검증한다(J1) — 실패해도 머지는 그대로 서 있고, 보고만 된다.
+      const mc = await loadContext(id);
+      const verify = mc ? await verifyBase(mc.repoId) : { status: '', output: '' };
+      results.push({ runId: id, status: 'merged', verify });
+      continue;
+    }
     if (!m.conflict) { results.push({ runId: id, status: 'skipped', detail: m.detail }); continue; }
 
     // 충돌 → 통합 태스크 자동 발사 (에이전트가 머지를 대신 푼다)
@@ -1544,9 +1633,9 @@ export async function integrateRuns(runIds: number[], real?: boolean): Promise<I
       `Do not modify files unrelated to the conflicts.`;
     const tIns = await db.insert(tasks).values({ repoId: ctx.repoId, title, prompt }).returning();
     const newTask = tIns[0]!;
-    const rIns = await db.insert(agentRuns).values({ taskId: newTask.id, machineId: ctx.machineId, agent: 'claude-code', status: 'pending' }).returning();
+    const rIns = await db.insert(agentRuns).values({ taskId: newTask.id, machineId: ctx.machineId, agent: 'claude-code', status: 'pending', real: real ?? true }).returning();
     const newRun = rIns[0]!;
-    broadcast({ type: 'run', runId: newRun.id, taskId: newTask.id, status: 'pending', agent: newRun.agent, branch: '', filesChanged: 0 });
+    broadcast({ type: 'run', runId: newRun.id, taskId: newTask.id, status: 'pending', agent: newRun.agent, real: real ?? true, branch: '', filesChanged: 0 });
     void launchRun(newRun.id, real ?? true);
     results.push({ runId: id, status: 'conflict', detail: m.detail, integrationTaskId: newTask.id, integrationRunId: newRun.id });
   }

package/src/server.ts

@@ -7,7 +7,7 @@ import { randomBytes } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import Fastify, { type FastifyInstance, type FastifyReply } from 'fastify';
 import websocket from '@fastify/websocket';
-import { eq, inArray, and, like, desc } from 'drizzle-orm';
+import { eq, inArray, and, like, desc, asc, sql } from 'drizzle-orm';
 import { authGate } from './auth';
 import { loginPageHTML } from './login';
 import {
@@ -21,7 +21,7 @@ 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, openSessionAt, deleteSession, getScrollback, 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 } 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';
@@ -30,6 +30,7 @@ import { getProvider, listProviders } from './providers';
 import { remoteState, setServe, setFunnel } from './remote';
 import { BOARD_HTML } from './board';
 import { COCKPIT_HTML } from './cockpit';
+import { HUD_HTML } from './hud';
 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';
 
@@ -47,6 +48,12 @@ const VENDOR: Record<string, { pkg: string; rel: string; type: string }> = {
   'marked.js': { pkg: 'marked/package.json', rel: 'marked.min.js', type: 'text/javascript' },
 };
 
+// 버전 치환은 **모듈 로드 때 한 번** — config.version 은 부트 후 변하지 않고, cockpit.ts 는
+// 281KB 짜리 한 문자열이다. 요청마다 전역 정규식으로 다시 훑던 것을 상수로 굳혔다
+// (보드는 원래 상수를 그대로 내보낸다 — 세 페이지가 같은 방식이 됐다).
+const COCKPIT_PAGE = COCKPIT_HTML.replace(/__COXPIT_VER__/g, config.version);
+const HUD_PAGE = HUD_HTML.replace(/__COXPIT_VER__/g, config.version);
+
 // ─── 읽기 전용 공유 페이지 (서버 렌더 스냅샷 — 스크립트 0, 액션 0) ───────────
 const escH = (x: unknown): string =>
   String(x ?? '').replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]!));
@@ -250,7 +257,10 @@ export async function buildServer(): Promise<FastifyInstance> {
   // 플릿 보드(단일 페이지). 인증 게이트 적용됨(무인증 요청은 게이트가 login/setup 페이지로 응답).
   app.get('/', async (_req, reply) => reply.type('text/html').send(BOARD_HTML));
   // 터미널 우선 셸(병행 개발) — 백엔드는 보드와 공유. Phase 5에서 데스크톱 기본을 여기로 플립 예정.
-  app.get('/cockpit', async (_req, reply) => reply.type('text/html').send(COCKPIT_HTML.replace(/__COXPIT_VER__/g, config.version)));
+  app.get('/cockpit', async (_req, reply) => 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));
 
   // ─── 접근키 인증(access-key) ────────────────────────────────────
   // 요청이 tunnel/https 를 탔나 — Secure 쿠키 여부 결정용.
@@ -366,24 +376,40 @@ export async function buildServer(): Promise<FastifyInstance> {
     const activeTasks = allTasks.filter((t) => t.status !== 'closed');
     const closedCount = allTasks.length - activeTasks.length;
     const ts = view === 'all' ? allTasks : activeTasks;
-    const taskIds = new Set(ts.map((t) => t.id));
-    const allRuns = await db.select().from(agentRuns);
-    const rns = view === 'all' ? allRuns : allRuns.filter((r) => taskIds.has(r.taskId));
+    const taskIds = ts.map((t) => t.id);
+    // run 도 **보는 뷰만** 가져온다 — 전량 로드 후 JS 필터가 아니라 SQL WHERE.
+    // 정렬을 명시하는 건 필터가 끼어도 클라이언트가 받던 id 오름차순을 그대로 지키기 위함이다.
+    const rns: Array<typeof agentRuns.$inferSelect> = view === 'all'
+      ? await db.select().from(agentRuns).orderBy(asc(agentRuns.id))
+      : taskIds.length
+        ? await db.select().from(agentRuns).where(inArray(agentRuns.taskId, taskIds)).orderBy(asc(agentRuns.id))
+        : [];
     const runIds = rns.map((r) => r.id);
-    // 이벤트는 대상 run 으로 스코프한 뒤 로드(전량 로드 후 슬라이스 = 고치려는 그 버그).
-    const evs = runIds.length ? await db.select().from(agentEvents).where(inArray(agentEvents.runId, runIds)) : [];
+    // 이벤트는 run 당 최근 EVENT_CAP 개만 **SQL 에서** 잘라 온다. 전량 로드 후 JS 슬라이스가
+    // 정확히 고치려던 그 낭비다(활성 run 의 모든 이벤트 행을 메모리에 올렸다).
+    // 창 함수로 run 별 역순 번호를 매겨 상한 안쪽만 남기고, 클라이언트가 기대하는 id 오름차순으로 낸다.
+    const evs: Array<{ run_id: number; kind: string; payload: string }> = runIds.length
+      ? await db.all<{ run_id: number; kind: string; payload: string }>(sql`
+          SELECT id, run_id, kind, payload FROM (
+            SELECT id, run_id, kind, payload,
+                   ROW_NUMBER() OVER (PARTITION BY run_id ORDER BY id DESC) AS rn
+            FROM agent_events WHERE ${inArray(agentEvents.runId, runIds)}
+          ) WHERE rn <= ${EVENT_CAP} ORDER BY run_id ASC, id ASC`)
+      : [];
     const byRun = new Map<number, Array<{ kind: string; payload: string }>>();
     for (const e of evs) {
-      const arr = byRun.get(e.runId) ?? [];
+      const arr = byRun.get(e.run_id) ?? [];
       arr.push({ kind: e.kind, payload: e.payload });
-      byRun.set(e.runId, arr);
+      byRun.set(e.run_id, arr);
     }
     const taskOut = new Map(ts.map((t) => [t.id, t.outputs]));
     return {
       machines: ms, repos: rs, tasks: ts, captures: dcs, groups: gs,
       runs: rns.map((r) => {
         const sig = noopSignal(r.status, r.filesChanged, r.exitSummary, taskOut.get(r.taskId) ?? '[]');
-        return { ...r, events: (byRun.get(r.id) ?? []).slice(-EVENT_CAP), noop: sig.noop, noopReason: sig.reason };
+        // real 은 언제나 불리언으로 나간다 — 클라이언트는 real===false 하나만 보고 dry 칩을 그린다.
+        // events 는 이미 SQL 에서 EVENT_CAP 으로 잘려 왔다 — 여기서 또 자르지 않는다.
+        return { ...r, real: !!r.real, events: byRun.get(r.id) ?? [], noop: sig.noop, noopReason: sig.reason };
       }),
       counts: { activeTasks: activeTasks.length, closedTasks: closedCount },
       // 지금 터미널이 붙어 있는 run 의 에이전트 상태(runId → {state,detail,ts}).
@@ -492,15 +518,28 @@ export async function buildServer(): Promise<FastifyInstance> {
     const grpTitle = new Map((await db.select().from(taskGroups)).map((g) => [g.id, g.title]));
     const total0 = closed.length;
     const page = closed.slice(offset, offset + limit);
+    // 페이지에 실릴 태스크의 run 을 **한 번에** 긁어 taskId 로 묶는다.
+    // 태스크마다 한 방씩 쏘던 N+1(50행 페이지 = 51 쿼리)을 한 쿼리로 접었다.
+    const pageIds = page.map((t) => t.id);
+    const runsByTask = new Map<number, Array<typeof agentRuns.$inferSelect>>();
+    if (pageIds.length) {
+      const pageRuns = await db.select().from(agentRuns)
+        .where(inArray(agentRuns.taskId, pageIds)).orderBy(asc(agentRuns.id));
+      for (const r of pageRuns) {
+        const arr = runsByTask.get(r.taskId) ?? [];
+        arr.push(r);
+        runsByTask.set(r.taskId, arr);
+      }
+    }
     const rows = [];
     for (const t of page) {
-      const rs = await db.select().from(agentRuns).where(eq(agentRuns.taskId, t.id));
+      const rs = runsByTask.get(t.id) ?? [];
       if (q.status && !rs.some((r) => r.status === q.status)) continue;
       rows.push({
         taskId: t.id, title: t.title, repoName: repoName.get(t.repoId) ?? '?',
         groupTitle: t.groupId != null ? grpTitle.get(t.groupId) ?? null : null,
         closedAt: t.closedAt ? Math.floor(t.closedAt.getTime() / 1000) : (t.createdAt ? Math.floor(t.createdAt.getTime() / 1000) : 0),
-        runs: rs.map((r) => ({ id: r.id, status: r.status, filesChanged: r.filesChanged, agent: r.agent, model: r.model })),
+        runs: rs.map((r) => ({ id: r.id, status: r.status, filesChanged: r.filesChanged, agent: r.agent, model: r.model, real: !!r.real })),
       });
     }
     // status 필터가 있으면 total 은 근사(페이지 내 필터) — UI 는 rows 로만 판단하니 total0 유지.
@@ -958,7 +997,7 @@ export async function buildServer(): Promise<FastifyInstance> {
     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' });
     const runs = await db.select().from(agentRuns).where(eq(agentRuns.taskId, id));
-    return { task: tr[0], runs };
+    return { task: tr[0], runs: runs.map((r) => ({ ...r, real: !!r.real })) };
   });
 
   // 태스크 이름 변경(=세션 이름 변경) + v6.0 S2 승격(repoId 재부모화).
@@ -1089,16 +1128,19 @@ export async function buildServer(): Promise<FastifyInstance> {
         });
       }
     }
+    // dry/real 은 run 의 성질이다 — 만들 때부터 각인한다(v5.28 H1). body 가 말이 없으면
+    // launchRun 이 쓰게 될 그 기본값(config.agent.real)을 그대로 쓴다: 행과 명령이 갈리면 안 된다.
+    const useReal = b.real === undefined ? config.agent.real : !!b.real;
     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, title, inPlace, status: 'pending' })
+        .values({ taskId: id, machineId: rp[0].machineId, agent, model, title, inPlace, status: 'pending', real: useReal })
         .returning();
       created.push(ins[0]!);
     }
     // 보드가 taskId 를 알도록 생성 브로드캐스트 후 백그라운드 시작.
     for (const r of created) {
-      broadcast({ type: 'run', runId: r.id, taskId: id, status: 'pending', agent, title, inPlace, branch: '', filesChanged: 0 });
+      broadcast({ type: 'run', runId: r.id, taskId: id, status: 'pending', agent, title, inPlace, real: useReal, 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 })) });
@@ -1124,7 +1166,7 @@ export async function buildServer(): Promise<FastifyInstance> {
     const runsOut = [];
     for (const r of trs) {
       const d = await getRunDiff(r.id);
-      runsOut.push({ ...r, diff: d.ok ? d.diff : '', stat: d.ok ? d.stat : d.stat });
+      runsOut.push({ ...r, real: !!r.real, diff: d.ok ? d.diff : '', stat: d.ok ? d.stat : d.stat });
     }
     return { task: tr[0], runs: runsOut };
   });
@@ -1165,7 +1207,7 @@ export async function buildServer(): Promise<FastifyInstance> {
     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 events = await db.select().from(agentEvents).where(eq(agentEvents.runId, id));
-    return { run: rr[0], events };
+    return { run: { ...rr[0], real: !!rr[0].real }, events };
   });
 
   // v6.0 T4 — run 의 역할 이름 변경(탭 더블클릭). title 만 받는다.
@@ -1226,7 +1268,11 @@ export async function buildServer(): Promise<FastifyInstance> {
     if (!rr[0]) return reply.code(404).send({ error: 'not found' });
     const res = await mergeRun(id);
     if (!res.ok) return reply.code(409).send(res);
-    return res;
+    // 내려앉은 그 호흡에 머지된 base 를 검증한다(v5.28 J1). verifyCmd 가 없으면 status ''(no-op),
+    // 실패해도 머지는 되돌리지 않는다 — 보고만 한다.
+    const tr = await db.select().from(tasks).where(eq(tasks.id, rr[0].taskId)).limit(1);
+    const verify = tr[0] ? await verifyBase(tr[0].repoId) : { status: '', output: '' };
+    return { ...res, verify };
   });
 
   // 후속 지시(steer) — 정착한 run 을 같은 세션(--resume)·같은 worktree 로 계속.
@@ -1261,6 +1307,25 @@ export async function buildServer(): Promise<FastifyInstance> {
     return res;
   });
 
+  // 살아 있는 run 의 tmux 에 한 줄 써 넣기 (v5.28 K) — 위 scrollback 의 **쓰기 쌍둥이**.
+  // HUD 가 코크핏을 열지 않고 "대기 중인 에이전트"에게 답하는 길이다(steer 는 정착한 run 전용이라
+  // 프롬프트 앞에 서 있는 run 에는 쓸 수 없다). 보내는 것은 언제나 사람이 고른 문자열이다 —
+  // 서버는 에이전트의 질문을 읽지도, 답을 고르지도 않는다.
+  // 세션이 없으면(정리됐거나 애초에 없음) 409, 모르는 run 은 404.
+  app.post('/api/runs/:id/input', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    if (!Number.isInteger(id)) return reply.code(400).send({ error: 'bad id' });
+    const b = (req.body ?? {}) as { text?: string };
+    const text = String(b.text ?? '');
+    if (!text.trim()) return reply.code(400).send({ error: 'text required' });
+    if (text.length > 4000) return reply.code(400).send({ error: 'text too long (max 4000)' });
+    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 sendRunInput(id, text);
+    if (!res.ok) return reply.code(409).send(res);
+    return res;
+  });
+
   // 페인이 지금 서 있는 폴더 (v5.28 D-fix) — 터미널이 찍은 상대경로를 무엇 기준으로 풀지.
   // 못 알아내면 200 + { ok:false, pwd:'' } — 클라이언트가 worktree 로 폴백한다(지어낸 경로는 없다).
   app.get('/api/runs/:id/pwd', async (req, reply) => {
@@ -1445,6 +1510,7 @@ export async function buildServer(): Promise<FastifyInstance> {
     const runs = g.rows.map(({ run, task }) => ({
       runId: run.id, taskId: task.id, title: task.title, status: run.status,
       agent: run.agent, model: run.model, branch: run.branch, filesChanged: run.filesChanged,
+      real: !!run.real,
       live: isRunLive(run.id), steerable: isSteerable(run),
       // 수렴 콕핏 결정 행용: 태스크 닫힘 여부 + worktree 생존(터미널 가드·머지 가능성 판단).
       taskStatus: task.status, hasWorktree: !!run.worktreePath,