coxpit 3.8.0 → 4.0.0

package/README.md

@@ -20,6 +20,9 @@ Your machines. Your auth. Your code never leaves your network.
 - **Multi-machine** — register remote machines over SSH (Tailscale/LAN); probe reachability (git·tmux), run fleets there.
 - **Safe stops** — stop kills the whole process group; task close stops and cleans every worktree/branch.
 - **Design Mode** — drag the `⌖ coxpit inspect` bookmarklet to your bar, click it on your running app, click any element: its selector, HTML and computed styles are captured and injected into the agents' prompt as design context.
+- **Self-orchestrating agents** — every local run can spawn its own sub-agents by writing `.coxpit/spawn.json` in its worktree (works under default permissions — no network, no escalation). The daemon launches each subtask as an isolated sub-run and maintains `.coxpit/subtasks.json` with live status. Orchestration moves inside the agent's own reasoning loop.
+- **Start from GitHub** — paste an issue/PR URL and the task form drafts itself from its title and body (gh CLI for private repos, public API otherwise). You review, pick a provider, Run fleet.
+- **Share a run** — one click mints a read-only snapshot link (timeline + diff, no auth, no actions). Show your fleet's work without opening your cockpit.
 
 External tools are spawned, never vendored: `git`, `tmux`, your agent CLI. No editor bundled — terminal-first.
 
@@ -74,6 +77,7 @@ Your keys and login never touch coxpit's config or database.
 | `COXPIT_AGENT_PERM` | `acceptEdits` | Claude Code headless permission mode |
 | `COXPIT_CODEX_BIN` | `codex` | Codex CLI command (optional second provider) |
 | `COXPIT_CODEX_SANDBOX` | `workspace-write` | Codex sandbox policy (`danger-full-access` for full autonomy) |
+| `COXPIT_AGENT_ORCH` | on | `0` disables agent self-orchestration (the `.coxpit/spawn.json` protocol + prompt note) |
 | `COXPIT_WEBHOOK_URL` | — | POSTs `{event:"run.settled",run:{...}}` when a run finishes — wire it to Telegram, Slack, anything |
 | `COXPIT_PUBLIC_URL` | — | if set, the webhook payload adds `url: <base>/?run=<id>` — tap it on your phone and the board opens that run |
 
@@ -105,7 +109,7 @@ One daemon, one SQLite file, zero external services. Machines are reached over S
 
 ## Status
 
-`v3.0` — fleet, compare/merge, terminal, Design Mode, run destinations (merge · export · PR), swarm (plan fan-out + integrate with conflict-resolving agents), AI review, and sessions (work/ask + notifications) — all shipped and e2e-tested. Roadmap: ROADMAP.md.
+`v4.0` — fleet, two providers (Claude Code · Codex), compare/merge + AI review + doc mode, terminal (full-screen, session tabs, mobile input bar), swarm (plan fan-out · integrate · agent self-orchestration), sessions (steer/ask · resume), mobile board with deep links, GitHub import, read-only share links — all shipped and e2e-tested (30 checks). Roadmap: ROADMAP.md.
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coxpit",
-  "version": "3.8.0",
+  "version": "4.0.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/auth.ts

@@ -3,7 +3,9 @@ import { config } from './config';
 
 // /api/design/capture · /design/bookmarklet.js 는 외부 앱(북마클릿)에서 오므로
 // basic 헤더를 못 싣는다 — 라우트 자체가 캡처 키(?k=)를 검증한다.
-const EXEMPT = new Set(['/api/health', '/api/design/capture', '/design/bookmarklet.js']);
+// /api/agent/subtasks 는 에이전트 Bearer 토큰(라우트 자체 검증), /share/* 는 토큰 URL 이 곧 능력.
+const EXEMPT = new Set(['/api/health', '/api/design/capture', '/design/bookmarklet.js', '/api/agent/subtasks']);
+const EXEMPT_PREFIX = ['/share/'];
 
 /**
  * 인증 게이트 — 현재 basic. 플러그형 좌석: 배포 시 앞단에 Cloudflare Access / Tailscale 을
@@ -13,6 +15,7 @@ export async function authGate(req: FastifyRequest, reply: FastifyReply): Promis
   if (config.auth.disabled) return;
   const path = req.url.split('?')[0] ?? '';
   if (EXEMPT.has(path)) return;
+  if (EXEMPT_PREFIX.some((p) => path.startsWith(p))) return;
 
   const h = req.headers.authorization ?? '';
   if (h.startsWith('Basic ') && config.auth.pass !== '') {

package/src/board.ts

@@ -399,6 +399,7 @@ export const BOARD_HTML = /* html */ `<!doctype html>
         <div id="panelTask" style="display:flex;flex-direction:column;gap:8px">
           <input id="taskTitle" placeholder="Task title" />
           <textarea id="taskPrompt" placeholder="Prompt — target files, constraints, how to verify"></textarea>
+          <button type="button" class="btn-ghost sm" id="ghImport">From GitHub issue / PR…</button>
           <div class="seg" id="provSeg" role="group" aria-label="agent provider">
             <button type="button" class="seg-opt on" data-agent="claude-code">Claude</button>
             <button type="button" class="seg-opt" data-agent="codex">Codex</button>
@@ -478,6 +479,7 @@ export const BOARD_HTML = /* html */ `<!doctype html>
       <button class="btn-ghost sm" id="mCompare">Compare runs</button>
       <button class="btn-ghost sm" id="mExport">Export files…</button>
       <button class="btn-ghost sm" id="mSync">Sync base</button>
+      <button class="btn-ghost sm" id="mShare" title="create a read-only share link (no auth, snapshot view)">Share</button>
       <span class="spacer"></span>
       <button class="btn-danger sm" id="mStop">Stop</button>
       <button class="btn-ghost sm" id="mCleanup">Cleanup</button>
@@ -548,6 +550,21 @@ export const BOARD_HTML = /* html */ `<!doctype html>
   <button class="btn-ghost sm" id="selCancel">Cancel</button>
 </div>
 
+<div class="overlay" id="ghOverlay">
+  <div class="cfm">
+    <div class="cfm-b">
+      <div class="m">Start from a GitHub issue or pull request</div>
+      <div class="s">Fetches the title and body into the task form — you review, pick a provider, then Run fleet. Private repos need the gh CLI signed in on the daemon machine.</div>
+      <p class="flabel" style="margin-top:12px">issue / PR url</p>
+      <input id="ghUrl" placeholder="https://github.com/owner/repo/issues/123" />
+    </div>
+    <div class="cfm-f">
+      <button class="btn-ghost sm" id="ghCancel">Cancel</button>
+      <button class="btn sm" id="ghOk">Fetch</button>
+    </div>
+  </div>
+</div>
+
 <div class="overlay" id="expOverlay">
   <div class="cfm">
     <div class="cfm-b">
@@ -726,6 +743,7 @@ function humanize(e){
     }
     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{
@@ -851,6 +869,7 @@ function cardHTML(r){
     + '<div class="meta"><span>branch <b>'+esc(r.branch||'—')+'</b></span>'
     + '<span>files <b>'+(r.filesChanged??0)+'</b></span>'
     + '<span>'+esc(r.agent||'')+'</span>'
+    + (task && task.parentRunId ? '<span title="spawned by agent r'+task.parentRunId+'">↳ by r'+task.parentRunId+'</span>' : '')
     + (r.sessionId && ['done','failed','stopped'].includes(r.status)
         ? '<span class="resumable" title="agent session preserved — open the run and Send a next instruction to continue">↻ resumable</span>' : '')
     + (r.prUrl ? '<a href="'+esc(r.prUrl)+'" target="_blank" rel="noopener" style="margin-left:auto">PR ↗</a>' : '')
@@ -1106,7 +1125,7 @@ $('grid').addEventListener('click',(e)=>{
 });
 $('mClose').addEventListener('click', closeModal);
 $('overlay').addEventListener('click',(e)=>{ if(e.target===$('overlay')) closeModal(); });
-document.addEventListener('keydown',(e)=>{ if(e.key==='Escape'){ closeDropdowns(); cfmClose(false); $('brwOverlay').classList.remove('open'); $('expOverlay').classList.remove('open'); closeTerm(); closeModal(); cmpTaskId=null; $('cmpOverlay').classList.remove('open'); } });
+document.addEventListener('keydown',(e)=>{ if(e.key==='Escape'){ closeDropdowns(); cfmClose(false); $('brwOverlay').classList.remove('open'); $('expOverlay').classList.remove('open'); $('ghOverlay').classList.remove('open'); closeTerm(); closeModal(); cmpTaskId=null; $('cmpOverlay').classList.remove('open'); } });
 $('mRefreshDiff').addEventListener('click', loadDiff);
 $('mExport').addEventListener('click', ()=>{
   if (openRunId==null) return;
@@ -1530,6 +1549,38 @@ let savedAgent = null;
 try { savedAgent = localStorage.getItem('coxpit.agent'); } catch {}
 if (savedAgent === 'codex') setProvider('codex', false);
 
+/* ── GitHub 이슈/PR → 태스크 초안 ── */
+$('ghImport').addEventListener('click', ()=>{ $('ghUrl').value=''; $('ghOverlay').classList.add('open'); $('ghUrl').focus(); });
+$('ghCancel').addEventListener('click', ()=>$('ghOverlay').classList.remove('open'));
+$('ghOverlay').addEventListener('click',(e)=>{ if(e.target===$('ghOverlay')) $('ghOverlay').classList.remove('open'); });
+async function ghFetch(){
+  const url = $('ghUrl').value.trim();
+  if (!url) return;
+  $('ghOk').disabled = true; $('ghOk').textContent = 'Fetching…';
+  try{
+    const res = await fetch('/api/tasks/from-github',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({url})});
+    const j = await res.json().catch(()=>({}));
+    if (!res.ok){ toast('github: '+(j.error||res.status), 'error'); return; }
+    $('taskTitle').value = j.title; $('taskPrompt').value = j.prompt;
+    $('ghOverlay').classList.remove('open');
+    toast('drafted from GitHub — review, then Run fleet', 'ok');
+  } finally { $('ghOk').disabled = false; $('ghOk').textContent = 'Fetch'; }
+}
+$('ghOk').addEventListener('click', ghFetch);
+$('ghUrl').addEventListener('keydown',(e)=>{ if(e.key==='Enter') ghFetch(); });
+
+/* ── 읽기 전용 공유 링크 ── */
+$('mShare').addEventListener('click', async ()=>{
+  if (openRunId==null) return;
+  const res = await fetch('/api/runs/'+openRunId+'/share',{method:'POST'});
+  const j = await res.json().catch(()=>({}));
+  if (!res.ok){ toast('share: '+(j.error||res.status), 'error'); return; }
+  const url = location.origin + j.url;
+  let copied = false;
+  try{ await navigator.clipboard.writeText(url); copied = true; }catch{}
+  toast((j.existing?'share link (existing)':'share link created')+(copied?' — copied':'')+': '+url, 'ok');
+});
+
 /* ── mobile drawer ── */
 const asideEl = document.querySelector('aside');
 function setDrawer(on){ asideEl.classList.toggle('open', on); $('scrim').classList.toggle('on', on); }

package/src/config.ts

@@ -75,6 +75,9 @@ export const config = {
     // 완전 자율은 bypassPermissions.
     perm: process.env.COXPIT_AGENT_PERM ?? 'acceptEdits',
   },
+  // 에이전트 셀프 오케스트레이션 — real+로컬 run 에 COXPIT_API/COXPIT_TOKEN env 와
+  // 능력 고지를 준다(에이전트가 /api/agent/subtasks 로 서브런 발사). '0' 으로 끔.
+  agentOrch: process.env.COXPIT_AGENT_ORCH !== '0',
   codex: {
     // 두 번째 프로바이더 — OpenAI Codex CLI (선택 설치). providers.ts 의 시임.
     bin: process.env.COXPIT_CODEX_BIN ?? 'codex',

package/src/db/index.ts

@@ -69,9 +69,16 @@ export async function ensureSchema(): Promise<void> {
       payload TEXT NOT NULL DEFAULT '',
       ts INTEGER DEFAULT (unixepoch())
     );
+    CREATE TABLE IF NOT EXISTS share_links (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id INTEGER NOT NULL,
+      token TEXT NOT NULL UNIQUE,
+      created_at INTEGER DEFAULT (unixepoch())
+    );
   `);
   // 기존 DB 마이그레이션(멱등)
   try { await client.execute('ALTER TABLE tasks ADD COLUMN design_capture_id INTEGER'); } catch { /* exists */ }
   try { await client.execute("ALTER TABLE agent_runs ADD COLUMN session_id TEXT NOT NULL DEFAULT ''"); } catch { /* exists */ }
   try { await client.execute("ALTER TABLE agent_runs ADD COLUMN pr_url TEXT NOT NULL DEFAULT ''"); } catch { /* exists */ }
+  try { await client.execute('ALTER TABLE tasks ADD COLUMN parent_run_id INTEGER'); } catch { /* exists */ }
 }

package/src/db/schema.ts

@@ -40,6 +40,15 @@ export const tasks = sqliteTable('tasks', {
   prompt: text('prompt').notNull().default(''),
   status: text('status').notNull().default('open'), // open | done
   designCaptureId: integer('design_capture_id'), // 선택 — 프롬프트에 DESIGN CONTEXT 주입
+  parentRunId: integer('parent_run_id'), // 에이전트 셀프 오케스트레이션 — 이 태스크를 발사한 run
+  createdAt: integer('created_at', { mode: 'timestamp' }),
+});
+
+/** 읽기 전용 공유 링크 — run 스냅샷을 무인증으로 보여준다(토큰 = capability). */
+export const shareLinks = sqliteTable('share_links', {
+  id: integer('id').primaryKey({ autoIncrement: true }),
+  runId: integer('run_id').notNull(),
+  token: text('token').notNull().unique(),
   createdAt: integer('created_at', { mode: 'timestamp' }),
 });
 

package/src/orchestrator.ts

@@ -1,7 +1,8 @@
+import { randomBytes } from 'node:crypto';
 import { posix as ppath } from 'node:path';
 import { createInterface } from 'node:readline';
 import { existsSync } from 'node:fs';
-import { mkdir, copyFile } from 'node:fs/promises';
+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';
@@ -40,6 +41,134 @@ async function setRun(runId: number, patch: Partial<typeof agentRuns.$inferInser
 const liveChildren = new Map<number, ChildProcess>();
 const stoppedRuns = new Set<number>();
 
+// ── 에이전트 셀프 오케스트레이션 ──────────────────────────────
+// run 마다 1회용 토큰을 발급해 에이전트 env 로 준다. 에이전트는 그 토큰으로
+// /api/agent/subtasks 를 호출해 같은 repo 에 독립 서브런을 발사할 수 있다.
+// 인메모리 = 데몬 재시작 시 무효(고아 정산과 같은 수명 철학).
+const agentTokens = new Map<string, number>(); // token -> runId
+
+function issueAgentToken(runId: number): string {
+  for (const [t, r] of agentTokens) if (r === runId) return t; // steer 재사용
+  const tok = randomBytes(16).toString('hex');
+  agentTokens.set(tok, runId);
+  return tok;
+}
+
+/** Bearer 토큰 → runId (없으면 null). server 의 /api/agent/* 가 사용. */
+export function resolveAgentToken(token: string): number | null {
+  return agentTokens.get(token) ?? null;
+}
+
+/** 에이전트 프롬프트에 붙는 능력 고지 — 독립 하위작업을 병렬 서브런으로 뺄 수 있다.
+ * 파일 기반: 기본 권한(claude acceptEdits · codex workspace-write)이 네트워크를 막아도
+ * 파일 쓰기는 되므로, spawn 요청을 워크트리의 .coxpit/spawn.json 으로 받는다. */
+function orchestrationNote(): string {
+  return '\n\n--- COXPIT ORCHESTRATION (optional) ---\n' +
+    'You can parallelize genuinely independent subwork by spawning sub-agents. To spawn, write the file ' +
+    '`.coxpit/spawn.json` in your working directory:\n' +
+    '  {"title": "short title", "prompt": "full agent prompt", "count": 1}\n' +
+    '(or an array of such objects, max 4). The daemon consumes it within ~2s and launches each subtask ' +
+    'as an isolated sub-run of this repository. It keeps `.coxpit/subtasks.json` updated with their live ' +
+    'status — read it to check progress. Prefer doing work yourself; spawn only clearly separable, ' +
+    'file-disjoint tasks. Do not busy-wait on sub-agents.\n' +
+    '--- END COXPIT ORCHESTRATION ---';
+}
+
+/**
+ * 파일 기반 오케스트레이션 워처 — run 이 사는 동안 worktree 의 .coxpit/spawn.json 을
+ * 소비해 서브태스크를 발사하고, .coxpit/subtasks.json 에 현황을 유지한다.
+ * 로컬 run 전용(원격은 데몬이 파일에 못 닿음). 반환된 타이머는 run 종료 시 정리.
+ */
+export function startOrchWatch(runId: number, wtPath: string, real: boolean): NodeJS.Timeout {
+  const dir = ppath.join(wtPath, '.coxpit');
+  let last = '';
+  let busy = false;
+  return setInterval(() => {
+    if (busy) return;
+    busy = true;
+    void (async () => {
+      try {
+        const spawnPath = ppath.join(dir, 'spawn.json');
+        const txt = await readFile(spawnPath, 'utf8').catch(() => null);
+        if (txt !== null) {
+          await rm(spawnPath).catch(() => { /* consumed */ });
+          try {
+            const req = JSON.parse(txt) as unknown;
+            const items = (Array.isArray(req) ? req : [req]) as Array<{ title?: string; prompt?: string; count?: number }>;
+            for (const it of items.slice(0, 4)) {
+              if (typeof it?.title === 'string' && typeof it?.prompt === 'string' && it.title && it.prompt) {
+                await spawnSubtasks(runId, it.title, it.prompt, Number(it.count) || 1, real);
+              }
+            }
+          } catch {
+            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);
+          }
+        }
+      } catch { /* 워처 오류는 조용히 — 다음 틱에 재시도 */ }
+      busy = false;
+    })();
+  }, 1500);
+}
+
+/**
+ * 에이전트가 요청한 서브태스크 생성+발사. 부모 run 의 repo/머신/프로바이더 상속, real 고정
+ * (토큰은 real run 에만 발급되므로). 결과는 부모 타임라인에 meta 이벤트로 남는다.
+ */
+export async function spawnSubtasks(parentRunId: number, title: string, prompt: string, count: number, real = true): Promise<{
+  ok: boolean; detail: string; taskId?: number; runIds?: number[];
+}> {
+  const pr = (await db.select().from(agentRuns).where(eq(agentRuns.id, parentRunId)).limit(1))[0];
+  if (!pr) return { ok: false, detail: 'parent run not found' };
+  const pt = (await db.select().from(tasks).where(eq(tasks.id, pr.taskId)).limit(1))[0];
+  if (!pt) return { ok: false, detail: 'parent task not found' };
+  // 폭주 가드 — 한 부모가 만들 수 있는 하위 태스크 상한
+  const siblings = await db.select().from(tasks).where(eq(tasks.parentRunId, parentRunId));
+  if (siblings.length >= 8) return { ok: false, detail: 'subtask limit reached (8 per run)' };
+  const n = Math.max(1, Math.min(4, count || 1));
+  const tIns = await db.insert(tasks).values({
+    repoId: pt.repoId, title: title.slice(0, 140), prompt, parentRunId,
+  }).returning();
+  const task = tIns[0]!;
+  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, status: 'pending',
+    }).returning();
+    const run = rIns[0]!;
+    broadcast({ type: 'run', runId: run.id, taskId: task.id, status: 'pending', agent: run.agent, branch: '', filesChanged: 0 });
+    void launchRun(run.id, real);
+    runIds.push(run.id);
+  }
+  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 };
+}
+
+/** 부모 run 이 발사한 서브태스크 현황 — 에이전트 폴링용. */
+export async function listSubtasks(parentRunId: number): Promise<Array<{
+  id: number; title: string; runs: Array<{ id: number; status: string; filesChanged: number; exitSummary: string }>;
+}>> {
+  const ts = await db.select().from(tasks).where(eq(tasks.parentRunId, parentRunId));
+  const out = [];
+  for (const t of ts) {
+    const rs = await db.select().from(agentRuns).where(eq(agentRuns.taskId, t.id));
+    out.push({
+      id: t.id, title: t.title,
+      runs: rs.map((r) => ({ id: r.id, status: r.status, filesChanged: r.filesChanged, exitSummary: r.exitSummary.slice(0, 200) })),
+    });
+  }
+  return out;
+}
+
 /**
  * 원격 에이전트 kill 스크립트 — pid 파일 기준.
  * $$ 가 그룹 리더가 아닐 수 있어 ps 로 실제 pgid 를 조회해 그룹째 죽인다
@@ -155,8 +284,29 @@ export async function launchRun(runId: number, real?: boolean): Promise<void> {
     const pidPrefix = isRemote ? `printf '%s' "$$" > .coxpit-agent.pid && ` : '';
     // 드라이런 모의 스트림은 claude 형태 — 파서도 claude 로 (배관 리허설은 프로바이더 불문)
     const provider = useReal ? getProvider(ctx.agent) : getProvider('claude-code');
-    const cmd = `cd ${shq(wtPath)} && ${pidPrefix}{ ${agentCommand(provider, ctx.prompt, useReal)}; }`;
-    await runAgentChild(runId, ctx.machine, wtPath, cmd, provider);
+    // 셀프 오케스트레이션 — real+로컬 run 에만 토큰/API env 와 능력 고지를 준다
+    // (원격은 127.0.0.1 이 데몬에 닿지 않음). COXPIT_AGENT_ORCH=0 으로 끌 수 있음.
+    let prompt = ctx.prompt;
+    let envPrefix = '';
+    if (useReal && !isRemote && config.agentOrch) {
+      const tok = issueAgentToken(runId);
+      envPrefix = `export COXPIT_API=${shq(`http://127.0.0.1:${config.port}`)} COXPIT_TOKEN=${shq(tok)}; `;
+      prompt += orchestrationNote();
+    }
+    const cmd = `cd ${shq(wtPath)} && ${envPrefix}${pidPrefix}{ ${agentCommand(provider, prompt, useReal)}; }`;
+    // 파일 오케스트레이션 — 로컬 run 이 사는 동안 .coxpit/spawn.json 감시.
+    // .coxpit/ 는 repo exclude 에 넣어 diff/머지를 오염시키지 않는다(멱등).
+    let orchTimer: NodeJS.Timeout | null = null;
+    if (!isRemote && config.agentOrch) {
+      await runShellOn(ctx.machine,
+        `EX=$(git -C ${shq(wtPath)} rev-parse --git-path info/exclude) && { grep -qxF '.coxpit/' "$EX" 2>/dev/null || echo '.coxpit/' >> "$EX"; }`, 8000);
+      orchTimer = startOrchWatch(runId, wtPath, useReal);
+    }
+    try {
+      await runAgentChild(runId, ctx.machine, wtPath, cmd, provider);
+    } finally {
+      if (orchTimer) clearInterval(orchTimer);
+    }
   } catch (e) {
     await recordEvent(runId, 'error', String(e).slice(0, 500));
     await setRun(runId, { status: 'error', endedAt: new Date(), exitSummary: 'orchestrator error' });
@@ -255,9 +405,18 @@ export async function steerRun(runId: number, message: string, mode: 'work' | 'a
   const isRemote = ctx.machine.kind !== 'local' && ctx.machine.address !== '';
   const pidPrefix = isRemote ? `printf '%s' "$$" > .coxpit-agent.pid && ` : '';
   const provider = getProvider(ctx.agent);
+  // steer 세션도 셀프 오케스트레이션 유지(데몬 재시작으로 무효화된 토큰 재발급)
+  const envPrefix = (!isRemote && config.agentOrch)
+    ? `export COXPIT_API=${shq(`http://127.0.0.1:${config.port}`)} COXPIT_TOKEN=${shq(issueAgentToken(runId))}; `
+    : '';
   const resume = provider.resumeCmd(run.sessionId, finalMessage);
-  const cmd = `cd ${shq(wt)} && ${pidPrefix}{ ${resume}; }`;
-  void runAgentChild(runId, ctx.machine, wt, cmd, provider);
+  const cmd = `cd ${shq(wt)} && ${envPrefix}${pidPrefix}{ ${resume}; }`;
+  if (!isRemote && config.agentOrch) {
+    const orchTimer = startOrchWatch(runId, wt, true);
+    void runAgentChild(runId, ctx.machine, wt, cmd, provider).finally(() => clearInterval(orchTimer));
+  } else {
+    void runAgentChild(runId, ctx.machine, wt, cmd, provider);
+  }
   return { ok: true, detail: 'steering' };
 }
 

package/src/server.ts

@@ -3,16 +3,17 @@ import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve as presolve, dirname as pdirname, join as pjoin } from 'node:path';
 import { createRequire } from 'node:module';
+import { randomBytes } from 'node:crypto';
 import Fastify, { type FastifyInstance } from 'fastify';
 import websocket from '@fastify/websocket';
 import { eq } from 'drizzle-orm';
 import { authGate } from './auth';
 import { config } from './config';
 import { db } from './db';
-import { machines, repos, tasks, agentRuns, agentEvents, designCaptures } from './db/schema';
+import { machines, repos, tasks, agentRuns, agentEvents, designCaptures, shareLinks } from './db/schema';
 import { BOOKMARKLET_JS } from './design';
 import { runShellOn, shq } from './exec';
-import { launchRun, cleanupRun, stopRun, getRunDiff, getRunDocs, mergeRun, getRunTermInfo, steerRun, exportRun, prRun, integrateRuns, planFanout, reviewTask, syncRun, openWorkbench } from './orchestrator';
+import { launchRun, cleanupRun, stopRun, getRunDiff, getRunDocs, mergeRun, getRunTermInfo, steerRun, exportRun, prRun, integrateRuns, planFanout, reviewTask, syncRun, openWorkbench, spawnSubtasks, listSubtasks, resolveAgentToken } from './orchestrator';
 import { openTerm } from './term';
 import { addSink, removeSink, broadcast } from './hub';
 import { getProvider, listProviders } from './providers';
@@ -28,6 +29,99 @@ const VENDOR: Record<string, { pkg: string; rel: string; type: string }> = {
   'addon-unicode11.js': { pkg: '@xterm/addon-unicode11/package.json', rel: 'lib/addon-unicode11.js', type: 'text/javascript' },
 };
 
+// ─── 읽기 전용 공유 페이지 (서버 렌더 스냅샷 — 스크립트 0, 액션 0) ───────────
+const escH = (x: unknown): string =>
+  String(x ?? '').replace(/[&<>"]/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[c]!));
+
+/** 보드 humanize 의 서버측 축약판 — 이벤트 한 줄을 {k, t} 로. null = 잡음. */
+function shareLine(kind: string, payload: string): { k: string; t: string } | null {
+  if (kind === 'steer') return { k: 'steer', t: '→ ' + payload };
+  if (kind === 'ask') return { k: 'ask', t: '? ' + payload };
+  if (kind === 'sync' || kind === 'pr' || kind === 'export') return { k: kind, t: payload };
+  if (kind === 'stderr' || kind === 'error') return { k: kind, t: payload };
+  try {
+    const o = JSON.parse(payload) as {
+      type?: string; subtype?: string; text?: string; result?: string; worktree?: string;
+      message?: { content?: Array<{ type?: string; text?: string; name?: string; input?: Record<string, string> }> };
+    };
+    if (o.type === 'system') return o.subtype === 'init' || !o.subtype ? { k: 'session', t: 'started' } : null;
+    if (o.type === 'user') return null;
+    if (o.type === 'assistant' && o.message) {
+      const parts: string[] = [];
+      for (const c of o.message.content ?? []) {
+        if (c.type === 'text' && c.text) parts.push(c.text);
+        else if (c.type === 'tool_use') {
+          const i = c.input ?? {};
+          const arg = i.file_path || i.command || i.path || i.pattern || '';
+          parts.push('▸ ' + (c.name ?? 'tool') + (arg ? ' — ' + String(arg).split('/').slice(-2).join('/').slice(0, 60) : ''));
+        }
+      }
+      return parts.length ? { k: 'agent', t: parts.join(' · ') } : 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.worktree) return { k: 'start', t: 'worktree ' + String(o.worktree).split('/').slice(-2).join('/') };
+    return null;
+  } catch { return payload.trim().startsWith('{') ? null : { k: kind, t: payload.slice(0, 160) }; }
+}
+
+function shareDiffHTML(text: string): string {
+  if (!text.trim()) return '<span style="color:#5c6675">no changes</span>';
+  return text.slice(0, 120_000).split('\n').map((l) => {
+    const e = escH(l);
+    if (l.startsWith('diff --git') || l.startsWith('+++') || l.startsWith('---')) return `<span class="f">${e}</span>`;
+    if (l.startsWith('@@')) return `<span class="h">${e}</span>`;
+    if (l.startsWith('+')) return `<span class="a">${e}</span>`;
+    if (l.startsWith('-')) return `<span class="d">${e}</span>`;
+    return e;
+  }).join('\n');
+}
+
+function sharePageHTML(
+  run: { id: number; status: string; branch: string; agent: string; filesChanged: number; exitSummary: string },
+  taskTitle: string,
+  events: Array<{ kind: string; payload: string }>,
+  diff: string,
+): string {
+  const lines = events.map((e) => shareLine(e.kind, e.payload)).filter((x): x is { k: string; t: string } => !!x);
+  const sc: Record<string, string> = { done: '#3fb970', merged: '#4ec9b0', failed: '#e5534b', error: '#e5534b', stopped: '#a371f7', running: '#4184e4', open: '#4ec9b0' };
+  const color = sc[run.status] ?? '#8792a2';
+  return `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>coxpit · r${run.id} — ${escH(taskTitle)}</title>
+<style>
+  body{margin:0;background:#0b0d12;color:#dee4ec;font-family:-apple-system,'Segoe UI',sans-serif;font-size:14px;line-height:1.55}
+  .wrap{max-width:960px;margin:0 auto;padding:28px 18px 60px}
+  .hd{display:flex;align-items:baseline;gap:10px;flex-wrap:wrap;margin-bottom:4px}
+  .mark{color:#4ec9b0;font-family:ui-monospace,monospace;font-weight:700}
+  .rid{color:#5c6675;font-family:ui-monospace,monospace}
+  h1{font-size:17px;margin:6px 0 2px}
+  .chip{display:inline-block;font-family:ui-monospace,monospace;font-size:11px;text-transform:uppercase;letter-spacing:.08em;
+    padding:2px 10px;border:1px solid ${color};border-radius:999px;color:${color}}
+  .meta{color:#5c6675;font-family:ui-monospace,monospace;font-size:11.5px;margin:8px 0 22px}
+  .sec{font-family:ui-monospace,monospace;font-size:10px;text-transform:uppercase;letter-spacing:.14em;color:#5c6675;
+    border-bottom:1px solid #222835;padding-bottom:6px;margin:26px 0 10px}
+  .tl{font-family:ui-monospace,monospace;font-size:12px;display:flex;flex-direction:column;gap:6px}
+  .tl .k{color:#4ec9b0;display:inline-block;min-width:64px}
+  .tl .t{color:#8792a2;word-break:break-word}
+  pre{background:#0e1118;border:1px solid #222835;border-radius:10px;padding:14px;overflow-x:auto;
+    font-family:ui-monospace,monospace;font-size:11.5px;line-height:1.5;white-space:pre-wrap;word-break:break-all}
+  .f{color:#4ec9b0;font-weight:600}.h{color:#4184e4}.a{color:#3fb970}.d{color:#e5534b}
+  .sum{background:#12151c;border:1px solid #222835;border-radius:10px;padding:12px 14px;color:#8792a2;font-size:13px}
+  .ft{margin-top:40px;color:#3d4657;font-size:12px;font-family:ui-monospace,monospace}
+  .ft a{color:#4ec9b0;text-decoration:none}
+</style></head><body><div class="wrap">
+  <div class="hd"><span class="mark">coxpit</span><span class="rid">r${run.id}</span><span class="chip">${escH(run.status)}</span></div>
+  <h1>${escH(taskTitle)}</h1>
+  <div class="meta">branch ${escH(run.branch || '—')} · ${run.filesChanged} file(s) changed · agent ${escH(run.agent)}</div>
+  ${run.exitSummary ? `<div class="sum">${escH(run.exitSummary)}</div>` : ''}
+  <div class="sec">Timeline</div>
+  <div class="tl">${lines.map((l) => `<div><span class="k">${escH(l.k)}</span><span class="t">${escH(l.t.slice(0, 220))}</span></div>`).join('') || '<span style="color:#5c6675">no events</span>'}</div>
+  <div class="sec">Diff</div>
+  <pre>${shareDiffHTML(diff)}</pre>
+  <div class="ft">read-only snapshot shared via <a href="https://github.com/hanmariyang/coxpit-oss">coxpit</a></div>
+</div></body></html>`;
+}
+
 export async function buildServer(): Promise<FastifyInstance> {
   const app = Fastify({ logger: true });
   await app.register(websocket);
@@ -517,6 +611,91 @@ export async function buildServer(): Promise<FastifyInstance> {
     return getRunDocs(id);
   });
 
+  // ─── 에이전트 셀프 오케스트레이션 (run 별 Bearer 토큰 — authGate 예외, 여기서 자체 검증) ──
+  const agentAuth = (req: { headers: { authorization?: string } }): number | null => {
+    const h = req.headers.authorization ?? '';
+    if (!h.startsWith('Bearer ')) return null;
+    return resolveAgentToken(h.slice(7).trim());
+  };
+
+  app.post('/api/agent/subtasks', async (req, reply) => {
+    const rid = agentAuth(req);
+    if (rid == null) return reply.code(401).send({ error: 'invalid agent token' });
+    const b = (req.body ?? {}) as { title?: string; prompt?: string; count?: number };
+    if (!b.title?.trim() || !b.prompt?.trim()) return reply.code(400).send({ error: 'title and prompt required' });
+    const r = await spawnSubtasks(rid, b.title.trim(), b.prompt, Number(b.count) || 1);
+    if (!r.ok) return reply.code(409).send({ error: r.detail });
+    return reply.code(201).send(r);
+  });
+
+  app.get('/api/agent/subtasks', async (req, reply) => {
+    const rid = agentAuth(req);
+    if (rid == null) return reply.code(401).send({ error: 'invalid agent token' });
+    return { subtasks: await listSubtasks(rid) };
+  });
+
+  // ─── GitHub 이슈/PR → 태스크 초안 (자동 발사 아님 — 사람이 검토 후 Run fleet) ──
+  app.post('/api/tasks/from-github', async (req, reply) => {
+    const b = (req.body ?? {}) as { url?: string };
+    const m = (b.url ?? '').trim().match(/^https:\/\/github\.com\/([\w.-]+)\/([\w.-]+)\/(issues|pull)\/(\d+)/);
+    if (!m) return reply.code(400).send({ error: 'expected a github.com issue or pull request URL' });
+    const [, owner, repo, kind, num] = m as unknown as [string, string, string, 'issues' | 'pull', string];
+    const isPr = kind === 'pull';
+    let title = '', body = '';
+    // gh CLI 우선(사설 repo 는 gh 인증이 필요) — 없거나 실패하면 공개 API 폴백
+    const local = { slug: 'local', kind: 'local', address: '', sshUser: '' };
+    const ghCmd = `gh ${isPr ? 'pr' : 'issue'} view ${shq(b.url!.trim())} --json title,body`;
+    const g = await runShellOn(local, `command -v gh >/dev/null 2>&1 && ${ghCmd}`, 20000);
+    if (g.ok) {
+      try { const j = JSON.parse(g.stdout) as { title?: string; body?: string }; title = j.title ?? ''; body = j.body ?? ''; } catch { /* fall through */ }
+    }
+    if (!title) {
+      try {
+        const r = await fetch(`https://api.github.com/repos/${owner}/${repo}/issues/${num}`, {
+          headers: { 'user-agent': 'coxpit', accept: 'application/vnd.github+json' },
+          signal: AbortSignal.timeout(10000),
+        });
+        if (r.ok) { const j = await r.json() as { title?: string; body?: string }; title = j.title ?? ''; body = j.body ?? ''; }
+      } catch { /* unreachable/private */ }
+    }
+    if (!title) return reply.code(502).send({ error: 'could not fetch it — private repo needs the gh CLI signed in on the daemon machine' });
+    return {
+      ok: true,
+      title: `${repo}#${num} · ${title}`.slice(0, 140),
+      prompt: `GitHub ${isPr ? 'pull request' : 'issue'}: ${b.url!.trim()}\n\n# ${title}\n\n${(body || '(no description)').slice(0, 6000)}\n\n---\nWork in this repository to address the ${isPr ? 'pull request' : 'issue'} above. Keep the change minimal and verifiable, and say how to verify it in your final summary.`,
+    };
+  });
+
+  // ─── 읽기 전용 공유 링크 — 토큰 URL 이 곧 능력(스냅샷 뷰, 액션 없음) ──
+  app.post('/api/runs/:id/share', 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 ex = await db.select().from(shareLinks).where(eq(shareLinks.runId, id));
+    if (ex[0]) return { ok: true, url: `/share/${ex[0].token}`, existing: true };
+    const token = randomBytes(12).toString('base64url');
+    await db.insert(shareLinks).values({ runId: id, token });
+    return reply.code(201).send({ ok: true, url: `/share/${token}` });
+  });
+
+  app.delete('/api/runs/:id/share', async (req, reply) => {
+    const id = Number((req.params as { id: string }).id);
+    await db.delete(shareLinks).where(eq(shareLinks.runId, id));
+    return { ok: true };
+  });
+
+  app.get('/share/:token', async (req, reply) => {
+    const { token } = req.params as { token: string };
+    const sl = (await db.select().from(shareLinks).where(eq(shareLinks.token, token)).limit(1))[0];
+    if (!sl) return reply.code(404).type('text/html').send('<!doctype html><meta charset="utf-8"><body style="background:#0b0d12;color:#8792a2;font-family:ui-monospace,monospace;padding:40px">share link not found or revoked</body>');
+    const run = (await db.select().from(agentRuns).where(eq(agentRuns.id, sl.runId)).limit(1))[0];
+    if (!run) return reply.code(404).send({ error: 'run gone' });
+    const task = (await db.select().from(tasks).where(eq(tasks.id, run.taskId)).limit(1))[0];
+    const evs = await db.select().from(agentEvents).where(eq(agentEvents.runId, run.id));
+    const d = await getRunDiff(run.id).catch(() => ({ ok: false, diff: '', stat: '' }));
+    return reply.type('text/html').send(sharePageHTML(run, task?.title ?? `task ${run.taskId}`, evs, d.ok ? d.diff : ''));
+  });
+
   // 라이브 스트림 좌석 — 오케스트레이터가 run/event 를 여기로 broadcast.
   app.get('/ws', { websocket: true }, (socket) => {
     addSink(socket);