@pitboss/cli 0.4.8 → 0.4.10

package/dist/cli.js

@@ -10864,7 +10864,7 @@ var require_lib2 = __commonJS({
       return matches;
     };
     exports.analyse = analyse;
-    var detectFile = (filepath, opts = {}) => new Promise((resolve8, reject) => {
+    var detectFile = (filepath, opts = {}) => new Promise((resolve9, reject) => {
       let fd;
       const fs = (0, node_1.default)();
       const handler = (err, buffer) => {
@@ -10874,7 +10874,7 @@ var require_lib2 = __commonJS({
         if (err) {
           reject(err);
         } else if (buffer) {
-          resolve8((0, exports.detect)(buffer));
+          resolve9((0, exports.detect)(buffer));
         } else {
           reject(new Error("No error and no buffer received"));
         }
@@ -17281,13 +17281,13 @@ var PromisePolyfill = class extends Promise {
   // Available starting from Node 22
   // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/withResolvers
   static withResolver() {
-    let resolve8;
+    let resolve9;
     let reject;
     const promise = new Promise((res, rej) => {
-      resolve8 = res;
+      resolve9 = res;
       reject = rej;
     });
-    return { promise, resolve: resolve8, reject };
+    return { promise, resolve: resolve9, reject };
   }
 };
 
@@ -17324,7 +17324,7 @@ function createPrompt(view) {
     });
     output.mute();
     const screen = new ScreenManager(rl);
-    const { promise, resolve: resolve8, reject } = PromisePolyfill.withResolver();
+    const { promise, resolve: resolve9, reject } = PromisePolyfill.withResolver();
     const cancel = () => reject(new CancelPromptError());
     if (signal) {
       const abort = () => reject(new AbortPromptError({ cause: signal.reason }));
@@ -17355,7 +17355,7 @@ function createPrompt(view) {
           try {
             const nextView = view(config, (value) => {
               if (effectsSettled) {
-                resolve8(value);
+                resolve9(value);
               } else {
                 pendingDone = { value };
               }
@@ -17378,7 +17378,7 @@ function createPrompt(view) {
           if (pendingDone !== null) {
             const { value } = pendingDone;
             pendingDone = null;
-            resolve8(value);
+            resolve9(value);
           }
         });
       };
@@ -17533,7 +17533,7 @@ var ExternalEditor = class {
   }
   runAsync(callback) {
     this.createTempFile();
-    const promise = new Promise((resolve8, reject) => {
+    const promise = new Promise((resolve9, reject) => {
       try {
         const editorProcess = spawn(this.editor.bin, this.editorArgs(), {
           shell: false,
@@ -17544,7 +17544,7 @@ var ExternalEditor = class {
         });
         editorProcess.once("exit", (code) => {
           this.lastExitStatus = code ?? 0;
-          resolve8();
+          resolve9();
         });
       } catch (launchError) {
         reject(new LaunchEditorError(launchError));
@@ -19107,6 +19107,7 @@ function isWorkerType(value) {
   return typeof value === "string" && WORKER_TYPES.includes(value);
 }
 var DEFAULT_UNSTARTED_AFTER_MS = 4 * 60 * 60 * 1e3;
+var DEFAULT_REVIEW_SILENT_MS = 40 * 60 * 1e3;
 var POOL_STOPPED_REASON = "pool member stopped by pitboss node";
 
 // src/lib/runtimes.ts
@@ -20287,6 +20288,8 @@ function summarize(e, bodyChars = 80, agentId) {
       return `review ${p.review?.decision ?? "submitted"}: "${taskTitle}"`;
     case "task.review_overdue":
       return `review OVERDUE: "${taskTitle}"`;
+    case "task.review_silent":
+      return `review SILENT: "${taskTitle}"`;
     case "thread.created":
       return `new thread: "${threadTitle}"`;
     case "thread.concluded":
@@ -20324,6 +20327,7 @@ var KIND_STYLE = {
   "task.review_started": source_default.magenta,
   "task.review_submitted": source_default.magenta,
   "task.review_overdue": source_default.yellow,
+  "task.review_silent": source_default.yellow,
   "thread.created": source_default.cyan,
   "thread.concluded": source_default.dim,
   "thread.message_ceiling": source_default.yellow
@@ -20599,14 +20603,13 @@ function hookCursorPromptCommand(opts) {
   process.stdout.write("{}");
 }
 
-// src/commands/node.ts
-import { execFileSync as execFileSync7, spawn as spawnChild } from "node:child_process";
-import { closeSync, existsSync as existsSync11, mkdirSync as mkdirSync9, openSync, readFileSync as readFileSync12, realpathSync as realpathSync5 } from "node:fs";
-import { dirname as dirname11, resolve as resolve7 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+// src/commands/onboard.ts
+import { execFileSync as execFileSync7 } from "node:child_process";
+import { existsSync as existsSync10, mkdirSync as mkdirSync9, readFileSync as readFileSync13, realpathSync as realpathSync5, writeFileSync as writeFileSync9 } from "node:fs";
+import { homedir as homedir6 } from "node:os";
 
-// src/node/spec.ts
-import { join as join15, resolve as resolve4, sep as sep2 } from "node:path";
+// src/node/onboard.ts
+import { join as join15, resolve as resolve4 } from "node:path";
 
 // ../claude-worker/src/session.ts
 import { spawn as spawn2 } from "child_process";
@@ -20667,7 +20670,8 @@ var BASE_TASK_LOOP = (agentId, repoPath) => `You are an AI worker agent (ID: ${a
    a one-line status on the task thread naming what you are checking) when you begin, then
    run the tests, compare the diff against the spec the task names, then
    \`mcp__relai__submit_review\` \u2014 \`approve\`, or \`reject\` with a specific note the author
-   can act on. Do this even when get_my_tasks is empty.
+   can act on. When the task is a goal's build with a PR, pass \`headSha\`: the full sha of the
+   commit you reviewed. Do this even when get_my_tasks is empty.
    If the change touches a long-running service or a third-party runtime integration (SSE/event streams, launchd/systemd, auth headers, a client library), run the changed path once before approving and quote what it printed. A type cast past a library's own types is a reason to stop and run it.
 
 4. Call \`mcp__relai__get_my_tasks\` \u2014 if it returns no tasks, stop immediately.
@@ -20909,7 +20913,11 @@ Find the default branch with \`git remote show origin\`.
    \`specialization\` or \`domains\` only to values agents in \`mcp__relai__list_agents\` declare:
    the router never hands out a task whose tag no agent matches. When the repo has \`writer\` agents, set
    \`specialization: "writer"\` on build tasks, so they wait for a writer instead of going to a reviewer.
-   Never name a build task's assignee as the goal's reviewer; the API refuses it. Make them small
+   Before writing any build task, choose the goal's reviewer (for a \`reviewer_agent\` gate): a
+   \`reviewer\` agent, on a different \`workerType\` from the writers when one exists. Never assign that
+   agent a build task, and never leave the only reviewers busy building: a goal whose every reviewer
+   built part of it has nobody left to review it. The API defaults a build task with no
+   \`specialization\` to \`writer\` when the repo has writers. Make them small
    and independently testable so several agents can work at once. Use \`blockedBy\` only where
    one task truly needs another's result. Each description is self-contained: what to change,
    which files, how to test it, and the acceptance criteria.
@@ -21052,6 +21060,9 @@ var USAGE_NUMBER_KEYS = [
   "cache_read_input_tokens",
   "cache_creation_input_tokens"
 ];
+function notReportedUsage(reason) {
+  return { notReported: true, reason };
+}
 function finiteNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
@@ -21119,14 +21130,32 @@ async function getTaskStatus(conn, id, logPrefix) {
     return void 0;
   }
 }
-async function sessionTouchedTaskIds(conn, candidates, logPrefix) {
+async function listUpdatedSince(conn, since, logPrefix) {
+  try {
+    const res = await fetch(
+      `${conn.apiUrl}/tasks?repoId=${conn.repoId}&assignedTo=${conn.agentId}&updatedAfter=${encodeURIComponent(since)}`,
+      { headers: { Authorization: `Bearer ${conn.apiSecret}` } }
+    );
+    if (!res.ok) throw new Error(`task list failed (${res.status} ${res.statusText})`);
+    const { data } = await res.json();
+    return (data ?? []).filter((row) => typeof row.id === "string" && row.id.length > 0).filter((row) => row.status !== "assigned").map((row) => row.id);
+  } catch (err) {
+    console.error(
+      `${logPrefix} Could not list tasks updated since the session started:`,
+      err instanceof Error ? err.message : String(err)
+    );
+    return [];
+  }
+}
+async function sessionTouchedTaskIds(conn, candidates, logPrefix, since) {
   const touched = [];
   for (const id of candidates) {
     const status = await getTaskStatus(conn, id, logPrefix);
     if (status !== void 0 && status !== "assigned") touched.push(id);
   }
   const inProgressAtClose = await listSessionTaskIds(conn, logPrefix, "in_progress");
-  return unionTaskIds(touched, inProgressAtClose);
+  const updated = since ? await listUpdatedSince(conn, since, logPrefix) : [];
+  return unionTaskIds(touched, inProgressAtClose, updated);
 }
 function unionTaskIds(...lists) {
   const seen = /* @__PURE__ */ new Set();
@@ -21140,34 +21169,99 @@ function unionTaskIds(...lists) {
   }
   return out;
 }
-async function writeSessionUsage(conn, taskIds, usage, logPrefix) {
-  const sessionUsage = {
-    ...usage,
-    at: (/* @__PURE__ */ new Date()).toISOString(),
-    sessionTaskIds: [...taskIds]
-  };
+async function writeSessionUsage(conn, taskIds, usage, logPrefix, opts = {}) {
   const headers = { "Content-Type": "application/json", Authorization: `Bearer ${conn.apiSecret}` };
   for (const id of taskIds) {
+    const slice = taskIds.length > 1 && !usage.notReported ? opts.slices?.[id] : void 0;
+    const share = usage.notReported ? void 0 : slice || taskIds.length === 1 ? "task" : "session";
+    const body = {
+      usage: slice ?? usage,
+      sessionTaskIds: taskIds,
+      ...opts.model ? { model: opts.model } : {},
+      ...share ? { share } : {}
+    };
     try {
-      const put = await fetch(`${conn.apiUrl}/tasks/${id}`, {
-        method: "PUT",
+      const res = await fetch(`${conn.apiUrl}/tasks/${id}/usage-report`, {
+        method: "POST",
         headers,
-        body: JSON.stringify({ metadata: { sessionUsage } })
+        body: JSON.stringify(body)
       });
-      if (!put.ok) {
-        console.error(`${logPrefix} Could not write sessionUsage on ${id} (${put.status} ${put.statusText})`);
+      if (!res.ok) {
+        console.error(`${logPrefix} Could not report usage on ${id} (${res.status} ${res.statusText})`);
       }
     } catch (err) {
       console.error(
-        `${logPrefix} Could not write sessionUsage on ${id}:`,
+        `${logPrefix} Could not report usage on ${id}:`,
         err instanceof Error ? err.message : String(err)
       );
     }
   }
 }
-async function recordSessionUsage(conn, startIds, usage, logPrefix) {
+async function recordSessionUsage(conn, startIds, usage, logPrefix, opts = {}) {
   const start = await startIds;
-  await writeSessionUsage(conn, await sessionTouchedTaskIds(conn, start, logPrefix), usage, logPrefix);
+  const { since, ...rest } = opts;
+  await writeSessionUsage(conn, await sessionTouchedTaskIds(conn, start, logPrefix, since), usage, logPrefix, rest);
+}
+var BOUNDARY_STATUSES = /* @__PURE__ */ new Set(["completed", "blocked", "pending_verification"]);
+function addUsage(into, from) {
+  into.num_turns = (into.num_turns ?? 0) + (from.num_turns ?? 0);
+  const total = into.usage ?? {};
+  for (const key of USAGE_NUMBER_KEYS) {
+    const n = from.usage?.[key];
+    if (n !== void 0) total[key] = (total[key] ?? 0) + n;
+  }
+  into.usage = total;
+}
+function createUsageTracker() {
+  let model;
+  let pending = /* @__PURE__ */ new Map();
+  const slices = {};
+  let anon = 0;
+  function cut(taskId) {
+    const slice = slices[taskId] ?? {};
+    for (const messageUsage of pending.values()) addUsage(slice, messageUsage);
+    pending = /* @__PURE__ */ new Map();
+    if (slice.usage) slices[taskId] = slice;
+  }
+  return {
+    observe(event) {
+      if (event.type === "system" && event.subtype === "init") {
+        if (typeof event.model === "string" && event.model) model = event.model;
+        return;
+      }
+      if (event.type !== "assistant") return;
+      const message = event.message ?? {};
+      const raw = message.usage;
+      if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+        const usage = pickNumbers(raw, USAGE_NUMBER_KEYS);
+        if (Object.keys(usage).length > 0) {
+          pending.set(typeof message.id === "string" ? message.id : `anon_${anon++}`, { num_turns: 1, usage });
+        }
+      }
+      const content = Array.isArray(message.content) ? message.content : [];
+      for (const block of content) {
+        if (block.type !== "tool_use" || typeof block.name !== "string" || !block.name.endsWith("update_task_status")) continue;
+        const input = block.input ?? {};
+        if (typeof input.taskId === "string" && typeof input.status === "string" && BOUNDARY_STATUSES.has(input.status)) {
+          cut(input.taskId);
+        }
+      }
+    },
+    model: () => model,
+    opts: () => ({ ...model ? { model } : {}, slices })
+  };
+}
+
+// ../claude-worker/src/model.ts
+import { readFileSync as readFileSync11 } from "node:fs";
+function pinnedModel(env2 = process.env) {
+  const file = env2.PITBOSS_MODEL_FILE;
+  if (!file) return void 0;
+  try {
+    return readFileSync11(file, "utf-8").trim() || void 0;
+  } catch {
+    return void 0;
+  }
 }
 
 // ../claude-worker/src/session.ts
@@ -21202,26 +21296,36 @@ function writeMcpConfig(config, prefix = "claude-worker") {
   writeFileSync6(path3, JSON.stringify(mcpConfig), { mode: 384 });
   return path3;
 }
+function claudeArgs(opts) {
+  return [
+    "--print",
+    "--mcp-config",
+    opts.mcpConfigPath,
+    "--no-session-persistence",
+    "--dangerously-skip-permissions",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--model",
+    opts.model,
+    "--add-dir",
+    opts.repoPath,
+    ...opts.isolateUserConfig ? ["--setting-sources", "project,local"] : []
+  ];
+}
 async function runClaudeSession(config) {
   const prompt = buildPrompt(config);
   const mcpConfigPath = writeMcpConfig(config);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const taskIdsPromise = listSessionTaskIds(config, "[claude-worker]");
   try {
-    return await new Promise((resolve8, reject) => {
-      const args = [
-        "--print",
-        "--mcp-config",
+    return await new Promise((resolve9, reject) => {
+      const args = claudeArgs({
         mcpConfigPath,
-        "--no-session-persistence",
-        "--dangerously-skip-permissions",
-        "--output-format",
-        "stream-json",
-        "--verbose",
-        "--model",
-        config.model,
-        "--add-dir",
-        config.repoPath
-      ];
+        model: pinnedModel() ?? config.model,
+        repoPath: config.repoPath,
+        isolateUserConfig: process.env.PITBOSS_ISOLATE_USER_CONFIG === "1"
+      });
       console.log(`[claude-worker] Spawning: ${config.claudeBin} ${args.slice(0, 4).join(" ")} ...`);
       console.log(`[claude-worker] cwd: ${config.repoPath}`);
       const { ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN, ...workerEnv } = process.env;
@@ -21237,6 +21341,8 @@ async function runClaudeSession(config) {
       let buffer = "";
       let resultError = "";
       let sessionUsage;
+      let sawResult = false;
+      const tracker = createUsageTracker();
       proc.stdout.on("data", (chunk) => {
         buffer += chunk.toString();
         const lines = buffer.split("\n");
@@ -21245,6 +21351,7 @@ async function runClaudeSession(config) {
           if (!line.trim()) continue;
           try {
             const event = JSON.parse(line);
+            tracker.observe(event);
             if (event.type === "assistant") {
               const content = event.message?.content ?? [];
               for (const block of content) {
@@ -21258,6 +21365,7 @@ async function runClaudeSession(config) {
                 }
               }
             } else if (event.type === "result") {
+              sawResult = true;
               const parsed = parseResultUsage(event);
               if (parsed) sessionUsage = parsed;
               if (event.is_error) {
@@ -21279,15 +21387,15 @@ async function runClaudeSession(config) {
       proc.on("close", (code, signal) => {
         const unique = [...new Set(toolsUsed)];
         console.log(`[claude-worker] Done \u2014 tools used: ${unique.length ? unique.join(", ") : "none"}`);
-        const usage = sessionUsage;
-        if (usage) console.log(formatSessionUsageLine("[claude-worker]", usage));
-        const finish = usage ? recordSessionUsage(config, taskIdsPromise, usage, "[claude-worker]") : Promise.resolve();
+        const usage = sessionUsage ?? notReportedUsage(sawResult ? "adapter" : "killed");
+        if (sessionUsage) console.log(formatSessionUsageLine("[claude-worker]", sessionUsage));
+        const finish = recordSessionUsage(config, taskIdsPromise, usage, "[claude-worker]", { since: startedAt, ...tracker.opts() });
         const settle = () => {
           if (signal || code !== 0 && code !== null) {
             const detail = (resultError || stderrOutput || "").trim();
             reject(new Error(`claude exited with ${signal ?? `code ${code}`}${detail ? `: ${detail}` : ""}`));
           } else {
-            resolve8(unique);
+            resolve9(unique);
           }
         };
         finish.then(settle, settle);
@@ -21339,8 +21447,8 @@ function classifySessionError(text) {
 
 // ../claude-worker/src/adapters/cursor.ts
 var bin = () => process.env.CURSOR_BIN ?? "cursor-agent";
-function cursorArgs(repoPath, prompt) {
-  return ["-p", "--trust", "--force", "--output-format", "stream-json", "--workspace", repoPath, prompt];
+function cursorArgs(repoPath, prompt, model) {
+  return ["-p", "--trust", "--force", "--output-format", "stream-json", "--workspace", repoPath, ...model ? ["--model", model] : [], prompt];
 }
 function readCursorEvent(line) {
   let event;
@@ -21349,6 +21457,9 @@ function readCursorEvent(line) {
   } catch {
     return {};
   }
+  if (event.type === "system" && event.subtype === "init") {
+    return typeof event.model === "string" && event.model ? { model: event.model } : {};
+  }
   if (event.type === "tool_call" && event.subtype === "started") {
     const call = event.tool_call ?? {};
     const [kind] = Object.keys(call);
@@ -21364,10 +21475,11 @@ function readCursorEvent(line) {
   return {};
 }
 async function runCursorSession(config) {
-  const args = cursorArgs(config.repoPath, buildPrompt(config));
+  const args = cursorArgs(config.repoPath, buildPrompt(config), pinnedModel());
   console.log(`[cursor-worker] Spawning: ${bin()} ${args.slice(0, 5).join(" ")} ...`);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
   const taskIdsPromise = listSessionTaskIds(config, "[cursor-worker]");
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const proc = spawn3(bin(), args, { cwd: config.repoPath, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
     console.log(`[cursor-worker] Process PID: ${proc.pid}`);
     const toolsUsed = [];
@@ -21375,12 +21487,14 @@ async function runCursorSession(config) {
     let resultError = "";
     let stderrOutput = "";
     let sessionUsage;
+    let model;
     proc.stdout.on("data", (chunk) => {
       buffer += chunk.toString();
       const lines = buffer.split("\n");
       buffer = lines.pop() ?? "";
       for (const line of lines) {
-        const { tool, error, usage } = readCursorEvent(line);
+        const { tool, error, usage, model: initModel } = readCursorEvent(line);
+        if (initModel) model = initModel;
         if (tool) {
           toolsUsed.push(tool);
           process.stdout.write(`  \u2699  ${tool}
@@ -21398,15 +21512,15 @@ async function runCursorSession(config) {
     });
     proc.on("close", (code, signal) => {
       console.log(`[cursor-worker] Done \u2014 tools used: ${toolsUsed.length ? [...new Set(toolsUsed)].join(", ") : "none"}`);
-      const usage = sessionUsage;
-      if (usage) console.log(formatSessionUsageLine("[cursor-worker]", usage));
-      const finish = usage ? recordSessionUsage(config, taskIdsPromise, usage, "[cursor-worker]") : Promise.resolve();
+      const usage = sessionUsage ?? notReportedUsage("killed");
+      if (sessionUsage) console.log(formatSessionUsageLine("[cursor-worker]", sessionUsage));
+      const finish = recordSessionUsage(config, taskIdsPromise, usage, "[cursor-worker]", { since: startedAt, ...model ? { model } : {} });
       const settle = () => {
         if (signal || code !== 0 && code !== null) {
           const detail = (resultError || stderrOutput).trim();
           reject(new Error(`cursor-agent exited with ${signal ?? `code ${code}`}${detail ? `: ${detail}` : ""}`));
         } else {
-          resolve8([...new Set(toolsUsed)]);
+          resolve9([...new Set(toolsUsed)]);
         }
       };
       finish.then(settle, settle);
@@ -21445,10 +21559,11 @@ import { unlinkSync as unlinkSync2 } from "fs";
 var bin2 = () => process.env.COPILOT_BIN ?? "copilot";
 var POLICY_BLOCKS = [/access denied by policy/i, /third-party mcp servers are disabled/i];
 var QUOTA = [/premium request/i, /monthly (?:limit|allowance|quota)/i];
-function copilotArgs(repoPath, prompt, mcpConfigPath) {
+function copilotArgs(repoPath, prompt, mcpConfigPath, model) {
   return [
     "-p",
     prompt,
+    ...model ? ["--model", model] : [],
     "--allow-all-tools",
     "--output-format",
     "json",
@@ -21470,6 +21585,7 @@ function readCopilotEvent(line) {
   const type = typeof event.type === "string" ? event.type : "";
   const data = event.data ?? {};
   const message = typeof data.message === "string" ? data.message : "";
+  if (type === "session.tools_updated" && typeof data.model === "string" && data.model) return { model: data.model };
   if (/^tool\..*start/.test(type) && typeof data.toolName === "string") return { tool: data.toolName };
   if (type === "session.error") return { error: message || "copilot session error" };
   if (type === "result" && typeof event.exitCode === "number" && event.exitCode !== 0) return { error: `copilot finished with exit code ${event.exitCode}` };
@@ -21478,21 +21594,25 @@ function readCopilotEvent(line) {
 }
 async function runCopilotSession(config) {
   const mcpConfigPath = writeMcpConfig(config, "copilot-worker");
-  const args = copilotArgs(config.repoPath, buildPrompt(config), mcpConfigPath);
+  const args = copilotArgs(config.repoPath, buildPrompt(config), mcpConfigPath, pinnedModel());
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const taskIdsPromise = listSessionTaskIds(config, "[copilot-worker]");
   console.log(`[copilot-worker] Spawning: ${bin2()} -p <prompt> ${args.slice(2, 6).join(" ")} ...`);
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const proc = spawn4(bin2(), args, { cwd: config.repoPath, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
     console.log(`[copilot-worker] Process PID: ${proc.pid}`);
     const toolsUsed = [];
     let buffer = "";
     let sessionError = "";
     let stderrOutput = "";
+    let model;
     proc.stdout.on("data", (chunk) => {
       buffer += chunk.toString();
       const lines = buffer.split("\n");
       buffer = lines.pop() ?? "";
       for (const line of lines) {
-        const { tool, error } = readCopilotEvent(line);
+        const { tool, error, model: initModel } = readCopilotEvent(line);
+        if (initModel) model = initModel;
         if (tool) {
           toolsUsed.push(tool);
           process.stdout.write(`  \u2699  ${tool}
@@ -21513,12 +21633,15 @@ async function runCopilotSession(config) {
       } catch {
       }
       console.log(`[copilot-worker] Done \u2014 tools used: ${toolsUsed.length ? [...new Set(toolsUsed)].join(", ") : "none"}`);
-      if (sessionError || signal || code !== 0 && code !== null) {
-        const detail = (sessionError || stderrOutput).trim();
-        reject(new Error(`copilot exited with ${signal ?? `code ${code}`}${detail ? `: ${detail}` : ""}`));
-      } else {
-        resolve8([...new Set(toolsUsed)]);
-      }
+      const settle = () => {
+        if (sessionError || signal || code !== 0 && code !== null) {
+          const detail = (sessionError || stderrOutput).trim();
+          reject(new Error(`copilot exited with ${signal ?? `code ${code}`}${detail ? `: ${detail}` : ""}`));
+        } else {
+          resolve9([...new Set(toolsUsed)]);
+        }
+      };
+      recordSessionUsage(config, taskIdsPromise, notReportedUsage("adapter"), "[copilot-worker]", { since: startedAt, ...model ? { model } : {} }).then(settle, settle);
     });
     proc.on("error", (err) => {
       try {
@@ -21551,7 +21674,7 @@ var bin3 = () => process.env.CODEX_BIN ?? "codex";
 var codexHome = () => process.env.CODEX_HOME ?? join14(homedir5(), ".codex");
 var QUOTA2 = [/usage limit/i, /rate limit reached for/i, /upgrade to (plus|pro)/i];
 var CREDENTIALS = [/not logged in/i, /codex login/i, /401 unauthorized/i];
-function codexArgs(repoPath, prompt, profile) {
+function codexArgs(repoPath, prompt, profile, model) {
   return [
     "exec",
     "--json",
@@ -21562,6 +21685,7 @@ function codexArgs(repoPath, prompt, profile) {
     repoPath,
     "-p",
     profile,
+    ...model ? ["-m", model] : [],
     prompt
   ];
 }
@@ -21610,9 +21734,11 @@ async function runCodexSession(config) {
     } catch {
     }
   };
-  const args = codexArgs(config.repoPath, buildPrompt(config), profile);
+  const args = codexArgs(config.repoPath, buildPrompt(config), profile, pinnedModel());
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const taskIdsPromise = listSessionTaskIds(config, "[codex-worker]");
   console.log(`[codex-worker] Spawning: ${bin3()} ${args.slice(0, 6).join(" ")} ...`);
-  return new Promise((resolve8, reject) => {
+  return new Promise((resolve9, reject) => {
     const proc = spawn5(bin3(), args, { cwd: config.repoPath, env: process.env, stdio: ["ignore", "pipe", "pipe"] });
     console.log(`[codex-worker] Process PID: ${proc.pid}`);
     const toolsUsed = [];
@@ -21642,12 +21768,15 @@ async function runCodexSession(config) {
     proc.on("close", (code, signal) => {
       cleanup();
       console.log(`[codex-worker] Done \u2014 tools used: ${toolsUsed.length ? [...new Set(toolsUsed)].join(", ") : "none"}`);
-      if (sessionError || signal || code !== 0 && code !== null) {
-        const detail = (sessionError || stderrOutput).trim();
-        reject(new Error(`codex exited with ${signal ?? `code ${code}`}${detail ? `: ${detail}` : ""}`));
-      } else {
-        resolve8([...new Set(toolsUsed)]);
-      }
+      const settle = () => {
+        if (sessionError || signal || code !== 0 && code !== null) {
+          const detail = (sessionError || stderrOutput).trim();
+          reject(new Error(`codex exited with ${signal ?? `code ${code}`}${detail ? `: ${detail}` : ""}`));
+        } else {
+          resolve9([...new Set(toolsUsed)]);
+        }
+      };
+      recordSessionUsage(config, taskIdsPromise, notReportedUsage("adapter"), "[codex-worker]", { since: startedAt }).then(settle, settle);
     });
     proc.on("error", (err) => {
       cleanup();
@@ -21683,7 +21812,65 @@ var DEFAULT_UNAVAILABLE_UNTIL_MS = 60 * 60 * 1e3;
 // ../claude-worker/src/config.ts
 var VALID_SPECIALIZATIONS = ["reviewer", "architect", "writer", "tester", "devops"];
 
+// src/node/onboard.ts
+var MAX_POOL = 30;
+var GITHUB = /^(?:https:\/\/github\.com\/|ssh:\/\/git@github\.com\/|git@github\.com:)([\w.-]+)\/([\w.-]+?)(?:\.git)?\/?$/;
+function planOnboard(url, opts) {
+  const match = GITHUB.exec(url.trim());
+  if (!match) throw new Error(`${url} is not a GitHub repo URL (https://github.com/<owner>/<repo> or git@github.com:<owner>/<repo>)`);
+  const [, owner, name] = match;
+  const writer = opts.writer ?? "claude";
+  const reviewer = opts.reviewer ?? (writer === "claude" ? "copilot" : "claude");
+  if (reviewer === writer) throw new Error(`the reviewer needs a different runtime from the writers (both are ${writer})`);
+  for (const r of [writer, reviewer]) {
+    if (!RUNTIMES3.includes(r)) throw new Error(`runtime "${r}" is not supported (have: ${RUNTIMES3.join(", ")})`);
+  }
+  const poolMax = opts.poolMax ?? 2;
+  if (!Number.isInteger(poolMax) || poolMax < 1 || poolMax > MAX_POOL) {
+    throw new Error(`pool size must be a whole number from 1 to ${MAX_POOL}, so the architect, reviewer and writers fit one approval`);
+  }
+  const id = name.replace(/^[^A-Za-z0-9]+/, "").slice(0, 40).replace(/[^A-Za-z0-9]+$/, "") || "repo";
+  const parent = resolve4(opts.parent ?? join15(opts.home, "github"));
+  const base2 = join15(parent, name);
+  const nodeDir2 = join15(parent, `${name}-node`);
+  const architect = join15(parent, `${name}-architect`);
+  const review = join15(parent, `${name}-reviewer`);
+  return {
+    owner,
+    name,
+    cloneUrl: `https://github.com/${owner}/${name}.git`,
+    base: base2,
+    nodeDir: nodeDir2,
+    specPath: join15(nodeDir2, "spec.json"),
+    configDir: join15(opts.home, ".config", "pitboss-repos", owner.toLowerCase(), name.toLowerCase()),
+    worktrees: [architect, review],
+    spec: {
+      api: "https://api.pitboss.dev",
+      agents: [
+        { name: `${id}-architect`, runtime: "claude", worktree: `../${name}-architect`, specialization: "architect", tier: 2 },
+        { name: `${id}-reviewer`, runtime: reviewer, worktree: `../${name}-reviewer`, specialization: "reviewer" },
+        {
+          pool: `${id}-pool`,
+          runtime: writer,
+          base: `../${name}`,
+          worktreeRoot: `../${name}-pool`,
+          specialization: "writer",
+          min: 0,
+          max: poolMax
+        }
+      ]
+    }
+  };
+}
+function originHost(origin) {
+  const url = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?([^/:]+)/i.exec(origin.trim());
+  if (url) return url[1].toLowerCase();
+  const scp = /^(?:[^@/]+@)?([^/:]+):/.exec(origin.trim());
+  return scp ? scp[1].toLowerCase() : null;
+}
+
 // src/node/spec.ts
+import { join as join16, resolve as resolve5, sep as sep2 } from "node:path";
 var DEFAULT_API2 = "https://api.pitboss.dev";
 var MAX_POOL_SIZE = 32;
 var NAME = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/;
@@ -21695,7 +21882,15 @@ var isWithin = (path3, dir) => path3 === dir || path3.startsWith(dir.endsWith(se
 function poolMembers(pool) {
   return Array.from({ length: pool.max }, (_, i) => {
     const name = `${pool.pool}-${i + 1}`;
-    return { name, runtime: pool.runtime, worktree: join15(pool.worktreeRoot, name), specialization: pool.specialization };
+    return {
+      name,
+      runtime: pool.runtime,
+      worktree: join16(pool.worktreeRoot, name),
+      specialization: pool.specialization,
+      ...pool.tier ? { tier: pool.tier } : {},
+      ...pool.model ? { model: pool.model } : {},
+      ...pool.isolateUserConfig ? { isolateUserConfig: true } : {}
+    };
   });
 }
 var allAgents = (spec) => [...spec.agents, ...spec.pools.flatMap(poolMembers)];
@@ -21712,6 +21907,24 @@ function specializationOf(a, i) {
   }
   return specialization;
 }
+function tierOf(a, i, specialization) {
+  if (a.tier === void 0) return specialization === "architect" ? { tier: 2 } : {};
+  if (a.tier !== 1 && a.tier !== 2) throw new Error(`agents[${i}].tier must be 1 or 2`);
+  return { tier: a.tier };
+}
+function modelOf(a, i) {
+  if (a.model === void 0) return {};
+  if (typeof a.model !== "string" || !/^[\w.:/@-]{1,100}$/.test(a.model)) {
+    throw new Error(`agents[${i}].model must be a model name (letters, digits and . : / @ _ -), at most 100 characters`);
+  }
+  return { model: a.model };
+}
+function isolateOf(a, i, runtime) {
+  if (a.isolateUserConfig === void 0 || a.isolateUserConfig === false) return {};
+  if (a.isolateUserConfig !== true) throw new Error(`agents[${i}].isolateUserConfig must be true or false`);
+  if (runtime !== "claude") throw new Error(`agents[${i}]: isolateUserConfig only applies to the claude runtime`);
+  return { isolateUserConfig: true };
+}
 function parsePool(a, i, specDir) {
   if (a.name !== void 0 || a.worktree !== void 0) throw new Error(`agents[${i}] must have either name or pool, not both`);
   if (typeof a.pool !== "string" || !POOL_NAME.test(a.pool)) throw new Error(`agents[${i}].pool must be letters, digits, '.', '_' or '-' (at most 60)`);
@@ -21727,10 +21940,10 @@ function parsePool(a, i, specDir) {
   if (typeof min !== "number" || !Number.isInteger(min) || min < 0 || min > max) {
     throw new Error(`agents[${i}].min must be an integer from 0 to max`);
   }
-  const base2 = resolve4(specDir, a.base);
-  const worktreeRoot = resolve4(specDir, a.worktreeRoot);
+  const base2 = resolve5(specDir, a.base);
+  const worktreeRoot = resolve5(specDir, a.worktreeRoot);
   if (isWithin(worktreeRoot, base2)) throw new Error(`agents[${i}].worktreeRoot ${worktreeRoot} is inside base ${base2}; pool worktrees never go inside your checkout`);
-  return { pool: a.pool, runtime, base: base2, worktreeRoot, specialization, min, max };
+  return { pool: a.pool, runtime, base: base2, worktreeRoot, specialization, ...tierOf(a, i, specialization), ...modelOf(a, i), ...isolateOf(a, i, runtime), min, max };
 }
 function parseSpec(text, specDir) {
   let raw;
@@ -21756,7 +21969,8 @@ function parseSpec(text, specDir) {
     if (typeof a.name !== "string" || !NAME.test(a.name)) throw new Error(`agents[${i}].name must be letters, digits, '.', '_' or '-'`);
     if (typeof a.worktree !== "string" || !a.worktree) throw new Error(`agents[${i}].worktree is required`);
     const runtime = runtimeOf(a, i);
-    agents.push({ name: a.name, runtime, worktree: resolve4(specDir, a.worktree), specialization: specializationOf(a, i) });
+    const specialization = specializationOf(a, i);
+    agents.push({ name: a.name, runtime, worktree: resolve5(specDir, a.worktree), specialization, ...tierOf(a, i, specialization), ...modelOf(a, i), ...isolateOf(a, i, runtime) });
   });
   for (const p of pools) {
     for (const a of agents) {
@@ -21783,13 +21997,15 @@ function parseSpec(text, specDir) {
 }
 
 // src/node/store.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync7, readdirSync as readdirSync2, readFileSync as readFileSync11, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname8, join as join16 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync7, readdirSync as readdirSync2, readFileSync as readFileSync12, renameSync as renameSync4, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname8, join as join17 } from "node:path";
 import { randomBytes as randomBytes4 } from "node:crypto";
-var nodeDir = () => join16(configDir(), "node");
-var credsPath = (name) => join16(nodeDir(), "agents", `${name}.json`);
-var statePath2 = () => join16(nodeDir(), "state.json");
-var logPath = (name) => join16(nodeDir(), "logs", `${name}.log`);
+var nodeDir = () => join17(configDir(), "node");
+var credsPath = (name) => join17(nodeDir(), "agents", `${name}.json`);
+var statePath2 = () => join17(nodeDir(), "state.json");
+var logPath = (name) => join17(nodeDir(), "logs", `${name}.log`);
+var activityPath = (name) => join17(nodeDir(), "activity", name);
+var modelPath = (name) => join17(nodeDir(), "model", name);
 function writePrivate(path3, value) {
   mkdirSync7(dirname8(path3), { recursive: true, mode: 448 });
   const tmp = `${path3}.relai-${randomBytes4(8).toString("hex")}`;
@@ -21798,7 +22014,7 @@ function writePrivate(path3, value) {
 }
 function readJson(path3) {
   if (!existsSync8(path3)) return null;
-  return JSON.parse(readFileSync11(path3, "utf-8"));
+  return JSON.parse(readFileSync12(path3, "utf-8"));
 }
 var readCreds = (name) => readJson(credsPath(name));
 var writeCreds = (name, creds) => writePrivate(credsPath(name), creds);
@@ -21807,14 +22023,187 @@ var removeCreds = (name) => {
   if (existsSync8(path3)) rmSync4(path3);
 };
 var listStoredAgentNames = () => {
-  const dir = join16(nodeDir(), "agents");
+  const dir = join17(nodeDir(), "agents");
   if (!existsSync8(dir)) return [];
   return readdirSync2(dir).filter((n) => n.endsWith(".json")).map((n) => n.slice(0, -".json".length)).sort();
 };
 var readState = () => readJson(statePath2());
 var writeState = (state) => writePrivate(statePath2(), state);
 
+// src/node/pool.ts
+import { execFileSync as execFileSync6 } from "node:child_process";
+import { existsSync as existsSync9, lstatSync as lstatSync3, mkdirSync as mkdirSync8, realpathSync as realpathSync4 } from "node:fs";
+import { basename as basename2, dirname as dirname9, join as join18, resolve as resolve6 } from "node:path";
+var IDLE_STOP_MS = 10 * 6e4;
+var RECONCILE_MS = 15e3;
+var UNAVAILABLE_FOR_MS = 7 * 24 * 60 * 6e4 - 6e4;
+var REMARK_AFTER_MS = 24 * 60 * 6e4;
+function positiveMs(raw, fallback2) {
+  const n = Number(raw);
+  return raw && Number.isInteger(n) && n > 0 ? n : fallback2;
+}
+function poolTimings(env2 = process.env) {
+  return {
+    reconcileMs: positiveMs(env2.PITBOSS_POOL_RECONCILE_MS, RECONCILE_MS),
+    idleStopMs: positiveMs(env2.PITBOSS_POOL_IDLE_STOP_MS, IDLE_STOP_MS)
+  };
+}
+function effectiveBounds(spec, desired) {
+  if (!desired) return { min: spec.min, max: spec.max, desiredMax: null, capped: false };
+  const max = Math.min(desired.max, spec.max);
+  return { min: Math.min(desired.min, max), max, desiredMax: desired.max, capped: desired.max > spec.max };
+}
+function reconcilePool({ pending, members, min, max, idleStopMs }) {
+  const isIdle = (m) => m.assigned === 0 && m.inProgress === 0;
+  const running = members.filter((m) => m.running);
+  const stopped = members.filter((m) => !m.running);
+  let count = running.length;
+  const start = [];
+  const take = (m) => {
+    start.push(m.name);
+    count++;
+  };
+  for (const m of stopped) {
+    if (count >= max) break;
+    if (m.inProgress > 0 || m.readyAssigned > 0) take(m);
+  }
+  const spare = () => stopped.filter((m) => !start.includes(m.name)).sort((a, b) => Number(isIdle(b)) - Number(isIdle(a)));
+  let demand = pending - running.filter(isIdle).length;
+  for (const m of spare()) {
+    if (demand <= 0 || count >= max) break;
+    take(m);
+    demand--;
+  }
+  for (const m of spare()) {
+    if (count >= min || count >= max) break;
+    take(m);
+  }
+  if (start.length > 0) return { start, stop: [] };
+  const stop = [];
+  let surplus = running.filter(isIdle).length - pending;
+  const eligible = running.filter((m) => isIdle(m) && m.idleMs >= idleStopMs).sort((a, b) => b.idleMs - a.idleMs);
+  for (const m of eligible) {
+    if (surplus <= 0 || count <= min) break;
+    stop.push(m.name);
+    count--;
+    surplus--;
+  }
+  return { start, stop };
+}
+function summarizeTasks(ready, held, members) {
+  const nameOf = new Map(members.map((m) => [m.agentId, m.name]));
+  const counts = Object.fromEntries(
+    members.map((m) => [m.name, { assigned: 0, inProgress: 0, readyAssigned: 0 }])
+  );
+  const pending = ready.filter((t) => t.status === "pending" && t.autoAssign).length;
+  let readyAssigned = 0;
+  for (const t of ready) {
+    const name = t.status === "assigned" && t.assignedTo ? nameOf.get(t.assignedTo) : void 0;
+    if (!name) continue;
+    counts[name].readyAssigned++;
+    readyAssigned++;
+  }
+  for (const t of held) {
+    const name = t.assignedTo ? nameOf.get(t.assignedTo) : void 0;
+    if (!name) continue;
+    if (t.status === "assigned") counts[name].assigned++;
+    if (t.status === "in_progress") counts[name].inProgress++;
+  }
+  return { pending, ready: pending + readyAssigned, members: counts };
+}
+function poolRootProblem(root, protectedPaths) {
+  for (const p of protectedPaths) {
+    if (isWithin(root, p.path)) return `worktreeRoot ${root} is inside ${p.label} ${p.path}; pool worktrees never go inside a checkout`;
+  }
+  return null;
+}
+function memberPathProblem(s) {
+  if (s.symlink) return `${s.path} is a symlink; refusing to use it as a pool worktree`;
+  if (s.exists && s.commonDir !== s.baseCommonDir) return `${s.path} exists and is not a worktree of the pool's base clone`;
+  if (!s.exists && s.tracked) return `${s.path} is tracked by git; refusing to create a pool worktree there`;
+  return null;
+}
+function realpathAllowMissing(path3) {
+  const abs = resolve6(path3);
+  if (existsSync9(abs)) return realpathSync4.native(abs);
+  return join18(realpathAllowMissing(dirname9(abs)), basename2(abs));
+}
+function run2(cwd, args) {
+  try {
+    return execFileSync6("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+  } catch (err) {
+    const stderr = err.stderr?.toString().trim();
+    throw new Error(`git ${args.join(" ")} in ${cwd} failed${stderr ? `: ${stderr}` : ""}`);
+  }
+}
+var commonDir = (cwd) => {
+  const dir = git(["rev-parse", "--path-format=absolute", "--git-common-dir"], cwd);
+  return dir ? realpathSync4.native(dir) : null;
+};
+function defaultBranch(cwd) {
+  const head = () => git(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], cwd);
+  let ref = head();
+  if (!ref) {
+    git(["remote", "set-head", "origin", "--auto"], cwd);
+    ref = head();
+  }
+  if (!ref || !ref.startsWith("origin/")) throw new Error(`${cwd}: cannot tell origin's default branch; run git remote set-head origin --auto`);
+  return ref.slice("origin/".length);
+}
+function ensurePoolWorktrees(pool, otherWorktrees = []) {
+  if (!existsSync9(pool.base)) throw new Error(`pool ${pool.pool}: base ${pool.base} does not exist`);
+  const baseTop = git(["rev-parse", "--show-toplevel"], pool.base);
+  const baseCommon = commonDir(pool.base);
+  if (!baseTop || !baseCommon) throw new Error(`pool ${pool.pool}: base ${pool.base} is not a git clone`);
+  const root = realpathAllowMissing(pool.worktreeRoot);
+  const rootProblem = poolRootProblem(root, [{ label: "base", path: realpathSync4.native(baseTop) }, ...otherWorktrees]);
+  if (rootProblem) throw new Error(`pool ${pool.pool}: ${rootProblem}`);
+  const members = poolMembers({ ...pool, worktreeRoot: root });
+  for (const m of members) {
+    let symlink = false;
+    try {
+      symlink = lstatSync3(m.worktree).isSymbolicLink();
+    } catch {
+      symlink = false;
+    }
+    const exists = !symlink && existsSync9(m.worktree);
+    const problem = memberPathProblem({
+      path: m.worktree,
+      symlink,
+      exists,
+      baseCommonDir: baseCommon,
+      commonDir: exists ? commonDir(m.worktree) : null,
+      tracked: !exists && !symlink && isTracked(m.worktree)
+    });
+    if (problem) throw new Error(`pool ${pool.pool}: ${problem}`);
+  }
+  const missing = members.filter((m) => !existsSync9(m.worktree));
+  if (missing.length > 0) {
+    mkdirSync8(root, { recursive: true });
+    run2(pool.base, ["fetch", "-q", "origin"]);
+    const branch = defaultBranch(pool.base);
+    run2(pool.base, ["worktree", "prune"]);
+    for (const m of missing) run2(pool.base, ["worktree", "add", "-q", "--detach", m.worktree, `origin/${branch}`]);
+  }
+  return members.map((m) => realpathSync4.native(m.worktree));
+}
+function resetWorktree(worktree) {
+  run2(worktree, ["fetch", "-q", "--prune", "origin"]);
+  const target = `origin/${defaultBranch(worktree)}`;
+  run2(worktree, ["checkout", "-q", "--detach", "--force", target]);
+  run2(worktree, ["reset", "-q", "--hard", target]);
+  run2(worktree, ["clean", "-fdq"]);
+}
+
 // src/node/identity.ts
+function requestedAgents(agents) {
+  return agents.map((a) => ({
+    name: a.name,
+    workerType: getAdapter(a.runtime).workerType,
+    specialization: a.specialization,
+    ...a.tier ? { tier: a.tier } : {}
+  }));
+}
 function collectInvites(agentNames, flags, env2) {
   const byLower = new Map(agentNames.map((n) => [n.toLowerCase(), n]));
   const out = /* @__PURE__ */ new Map();
@@ -21851,6 +22240,7 @@ function matchInvites(agents, invites) {
   }
   return { matched, ungranted, extra: left, refused };
 }
+var MAX_REQUESTED = 32;
 function groupByRepo(agents, originOf2) {
   const groups = /* @__PURE__ */ new Map();
   for (const agent of agents) {
@@ -21858,7 +22248,10 @@ function groupByRepo(agents, originOf2) {
     if (!remote) throw new Error(`${agent.name}: ${agent.worktree} has no git origin; each worktree must be a clone of the agent's repo`);
     groups.set(remote, [...groups.get(remote) ?? [], agent]);
   }
-  return [...groups].map(([remote, members]) => ({ remote, agents: members }));
+  return [...groups].flatMap(([remote, members]) => Array.from({ length: Math.ceil(members.length / MAX_REQUESTED) }, (_, i) => ({
+    remote,
+    agents: members.slice(i * MAX_REQUESTED, (i + 1) * MAX_REQUESTED)
+  })));
 }
 var originOf = (worktree) => git(["remote", "get-url", "origin"], worktree);
 async function abandonMinted(spec, agent, minted, reason) {
@@ -21964,10 +22357,12 @@ async function ensureIdentities(spec, inviteCodes, specPath) {
     console.log(source_default.bold(`
   Approve ${repoName}`));
     console.log(`  On the approval screen add these agents as workers:`);
-    for (const a of group.agents) console.log(`    ${source_default.cyan(a.name)}  ${source_default.dim(`${a.runtime}, ${a.specialization}`)}`);
+    for (const a of group.agents) {
+      console.log(`    ${source_default.cyan(a.name)}  ${source_default.dim(`${a.runtime}, ${a.specialization}${a.tier ? `, tier ${a.tier}` : ""}`)}`);
+    }
     let grant;
     try {
-      grant = await requestDeviceGrant(spec.api, { repoName, remote: group.remote }, "pitboss node up");
+      grant = await requestDeviceGrant(spec.api, { repoName, remote: group.remote, agents: requestedAgents(group.agents) }, "pitboss node up");
     } catch (err) {
       console.log(source_default.red(`  \u2715 ${repoName}: ${err instanceof Error ? err.message : String(err)} ${group.agents.map((a) => a.name).join(", ")} will not start.`));
       continue;
@@ -22007,6 +22402,106 @@ async function ensureIdentities(spec, inviteCodes, specPath) {
   return have;
 }
 
+// src/commands/onboard.ts
+function isGitHubHost(host) {
+  if (!host) return false;
+  if (host === "github.com") return true;
+  try {
+    const resolved = execFileSync7("ssh", ["-G", host], { encoding: "utf-8" }).match(/^hostname (\S+)$/m)?.[1];
+    return resolved?.toLowerCase() === "github.com";
+  } catch {
+    return false;
+  }
+}
+var shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+async function onboardCommand(url, opts) {
+  try {
+    const plan = planOnboard(url, {
+      home: homedir6(),
+      parent: opts.dir,
+      writer: opts.writer,
+      reviewer: opts.reviewer,
+      poolMax: opts.poolMax === void 0 ? void 0 : Number(opts.poolMax)
+    });
+    const env2 = { ...process.env };
+    if (opts.account) {
+      env2.GH_TOKEN = execFileSync7("gh", ["auth", "token", "--hostname", "github.com", "--user", opts.account], { encoding: "utf-8" }).trim();
+    }
+    if (existsSync10(plan.base)) {
+      const origin = execFileSync7("git", ["-C", plan.base, "remote", "get-url", "origin"], { encoding: "utf-8" }).trim();
+      if (normalizeRepoUrl(origin) !== normalizeRepoUrl(plan.cloneUrl) || !isGitHubHost(originHost(origin))) {
+        throw new Error(`${plan.base} exists but its origin is ${origin}, not ${plan.cloneUrl} on github.com`);
+      }
+      console.log(source_default.dim(`  using the clone at ${plan.base}`));
+    } else {
+      execFileSync7("gh", ["repo", "clone", `${plan.owner}/${plan.name}`, plan.base], { stdio: "inherit", env: env2 });
+    }
+    const commonDir2 = (dir) => realpathSync5.native(
+      execFileSync7("git", ["-C", dir, "rev-parse", "--path-format=absolute", "--git-common-dir"], { encoding: "utf-8" }).trim()
+    );
+    for (const path3 of plan.worktrees) {
+      if (!existsSync10(path3)) {
+        execFileSync7("git", ["-C", plan.base, "worktree", "add", "--detach", path3], { stdio: "inherit" });
+      } else if (commonDir2(path3) !== commonDir2(plan.base)) {
+        throw new Error(`${path3} exists but is not a worktree of ${plan.base}; move it aside or pass --dir`);
+      }
+    }
+    const specText = JSON.stringify(plan.spec, null, 2) + "\n";
+    const parsed = parseSpec(specText, plan.nodeDir);
+    if (existsSync10(plan.specPath) && readFileSync13(plan.specPath, "utf-8") !== specText && !opts.force) {
+      throw new Error(`${plan.specPath} already exists with different contents; pass --force to replace it`);
+    }
+    mkdirSync9(plan.nodeDir, { recursive: true });
+    writeFileSync9(plan.specPath, specText);
+    process.env.PITBOSS_CONFIG_DIR = plan.configDir;
+    mkdirSync9(plan.configDir, { recursive: true, mode: 448 });
+    const specReal = realpathSync5.native(plan.specPath);
+    const foreign = allAgents(parsed).map((a) => readCreds(a.name)).find((c) => c?.spec && c.spec !== specReal);
+    if (foreign) throw new Error(`${plan.configDir} holds credentials for another node spec (${foreign.spec}); onboard will not overwrite them`);
+    const plain = parsed.agents.map((a) => ({ ...a, worktree: realpathSync5.native(a.worktree) }));
+    const ownToken = process.env.GH_TOKEN;
+    if (env2.GH_TOKEN) process.env.GH_TOKEN = env2.GH_TOKEN;
+    let pooled;
+    try {
+      pooled = parsed.pools.flatMap((pool) => {
+        const paths = ensurePoolWorktrees(pool, plain.map((a) => ({ label: `agent ${a.name}'s worktree`, path: a.worktree })));
+        return poolMembers(pool).map((m, i) => ({ ...m, worktree: paths[i] }));
+      });
+    } finally {
+      if (ownToken === void 0) delete process.env.GH_TOKEN;
+      else process.env.GH_TOKEN = ownToken;
+    }
+    const everyone = [...plain, ...pooled];
+    const seen = /* @__PURE__ */ new Map();
+    for (const a of everyone) {
+      const other = seen.get(a.worktree);
+      if (other) throw new Error(`agents "${other}" and "${a.name}" resolve to the same worktree ${a.worktree}; each needs its own`);
+      seen.set(a.worktree, a.name);
+    }
+    const creds = await ensureIdentities({ ...parsed, agents: everyone }, /* @__PURE__ */ new Map(), specReal);
+    const missing = everyone.filter((a) => !creds.has(a.name)).map((a) => a.name);
+    if (missing.length === everyone.length) throw new Error("no agent was granted; approve the device code again by re-running onboard");
+    if (missing.length > 0) process.exitCode = 1;
+    console.log(source_default.bold(`
+  ${plan.name} is onboarded${missing.length ? source_default.yellow(` except ${missing.join(", ")}`) : ""}.`));
+    console.log(`  spec      ${plan.specPath}`);
+    console.log(`  config    ${plan.configDir}`);
+    console.log(`
+  Start it when you want it running (long-running, foreground):`);
+    console.log(source_default.cyan(`    cd ${shellQuote(plan.nodeDir)} && PITBOSS_CONFIG_DIR=${shellQuote(plan.configDir)} pitboss node up spec.json`));
+    if (opts.account) console.log(source_default.dim(`    with GH_TOKEN from \`gh auth token --user ${opts.account}\` in that shell`));
+  } catch (err) {
+    console.error(source_default.red(`  \u2715 ${err instanceof Error ? err.message : String(err)}`));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/node.ts
+import { execFileSync as execFileSync8, spawn as spawnChild } from "node:child_process";
+import { closeSync, existsSync as existsSync12, mkdirSync as mkdirSync11, openSync, readFileSync as readFileSync15, realpathSync as realpathSync6, rmSync as rmSync6 } from "node:fs";
+import { dirname as dirname12, resolve as resolve8 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+
 // src/node/supervisor.ts
 function nextDelay(consecutiveFailures, { baseMs, maxMs }) {
   return Math.min(baseMs * 2 ** Math.max(0, consecutiveFailures - 1), maxMs);
@@ -22131,44 +22626,67 @@ var Supervisor = class {
   }
 };
 
+// src/node/model.ts
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync14, renameSync as renameSync5, rmSync as rmSync5, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname10 } from "node:path";
+function writeModelFiles(agents) {
+  for (const a of agents) {
+    const path3 = modelPath(a.name);
+    if (!a.model) {
+      rmSync5(path3, { force: true });
+      continue;
+    }
+    let current = null;
+    try {
+      current = readFileSync14(path3, "utf-8");
+    } catch {
+    }
+    if (current === a.model) continue;
+    mkdirSync10(dirname10(path3), { recursive: true });
+    const tmp = `${path3}.${process.pid}.tmp`;
+    writeFileSync10(tmp, a.model);
+    renameSync5(tmp, path3);
+  }
+}
+
 // src/node/entries.ts
-import { existsSync as existsSync9 } from "node:fs";
-import { dirname as dirname9, join as join17, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync11 } from "node:fs";
+import { dirname as dirname11, join as join19, resolve as resolve7 } from "node:path";
 var MISSING_WORKER = "event-worker not found next to this CLI. Run node from a pitboss checkout, or set PITBOSS_EVENT_WORKER to packages/event-worker.";
 function checkoutWorker(dir) {
   return {
-    command: join17(dir, "node_modules", ".bin", "tsx"),
-    args: [join17(dir, "src", "index.ts")]
+    command: join19(dir, "node_modules", ".bin", "tsx"),
+    args: [join19(dir, "src", "index.ts")]
   };
 }
 function checkoutMcp(dir, execPath) {
   return {
     command: execPath,
     args: [
-      join17(dir, "node_modules", "tsx", "dist", "cli.mjs"),
-      join17(dir, "src", "index.ts")
+      join19(dir, "node_modules", "tsx", "dist", "cli.mjs"),
+      join19(dir, "src", "index.ts")
     ]
   };
 }
 function walkFor(here, packageName, exists) {
-  for (let dir = dirname9(here); dirname9(dir) !== dir; dir = dirname9(dir)) {
-    const candidate = join17(dir, packageName);
-    if (exists(join17(candidate, "src", "index.ts"))) return candidate;
+  for (let dir = dirname11(here); dirname11(dir) !== dir; dir = dirname11(dir)) {
+    const candidate = join19(dir, packageName);
+    if (exists(join19(candidate, "src", "index.ts"))) return candidate;
   }
   return null;
 }
 function resolveEventWorker(opts) {
   const env2 = opts.env ?? process.env;
   const execPath = opts.execPath ?? process.execPath;
-  const exists = opts.exists ?? existsSync9;
+  const exists = opts.exists ?? existsSync11;
   const override = env2.PITBOSS_EVENT_WORKER;
   if (override) {
-    const resolved = resolve5(override);
+    const resolved = resolve7(override);
     if (resolved.endsWith(".js") && exists(resolved)) return { command: execPath, args: [resolved] };
-    if (exists(join17(resolved, "src", "index.ts"))) return checkoutWorker(resolved);
+    if (exists(join19(resolved, "src", "index.ts"))) return checkoutWorker(resolved);
     throw new Error(MISSING_WORKER);
   }
-  const bundled = join17(dirname9(opts.here), "event-worker.js");
+  const bundled = join19(dirname11(opts.here), "event-worker.js");
   if (exists(bundled)) return { command: execPath, args: [bundled] };
   const dir = walkFor(opts.here, "event-worker", exists);
   if (dir) return checkoutWorker(dir);
@@ -22176,8 +22694,8 @@ function resolveEventWorker(opts) {
 }
 function resolveMcpServer(opts) {
   const execPath = opts.execPath ?? process.execPath;
-  const exists = opts.exists ?? existsSync9;
-  const bundled = join17(dirname9(opts.here), "mcp.js");
+  const exists = opts.exists ?? existsSync11;
+  const bundled = join19(dirname11(opts.here), "mcp.js");
   if (exists(bundled)) return { command: execPath, args: [bundled] };
   const dir = walkFor(opts.here, "mcp-server", exists);
   if (dir) return checkoutMcp(dir, execPath);
@@ -22285,176 +22803,41 @@ function loadPruneTargets(names) {
   });
 }
 
-// src/node/pool.ts
-import { execFileSync as execFileSync6 } from "node:child_process";
-import { existsSync as existsSync10, lstatSync as lstatSync3, mkdirSync as mkdirSync8, realpathSync as realpathSync4 } from "node:fs";
-import { basename as basename2, dirname as dirname10, join as join18, resolve as resolve6 } from "node:path";
-var IDLE_STOP_MS = 10 * 6e4;
-var RECONCILE_MS = 15e3;
-var UNAVAILABLE_FOR_MS = 7 * 24 * 60 * 6e4 - 6e4;
-var REMARK_AFTER_MS = 24 * 60 * 6e4;
-function positiveMs(raw, fallback2) {
-  const n = Number(raw);
-  return raw && Number.isInteger(n) && n > 0 ? n : fallback2;
-}
-function poolTimings(env2 = process.env) {
-  return {
-    reconcileMs: positiveMs(env2.PITBOSS_POOL_RECONCILE_MS, RECONCILE_MS),
-    idleStopMs: positiveMs(env2.PITBOSS_POOL_IDLE_STOP_MS, IDLE_STOP_MS)
-  };
-}
-function effectiveBounds(spec, desired) {
-  if (!desired) return { min: spec.min, max: spec.max, desiredMax: null, capped: false };
-  const max = Math.min(desired.max, spec.max);
-  return { min: Math.min(desired.min, max), max, desiredMax: desired.max, capped: desired.max > spec.max };
-}
-function reconcilePool({ pending, members, min, max, idleStopMs }) {
-  const isIdle = (m) => m.assigned === 0 && m.inProgress === 0;
-  const running = members.filter((m) => m.running);
-  const stopped = members.filter((m) => !m.running);
-  let count = running.length;
-  const start = [];
-  const take = (m) => {
-    start.push(m.name);
-    count++;
-  };
-  for (const m of stopped) {
-    if (count >= max) break;
-    if (m.inProgress > 0 || m.readyAssigned > 0) take(m);
-  }
-  const spare = () => stopped.filter((m) => !start.includes(m.name)).sort((a, b) => Number(isIdle(b)) - Number(isIdle(a)));
-  let demand = pending - running.filter(isIdle).length;
-  for (const m of spare()) {
-    if (demand <= 0 || count >= max) break;
-    take(m);
-    demand--;
-  }
-  for (const m of spare()) {
-    if (count >= min || count >= max) break;
-    take(m);
-  }
-  if (start.length > 0) return { start, stop: [] };
-  const stop = [];
-  let surplus = running.filter(isIdle).length - pending;
-  const eligible = running.filter((m) => isIdle(m) && m.idleMs >= idleStopMs).sort((a, b) => b.idleMs - a.idleMs);
-  for (const m of eligible) {
-    if (surplus <= 0 || count <= min) break;
-    stop.push(m.name);
-    count--;
-    surplus--;
-  }
-  return { start, stop };
-}
-function summarizeTasks(ready, held, members) {
-  const nameOf = new Map(members.map((m) => [m.agentId, m.name]));
-  const counts = Object.fromEntries(
-    members.map((m) => [m.name, { assigned: 0, inProgress: 0, readyAssigned: 0 }])
-  );
-  const pending = ready.filter((t) => t.status === "pending" && t.autoAssign).length;
-  let readyAssigned = 0;
-  for (const t of ready) {
-    const name = t.status === "assigned" && t.assignedTo ? nameOf.get(t.assignedTo) : void 0;
-    if (!name) continue;
-    counts[name].readyAssigned++;
-    readyAssigned++;
-  }
-  for (const t of held) {
-    const name = t.assignedTo ? nameOf.get(t.assignedTo) : void 0;
-    if (!name) continue;
-    if (t.status === "assigned") counts[name].assigned++;
-    if (t.status === "in_progress") counts[name].inProgress++;
-  }
-  return { pending, ready: pending + readyAssigned, members: counts };
-}
-function poolRootProblem(root, protectedPaths) {
-  for (const p of protectedPaths) {
-    if (isWithin(root, p.path)) return `worktreeRoot ${root} is inside ${p.label} ${p.path}; pool worktrees never go inside a checkout`;
-  }
-  return null;
-}
-function memberPathProblem(s) {
-  if (s.symlink) return `${s.path} is a symlink; refusing to use it as a pool worktree`;
-  if (s.exists && s.commonDir !== s.baseCommonDir) return `${s.path} exists and is not a worktree of the pool's base clone`;
-  if (!s.exists && s.tracked) return `${s.path} is tracked by git; refusing to create a pool worktree there`;
-  return null;
-}
-function realpathAllowMissing(path3) {
-  const abs = resolve6(path3);
-  if (existsSync10(abs)) return realpathSync4.native(abs);
-  return join18(realpathAllowMissing(dirname10(abs)), basename2(abs));
-}
-function run2(cwd, args) {
-  try {
-    return execFileSync6("git", args, { cwd, encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
-  } catch (err) {
-    const stderr = err.stderr?.toString().trim();
-    throw new Error(`git ${args.join(" ")} in ${cwd} failed${stderr ? `: ${stderr}` : ""}`);
-  }
-}
-var commonDir = (cwd) => {
-  const dir = git(["rev-parse", "--path-format=absolute", "--git-common-dir"], cwd);
-  return dir ? realpathSync4.native(dir) : null;
-};
-function defaultBranch(cwd) {
-  const head = () => git(["symbolic-ref", "--short", "refs/remotes/origin/HEAD"], cwd);
-  let ref = head();
-  if (!ref) {
-    git(["remote", "set-head", "origin", "--auto"], cwd);
-    ref = head();
-  }
-  if (!ref || !ref.startsWith("origin/")) throw new Error(`${cwd}: cannot tell origin's default branch; run git remote set-head origin --auto`);
-  return ref.slice("origin/".length);
-}
-function ensurePoolWorktrees(pool, otherWorktrees = []) {
-  if (!existsSync10(pool.base)) throw new Error(`pool ${pool.pool}: base ${pool.base} does not exist`);
-  const baseTop = git(["rev-parse", "--show-toplevel"], pool.base);
-  const baseCommon = commonDir(pool.base);
-  if (!baseTop || !baseCommon) throw new Error(`pool ${pool.pool}: base ${pool.base} is not a git clone`);
-  const root = realpathAllowMissing(pool.worktreeRoot);
-  const rootProblem = poolRootProblem(root, [{ label: "base", path: realpathSync4.native(baseTop) }, ...otherWorktrees]);
-  if (rootProblem) throw new Error(`pool ${pool.pool}: ${rootProblem}`);
-  const members = poolMembers({ ...pool, worktreeRoot: root });
-  for (const m of members) {
-    let symlink = false;
-    try {
-      symlink = lstatSync3(m.worktree).isSymbolicLink();
-    } catch {
-      symlink = false;
-    }
-    const exists = !symlink && existsSync10(m.worktree);
-    const problem = memberPathProblem({
-      path: m.worktree,
-      symlink,
-      exists,
-      baseCommonDir: baseCommon,
-      commonDir: exists ? commonDir(m.worktree) : null,
-      tracked: !exists && !symlink && isTracked(m.worktree)
-    });
-    if (problem) throw new Error(`pool ${pool.pool}: ${problem}`);
-  }
-  const missing = members.filter((m) => !existsSync10(m.worktree));
-  if (missing.length > 0) {
-    mkdirSync8(root, { recursive: true });
-    run2(pool.base, ["fetch", "-q", "origin"]);
-    const branch = defaultBranch(pool.base);
-    run2(pool.base, ["worktree", "prune"]);
-    for (const m of missing) run2(pool.base, ["worktree", "add", "-q", "--detach", m.worktree, `origin/${branch}`]);
-  }
-  return members.map((m) => realpathSync4.native(m.worktree));
-}
-function resetWorktree(worktree) {
-  run2(worktree, ["fetch", "-q", "--prune", "origin"]);
-  const target = `origin/${defaultBranch(worktree)}`;
-  run2(worktree, ["checkout", "-q", "--detach", "--force", target]);
-  run2(worktree, ["reset", "-q", "--hard", target]);
-  run2(worktree, ["clean", "-fdq"]);
+// src/node/activity.ts
+var ACTIVITY_REPORT_MS = 15e3;
+var REVIEW_HEARTBEAT_MS = 6e4;
+function deriveActivity({ running, sessionActive, reviewing, waiting }) {
+  if (!running) return "stopped";
+  if (sessionActive) return "working";
+  if (reviewing) return "reviewing";
+  return waiting ? "waiting" : "idle";
+}
+function heldAgentIds(tasks) {
+  const reviewing = /* @__PURE__ */ new Set();
+  const waiting = /* @__PURE__ */ new Set();
+  for (const t of tasks) {
+    if (t.assignedTo && (t.status === "blocked" || t.status === "pending_verification")) waiting.add(t.assignedTo);
+    if (t.status === "pending_verification" && t.verifyReviewerId && t.metadata?.reviewStartedBy === t.verifyReviewerId) reviewing.add(t.verifyReviewerId);
+  }
+  return { reviewing, waiting };
+}
+function startedReviewTaskIds(tasks) {
+  const byAgent = /* @__PURE__ */ new Map();
+  for (const t of tasks) {
+    if (t.status !== "pending_verification" || !t.verifyReviewerId || t.metadata?.reviewStartedBy !== t.verifyReviewerId) continue;
+    byAgent.set(t.verifyReviewerId, [...byAgent.get(t.verifyReviewerId) ?? [], t.id]);
+  }
+  return byAgent;
+}
+function reviewerIsLive({ running, sessionActive }) {
+  return running && sessionActive;
 }
 
 // src/commands/node.ts
 var HERE = fileURLToPath3(import.meta.url);
 function inspectProcess(pid) {
   try {
-    const out = execFileSync7("ps", ["-o", "pgid=,command=", "-p", String(pid)], { encoding: "utf-8" }).trim();
+    const out = execFileSync8("ps", ["-o", "pgid=,command=", "-p", String(pid)], { encoding: "utf-8" }).trim();
     const match = /^(\d+)\s+(.*)$/.exec(out);
     return match ? { pgid: Number(match[1]), command: match[2] } : null;
   } catch {
@@ -22462,7 +22845,7 @@ function inspectProcess(pid) {
   }
 }
 function childSpec(agent, creds, worker, onDemand = false) {
-  const { ANTHROPIC_API_KEY: _key, ANTHROPIC_AUTH_TOKEN: _tok, ...inherited } = process.env;
+  const { ANTHROPIC_API_KEY: _key, ANTHROPIC_AUTH_TOKEN: _tok, PITBOSS_ISOLATE_USER_CONFIG: _iso, ...inherited } = process.env;
   return {
     name: agent.name,
     command: worker.command,
@@ -22478,7 +22861,10 @@ function childSpec(agent, creds, worker, onDemand = false) {
       REPO_ID: creds.repoId,
       REPO_PATH: agent.worktree,
       SPECIALIZATION: agent.specialization,
-      WORKER_RUNTIME: agent.runtime
+      WORKER_RUNTIME: agent.runtime,
+      PITBOSS_ACTIVITY_FILE: activityPath(agent.name),
+      PITBOSS_MODEL_FILE: resolve8(modelPath(agent.name)),
+      ...agent.isolateUserConfig ? { PITBOSS_ISOLATE_USER_CONFIG: "1" } : {}
     }
   };
 }
@@ -22494,12 +22880,13 @@ function prepareAgent(agent, creds, mcp) {
       excludeIfUntracked(root, target);
     },
     run(bin4, args, cwd) {
-      execFileSync7(bin4, args, { cwd, stdio: "ignore" });
+      execFileSync8(bin4, args, { cwd, stdio: "ignore" });
     }
   });
 }
 function spawnWorker(spec) {
-  mkdirSync9(dirname11(spec.logPath), { recursive: true, mode: 448 });
+  mkdirSync11(dirname12(spec.logPath), { recursive: true, mode: 448 });
+  rmSync6(activityPath(spec.name), { force: true });
   const log = openSync(spec.logPath, "a", 384);
   try {
     const child = spawnChild(spec.command, spec.args, { cwd: spec.cwd, env: spec.env, stdio: ["ignore", log, log], detached: true });
@@ -22546,6 +22933,63 @@ async function reportScale(creds, event) {
   });
   if (!res.ok) throw new Error(`POST /agents/${creds.agentId}/pool-events returned HTTP ${res.status}`);
 }
+async function reportActivity(creds, state) {
+  const res = await fetch(`${creds.api}/agents/${encodeURIComponent(creds.agentId)}/activity`, {
+    method: "PUT",
+    headers: { Authorization: `Bearer ${creds.token}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ state })
+  });
+  if (!res.ok) throw new Error(`PUT /agents/${creds.agentId}/activity returned HTTP ${res.status}`);
+}
+function startActivityLoop(agents, sup) {
+  let busy = false;
+  const sent = /* @__PURE__ */ new Map();
+  const beatAt = /* @__PURE__ */ new Map();
+  const heartbeatReviews = async (creds, name, live, taskIds) => {
+    if (!live || taskIds.length === 0 || Date.now() - (beatAt.get(name) ?? 0) < REVIEW_HEARTBEAT_MS) return;
+    beatAt.set(name, Date.now());
+    for (const id of taskIds) {
+      const res = await fetch(`${creds.api}/tasks/${encodeURIComponent(id)}/review/start`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${creds.token}` }
+      });
+      if (!res.ok) throw new Error(`POST /tasks/${id}/review/start returned HTTP ${res.status}`);
+    }
+  };
+  const tick = async () => {
+    if (busy) return;
+    busy = true;
+    try {
+      const reader = agents[0].creds;
+      const held = await fetchTasks(reader, "status=blocked,pending_verification");
+      const { reviewing, waiting } = heldAgentIds(held);
+      const reviewIds = startedReviewTaskIds(held);
+      for (const { name, creds } of agents) {
+        const signals2 = {
+          running: sup.isActive(name),
+          sessionActive: existsSync12(activityPath(name))
+        };
+        const live = reviewerIsLive(signals2);
+        const state = deriveActivity({
+          ...signals2,
+          reviewing: reviewing.has(creds.agentId),
+          waiting: waiting.has(creds.agentId)
+        });
+        await heartbeatReviews(creds, name, live, reviewIds.get(creds.agentId) ?? []);
+        if (sent.get(name) === state) continue;
+        await reportActivity(creds, state);
+        sent.set(name, state);
+      }
+    } catch (err) {
+      console.log(`${(/* @__PURE__ */ new Date()).toISOString()}  activity: ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      busy = false;
+    }
+  };
+  void tick();
+  const timer = setInterval(() => void tick(), ACTIVITY_REPORT_MS);
+  return () => clearInterval(timer);
+}
 function startPoolLoop(run3, sup, record) {
   const { pool, members } = run3;
   const { reconcileMs, idleStopMs } = poolTimings();
@@ -22631,19 +23075,20 @@ function startPoolLoop(run3, sup, record) {
   const timer = setInterval(() => void tick(), reconcileMs);
   return () => clearInterval(timer);
 }
+var MODEL_REFRESH_MS = 15e3;
 async function nodeUpCommand(specFile, opts = {}) {
   try {
-    const specPath = resolve7(specFile);
-    const specRealpath = realpathSync5.native(specPath);
-    const parsed = parseSpec(readFileSync12(specPath, "utf-8"), dirname11(specPath));
+    const specPath = resolve8(specFile);
+    const specRealpath = realpathSync6.native(specPath);
+    const parsed = parseSpec(readFileSync15(specPath, "utf-8"), dirname12(specPath));
     const previous = readState();
     if (previous && previous.supervisorPid !== process.pid && isAlive(previous.supervisorPid)) {
       throw new Error(`a node is already running (pid ${previous.supervisorPid}, ${previous.specPath}). Stop it first.`);
     }
     for (const a of parsed.agents) {
-      if (!existsSync11(a.worktree)) throw new Error(`${a.name}: worktree ${a.worktree} does not exist`);
+      if (!existsSync12(a.worktree)) throw new Error(`${a.name}: worktree ${a.worktree} does not exist`);
     }
-    const plain = parsed.agents.map((a) => ({ ...a, worktree: realpathSync5.native(a.worktree) }));
+    const plain = parsed.agents.map((a) => ({ ...a, worktree: realpathSync6.native(a.worktree) }));
     const pools = parsed.pools.map((pool) => {
       const paths = ensurePoolWorktrees(pool, plain.map((a) => ({ label: `agent ${a.name}'s worktree`, path: a.worktree })));
       return { pool, members: poolMembers(pool).map((m, i) => ({ ...m, worktree: paths[i] })) };
@@ -22673,6 +23118,20 @@ async function nodeUpCommand(specFile, opts = {}) {
     const inviteCodes = collectInvites(spec.agents.map((a) => a.name), opts.invite ?? [], process.env);
     const creds = await ensureIdentities(spec, inviteCodes, specRealpath);
     const runnable = spec.agents.filter((a) => creds.has(a.name));
+    writeModelFiles(spec.agents);
+    let modelError = "";
+    const refreshModels = setInterval(() => {
+      try {
+        const fresh = new Map(allAgents(parseSpec(readFileSync15(specPath, "utf-8"), dirname12(specPath))).map((a) => [a.name, a.model]));
+        writeModelFiles(spec.agents.map((a) => ({ name: a.name, model: fresh.get(a.name) })));
+        modelError = "";
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message !== modelError) console.log(source_default.yellow(`  ! spec not re-read for models: ${message}`));
+        modelError = message;
+      }
+    }, MODEL_REFRESH_MS);
+    refreshModels.unref();
     if (runnable.length === 0) throw new Error("no agent has credentials, nothing to start");
     const mcp = resolveMcpServer({ here: HERE });
     for (const a of runnable) prepareAgent(a, creds.get(a.name), mcp);
@@ -22711,6 +23170,12 @@ async function nodeUpCommand(specFile, opts = {}) {
     process.on("SIGTERM", shutdown);
     process.on("SIGHUP", shutdown);
     sup.start();
+    const byRepo = /* @__PURE__ */ new Map();
+    for (const a of runnable) {
+      const c = creds.get(a.name);
+      byRepo.set(c.repoId, [...byRepo.get(c.repoId) ?? [], { name: a.name, creds: c }]);
+    }
+    for (const group of byRepo.values()) stopLoops.push(startActivityLoop(group, sup));
     for (const { pool, members } of pools) {
       const ready = members.filter((m) => creds.has(m.name)).map((agent) => ({ agent, creds: creds.get(agent.name) }));
       if (ready.length === 0) {
@@ -22731,9 +23196,9 @@ async function nodeUpCommand(specFile, opts = {}) {
 }
 async function nodePruneCommand(specFile, opts = {}) {
   try {
-    const specPath = resolve7(specFile);
-    const specRealpath = realpathSync5.native(specPath);
-    const spec = parseSpec(readFileSync12(specPath, "utf-8"), dirname11(specPath));
+    const specPath = resolve8(specFile);
+    const specRealpath = realpathSync6.native(specPath);
+    const spec = parseSpec(readFileSync15(specPath, "utf-8"), dirname12(specPath));
     const { orphans: names, unattributed } = classifyStored(allAgents(spec).map((a) => a.name), specRealpath);
     if (names.length === 0) {
       console.log("No stored credentials are missing from the spec.");
@@ -22839,6 +23304,7 @@ var token = program2.command("token").description("Manage your agent's API token
 token.command("rotate").description("Issue a new token, revoke the old one, and list the configs that still hold it").action(tokenRotateCommand);
 token.command("list").description("List your agent's tokens, live and revoked, and mark the one in use").action(tokenListCommand);
 token.command("revoke <tokenId>").description("Revoke a specific token id").action(tokenRevokeCommand);
+program2.command("onboard <github-url>").description("Set a GitHub repo up for pitboss: clone it, write a node spec (tier-2 architect, reviewer, writer pool) and print one device code that grants every agent. Starts nothing").option("--account <login>", "GitHub account to clone and work as, from `gh auth` (for example a personal account)").option("--dir <path>", "Parent directory for the clone, worktrees and spec (default ~/github)").option("--writer <runtime>", "Runtime for the writer pool (default claude)").option("--reviewer <runtime>", "Runtime for the reviewer; must differ from the writers (default copilot, or claude for non-claude writers)").option("--pool-max <n>", "Writer pool size (default 2)").option("--force", "Replace an existing spec with different contents").action(onboardCommand);
 var node = program2.command("node").description("Run this machine's agents headless and keep them running");
 node.command("up <spec>").description("Start every agent in a spec file and restart any that exit (foreground; Ctrl-C stops them)").option(
   "--invite <name=code>",