@pitboss/cli 0.4.7 → 0.4.9

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";
@@ -20643,6 +20646,14 @@ var BASE_TASK_LOOP = (agentId, repoPath) => `You are an AI worker agent (ID: ${a
    human. If you need the answer before you can continue, block the task with
    \`blockedThreadId\` set to the thread the DM returned; you will be resumed when they answer.
 
+   **A blocker travels up the chain.** When another agent's task blocks, the repo's orchestrator
+   and the planner of that task's goal are told, as well as the owner. If that is you, read the
+   question on its \`blockedThreadId\`. When the plan, the goal, its issue or its PR already answers
+   it, reply there with the answer and where it comes from. As the planner, if the block shows the
+   plan is wrong (a missing dependency, a task too big), fix the plan. Never answer for the owner on
+   deletes, scope changes, approvals or publishing; those wait for the owner or their delegate.
+   Otherwise do nothing: the owner has already been told.
+
 2. Call \`mcp__relai__session_start\` for orientation. It is an **index, not an archive**: lists are
    capped and long bodies are clipped. Anything marked \`truncated: true\`, and anything named under
    \`notShown\`, is a pointer: fetch the real thing with the tool it names before you rely on it,
@@ -20659,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.
@@ -20901,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.
@@ -20921,6 +20937,62 @@ Find the default branch with \`git remote show origin\`.
    Write it to a file and run \`gh pr edit <prUrl> --body-file <file>\`. Post the same plan on
    the planning task's thread and complete it.
 
+**Review goals** (the order's \`kind\` is \`"review"\`; the planning task carries
+\`metadata.orderKind: "review"\`): the goal is one review posted on the existing pull request at the
+order's \`prUrl\`. There is no order branch, no draft PR and no merge, so skip steps 2 to 6 above.
+Nobody pushes to the PR's branch, approves it, or requests changes on it.
+1. As the planner, read the PR with \`gh pr view <prUrl>\` and \`gh pr diff <prUrl>\`. Pick the
+   angles it needs: correctness, security, simplicity, tests and consistency with the codebase for a
+   real change; correctness and consistency alone for a small, low-risk one (docs, tests, under about
+   150 changed lines with no auth, input handling, secrets, money or migrations).
+2. One task per angle, \`epicId\` = the order's \`epicId\`,
+   \`metadata: { orderId, orderRole: "review", angle: "<angle>", prUrl }\`. Spread the angles
+   across vendors: assign each to a different agent from \`mcp__relai__list_agents\`, preferring a
+   different \`workerType\` from the agents already given one, and reuse agents only when there are
+   more angles than agents. Each description names the angle, the PR, what that angle hunts for, and
+   the reporting format below.
+3. One lead task, \`blockedBy\` every angle task, assigned to yourself, with
+   \`metadata: { orderId, orderRole: "review_lead", prUrl }\`.
+4. When acceptance includes \`human_approval\`, add a gate task blocked by the lead
+   (\`metadata: { orderId, orderRole: "gate" }\`, \`verifyKind: "human_approval"\`) and a post task
+   blocked by the gate (\`metadata: { orderId, orderRole: "post_review", prUrl }\`). Without it,
+   the lead posts the review itself.
+5. If the order has \`relatedRepos\`, copy them into every angle and lead task's metadata and name them in
+   each description, so reviewers check the contracts this PR depends on in those repos.
+6. Post the task list on the planning task's thread and complete it.
+
+**orderRole "review"** (one angle of a review goal):
+- Read the diff and as much surrounding code as you need. To run anything, check out the PR head
+  detached: \`git fetch origin pull/<n>/head && git checkout --detach FETCH_HEAD\`. Never push, never
+  comment on the PR, never edit the repo's history.
+- Verify by running code where you can. Report your 3 to 5 best-evidenced findings for your angle, most
+  severe first, each with severity (blocker, high, medium, low), file:line, and a concrete failing
+  input or scenario. "No findings" is a valid report. A missing code comment is not a finding.
+- When the task names \`relatedRepos\`, read them for any contract this change depends on (an endpoint it
+  calls, a helper it imports, a config value it reads). Read only, outside your worktree: a shallow
+  clone into a temp directory (\`gh repo clone <url> <tmp dir> -- --depth 1\`) or one file at a time with
+  \`gh api repos/<owner>/<repo>/contents/<path>\`. Never push, branch, comment or open anything there.
+  A finding that rests on a related repo cites the file and line there. If you could not read the
+  repo, mark that finding UNPROVEN and say why rather than guessing what the other side does.
+- Post the report with \`mcp__relai__add_task_comment\` on this task, then complete it.
+
+**orderRole "review_lead"**:
+- Read every angle task's report with \`mcp__relai__get_task_comments\`. Merge duplicates, drop
+  findings you cannot reproduce or whose premise is wrong, and rank what is left. Keep an UNPROVEN mark
+  on any finding about a related repo nobody could read. Severity sets the
+  verdict: any blocker or high means changes are needed; otherwise it is safe to merge with the
+  noted follow-ups.
+- Write one review: the verdict in the first line, then the findings, each with file:line, the
+  failure and the fix you would ask for, then which angles ran, each with its agent's name and vendor
+  (\`workerType\` from \`mcp__relai__list_agents\`), and which related repos were read. Keep it short.
+- Without a \`human_approval\` gate, post it with \`gh pr review <prUrl> --comment --body-file <file>\`
+  and put the review URL on the task's thread. With a gate, post the review as a comment on this task
+  for the owner to approve, and do not touch the PR. Then complete.
+
+**orderRole "post_review"**: once the gate is approved, post the lead's review comment from the
+lead task's thread with \`gh pr review <prUrl> --comment --body-file <file>\`, put the review URL on
+this task's thread, and complete.
+
 **orderRole "plan_review"** (assigned to the planner, reviewed by another agent):
 - After the task graph is written, complete each plan review task. That hands the plan to its
   reviewer. Every build task waits until all plan reviews are approved.
@@ -21106,6 +21178,18 @@ async function recordSessionUsage(conn, startIds, usage, logPrefix) {
   await writeSessionUsage(conn, await sessionTouchedTaskIds(conn, start, logPrefix), usage, logPrefix);
 }
 
+// ../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
 function mcpServerEntry() {
   return fileURLToPath2(new URL("../../mcp-server/src/index.ts", import.meta.url));
@@ -21143,7 +21227,7 @@ async function runClaudeSession(config) {
   const mcpConfigPath = writeMcpConfig(config);
   const taskIdsPromise = listSessionTaskIds(config, "[claude-worker]");
   try {
-    return await new Promise((resolve8, reject) => {
+    return await new Promise((resolve9, reject) => {
       const args = [
         "--print",
         "--mcp-config",
@@ -21154,7 +21238,7 @@ async function runClaudeSession(config) {
         "stream-json",
         "--verbose",
         "--model",
-        config.model,
+        pinnedModel() ?? config.model,
         "--add-dir",
         config.repoPath
       ];
@@ -21223,7 +21307,7 @@ async function runClaudeSession(config) {
             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);
@@ -21275,8 +21359,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;
@@ -21300,10 +21384,10 @@ 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 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 = [];
@@ -21342,7 +21426,7 @@ async function runCursorSession(config) {
           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);
@@ -21381,10 +21465,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",
@@ -21414,9 +21499,9 @@ 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());
   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 = [];
@@ -21453,7 +21538,7 @@ async function runCopilotSession(config) {
         const detail = (sessionError || stderrOutput).trim();
         reject(new Error(`copilot exited with ${signal ?? `code ${code}`}${detail ? `: ${detail}` : ""}`));
       } else {
-        resolve8([...new Set(toolsUsed)]);
+        resolve9([...new Set(toolsUsed)]);
       }
     });
     proc.on("error", (err) => {
@@ -21487,7 +21572,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",
@@ -21498,6 +21583,7 @@ function codexArgs(repoPath, prompt, profile) {
     repoPath,
     "-p",
     profile,
+    ...model ? ["-m", model] : [],
     prompt
   ];
 }
@@ -21546,9 +21632,9 @@ async function runCodexSession(config) {
     } catch {
     }
   };
-  const args = codexArgs(config.repoPath, buildPrompt(config), profile);
+  const args = codexArgs(config.repoPath, buildPrompt(config), profile, pinnedModel());
   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 = [];
@@ -21582,7 +21668,7 @@ async function runCodexSession(config) {
         const detail = (sessionError || stderrOutput).trim();
         reject(new Error(`codex exited with ${signal ?? `code ${code}`}${detail ? `: ${detail}` : ""}`));
       } else {
-        resolve8([...new Set(toolsUsed)]);
+        resolve9([...new Set(toolsUsed)]);
       }
     });
     proc.on("error", (err) => {
@@ -21619,7 +21705,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}$/;
@@ -21631,7 +21775,14 @@ 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 } : {}
+    };
   });
 }
 var allAgents = (spec) => [...spec.agents, ...spec.pools.flatMap(poolMembers)];
@@ -21648,6 +21799,18 @@ 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 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)`);
@@ -21663,10 +21826,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), min, max };
 }
 function parseSpec(text, specDir) {
   let raw;
@@ -21692,7 +21855,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) });
   });
   for (const p of pools) {
     for (const a of agents) {
@@ -21719,13 +21883,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")}`;
@@ -21734,7 +21900,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);
@@ -21743,14 +21909,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();
@@ -21787,6 +22126,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) {
@@ -21794,7 +22134,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) {
@@ -21900,10 +22243,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;
@@ -21943,6 +22288,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);
@@ -22067,44 +22512,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);
@@ -22112,8 +22580,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);
@@ -22221,176 +22689,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 {
@@ -22414,7 +22747,9 @@ 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))
     }
   };
 }
@@ -22430,12 +22765,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 });
@@ -22482,6 +22818,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();
@@ -22567,19 +22960,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] })) };
@@ -22609,6 +23003,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);
@@ -22647,6 +23055,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) {
@@ -22667,9 +23081,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.");
@@ -22775,6 +23189,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>",