npm - coxpit - Versions diffs - 5.0.3 → 5.1.0 - Mend

coxpit 5.0.3 → 5.1.0

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 (4) hide show

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "coxpit",
-  "version": "5.0.3",
+  "version": "5.1.0",
   "description": "Self-hosted cockpit for running a fleet of AI coding agents across your own machines — parallel worktree runs, live board, compare & merge, web terminal, design capture.",
   "type": "module",
   "license": "MIT",

package/src/board.ts CHANGED Viewed

@@ -312,6 +312,19 @@ export const BOARD_HTML = /* html */ `<!doctype html>
   .gband-fold{background:none;border:none;color:var(--muted);cursor:pointer;font-size:12px}
   .gband.folded .gband-grid{display:none}
   .gband-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(360px,1fr));gap:14px}
+  /* v5.1 A3 — sibling overlap panel */
+  .gband-overlap{margin:0 0 10px;padding:10px 12px;border:1px solid var(--line);border-radius:9px;
+    background:#0e1118;font-family:var(--mono);font-size:11.5px;color:var(--muted)}
+  .gov-load{color:var(--faint)}
+  .gov-clean{color:var(--brand);display:flex;align-items:center;gap:6px}
+  .gov-clean .ic{width:13px;height:13px}
+  .gov-t{color:var(--ink);margin-bottom:6px}
+  .gov-list{list-style:none;margin:0 0 6px;padding:0;display:flex;flex-direction:column;gap:3px}
+  .gov-list li{display:flex;align-items:center;gap:8px}
+  .gov-list code{background:var(--surface2);border:1px solid var(--line);border-radius:4px;padding:0 5px;color:var(--ink)}
+  .gov-r{color:#c9922e}
+  .gov-order{color:var(--muted);border-top:1px solid var(--line);padding-top:6px;margin-top:2px}
+  .gov-order b{color:var(--brand)}
   .attempt{color:var(--brand);opacity:.8}
   /* ── goal workroom (v4.6) — 한 goal 을 여는 단일 방 ── */
@@ -452,6 +465,10 @@ export const BOARD_HTML = /* html */ `<!doctype html>
   .chip.running i{animation:pulse 1.2s ease-in-out infinite}
   @keyframes pulse{0%,100%{opacity:1}50%{opacity:.25}}
   @media (prefers-reduced-motion:reduce){.chip.running i{animation:none}.card:hover{transform:none}}
+  /* v5.1 A2 — a settled run that changed nothing (intent-gated); 'blocked' = likely stalled on approval */
+  .chip.noop{color:#c9922e;border-color:rgba(201,146,46,.45)}
+  .chip.noop.blk{color:#e0955a;border-color:rgba(224,149,90,.6)}
+  .card-h .chip.noop::before{content:"";width:6px;height:6px;border-radius:50%;background:currentColor;margin-right:1px}
   .meta{display:flex;gap:16px;padding:0 14px 10px;font-family:var(--mono);font-size:11px;color:var(--faint)}
   .meta b{color:var(--muted);font-weight:500;font-variant-numeric:tabular-nums}
   .meta .resumable{color:var(--brand);opacity:.75}
@@ -1465,11 +1482,38 @@ function bandHTML(g, grpRuns){
     + '<span class="gband-n">'+taskIds.length+' task'+(taskIds.length>1?'s':'')+' · '+settled+' settled</span>'
     + '<span class="gband-sp"></span>'
     + '<button class="btn-ghost sm gband-open" data-groom="'+g.id+'">⌒ Open workroom</button>'
+    + '<button class="btn-ghost sm" data-goverlap="'+g.id+'" title="which files sibling runs both touch — plan the land order">⧉ Overlap</button>'
     + '<button class="btn-ghost sm" data-gsel="'+g.id+'">Select runs</button>'
     + '<button class="btn-ghost sm" data-gclose="'+g.id+'">Close group</button>'
     + '<button class="gband-fold" data-gfold="'+g.id+'" title="fold">'+(folded?'▸':'▾')+'</button></div>'
+    + '<div class="gband-overlap" id="gov-'+g.id+'" hidden></div>'
     + '<div class="gband-grid">'+cards+'</div></div>';
 }
+// v5.1 A3 — sibling overlap: on-demand fetch, render contended files + suggested land order.
+async function toggleOverlap(gid){
+  const box = $('gov-'+gid); if(!box) return;
+  if (!box.hidden){ box.hidden = true; box.innerHTML=''; return; }
+  box.hidden = false; box.innerHTML = '<span class="gov-load">checking overlap…</span>';
+  try {
+    const res = await fetch('/api/groups/'+gid+'/overlap');
+    box.innerHTML = overlapHTML(await res.json());
+  } catch(e){ box.innerHTML = '<span class="gov-load">overlap check failed</span>'; }
+}
+function overlapHTML(j){
+  const runs = j.runs||[];
+  if (!runs.length) return '<span class="gov-load">no run diffs yet — land order needs settled runs</span>';
+  const cont = j.contended||[];
+  const order = (j.order||[]).map(id=>'r'+id).join(' → ');
+  let h = '';
+  if (!cont.length){
+    h += '<div class="gov-clean">'+ic('check')+' no file overlap — siblings touch disjoint files, land in any order</div>';
+  } else {
+    h += '<div class="gov-t">'+cont.length+' contended file'+(cont.length>1?'s':'')+' — plan the sequence</div>';
+    h += '<ul class="gov-list">'+cont.map(c=>'<li><code>'+esc(c.path)+'</code><span class="gov-r">'+c.runIds.map(i=>'r'+i).join(' · ')+'</span></li>').join('')+'</ul>';
+  }
+  if (order) h += '<div class="gov-order">suggested land order · <b>'+esc(order)+'</b></div>';
+  return h;
+}
 // v5.0 — 레일에서 고른 repo 로 run 을 스코프(client-side). selectedRepo=null → 전체.
 function runInScope(r){
   if (selectedRepo==null) return true;
@@ -1678,7 +1722,11 @@ function cardHTML(r){
   const selCls = (selectMode?' selmode':'') + (selected.has(r.id)?' selected':'') + (closed?' closed':'');
   return '<div class="card'+selCls+'" id="card-'+r.id+'">'
     + '<div class="card-h"><span class="rid">r'+r.id+'</span><span class="title">'+title+'</span>'
-    + '<span class="selbox">'+ic('check')+'</span>'+chipHTML(r.status)+'</div>'
+    + '<span class="selbox">'+ic('check')+'</span>'+chipHTML(r.status)
+    + (r.noop ? '<span class="chip noop'+(r.noopReason==='blocked'?' blk':'')+'" title="'
+        +(r.noopReason==='blocked'?'settled without making the change it was asked for — likely stalled on approval':'this run changed no files — did it actually do the work?')
+        +'">'+(r.noopReason==='blocked'?'blocked':'no changes')+'</span>' : '')
+    + '</div>'
     + '<div class="meta"><span>branch <b>'+esc(r.branch||'—')+'</b></span>'
     + '<span>files <b>'+(r.filesChanged??0)+'</b></span>'
     + '<span>'+esc(r.agent||'')+'</span>'
@@ -2178,6 +2226,8 @@ $('selGo').addEventListener('click', async ()=>{
 $('grid').addEventListener('click', async (e)=>{
   const groom = e.target.closest('[data-groom]');
   if (groom){ openRoom(Number(groom.dataset.groom)); return; }
+  const gov = e.target.closest('[data-goverlap]');
+  if (gov){ toggleOverlap(Number(gov.dataset.goverlap)); return; }
   const fold = e.target.closest('[data-gfold]');
   if (fold){ const g=Number(fold.dataset.gfold); if(gfold.has(g)) gfold.delete(g); else gfold.add(g); saveGfold(); render(); return; }
   const gsel = e.target.closest('[data-gsel]');
@@ -2377,24 +2427,52 @@ async function paintCompare(){
     }
   }
 }
+// v5.1 step 2+3 — preview the land (target drift + conflict files) and warn at the decision point.
+async function driftNote(rid){
+  try{
+    const p = await (await fetch('/api/runs/'+rid+'/merge/preview?fetch=1')).json();
+    if (!p || !p.target) return '';
+    if (p.supported && !p.clean && (p.conflicts||[]).length){
+      const files = p.conflicts.slice(0,4).join(', ') + (p.conflicts.length>4 ? ' +'+(p.conflicts.length-4)+' more' : '');
+      return ' ⚠ landing on '+p.target+' would conflict in '+p.conflicts.length+' file'+(p.conflicts.length>1?'s':'')
+        +' ('+files+'). Resolve on the branch first, or land (rebase) instead of a whole-branch merge.';
+    }
+    if ((p.behind||0) > 0) return ' ⚠ the base is '+p.behind+' commit'+(p.behind>1?'s':'')+' behind '+p.target
+      +' — a whole-branch merge may conflict; landing (rebase onto '+p.target+') is safer.';
+    if (p.supported && p.clean) return ' ✓ clean against '+p.target+'.';
+    return '';
+  }catch(e){ return ''; }
+}
 $('cmpBody').addEventListener('click', async (e)=>{
   const prBtn = e.target.closest('button[data-pr]');
   if (prBtn){
     const rid = Number(prBtn.dataset.pr);
-    const yes = await confirmUI('Open a pull request from r'+rid+'?',
-      { sub: 'Commits the worktree, pushes the branch to origin, and opens a PR against the base branch (needs gh CLI signed in).', okLabel: 'Open PR' });
+    const yes = await confirmUI('Land r'+rid+' as a pull request?',
+      { sub: 'Rebases this run onto the latest origin target, pushes it as coxpit/<task>-r'+rid+', and opens a PR against that target (needs gh signed in).'+(await driftNote(rid)), okLabel: 'Land · PR' });
     if (!yes) return;
     prBtn.disabled = true;
     const res = await fetch('/api/runs/'+rid+'/pr',{method:'POST'});
     const j = await res.json().catch(()=>({}));
     if (res.ok){ toast('PR opened: '+j.url, 'ok'); await paintCompare(); hydrate(); }
+    else if (j.conflict){
+      const cf = (j.conflicts||[]);
+      const go = await confirmUI('r'+rid+' conflicts with the target in '+cf.length+' file'+(cf.length>1?'s':'')+'.',
+        { sub: cf.slice(0,6).join(', ')+'. Let the agent resolve the markers, then land automatically — coxpit drives git, the agent only edits files.', okLabel: 'Agent · resolve & land' });
+      if (go){
+        const r2 = await fetch('/api/runs/'+rid+'/land/resolve',{method:'POST'});
+        const j2 = await r2.json().catch(()=>({}));
+        toast(r2.ok ? (j2.detail||'resolving…') : ('resolve: '+(j2.detail||r2.status)), r2.ok?'ok':'error');
+        hydrate();
+      }
+      prBtn.disabled = false;
+    }
     else { toast('PR: '+(j.detail||res.status), 'error'); prBtn.disabled = false; }
     return;
   }
   const btn = e.target.closest('button[data-merge]'); if(!btn) return;
   const rid = Number(btn.dataset.merge);
   const yes = await confirmUI('Merge r'+rid+' into the base branch?',
-    { sub: 'Uncommitted worktree changes are committed first. Conflicts abort automatically.', okLabel: 'Merge' });
+    { sub: 'Uncommitted worktree changes are committed first. Conflicts abort automatically.'+(await driftNote(rid)), okLabel: 'Merge' });
   if (!yes) return;
   btn.disabled = true;
   const res = await fetch('/api/runs/'+rid+'/merge',{method:'POST'});

package/src/orchestrator.ts CHANGED Viewed

@@ -5,7 +5,7 @@ import { existsSync } from 'node:fs';
 import { mkdir, copyFile, readFile, writeFile, rm } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import type { ChildProcess } from 'node:child_process';
-import { eq } from 'drizzle-orm';
+import { eq, inArray } from 'drizzle-orm';
 import { config } from './config';
 import { db } from './db';
 import { agentRuns, agentEvents, tasks, repos, machines, designCaptures, docSnapshots, taskGroups } from './db/schema';
@@ -39,6 +39,26 @@ export function parseOutputs(raw: string | null | undefined): OutputType[] {
   try { return normalizeOutputs(JSON.parse(raw)); } catch { return []; }
 }
+/**
+ * v5.1 A2 — a run that settled clean but did nothing it was asked to.
+ * Deterministic signal (primary): status 'done' with zero files changed.
+ * Gated on intent so an answer-only task legitimately changing nothing stays quiet.
+ * The 'blocked' upgrade is best-effort natural-language matching on the final message —
+ * no provider emits a structured "needs approval" event, so never depend on it.
+ */
+export function noopSignal(
+  status: string,
+  filesChanged: number,
+  exitSummary: string | null | undefined,
+  taskOutputs: string | null | undefined,
+): { noop: boolean; reason: 'blocked' | 'no-changes' | null } {
+  if (status !== 'done' || (filesChanged ?? 0) > 0) return { noop: false, reason: null };
+  const declared = parseOutputs(taskOutputs);
+  if (declared.length > 0 && declared.every((t) => t === 'answer')) return { noop: false, reason: null };
+  const blocked = /\b(approval|permission|not allowed|need(s)?\s+(explicit\s+)?approv|explicit(ly)?\s+approv|allow me to)\b/i.test(exitSummary ?? '');
+  return { noop: true, reason: blocked ? 'blocked' : 'no-changes' };
+}
 /** 프롬프트에 붙는 Deliverables 블록(A3). declared 는 비어있지 않다. */
 function deliverablesNote(declared: OutputType[]): string {
   const human: Record<OutputType, string> = {
@@ -1219,7 +1239,19 @@ export async function exportRun(runId: number, destIn?: string): Promise<{ ok: b
  * PR 모드 — run 브랜치를 origin 에 push 하고 gh 로 pull request 를 연다.
  * 팀 repo·리뷰 흐름용: 로컬 merge 대신 PR 로 결과를 보낸다.
  */
-export async function prRun(runId: number): Promise<{ ok: boolean; detail: string; url?: string }> {
+/** Product-appropriate PR branch name: coxpit/<task-slug>-r<id> — meaningful, unique, namespaced. */
+function slugify(s: string): string {
+  return (s || 'run').toLowerCase().normalize('NFKD').replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40) || 'run';
+}
+/**
+ * v5.1 step 4 — land a run: origin-aware. Resolve the target (origin/<x>, may differ from the
+ * local base), preview conflicts, then squash the run's net diff onto a fresh branch AT the
+ * target (avoids the base-merge-commit drag, C6), push under the product name, and open a PR
+ * against the target branch. On conflict returns { conflict } for the integration loop (step 5).
+ * Falls back to the legacy push-branch/PR-against-base when the base has no upstream.
+ */
+export async function prRun(runId: number): Promise<{ ok: boolean; detail: string; url?: string; conflict?: boolean; conflicts?: string[] }> {
   const ctx = await loadContext(runId);
   const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, runId)).limit(1);
   const run = rr[0];
@@ -1227,37 +1259,141 @@ export async function prRun(runId: number): Promise<{ ok: boolean; detail: strin
   if (liveChildren.has(runId)) return { ok: false, detail: 'still running — stop it first' };
   if (!['done', 'failed', 'stopped', 'open'].includes(run.status)) return { ok: false, detail: `cannot open a PR from a '${run.status}' run` };
   const wt = shq(run.worktreePath);
+  const ident = `-c user.name='coxpit' -c user.email='coxpit@local'`;
-  // 0) 사전 조건: origin 리모트 + gh CLI
+  // 0) preconditions: origin remote + gh CLI
   const pre = await runShellOn(ctx.machine,
     `cd ${wt} && { git remote get-url origin >/dev/null 2>&1 && echo R1 || echo R0; } && { command -v gh >/dev/null 2>&1 && echo G1 || echo G0; }`, 10000);
   if (!pre.stdout.includes('R1')) return { ok: false, detail: 'no origin remote on this repo' };
   if (!pre.stdout.includes('G1')) return { ok: false, detail: 'GitHub CLI (gh) not found on the machine' };
-  // 1) worktree 미커밋 변경 자동 커밋
-  const ident = `-c user.name='coxpit' -c user.email='coxpit@local'`;
+  // 1) commit worktree changes
   const c1 = await runShellOn(ctx.machine,
     `cd ${wt} && git add -A && (git diff --cached --quiet || git ${ident} -c commit.gpgsign=false commit -m ${shq(`coxpit r${runId}: agent changes`)})`, 20000);
   if (!c1.ok) return { ok: false, detail: 'worktree commit failed: ' + (c1.stderr || c1.stdout).trim().slice(0, 300) };
-  // 2) push
-  const push = await runShellOn(ctx.machine, `cd ${wt} && git push -u origin ${shq(run.branch)} 2>&1`, 60000);
-  if (!push.ok) return { ok: false, detail: 'push failed: ' + (push.stderr || push.stdout).trim().slice(0, 300) };
-  // 3) PR 생성 (동일 브랜치 PR 이 이미 있으면 그 URL 재사용)
   const tr = await db.select().from(tasks).where(eq(tasks.id, run.taskId)).limit(1);
   const title = `${tr[0]?.title ?? 'coxpit run'} (r${runId})`;
   const body = (run.exitSummary ? run.exitSummary + '\n\n' : '') + '🤖 Opened from a coxpit agent run';
+  // 2) resolve the land target (fresh) — origin-aware path when the base tracks a remote
+  const lt = await landTarget(runId, { fetch: true });
+  const target = lt.target;
+  if (target) {
+    const pv = await mergePreview(runId, { target });
+    if (pv.supported && !pv.clean && pv.conflicts.length) {
+      return { ok: false, conflict: true, conflicts: pv.conflicts,
+        detail: `would conflict on ${target} in ${pv.conflicts.length} file(s): ${pv.conflicts.slice(0, 6).join(', ')} — resolve on the branch first, then land.` };
+    }
+    const targetBranch = target.replace(/^[^/]+\//, '');           // origin/develop -> develop
+    const landBranch = `coxpit/${slugify(tr[0]?.title ?? 'run')}-r${runId}`;
+    const range = shq(ctx.baseBranch + '...' + run.branch);
+    // squash the run's net diff onto a fresh branch at the target (3-way apply; clean per preview)
+    const land = await runShellOn(ctx.machine,
+      `cd ${wt} && git checkout -B ${shq(landBranch)} ${shq(target)} 2>&1 && ` +
+      `git diff ${range} | git apply --3way --index - 2>&1 && ` +
+      `(git diff --cached --quiet || git ${ident} -c commit.gpgsign=false commit -m ${shq(title)}) 2>&1`, 60000);
+    if (!land.ok) return { ok: false, detail: `land (onto ${target}) failed: ` + (land.stderr || land.stdout).trim().slice(0, 300) };
+    const push = await runShellOn(ctx.machine, `cd ${wt} && git push -u origin ${shq(landBranch)} 2>&1`, 60000);
+    if (!push.ok) return { ok: false, detail: 'push failed: ' + (push.stderr || push.stdout).trim().slice(0, 300) };
+    const pr = await runShellOn(ctx.machine,
+      `cd ${wt} && gh pr create -B ${shq(targetBranch)} -H ${shq(landBranch)} -t ${shq(title)} -b ${shq(body)} 2>&1 || true`, 60000);
+    const m = (pr.stdout + pr.stderr).match(/https:\/\/github\.com\/\S+\/pull\/\d+/);
+    if (!m) return { ok: false, detail: 'gh pr create failed: ' + (pr.stdout || pr.stderr).trim().slice(0, 300) };
+    await setRun(runId, { prUrl: m[0] });
+    await recordEvent(runId, 'pr', `${m[0]} (landed on ${targetBranch})`);
+    return { ok: true, detail: `landed on ${targetBranch} · PR opened`, url: m[0] };
+  }
+  // fallback: no upstream target — legacy push-branch / PR-against-base
+  const push = await runShellOn(ctx.machine, `cd ${wt} && git push -u origin ${shq(run.branch)} 2>&1`, 60000);
+  if (!push.ok) return { ok: false, detail: 'push failed: ' + (push.stderr || push.stdout).trim().slice(0, 300) };
   const pr = await runShellOn(ctx.machine,
     `cd ${wt} && gh pr create -B ${shq(ctx.baseBranch)} -H ${shq(run.branch)} -t ${shq(title)} -b ${shq(body)} 2>&1 || true`, 60000);
   const m = (pr.stdout + pr.stderr).match(/https:\/\/github\.com\/\S+\/pull\/\d+/);
   if (!m) return { ok: false, detail: 'gh pr create failed: ' + (pr.stdout || pr.stderr).trim().slice(0, 300) };
   await setRun(runId, { prUrl: m[0] });
   await recordEvent(runId, 'pr', m[0]);
   return { ok: true, detail: 'pull request opened', url: m[0] };
 }
+// v5.1 step 5 — the integration loop. coxpit owns git; the agent only edits conflict markers.
+type PendingLand = { target: string; targetBranch: string; landBranch: string; title: string; body: string };
+const pendingLand = new Map<number, PendingLand>();
+/**
+ * Start resolving a conflicting land in-app: coxpit stages the run's work, checks out a fresh
+ * branch at the target and 3-way-applies the net diff (leaving conflict markers), then RESUMES
+ * the run's own agent scoped to editing those markers only (no git — that would hit the sandbox
+ * wall that blocked the merge in the first place). When the agent settles, finalizeLand() commits,
+ * pushes and opens the PR. The agent carries the original context, so it resolves knowingly.
+ */
+export async function startLandResolve(runId: number): Promise<{ ok: boolean; detail: string }> {
+  const ctx = await loadContext(runId);
+  const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, runId)).limit(1);
+  const run = rr[0];
+  if (!ctx || !run || !run.worktreePath || !run.branch) return { ok: false, detail: 'no worktree/branch' };
+  if (liveChildren.has(runId)) return { ok: false, detail: 'still running — stop it first' };
+  if (!run.sessionId) return { ok: false, detail: 'no agent session — dry runs cannot auto-resolve; open the workbench' };
+  const wt = shq(run.worktreePath);
+  const ident = `-c user.name='coxpit' -c user.email='coxpit@local'`;
+  await runShellOn(ctx.machine, `cd ${wt} && git add -A && (git diff --cached --quiet || git ${ident} -c commit.gpgsign=false commit -m ${shq(`coxpit r${runId}: agent changes`)})`, 20000);
+  const lt = await landTarget(runId, { fetch: true });
+  const target = lt.target;
+  if (!target) return { ok: false, detail: 'no upstream target to land on' };
+  const targetBranch = target.replace(/^[^/]+\//, '');
+  const tr = await db.select().from(tasks).where(eq(tasks.id, run.taskId)).limit(1);
+  const title = `${tr[0]?.title ?? 'coxpit run'} (r${runId})`;
+  const body = (run.exitSummary ? run.exitSummary + '\n\n' : '') + '🤖 Landed from a coxpit agent run (conflicts resolved by the agent)';
+  const landBranch = `coxpit/${slugify(tr[0]?.title ?? 'run')}-r${runId}`;
+  const range = shq(ctx.baseBranch + '...' + run.branch);
+  const prep = await runShellOn(ctx.machine,
+    `cd ${wt} && git checkout -B ${shq(landBranch)} ${shq(target)} 2>&1 && { git diff ${range} | git apply --3way --index - 2>&1 || true; } && git rev-parse --abbrev-ref HEAD`, 60000);
+  if (!prep.stdout.trim().endsWith(landBranch)) return { ok: false, detail: 'could not prepare land branch: ' + prep.stdout.trim().slice(-200) };
+  pendingLand.set(runId, { target, targetBranch, landBranch, title, body });
+  const prompt = `You are on branch ${landBranch}. Landing your change onto ${target} produced git conflict markers (<<<<<<<, =======, >>>>>>>) in one or more files. Resolve EVERY conflict marker by editing the files to the correct merged result — keep both your change and the target's changes where each belongs. Do NOT run any git commands (no add/commit/rebase/merge) — only edit the files. When every marker is gone, end your turn.`;
+  await setRun(runId, { status: 'running', endedAt: null });
+  await recordEvent(runId, 'integrate', `resolving conflicts to land on ${targetBranch} — the agent is editing markers`);
+  const provider = getProvider(ctx.agent);
+  const isRemote = ctx.machine.kind !== 'local' && ctx.machine.address !== '';
+  const pidPrefix = isRemote ? `printf '%s' "$$" > .coxpit-agent.pid && ` : '';
+  const resume = provider.resumeCmd(run.sessionId, prompt, run.model || undefined);
+  const cmd = `cd ${shq(run.worktreePath)} && ${pidPrefix}{ ${resume}; }`;
+  void runAgentChild(runId, ctx.machine, run.worktreePath, cmd, provider).then(() => finalizeLand(runId)).catch(() => { pendingLand.delete(runId); });
+  return { ok: true, detail: `integrating — the agent is resolving conflicts; it lands on ${targetBranch} automatically when clean` };
+}
+/** After the resolve agent settles: verify no markers remain, then commit + push + open the PR. */
+async function finalizeLand(runId: number): Promise<void> {
+  const pend = pendingLand.get(runId);
+  if (!pend) return;
+  pendingLand.delete(runId);
+  const ctx = await loadContext(runId);
+  const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, runId)).limit(1);
+  const run = rr[0];
+  if (!ctx || !run || !run.worktreePath) return;
+  const wt = shq(run.worktreePath);
+  const ident = `-c user.name='coxpit' -c user.email='coxpit@local'`;
+  const chk = await runShellOn(ctx.machine,
+    `cd ${wt} && git diff --name-only | tr '\\n' '\\0' | xargs -0 -r grep -lE '^(<<<<<<< |>>>>>>> )' 2>/dev/null | head -20`, 15000);
+  const leftover = chk.stdout.trim();
+  if (leftover) {
+    await recordEvent(runId, 'error', 'conflict markers still present after the agent pass — resolve the rest (attach the terminal) or run resolve again:\n' + leftover.slice(0, 300));
+    return;
+  }
+  const c = await runShellOn(ctx.machine,
+    `cd ${wt} && git add -A && (git diff --cached --quiet || git ${ident} -c commit.gpgsign=false commit -m ${shq(pend.title)}) 2>&1`, 30000);
+  if (!c.ok) { await recordEvent(runId, 'error', 'land commit failed: ' + (c.stderr || c.stdout).trim().slice(0, 200)); return; }
+  const push = await runShellOn(ctx.machine, `cd ${wt} && git push -u origin ${shq(pend.landBranch)} 2>&1`, 60000);
+  if (!push.ok) { await recordEvent(runId, 'error', 'push failed: ' + (push.stderr || push.stdout).trim().slice(0, 200)); return; }
+  const pr = await runShellOn(ctx.machine,
+    `cd ${wt} && gh pr create -B ${shq(pend.targetBranch)} -H ${shq(pend.landBranch)} -t ${shq(pend.title)} -b ${shq(pend.body)} 2>&1 || true`, 60000);
+  const m = (pr.stdout + pr.stderr).match(/https:\/\/github\.com\/\S+\/pull\/\d+/);
+  if (!m) { await recordEvent(runId, 'error', 'gh pr create failed: ' + (pr.stdout || pr.stderr).trim().slice(0, 200)); return; }
+  await setRun(runId, { prUrl: m[0] });
+  await recordEvent(runId, 'pr', `${m[0]} (landed on ${pend.targetBranch} after resolve)`);
+}
 /**
  * worktree/브랜치/tmux 정리(태스크 종료·run 폐기 시).
  */
@@ -1293,6 +1429,139 @@ export async function taskCloseRisk(taskId: number): Promise<Array<{ runId: numb
   return atRisk;
 }
+/**
+ * v5.1 A3 — sibling overlap within a group: which files two or more sibling runs both touch,
+ * and a suggested land order (fewest contended files first). Read-only; on-demand (git per run),
+ * never on the fleet-poll path. Uses `diff --name-only base...branch` (merge-base) = each run's
+ * OWN change set, so base drift doesn't inflate it.
+ */
+export async function groupOverlap(groupId: number): Promise<{
+  runs: Array<{ runId: number; files: string[] }>;
+  contended: Array<{ path: string; runIds: number[] }>;
+  order: number[];
+}> {
+  const taskRows = await db.select().from(tasks).where(eq(tasks.groupId, groupId));
+  const taskIds = taskRows.map((t) => t.id);
+  if (!taskIds.length) return { runs: [], contended: [], order: [] };
+  const rns = await db.select().from(agentRuns).where(inArray(agentRuns.taskId, taskIds));
+  const perRun: Array<{ runId: number; files: string[] }> = [];
+  for (const r of rns) {
+    if (!r.branch || !r.worktreePath || r.status === 'merged') continue;
+    const ctx = await loadContext(r.id);
+    if (!ctx) continue;
+    const out = await runShellOn(
+      ctx.machine,
+      `git -C ${shq(ctx.repoPath)} diff --name-only ${shq(ctx.baseBranch)}...${shq(r.branch)}`,
+      10000,
+    );
+    const files = out.ok ? out.stdout.split('\n').map((s) => s.trim()).filter(Boolean) : [];
+    perRun.push({ runId: r.id, files });
+  }
+  const byFile = new Map<string, number[]>();
+  for (const pr of perRun) for (const f of pr.files) {
+    const a = byFile.get(f) ?? []; a.push(pr.runId); byFile.set(f, a);
+  }
+  const contended = [...byFile.entries()]
+    .filter(([, ids]) => ids.length > 1)
+    .map(([path, runIds]) => ({ path, runIds }))
+    .sort((a, b) => b.runIds.length - a.runIds.length || a.path.localeCompare(b.path));
+  const contendedSet = new Set(contended.map((c) => c.path));
+  const contendedCount = (pr: { files: string[] }) => pr.files.filter((f) => contendedSet.has(f)).length;
+  const order = perRun.slice()
+    .sort((a, b) => contendedCount(a) - contendedCount(b) || a.runId - b.runId)
+    .map((p) => p.runId);
+  return { runs: perRun, contended, order };
+}
+/**
+ * v5.1 Part C foundation — resolve the land *target* for a run and measure base drift.
+ * The target is NOT assumed to be the base: default = the base branch's upstream
+ * (`<base>@{u}`, e.g. main→origin/main), else `origin/<base>` if it exists, else null
+ * (the caller must pick one). With { fetch }, refresh the remote first so drift is current.
+ * ahead = commits the local base has that the target lacks; behind = commits the target has
+ * that the local base lacks (the drift that makes a whole-branch merge explode).
+ */
+export async function landTarget(runId: number, opts: { fetch?: boolean } = {}): Promise<{
+  base: string; target: string | null; remote: string | null;
+  ahead: number; behind: number; fetched: boolean; detail?: string;
+}> {
+  const ctx = await loadContext(runId);
+  if (!ctx) return { base: '', target: null, remote: null, ahead: 0, behind: 0, fetched: false, detail: 'no context' };
+  const repo = shq(ctx.repoPath);
+  const base = ctx.baseBranch;
+  const up = await runShellOn(ctx.machine, `git -C ${repo} rev-parse --abbrev-ref ${shq(base + '@{u}')} 2>/dev/null`, 8000);
+  let target: string | null = up.ok && up.stdout.trim() ? up.stdout.trim() : null;
+  let remote: string | null = target ? (target.split('/')[0] ?? null) : null;
+  if (!target) {
+    const has = await runShellOn(ctx.machine, `git -C ${repo} rev-parse --verify --quiet ${shq('origin/' + base)}`, 8000);
+    if (has.ok && has.stdout.trim()) { target = 'origin/' + base; remote = 'origin'; }
+  }
+  if (!target) return { base, target: null, remote: null, ahead: 0, behind: 0, fetched: false, detail: 'no upstream — pick a target' };
+  let fetched = false;
+  if (opts.fetch && remote) {
+    const f = await runShellOn(ctx.machine, `git -C ${repo} fetch ${shq(remote)} 2>&1`, 30000);
+    fetched = f.ok;
+  }
+  const rl = await runShellOn(ctx.machine, `git -C ${repo} rev-list --left-right --count ${shq(base + '...' + target)}`, 10000);
+  let ahead = 0, behind = 0;
+  if (rl.ok) { const [a = '0', b = '0'] = rl.stdout.trim().split(/\s+/); ahead = parseInt(a, 10) || 0; behind = parseInt(b, 10) || 0; }
+  return { base, target, remote, ahead, behind, fetched };
+}
+/**
+ * v5.1 A1 (step 3) — conflict preview: what WOULD conflict if this run landed on the target,
+ * computed with `git merge-tree --write-tree` (git ≥ 2.38) — no working tree, no commit, no
+ * side effects. Previews against the land *target* (origin/<x>), not the local base (a run never
+ * conflicts with the base it descends from). Folds in the drift (ahead/behind) from landTarget so
+ * one call answers "is landing safe, and if not, which files".
+ *
+ * merge-tree output: line 0 = tree OID; on conflict, the conflicted paths follow until a blank
+ * line (informational messages after). Exit 0 = clean, non-zero = conflicts.
+ */
+export async function mergePreview(runId: number, opts: { fetch?: boolean; target?: string } = {}): Promise<{
+  supported: boolean; clean: boolean; conflicts: string[]; target: string | null;
+  ahead: number; behind: number; detail?: string;
+}> {
+  const ctx = await loadContext(runId);
+  const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, runId)).limit(1);
+  const run = rr[0];
+  if (!ctx || !run || !run.branch) return { supported: true, clean: false, conflicts: [], target: null, ahead: 0, behind: 0, detail: 'no branch' };
+  const lt = await landTarget(runId, { fetch: opts.fetch });
+  const target = opts.target ?? lt.target;
+  if (!target) return { supported: true, clean: false, conflicts: [], target: null, ahead: lt.ahead, behind: lt.behind, detail: 'no target — pick one' };
+  const repo = shq(ctx.repoPath);
+  // The agent edits files but does NOT commit (acceptEdits/workspace-write allow edits, not git),
+  // so run.branch's tip lags the worktree. Land commits first — so preview the state land will
+  // actually see: `git stash create` mints a commit of the working tree (tracked mods) without
+  // touching anything, sharing the object store so merge-tree in the repo can reference it.
+  let tip = run.branch;
+  if (run.worktreePath) {
+    const st = await runShellOn(ctx.machine, `git -C ${shq(run.worktreePath)} stash create 2>/dev/null`, 10000);
+    const stashCommit = st.ok ? st.stdout.trim() : '';
+    if (/^[0-9a-f]{7,40}$/.test(stashCommit)) tip = stashCommit;
+  }
+  const mt = await runShellOn(
+    ctx.machine,
+    `git -C ${repo} merge-tree --write-tree --name-only ${shq(target)} ${shq(tip)} 2>&1; echo "EXIT=$?"`,
+    20000,
+  );
+  const raw = mt.stdout;
+  if (/usage: git merge-tree|unknown option|error: unknown/i.test(raw)) {
+    return { supported: false, clean: false, conflicts: [], target, ahead: lt.ahead, behind: lt.behind, detail: 'git >= 2.38 required for conflict preview' };
+  }
+  const m = raw.match(/EXIT=(\d+)\s*$/);
+  const code = m ? parseInt(m[1] ?? '1', 10) : 1;
+  const body = raw.replace(/\n?EXIT=\d+\s*$/, '');
+  const lines = body.split('\n');
+  const conflicts: string[] = [];
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i]?.trim() === '') break;
+    const p = lines[i]?.trim();
+    if (p) conflicts.push(p);
+  }
+  return { supported: true, clean: code === 0, conflicts, target, ahead: lt.ahead, behind: lt.behind };
+}
 export async function cleanupRun(runId: number): Promise<{ ok: boolean; detail: string }> {
   const ctx = await loadContext(runId);
   const rr = await db.select().from(agentRuns).where(eq(agentRuns.id, runId)).limit(1);

package/src/server.ts CHANGED Viewed

@@ -18,7 +18,7 @@ import { db } from './db';
 import { machines, repos, tasks, agentRuns, agentEvents, designCaptures, shareLinks, taskGroups } 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 } from './orchestrator';
+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 } from './orchestrator';
 import { openTerm } from './term';
 import { addSink, removeSink, broadcast } from './hub';
 import { getProvider, listProviders } from './providers';
@@ -328,9 +328,13 @@ export async function buildServer(): Promise<FastifyInstance> {
       arr.push({ kind: e.kind, payload: e.payload });
       byRun.set(e.runId, 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) => ({ ...r, events: (byRun.get(r.id) ?? []).slice(-EVENT_CAP) })),
+      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 };
+      }),
       counts: { activeTasks: activeTasks.length, closedTasks: closedCount },
       // 보드 헤더 "어느 데몬에 붙어 있나" 표시용 (인증 뒤라 dbPath 노출 가능)
       // authOpen = 비밀번호 미설정 → Funnel(공개) 가드가 켜져야 함(원격접근 카드용)
@@ -859,6 +863,24 @@ export async function buildServer(): Promise<FastifyInstance> {
     return res;
   });
+  // v5.1 Part C foundation — resolve the land target + base drift for a run.
+  // ?fetch=1 refreshes the remote first (network) so ahead/behind are current.
+  app.get('/api/runs/:id/land-target', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    if (!Number.isFinite(id)) return reply.code(400).send({ error: 'bad id' });
+    const doFetch = ((req.query ?? {}) as { fetch?: string }).fetch === '1';
+    return await landTarget(id, { fetch: doFetch });
+  });
+  // v5.1 A1 — conflict preview: what would conflict if this run landed on the target (merge-tree,
+  // read-only). ?fetch=1 refreshes origin first; ?target=origin/x overrides the resolved target.
+  app.get('/api/runs/:id/merge/preview', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    if (!Number.isFinite(id)) return reply.code(400).send({ error: 'bad id' });
+    const q = (req.query ?? {}) as { fetch?: string; target?: string };
+    return await mergePreview(id, { fetch: q.fetch === '1', target: q.target && q.target.trim() ? q.target.trim() : undefined });
+  });
   // 승자 run 머지 — run 브랜치를 repo 기본 브랜치로.
   app.post('/api/runs/:id/merge', async (req, reply) => {
     const id = Number((req.params as { id: string }).id);
@@ -961,6 +983,14 @@ export async function buildServer(): Promise<FastifyInstance> {
     };
   });
+  // v5.1 A3 — sibling overlap: which files 2+ runs in the group both touch + suggested land order.
+  // Read-only, on-demand (shells git per run) — never on the fleet-poll path.
+  app.get('/api/groups/:id/overlap', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    if (!Number.isFinite(id)) return reply.code(400).send({ error: 'bad id' });
+    return await groupOverlap(id);
+  });
   // B2 — "＋ New attempt": 그룹에 새 시도(들)를 발사. repo 는 그룹의 기존 태스크에서 상속.
   app.post('/api/groups/:id/spawn', async (req, reply) => {
     const id = Number((req.params as { id: string }).id);
@@ -1061,6 +1091,17 @@ export async function buildServer(): Promise<FastifyInstance> {
     return res;
   });
+  // v5.1 step 5 — resolve a conflicting land in-app: coxpit prepares the conflict state, the run's
+  // own agent edits the markers, then it commits/pushes/PRs automatically when clean.
+  app.post('/api/runs/:id/land/resolve', 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);
+    if (!rr[0]) return reply.code(404).send({ error: 'not found' });
+    const res = await startLandResolve(id);
+    if (!res.ok) return reply.code(409).send(res);
+    return res;
+  });
   // 실행 중 run 중지(SIGTERM) — close 핸들러가 stopped 로 봉인.
   app.post('/api/runs/:id/stop', async (req, reply) => {
     const id = Number((req.params as { id: string }).id);