coxpit 6.1.0 → 6.3.0

package/src/db/index.ts

@@ -115,4 +115,6 @@ 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 */ }
+  // 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

@@ -93,6 +93,10 @@ export const agentRuns = sqliteTable('agent_runs', {
   sessionId: text('session_id').notNull().default(''), // 에이전트 세션(steer 용 --resume 키)
   prUrl: text('pr_url').notNull().default(''), // PR 모드로 올린 pull request URL
   model: text('model').notNull().default(''), // 런치별 모델 지정(빈값 = CLI 기본)
+  // v5.28 Part H — 이 run 이 진짜 에이전트로 돌았나(real), 모의 스트림이었나(dry).
+  // 기본 true(real)는 **의도**다: 이 컬럼이 생기기 전 run 은 알 수 없고, 모르는 것을 dry 라
+  // 부르면 거짓 경보가 된다. 아는 dry 만 표시한다 — dry 를 배지하되, dry 를 추측하지 않는다.
+  real: integer('real', { mode: 'boolean' }).notNull().default(true),
   filesChanged: integer('files_changed').notNull().default(0),
   agentPid: integer('agent_pid').notNull().default(0),   // detached sh pgid — 재시작 후 생존 판정/stop
   logOffset: integer('log_offset').notNull().default(0), // 내구 로그에서 tail 이 소비한 바이트(재-adopt 시 여기부터)

package/src/humanize.ts

@@ -0,0 +1,62 @@
+// 이벤트 인간화 — 보드와 코크핏이 **같은 한 벌**을 쓴다(사본 금지).
+// 보드 모달의 타임라인과 코크핏 활동 페인(v5.28 E)이 같은 줄을 같은 규칙으로 보여야 하므로,
+// 클라이언트 JS 를 여기 한 곳에 두고 두 페이지의 <script> 에 그대로 끼워 넣는다(icons.ts 전례).
+// 문자열 안의 이스케이프는 **클라이언트 기준**이다: \\n 은 클라이언트의 \n 이 된다.
+export const HUMANIZE_JS = `/* 이벤트 인간화 — JSON 원문 대신 사람이 읽는 한 줄로. null = 표시 생략(노이즈). */
+function humanize(e){
+  const kind = e.kind, payload = e.payload;
+  if (kind === 'rate_limit_event') return null;
+  if (kind === 'steer') return { k:'steer', t:'→ '+payload };
+  if (kind === 'ask') return { k:'ask', t:'? '+payload };
+  if (kind === 'sync') return { k:'sync', t:payload };
+  if (kind === 'export'){ try{ const o=JSON.parse(payload); return { k:'export', t:o.copied+' file(s) → '+o.dest }; }catch{ return { k:'export', t:payload }; } }
+  if (kind === 'pr') return { k:'pr', t:payload };
+  if (kind === 'stderr') return { k:'stderr', t:payload };
+  try{
+    const o = JSON.parse(payload);
+    if (o.type === 'system'){
+      if (o.subtype === 'init' || !o.subtype) return { k:'session',
+        t:'started'+(o.model?' · '+String(o.model).replace(/\\u001b\\[[0-9;]*m/g,'')
+                                                  .replace(/\\x1b\\[[0-9;]*m/g,'') : '') };
+      if (o.subtype === 'permission_denied') return { k:'denied', t:'⛔ '+(o.tool_name||o.tool||'tool use')+' blocked — attach the Terminal to approve, or widen COXPIT_AGENT_PERM' };
+      return null; // thinking_tokens 등 스트림 잡음
+    }
+    if (o.type === 'user') return null; // tool 결과 회신 — 노이즈
+    if (o.type === 'assistant' && o.message){
+      const parts = [];
+      for (const x of (o.message.content||[])){
+        if (x.type === 'text' && x.text) parts.push({ k:'said', t:x.text });
+        else if (x.type === 'tool_use'){
+          const i = x.input || {};
+          const arg = i.file_path || i.command || i.path || i.pattern || '';
+          parts.push({ k:'tool', t:'▸ '+x.name+(arg?' — '+String(arg).split('/').slice(-2).join('/').slice(0,60):'') });
+        }
+      }
+      return parts.length ? parts : null;
+    }
+    if (o.type === 'assistant' && o.text) return { k:'said', t:o.text };
+    if (o.type === 'result') return { k:'done', t:o.result || 'finished' };
+    if (kind === 'meta' && o.subtask) return { k:'swarm', t:'↳ spawned task #'+o.subtask+' — '+String(o.title||'').slice(0,60)+' ('+((o.runs||[]).map(x=>'r'+x).join(' '))+')' };
+    if (kind === 'meta') return { k:'start', t:'worktree '+String(o.worktree||'').split('/').slice(-2).join('/') };
+    return { k:kind, t:payload.slice(0,140) };
+  }catch{
+    // 파싱 실패(과거에 잘려 저장된 이벤트 등) — JSON 잔해를 그대로 보여주지 않는다:
+    // text 조각만 구제하고, 없으면 생략.
+    if (payload.trim().startsWith('{')){
+      const texts = [];
+      const re = /"text":"((?:[^"\\\\]|\\\\.)*)"/g; let m;
+      while ((m = re.exec(payload)) && texts.length < 2) texts.push(m[1].replace(/\\\\n/g,' ').slice(0,140));
+      return texts.length ? { k:'said', t:texts.join(' · ') } : null;
+    }
+    return { k:kind, t:payload };
+  }
+}
+function humanLines(events){
+  const out = [];
+  for (const e of (events||[])){
+    const h = humanize(e);
+    if (!h) continue;
+    if (Array.isArray(h)) out.push(...h); else out.push(h);
+  }
+  return out;
+}`;

package/src/orchestrator.ts

@@ -344,10 +344,10 @@ 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);
   }
@@ -484,7 +484,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 +609,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 +639,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) };
+  }
 }
 
 /**
@@ -1267,9 +1302,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 +1547,8 @@ export interface IntegrateResult {
   detail?: string;
   integrationTaskId?: number;
   integrationRunId?: number;
+  /** 머지된 건에 한해 base 검증 결과(v5.28 J1). verifyCmd 가 없으면 status ''. */
+  verify?: { status: string; output: string };
 }
 
 /**
@@ -1529,7 +1566,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 +1587,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

@@ -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, 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';
@@ -383,7 +383,8 @@ export async function buildServer(): Promise<FastifyInstance> {
       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 칩을 그린다.
+        return { ...r, real: !!r.real, 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}).
@@ -500,7 +501,7 @@ export async function buildServer(): Promise<FastifyInstance> {
         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 +959,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 +1090,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 +1128,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 +1169,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 +1230,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 로 계속.
@@ -1445,6 +1453,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,