opencara 0.18.4 → 0.18.6

package/dist/index.js

@@ -7,8 +7,7 @@ import { Command as Command5 } from "commander";
 import { Command } from "commander";
 import { execFile } from "child_process";
 import crypto2 from "crypto";
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as path8 from "path";
 
 // ../shared/dist/types.js
 function isDedupRole(role) {
@@ -17,15 +16,24 @@ function isDedupRole(role) {
 function isTriageRole(role) {
   return role === "pr_triage" || role === "issue_triage";
 }
-function isRepoAllowed(repoConfig, targetOwner, targetRepo, agentOwner) {
+function isRepoAllowed(repoConfig, targetOwner, targetRepo, agentOwner, userOrgs) {
   if (!repoConfig)
     return true;
   const fullRepo = `${targetOwner}/${targetRepo}`;
   switch (repoConfig.mode) {
-    case "all":
+    case "public":
+      return true;
+    case "private": {
+      const normalizedTarget = targetOwner.toLowerCase();
+      const normalizedOwner = agentOwner?.toLowerCase();
+      const hasAccess = normalizedOwner === normalizedTarget || userOrgs != null && userOrgs.has(normalizedTarget);
+      if (!hasAccess)
+        return false;
+      if (repoConfig.list && repoConfig.list.length > 0) {
+        return repoConfig.list.includes(fullRepo);
+      }
       return true;
-    case "own":
-      return agentOwner === targetOwner;
+    }
     case "whitelist":
       return (repoConfig.list ?? []).includes(fullRepo);
     case "blacklist":
@@ -159,6 +167,20 @@ function parseStringArray(value) {
     return [];
   return value.filter((v) => typeof v === "string");
 }
+var DEFAULT_MODEL_DIVERSITY_GRACE_MS = 3e4;
+function parseDurationSeconds(value, defaultMs) {
+  if (typeof value === "number")
+    return value === 0 ? 0 : clamp(value, 0, 300) * 1e3;
+  if (typeof value !== "string")
+    return defaultMs;
+  if (value === "0" || value === "0s")
+    return 0;
+  const match = value.match(/^(\d+)s$/);
+  if (!match)
+    return defaultMs;
+  const seconds = parseInt(match[1], 10);
+  return clamp(seconds, 0, 300) * 1e3;
+}
 var DEFAULT_TRIGGER = {
   on: ["opened"],
   comment: "/opencara review",
@@ -169,13 +191,14 @@ var DEFAULT_FEATURE_CONFIG = {
   agentCount: 1,
   timeout: "10m",
   preferredModels: [],
-  preferredTools: []
+  preferredTools: [],
+  modelDiversityGraceMs: DEFAULT_MODEL_DIVERSITY_GRACE_MS
 };
 var DEFAULT_REVIEW_SECTION = {
   ...DEFAULT_FEATURE_CONFIG,
   trigger: DEFAULT_TRIGGER,
   reviewer: { whitelist: [], blacklist: [] },
-  summarizer: { whitelist: [], blacklist: [], preferred: [] }
+  summarizer: { whitelist: [], blacklist: [], preferred: [], preferredModels: [] }
 };
 function toGithubEntity(name) {
   return { github: name };
@@ -184,27 +207,30 @@ function parseSummarizerSection(raw) {
   const defaults = {
     whitelist: [],
     blacklist: [],
-    preferred: []
+    preferred: [],
+    preferredModels: []
   };
   if (typeof raw === "string") {
     return { ...defaults, preferred: [toGithubEntity(raw)] };
   }
   if (!isObject(raw))
     return defaults;
+  const preferredModels = parseStringArray(raw.preferred_models);
   if (raw.only !== void 0) {
     if (typeof raw.only === "string") {
-      return { ...defaults, whitelist: [toGithubEntity(raw.only)] };
+      return { ...defaults, whitelist: [toGithubEntity(raw.only)], preferredModels };
     }
     if (Array.isArray(raw.only)) {
       const entries = raw.only.filter((v) => typeof v === "string").map((v) => toGithubEntity(v));
-      return { ...defaults, whitelist: entries };
+      return { ...defaults, whitelist: entries, preferredModels };
     }
-    return defaults;
+    return { ...defaults, preferredModels };
   }
   return {
     whitelist: parseEntityList(raw.whitelist),
     blacklist: parseEntityList(raw.blacklist),
-    preferred: parseEntityList(raw.preferred)
+    preferred: parseEntityList(raw.preferred),
+    preferredModels
   };
 }
 function parseAgentSlots(value) {
@@ -235,6 +261,7 @@ function parseFeatureFields(raw, defaults) {
     timeout: parseTimeout(raw.timeout ?? defaults.timeout),
     preferredModels: parseStringArray(raw.preferred_models ?? defaults.preferredModels),
     preferredTools: parseStringArray(raw.preferred_tools ?? defaults.preferredTools),
+    modelDiversityGraceMs: parseDurationSeconds(raw.model_diversity_grace, defaults.modelDiversityGraceMs),
     ...agentSlots ? { agents: agentSlots } : {}
   };
 }
@@ -261,7 +288,8 @@ var DEFAULT_DEDUP_FEATURE = {
   agentCount: 1,
   timeout: "10m",
   preferredModels: [],
-  preferredTools: []
+  preferredTools: [],
+  modelDiversityGraceMs: DEFAULT_MODEL_DIVERSITY_GRACE_MS
 };
 function parseDedupTarget(raw) {
   const base = parseFeatureFields(raw, DEFAULT_DEDUP_FEATURE);
@@ -291,7 +319,8 @@ var DEFAULT_TRIAGE_FEATURE = {
   agentCount: 1,
   timeout: "10m",
   preferredModels: [],
-  preferredTools: []
+  preferredTools: [],
+  modelDiversityGraceMs: DEFAULT_MODEL_DIVERSITY_GRACE_MS
 };
 function parseTriageSection(raw) {
   const base = parseFeatureFields(raw, DEFAULT_TRIAGE_FEATURE);
@@ -360,6 +389,7 @@ function parseLegacyReviewConfig(raw) {
     timeout: parseTimeout(raw.timeout),
     preferredModels: parseStringArray(agentsRaw.preferred_models),
     preferredTools: parseStringArray(agentsRaw.preferred_tools),
+    modelDiversityGraceMs: parseDurationSeconds(raw.model_diversity_grace ?? agentsRaw.model_diversity_grace, DEFAULT_MODEL_DIVERSITY_GRACE_MS),
     trigger: {
       on: Array.isArray(triggerRaw.on) ? triggerRaw.on.filter((v) => typeof v === "string") : DEFAULT_TRIGGER.on,
       comment: typeof triggerRaw.comment === "string" ? triggerRaw.comment : DEFAULT_TRIGGER.comment,
@@ -387,8 +417,12 @@ function ensureConfigDir() {
 }
 var DEFAULT_MAX_DIFF_SIZE_KB = 100;
 var DEFAULT_MAX_CONSECUTIVE_ERRORS = 10;
-var VALID_REPO_MODES = ["all", "own", "whitelist", "blacklist"];
+var VALID_REPO_MODES = ["public", "private", "whitelist", "blacklist"];
 var REPO_PATTERN = /^[^/]+\/[^/]+$/;
+var REPO_MODE_ALIASES = {
+  all: "public",
+  own: "private"
+};
 var RepoConfigError = class extends Error {
   constructor(message) {
     super(message);
@@ -412,10 +446,17 @@ function parseRepoConfig(obj, index, field = "repos") {
     throw new RepoConfigError(`agents[${index}].${field} must be an object`);
   }
   const reposObj = raw;
-  const mode = reposObj.mode;
+  let mode = reposObj.mode;
   if (mode === void 0) {
     throw new RepoConfigError(`agents[${index}].${field}.mode is required`);
   }
+  if (typeof mode === "string" && Object.hasOwn(REPO_MODE_ALIASES, mode)) {
+    const resolved = REPO_MODE_ALIASES[mode];
+    console.warn(
+      `\u26A0 Config warning: agents[${index}].${field}.mode "${mode}" is deprecated, use "${resolved}" instead`
+    );
+    mode = resolved;
+  }
   if (typeof mode !== "string" || !VALID_REPO_MODES.includes(mode)) {
     throw new RepoConfigError(
       `agents[${index}].${field}.mode must be one of: ${VALID_REPO_MODES.join(", ")}`
@@ -509,6 +550,15 @@ function parseAgents(data) {
       );
     }
     if (typeof obj.codebase_dir === "string") agent.codebase_dir = obj.codebase_dir;
+    if (typeof obj.instances === "number") {
+      if (!Number.isInteger(obj.instances) || obj.instances < 1) {
+        console.warn(
+          `\u26A0 Config warning: agents[${i}].instances must be a positive integer, got ${obj.instances}. Value ignored.`
+        );
+      } else {
+        agent.instances = obj.instances;
+      }
+    }
     const repoConfig = parseRepoConfig(obj, i);
     if (repoConfig) agent.repos = repoConfig;
     const synthesizeRepoConfig = parseRepoConfig(obj, i, "synthesize_repos");
@@ -568,6 +618,7 @@ function loadConfig() {
     maxDiffSizeKb: DEFAULT_MAX_DIFF_SIZE_KB,
     maxConsecutiveErrors: DEFAULT_MAX_CONSECUTIVE_ERRORS,
     codebaseDir: null,
+    codebaseTtl: null,
     agentCommand: null,
     agents: null,
     usageLimits: {
@@ -611,6 +662,7 @@ function loadConfig() {
     maxDiffSizeKb: overrides.maxDiffSizeKb ?? (typeof data.max_diff_size_kb === "number" ? data.max_diff_size_kb : DEFAULT_MAX_DIFF_SIZE_KB),
     maxConsecutiveErrors: overrides.maxConsecutiveErrors ?? (typeof data.max_consecutive_errors === "number" ? data.max_consecutive_errors : DEFAULT_MAX_CONSECUTIVE_ERRORS),
     codebaseDir: typeof data.codebase_dir === "string" ? data.codebase_dir : null,
+    codebaseTtl: typeof data.codebase_ttl === "string" ? data.codebase_ttl : null,
     agentCommand: typeof data.agent_command === "string" ? data.agent_command : null,
     agents: parseAgents(data),
     usageLimits: {
@@ -629,10 +681,10 @@ function resolveCodebaseDir(agentDir, globalDir) {
   return path.resolve(raw);
 }
 
-// src/codebase.ts
-import { execFileSync } from "child_process";
-import * as fs2 from "fs";
-import * as path2 from "path";
+// src/repo-cache.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import * as fs3 from "fs";
+import * as path3 from "path";
 
 // src/sanitize.ts
 var GITHUB_TOKEN_PATTERN = /\b(ghp_[A-Za-z0-9_]{1,255}|gho_[A-Za-z0-9_]{1,255}|ghs_[A-Za-z0-9_]{1,255}|ghr_[A-Za-z0-9_]{1,255}|github_pat_[A-Za-z0-9_]{1,255})\b/g;
@@ -643,47 +695,10 @@ function sanitizeTokens(input) {
 }
 
 // src/codebase.ts
+import { execFileSync } from "child_process";
+import * as fs2 from "fs";
+import * as path2 from "path";
 var VALID_NAME_PATTERN = /^[a-zA-Z0-9._-]+$/;
-var GH_CREDENTIAL_HELPER = "!gh auth git-credential";
-function cloneOrUpdate(owner, repo, prNumber, baseDir, taskId) {
-  validatePathSegment(owner, "owner");
-  validatePathSegment(repo, "repo");
-  if (taskId) {
-    validatePathSegment(taskId, "taskId");
-  }
-  const repoDir = taskId ? path2.join(baseDir, owner, repo, taskId) : path2.join(baseDir, owner, repo);
-  const ghAvailable = isGhAvailable();
-  let cloned = false;
-  if (!fs2.existsSync(path2.join(repoDir, ".git"))) {
-    if (ghAvailable) {
-      ghClone(owner, repo, repoDir);
-    } else {
-      fs2.mkdirSync(repoDir, { recursive: true });
-      const cloneUrl = buildCloneUrl(owner, repo);
-      git(["clone", "--depth", "1", cloneUrl, repoDir]);
-    }
-    cloned = true;
-  }
-  const credArgs = ghAvailable ? ["-c", `credential.helper=${GH_CREDENTIAL_HELPER}`] : [];
-  git(
-    [...credArgs, "fetch", "--force", "--depth", "1", "origin", `pull/${prNumber}/head`],
-    repoDir
-  );
-  git(["checkout", "FETCH_HEAD"], repoDir);
-  return { localPath: repoDir, cloned };
-}
-function cleanupTaskDir(dirPath) {
-  if (!path2.isAbsolute(dirPath) || dirPath.split(path2.sep).filter(Boolean).length < 3) {
-    return;
-  }
-  try {
-    fs2.rmSync(dirPath, { recursive: true, force: true });
-  } catch (err) {
-    if (err?.code !== "ENOENT") {
-      console.warn(`[cleanup] Failed to remove ${dirPath}: ${err.message}`);
-    }
-  }
-}
 function validatePathSegment(segment, name) {
   if (!VALID_NAME_PATTERN.test(segment) || segment === "." || segment === "..") {
     throw new Error(`Invalid ${name}: '${segment}' contains disallowed characters`);
@@ -704,24 +719,111 @@ function isGhAvailable() {
     return false;
   }
 }
-function ghClone(owner, repo, targetDir) {
+
+// src/repo-cache.ts
+var GH_CREDENTIAL_HELPER = "!gh auth git-credential";
+var GIT_TIMEOUT_MS = 12e4;
+var repoLocks = /* @__PURE__ */ new Map();
+async function withRepoLock(repoKey, fn) {
+  const existing = repoLocks.get(repoKey);
+  let release;
+  const gate = new Promise((resolve2) => {
+    release = resolve2;
+  });
+  repoLocks.set(repoKey, gate);
   try {
-    execFileSync("gh", ["repo", "clone", `${owner}/${repo}`, targetDir, "--", "--depth", "1"], {
-      encoding: "utf-8",
-      timeout: 12e4,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(sanitizeTokens(message));
+    if (existing) await existing;
+    return await fn();
+  } finally {
+    release();
+    if (repoLocks.get(repoKey) === gate) {
+      repoLocks.delete(repoKey);
+    }
+  }
+}
+function ensureBareClone(owner, repo, baseDir, ghAvailable) {
+  validatePathSegment(owner, "owner");
+  validatePathSegment(repo, "repo");
+  const bareRepoPath = path3.join(baseDir, owner, `${repo}.git`);
+  if (fs3.existsSync(path3.join(bareRepoPath, "HEAD"))) {
+    return { bareRepoPath, cloned: false };
+  }
+  fs3.mkdirSync(path3.join(baseDir, owner), { recursive: true });
+  if (ghAvailable) {
+    gitExec("gh", [
+      "repo",
+      "clone",
+      `${owner}/${repo}`,
+      bareRepoPath,
+      "--",
+      "--bare",
+      "--filter=blob:none"
+    ]);
+  } else {
+    const cloneUrl = buildCloneUrl(owner, repo);
+    gitExec("git", ["clone", "--bare", "--filter=blob:none", cloneUrl, bareRepoPath]);
   }
+  return { bareRepoPath, cloned: true };
+}
+function fetchPRRef(bareRepoPath, prNumber, ghAvailable) {
+  const credArgs = ghAvailable ? ["-c", `credential.helper=${GH_CREDENTIAL_HELPER}`] : [];
+  gitExec(
+    "git",
+    [...credArgs, "fetch", "--force", "origin", `pull/${prNumber}/head`],
+    bareRepoPath
+  );
+}
+function addWorktree(bareRepoPath, taskId) {
+  validatePathSegment(taskId, "taskId");
+  const repoName = path3.basename(bareRepoPath, ".git");
+  const worktreeBase = path3.join(path3.dirname(bareRepoPath), `${repoName}-worktrees`);
+  const worktreePath = path3.join(worktreeBase, taskId);
+  fs3.mkdirSync(worktreeBase, { recursive: true });
+  gitExec("git", ["worktree", "add", "--detach", worktreePath, "FETCH_HEAD"], bareRepoPath);
+  return worktreePath;
+}
+function removeWorktree(bareRepoPath, worktreePath) {
+  try {
+    gitExec("git", ["worktree", "remove", "--force", worktreePath], bareRepoPath);
+  } catch {
+    try {
+      fs3.rmSync(worktreePath, { recursive: true, force: true });
+      gitExec("git", ["worktree", "prune"], bareRepoPath);
+    } catch {
+      console.warn(`[repo-cache] Failed to clean up worktree: ${worktreePath}`);
+    }
+  }
+}
+function repoKeyFromBarePath(bareRepoPath) {
+  const repoName = path3.basename(bareRepoPath, ".git");
+  const owner = path3.basename(path3.dirname(bareRepoPath));
+  return `${owner}/${repoName}`;
+}
+async function checkoutWorktree(owner, repo, prNumber, baseDir, taskId) {
+  validatePathSegment(owner, "owner");
+  validatePathSegment(repo, "repo");
+  validatePathSegment(taskId, "taskId");
+  const repoKey = `${owner}/${repo}`;
+  const ghAvailable = isGhAvailable();
+  return withRepoLock(repoKey, () => {
+    const { bareRepoPath, cloned } = ensureBareClone(owner, repo, baseDir, ghAvailable);
+    fetchPRRef(bareRepoPath, prNumber, ghAvailable);
+    const worktreePath = addWorktree(bareRepoPath, taskId);
+    return { worktreePath, bareRepoPath, cloned };
+  });
 }
-function git(args, cwd) {
+async function cleanupWorktree(bareRepoPath, worktreePath) {
+  const repoKey = repoKeyFromBarePath(bareRepoPath);
+  await withRepoLock(repoKey, () => {
+    removeWorktree(bareRepoPath, worktreePath);
+  });
+}
+function gitExec(command, args, cwd) {
   try {
-    return execFileSync("git", args, {
+    return execFileSync2(command, args, {
       cwd,
       encoding: "utf-8",
-      timeout: 12e4,
+      timeout: GIT_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "pipe"]
     });
   } catch (err) {
@@ -730,20 +832,170 @@ function git(args, cwd) {
   }
 }
 
+// src/codebase-cleanup.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+var DEFAULT_CODEBASE_TTL_MS = 30 * 60 * 1e3;
+function parseTtl(value) {
+  const trimmed = value.trim();
+  if (trimmed === "0") return 0;
+  const match = trimmed.match(/^(\d+)\s*(ms|s|m|h|d)$/);
+  if (match) {
+    const num = parseInt(match[1], 10);
+    switch (match[2]) {
+      case "ms":
+        return num;
+      case "s":
+        return num * 1e3;
+      case "m":
+        return num * 60 * 1e3;
+      case "h":
+        return num * 60 * 60 * 1e3;
+      case "d":
+        return num * 24 * 60 * 60 * 1e3;
+      default:
+        throw new Error(`Unreachable: unhandled unit "${match[2]}"`);
+    }
+  }
+  if (/^\d+$/.test(trimmed)) {
+    return parseInt(trimmed, 10) * 1e3;
+  }
+  throw new Error(`Invalid codebase_ttl: "${value}". Use "0", "30m", "2h", "24h", "1d", etc.`);
+}
+var CodebaseCleanupTracker = class {
+  pending = [];
+  ttlMs;
+  constructor(ttlMs) {
+    this.ttlMs = ttlMs;
+  }
+  /**
+   * Record a completed task's worktree for deferred cleanup.
+   */
+  track(bareRepoPath, worktreePath) {
+    this.pending.push({
+      bareRepoPath,
+      worktreePath,
+      completedAt: Date.now()
+    });
+  }
+  /**
+   * Check for and remove any worktrees that have exceeded the TTL.
+   * Returns the number of directories cleaned up.
+   *
+   * The removeFn callback performs the actual git worktree removal.
+   */
+  async sweep(removeFn) {
+    const now = Date.now();
+    const expired = [];
+    const remaining = [];
+    for (const entry of this.pending) {
+      if (now - entry.completedAt >= this.ttlMs) {
+        expired.push(entry);
+      } else {
+        remaining.push(entry);
+      }
+    }
+    this.pending = remaining;
+    let cleaned = 0;
+    for (const entry of expired) {
+      try {
+        await removeFn(entry.bareRepoPath, entry.worktreePath);
+        cleaned++;
+      } catch {
+        this.pending.push(entry);
+      }
+    }
+    return cleaned;
+  }
+  /** Number of entries pending cleanup. */
+  get size() {
+    return this.pending.length;
+  }
+};
+function scanAndCleanStaleWorktrees(baseDir, ttlMs) {
+  if (!fs4.existsSync(baseDir)) return 0;
+  const now = Date.now();
+  let cleaned = 0;
+  let ownerDirs;
+  try {
+    ownerDirs = fs4.readdirSync(baseDir);
+  } catch {
+    return 0;
+  }
+  for (const ownerName of ownerDirs) {
+    const ownerPath = path4.join(baseDir, ownerName);
+    let stat;
+    try {
+      stat = fs4.statSync(ownerPath);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+    let entries;
+    try {
+      entries = fs4.readdirSync(ownerPath);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith("-worktrees")) continue;
+      const worktreeBasePath = path4.join(ownerPath, entry);
+      let worktreeStat;
+      try {
+        worktreeStat = fs4.statSync(worktreeBasePath);
+      } catch {
+        continue;
+      }
+      if (!worktreeStat.isDirectory()) continue;
+      let taskDirs;
+      try {
+        taskDirs = fs4.readdirSync(worktreeBasePath);
+      } catch {
+        continue;
+      }
+      for (const taskId of taskDirs) {
+        const taskPath = path4.join(worktreeBasePath, taskId);
+        let taskStat;
+        try {
+          taskStat = fs4.statSync(taskPath);
+        } catch {
+          continue;
+        }
+        if (!taskStat.isDirectory()) continue;
+        const age = now - taskStat.mtimeMs;
+        if (age >= ttlMs) {
+          try {
+            fs4.rmSync(taskPath, { recursive: true, force: true });
+            const repoName = entry.replace(/-worktrees$/, "");
+            const metadataPath = path4.join(ownerPath, `${repoName}.git`, "worktrees", taskId);
+            try {
+              fs4.rmSync(metadataPath, { recursive: true, force: true });
+            } catch {
+            }
+            cleaned++;
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  return cleaned;
+}
+
 // src/auth.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 import * as os2 from "os";
 import * as crypto from "crypto";
-var AUTH_DIR = path3.join(os2.homedir(), ".opencara");
+var AUTH_DIR = path5.join(os2.homedir(), ".opencara");
 function getAuthFilePath() {
   const envPath = process.env.OPENCARA_AUTH_FILE?.trim();
-  return envPath || path3.join(AUTH_DIR, "auth.json");
+  return envPath || path5.join(AUTH_DIR, "auth.json");
 }
 function loadAuth() {
   const filePath = getAuthFilePath();
   try {
-    const raw = fs3.readFileSync(filePath, "utf-8");
+    const raw = fs5.readFileSync(filePath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data.access_token === "string" && typeof data.expires_at === "number" && typeof data.github_username === "string" && typeof data.github_user_id === "number" && // refresh_token is optional — tolerate non-refreshable tokens, but validate type when present
     (data.refresh_token === void 0 || typeof data.refresh_token === "string")) {
@@ -756,15 +1008,15 @@ function loadAuth() {
 }
 function saveAuth(auth) {
   const filePath = getAuthFilePath();
-  const dir = path3.dirname(filePath);
-  fs3.mkdirSync(dir, { recursive: true });
-  const tmpPath = path3.join(dir, `.auth-${crypto.randomBytes(8).toString("hex")}.tmp`);
+  const dir = path5.dirname(filePath);
+  fs5.mkdirSync(dir, { recursive: true });
+  const tmpPath = path5.join(dir, `.auth-${crypto.randomBytes(8).toString("hex")}.tmp`);
   try {
-    fs3.writeFileSync(tmpPath, JSON.stringify(auth, null, 2), { encoding: "utf-8", mode: 384 });
-    fs3.renameSync(tmpPath, filePath);
+    fs5.writeFileSync(tmpPath, JSON.stringify(auth, null, 2), { encoding: "utf-8", mode: 384 });
+    fs5.renameSync(tmpPath, filePath);
   } catch (err) {
     try {
-      fs3.unlinkSync(tmpPath);
+      fs5.unlinkSync(tmpPath);
     } catch {
     }
     throw err;
@@ -773,7 +1025,7 @@ function saveAuth(auth) {
 function deleteAuth() {
   const filePath = getAuthFilePath();
   try {
-    fs3.unlinkSync(filePath);
+    fs5.unlinkSync(filePath);
   } catch (err) {
     if (err.code !== "ENOENT") {
       throw err;
@@ -946,6 +1198,30 @@ async function resolveUser(token, fetchFn = fetch) {
   }
   return { login: data.login, id: data.id };
 }
+async function fetchUserOrgs(token, fetchFn = fetch) {
+  try {
+    const res = await fetchFn("https://api.github.com/user/orgs?per_page=100", {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github+json",
+        "X-GitHub-Api-Version": "2022-11-28"
+      }
+    });
+    if (!res.ok) {
+      return /* @__PURE__ */ new Set();
+    }
+    const data = await res.json();
+    const orgs = /* @__PURE__ */ new Set();
+    for (const org of data) {
+      if (typeof org.login === "string") {
+        orgs.add(org.login.toLowerCase());
+      }
+    }
+    return orgs;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
 
 // src/http.ts
 var HttpError = class extends Error {
@@ -1043,27 +1319,27 @@ var ApiClient = class {
       clearTimeout(timer);
     }
   }
-  async get(path7) {
-    this.log(`GET ${path7}`);
-    const res = await this.timedFetch(`${this.baseUrl}${path7}`, {
+  async get(path9) {
+    this.log(`GET ${path9}`);
+    const res = await this.timedFetch(`${this.baseUrl}${path9}`, {
       method: "GET",
       headers: this.headers()
     });
-    return this.handleResponse(res, path7, "GET");
+    return this.handleResponse(res, path9, "GET");
   }
-  async post(path7, body) {
-    this.log(`POST ${path7}`);
-    const res = await this.timedFetch(`${this.baseUrl}${path7}`, {
+  async post(path9, body) {
+    this.log(`POST ${path9}`);
+    const res = await this.timedFetch(`${this.baseUrl}${path9}`, {
       method: "POST",
       headers: this.headers(),
       body: body !== void 0 ? JSON.stringify(body) : void 0
     });
-    return this.handleResponse(res, path7, "POST", body);
+    return this.handleResponse(res, path9, "POST", body);
   }
-  async handleResponse(res, path7, method, body) {
+  async handleResponse(res, path9, method, body) {
     if (!res.ok) {
       const { message, errorCode, minimumVersion } = await this.parseErrorBody(res);
-      this.log(`${res.status} ${message} (${path7})`);
+      this.log(`${res.status} ${message} (${path9})`);
       if (res.status === 426) {
         throw new UpgradeRequiredError(this.cliVersion ?? "unknown", minimumVersion);
       }
@@ -1072,12 +1348,12 @@ var ApiClient = class {
         try {
           this.authToken = await this.onTokenRefresh();
           this.log("Token refreshed, retrying request");
-          const retryRes = await this.timedFetch(`${this.baseUrl}${path7}`, {
+          const retryRes = await this.timedFetch(`${this.baseUrl}${path9}`, {
             method,
             headers: this.headers(),
             body: body !== void 0 ? JSON.stringify(body) : void 0
           });
-          return this.handleRetryResponse(retryRes, path7);
+          return this.handleRetryResponse(retryRes, path9);
         } catch (refreshErr) {
           this.log(`Token refresh failed: ${refreshErr.message}`);
           throw new HttpError(res.status, message, errorCode);
@@ -1085,20 +1361,20 @@ var ApiClient = class {
       }
       throw new HttpError(res.status, message, errorCode);
     }
-    this.log(`${res.status} OK (${path7})`);
+    this.log(`${res.status} OK (${path9})`);
     return await res.json();
   }
   /** Handle response for a retry after token refresh — no second refresh attempt. */
-  async handleRetryResponse(res, path7) {
+  async handleRetryResponse(res, path9) {
     if (!res.ok) {
       const { message, errorCode, minimumVersion } = await this.parseErrorBody(res);
-      this.log(`${res.status} ${message} (${path7}) [retry]`);
+      this.log(`${res.status} ${message} (${path9}) [retry]`);
       if (res.status === 426) {
         throw new UpgradeRequiredError(this.cliVersion ?? "unknown", minimumVersion);
       }
       throw new HttpError(res.status, message, errorCode);
     }
-    this.log(`${res.status} OK (${path7}) [retry]`);
+    this.log(`${res.status} OK (${path9}) [retry]`);
     return await res.json();
   }
 };
@@ -1153,9 +1429,9 @@ function sleep(ms, signal) {
 }
 
 // src/tool-executor.ts
-import { spawn, execFileSync as execFileSync2 } from "child_process";
-import * as fs4 from "fs";
-import * as path4 from "path";
+import { spawn, execFileSync as execFileSync3 } from "child_process";
+import * as fs6 from "fs";
+import * as path6 from "path";
 var ToolTimeoutError = class extends Error {
   constructor(message) {
     super(message);
@@ -1167,9 +1443,9 @@ var MIN_PARTIAL_RESULT_LENGTH = 50;
 var MAX_STDERR_LENGTH = 1e3;
 function validateCommandBinary(commandTemplate) {
   const { command } = parseCommandTemplate(commandTemplate);
-  if (path4.isAbsolute(command)) {
+  if (path6.isAbsolute(command)) {
     try {
-      fs4.accessSync(command, fs4.constants.X_OK);
+      fs6.accessSync(command, fs6.constants.X_OK);
       return true;
     } catch {
       return false;
@@ -1178,9 +1454,9 @@ function validateCommandBinary(commandTemplate) {
   try {
     const isWindows = process.platform === "win32";
     if (isWindows) {
-      execFileSync2("where", [command], { stdio: "pipe" });
+      execFileSync3("where", [command], { stdio: "pipe" });
     } else {
-      execFileSync2("sh", ["-c", 'command -v -- "$1"', "_", command], { stdio: "pipe" });
+      execFileSync3("sh", ["-c", 'command -v -- "$1"', "_", command], { stdio: "pipe" });
     }
     return true;
   } catch {
@@ -1537,7 +1813,10 @@ ${userMessage}`;
       verdict,
       tokensUsed: result.tokensUsed + inputTokens,
       tokensEstimated: !result.tokensParsed,
-      tokenDetail
+      tokenDetail,
+      toolStdout: result.stdout,
+      toolStderr: result.stderr,
+      promptLength: fullPrompt.length
     };
   } finally {
     clearTimeout(abortTimer);
@@ -1716,7 +1995,10 @@ ${userMessage}`;
       tokensUsed: result.tokensUsed + inputTokens,
       tokensEstimated: !result.tokensParsed,
       tokenDetail,
-      flaggedReviews
+      flaggedReviews,
+      toolStdout: result.stdout,
+      toolStderr: result.stderr,
+      promptLength: fullPrompt.length
     };
   } finally {
     clearTimeout(abortTimer);
@@ -1914,9 +2196,9 @@ function formatPostReviewStats(session) {
 }
 
 // src/usage-tracker.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-var USAGE_FILE = path5.join(CONFIG_DIR, "usage.json");
+import * as fs7 from "fs";
+import * as path7 from "path";
+var USAGE_FILE = path7.join(CONFIG_DIR, "usage.json");
 var MAX_HISTORY_DAYS = 30;
 var WARNING_THRESHOLD = 0.8;
 function todayKey() {
@@ -1939,8 +2221,8 @@ var UsageTracker = class {
   }
   load() {
     try {
-      if (fs5.existsSync(this.filePath)) {
-        const raw = fs5.readFileSync(this.filePath, "utf-8");
+      if (fs7.existsSync(this.filePath)) {
+        const raw = fs7.readFileSync(this.filePath, "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed && Array.isArray(parsed.days)) {
           return parsed;
@@ -1952,7 +2234,7 @@ var UsageTracker = class {
   }
   save() {
     ensureConfigDir();
-    fs5.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2), {
+    fs7.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2), {
       encoding: "utf-8",
       mode: 384
     });
@@ -2156,6 +2438,36 @@ function createLogger(label) {
     logWarn: (msg) => console.warn(`${pc.dim(`[${timestamp()}]`)}${labelStr} ${pc.yellow(sanitizeTokens(msg))}`)
   };
 }
+var VERBOSE_TRUNCATE_LIMIT = 2e3;
+var CHARS_PER_TOKEN_ESTIMATE = 4;
+function logVerboseToolOutput(logger, label, stdout, stderr, promptLength, limit = VERBOSE_TRUNCATE_LIMIT) {
+  const estimatedTokens = Math.ceil(promptLength / CHARS_PER_TOKEN_ESTIMATE);
+  logger.log(
+    `${icons.info} [verbose] ${label} \u2014 prompt: ${promptLength} chars (~${estimatedTokens} tokens)`
+  );
+  if (stdout) {
+    const truncated = stdout.length > limit ? stdout.slice(0, limit) + `
+... (truncated at ${limit} chars)` : stdout;
+    logger.log(
+      `${icons.info} [verbose] ${label} stdout (${stdout.length} chars):
+---
+${truncated}
+---`
+    );
+  } else {
+    logger.log(`${icons.info} [verbose] ${label} stdout: (empty)`);
+  }
+  if (stderr) {
+    const truncated = stderr.length > limit ? stderr.slice(0, limit) + `
+... (truncated at ${limit} chars)` : stderr;
+    logger.log(
+      `${icons.info} [verbose] ${label} stderr (${stderr.length} chars):
+---
+${truncated}
+---`
+    );
+  }
+}
 function createAgentSession() {
   return {
     startTime: Date.now(),
@@ -2926,7 +3238,11 @@ async function pollLoop(client, agentId, reviewDeps, consumptionDeps, agentInfo,
     repoConfig,
     roles,
     synthesizeRepos,
-    signal
+    signal,
+    cleanupTracker,
+    verbose,
+    agentOwner,
+    userOrgs
   } = options;
   const { log, logError, logWarn } = logger;
   log(`${icons.polling} Polling every ${pollIntervalMs / 1e3}s...`);
@@ -2958,10 +3274,20 @@ async function pollLoop(client, agentId, reviewDeps, consumptionDeps, agentInfo,
       const pollResponse = await client.post("/api/tasks/poll", pollBody);
       consecutiveAuthErrors = 0;
       consecutiveErrors = 0;
-      const eligibleTasks = repoConfig ? pollResponse.tasks.filter((t) => isRepoAllowed(repoConfig, t.owner, t.repo)) : pollResponse.tasks;
+      const eligibleTasks = repoConfig ? pollResponse.tasks.filter(
+        (t) => isRepoAllowed(repoConfig, t.owner, t.repo, agentOwner, userOrgs)
+      ) : pollResponse.tasks;
       const task = eligibleTasks.find(
         (t) => (diffFailCounts.get(t.task_id) ?? 0) < MAX_DIFF_FETCH_ATTEMPTS
       );
+      if (cleanupTracker) {
+        const swept = await cleanupTracker.sweep(cleanupWorktree);
+        if (swept > 0) {
+          log(
+            `${icons.info} Cleaned up ${swept} stale codebase director${swept === 1 ? "y" : "ies"}`
+          );
+        }
+      }
       if (task) {
         const result = await handleTask(
           client,
@@ -2973,7 +3299,9 @@ async function pollLoop(client, agentId, reviewDeps, consumptionDeps, agentInfo,
           logger,
           agentSession,
           routerRelay,
-          signal
+          signal,
+          cleanupTracker,
+          verbose
         );
         if (result.diffFetchFailed) {
           agentSession.errorsEncountered++;
@@ -3031,7 +3359,7 @@ async function pollLoop(client, agentId, reviewDeps, consumptionDeps, agentInfo,
     await sleep2(pollIntervalMs, signal);
   }
 }
-async function handleTask(client, agentId, task, reviewDeps, consumptionDeps, agentInfo, logger, agentSession, routerRelay, signal) {
+async function handleTask(client, agentId, task, reviewDeps, consumptionDeps, agentInfo, logger, agentSession, routerRelay, signal, cleanupTracker, verbose) {
   const { task_id, owner, repo, pr_number, diff_url, timeout_seconds, prompt, role } = task;
   const { log, logError, logWarn } = logger;
   const isIssueTask = pr_number === 0;
@@ -3068,6 +3396,7 @@ async function handleTask(client, agentId, task, reviewDeps, consumptionDeps, ag
   let diffContent = "";
   let taskReviewDeps = reviewDeps;
   let taskCheckoutPath = null;
+  let taskBareRepoPath = null;
   let contextBlock;
   if (isIssueTask) {
     log("  Issue-based task \u2014 skipping diff fetch");
@@ -3091,33 +3420,20 @@ async function handleTask(client, agentId, task, reviewDeps, consumptionDeps, ag
       );
       return { diffFetchFailed: true };
     }
-    if (reviewDeps.codebaseDir) {
+    {
+      const codebaseDir = reviewDeps.codebaseDir || path8.join(CONFIG_DIR, "repos");
       try {
-        const result = cloneOrUpdate(owner, repo, pr_number, reviewDeps.codebaseDir, task_id);
-        log(`  Codebase ${result.cloned ? "cloned" : "updated"}: ${result.localPath}`);
-        taskCheckoutPath = result.localPath;
-        taskReviewDeps = { ...reviewDeps, codebaseDir: result.localPath };
+        const result = await checkoutWorktree(owner, repo, pr_number, codebaseDir, task_id);
+        log(`  Codebase ${result.cloned ? "cloned" : "cached"} \u2192 worktree: ${result.worktreePath}`);
+        taskCheckoutPath = result.worktreePath;
+        taskBareRepoPath = result.bareRepoPath;
+        taskReviewDeps = { ...reviewDeps, codebaseDir: result.worktreePath };
       } catch (err) {
         logWarn(
-          `  Warning: codebase clone failed: ${err.message}. Continuing with diff-only review.`
+          `  Warning: worktree checkout failed: ${err.message}. Continuing with diff-only review.`
         );
         taskReviewDeps = { ...reviewDeps, codebaseDir: null };
       }
-    } else {
-      try {
-        validatePathSegment(owner, "owner");
-        validatePathSegment(repo, "repo");
-        validatePathSegment(task_id, "task_id");
-        const repoScopedDir = path6.join(CONFIG_DIR, "repos", owner, repo, task_id);
-        fs6.mkdirSync(repoScopedDir, { recursive: true });
-        taskCheckoutPath = repoScopedDir;
-        taskReviewDeps = { ...reviewDeps, codebaseDir: repoScopedDir };
-        log(`  Working directory: ${repoScopedDir}`);
-      } catch (err) {
-        logWarn(
-          `  Warning: failed to create working directory: ${err.message}. Continuing without scoped cwd.`
-        );
-      }
     }
     try {
       const prContext = await fetchPRContext(owner, repo, pr_number, {
@@ -3219,7 +3535,8 @@ async function handleTask(client, agentId, task, reviewDeps, consumptionDeps, ag
         agentInfo,
         routerRelay,
         signal,
-        contextBlock
+        contextBlock,
+        verbose
       );
     } else {
       await executeReviewTask(
@@ -3238,7 +3555,8 @@ async function handleTask(client, agentId, task, reviewDeps, consumptionDeps, ag
         agentInfo,
         routerRelay,
         signal,
-        contextBlock
+        contextBlock,
+        verbose
       );
     }
     agentSession.tasksCompleted++;
@@ -3252,8 +3570,12 @@ async function handleTask(client, agentId, task, reviewDeps, consumptionDeps, ag
       await safeError(client, task_id, agentId, err.message, logger);
     }
   } finally {
-    if (taskCheckoutPath) {
-      cleanupTaskDir(taskCheckoutPath);
+    if (taskCheckoutPath && taskBareRepoPath) {
+      if (cleanupTracker) {
+        cleanupTracker.track(taskBareRepoPath, taskCheckoutPath);
+      } else {
+        await cleanupWorktree(taskBareRepoPath, taskCheckoutPath);
+      }
     }
   }
   return {};
@@ -3288,7 +3610,7 @@ async function safeError(client, taskId, agentId, error, logger) {
     );
   }
 }
-async function executeReviewTask(client, agentId, taskId, owner, repo, prNumber, diffContent, prompt, timeoutSeconds, reviewDeps, consumptionDeps, logger, agentInfo, routerRelay, signal, contextBlock) {
+async function executeReviewTask(client, agentId, taskId, owner, repo, prNumber, diffContent, prompt, timeoutSeconds, reviewDeps, consumptionDeps, logger, agentInfo, routerRelay, signal, contextBlock, verbose) {
   if (consumptionDeps.usageLimits?.maxTokensPerReview != null && consumptionDeps.usageTracker) {
     const estimatedInput = estimateTokens(diffContent + prompt + (contextBlock ?? ""));
     const perReviewCheck = consumptionDeps.usageTracker.checkPerReviewLimit(
@@ -3354,6 +3676,15 @@ async function executeReviewTask(client, agentId, taskId, owner, repo, prNumber,
       totalTokens: result.tokensUsed,
       estimated: result.tokensEstimated
     };
+    if (verbose) {
+      logVerboseToolOutput(
+        logger,
+        "Review",
+        result.toolStdout,
+        result.toolStderr,
+        result.promptLength
+      );
+    }
   }
   const reviewMeta = {
     model: agentInfo.model,
@@ -3383,7 +3714,7 @@ async function executeReviewTask(client, agentId, taskId, owner, repo, prNumber,
   logger.log(`  ${icons.success} Review submitted (${tokensUsed.toLocaleString()} tokens)`);
   logger.log(formatPostReviewStats(consumptionDeps.session));
 }
-async function executeSummaryTask(client, agentId, taskId, owner, repo, prNumber, diffContent, prompt, timeoutSeconds, reviews, reviewDeps, consumptionDeps, logger, agentInfo, routerRelay, signal, contextBlock) {
+async function executeSummaryTask(client, agentId, taskId, owner, repo, prNumber, diffContent, prompt, timeoutSeconds, reviews, reviewDeps, consumptionDeps, logger, agentInfo, routerRelay, signal, contextBlock, verbose) {
   const meta = { model: agentInfo.model, tool: agentInfo.tool };
   if (reviews.length === 0) {
     let reviewText;
@@ -3441,6 +3772,15 @@ async function executeSummaryTask(client, agentId, taskId, owner, repo, prNumber
         totalTokens: result.tokensUsed,
         estimated: result.tokensEstimated
       };
+      if (verbose) {
+        logVerboseToolOutput(
+          logger,
+          "Summary (single-agent)",
+          result.toolStdout,
+          result.toolStderr,
+          result.promptLength
+        );
+      }
     }
     const headerSingle = buildMetadataHeader(verdict ?? "comment", meta);
     const sanitizedReview = sanitizeTokens(headerSingle + reviewText);
@@ -3534,6 +3874,15 @@ async function executeSummaryTask(client, agentId, taskId, owner, repo, prNumber
       totalTokens: result.tokensUsed,
       estimated: result.tokensEstimated
     };
+    if (verbose) {
+      logVerboseToolOutput(
+        logger,
+        "Summary",
+        result.toolStdout,
+        result.toolStderr,
+        result.promptLength
+      );
+    }
   }
   if (flaggedReviews.length > 0) {
     logger.logWarn(
@@ -3592,7 +3941,7 @@ function sleep2(ms, signal) {
 async function startAgent(agentId, platformUrl, agentInfo, reviewDeps, consumptionDeps, options) {
   const client = new ApiClient(platformUrl, {
     authToken: options?.authToken,
-    cliVersion: "0.18.4",
+    cliVersion: "0.18.6",
     versionOverride: options?.versionOverride,
     onTokenRefresh: options?.onTokenRefresh
   });
@@ -3617,6 +3966,9 @@ async function startAgent(agentId, platformUrl, agentInfo, reviewDeps, consumpti
   if (options?.versionOverride) {
     log(`${icons.info} Version override active: ${options.versionOverride}`);
   }
+  if (options?.verbose) {
+    log(`${icons.info} Verbose mode enabled \u2014 tool stdout/stderr will be logged`);
+  }
   if (!reviewDeps) {
     logError(`${icons.error} No review command configured. Set command in config.toml`);
     return;
@@ -3630,6 +3982,16 @@ async function startAgent(agentId, platformUrl, agentInfo, reviewDeps, consumpti
       logWarn(`${icons.warn} Command test failed (${result.error}). Reviews may fail.`);
     }
   }
+  const ttlMs = options?.codebaseTtl != null ? parseTtl(options.codebaseTtl) : 0;
+  const codebaseDir = reviewDeps.codebaseDir || path8.join(CONFIG_DIR, "repos");
+  const scanTtl = Math.max(ttlMs, DEFAULT_CODEBASE_TTL_MS);
+  const staleCount = scanAndCleanStaleWorktrees(codebaseDir, scanTtl);
+  if (staleCount > 0) {
+    log(
+      `${icons.info} Cleaned up ${staleCount} stale codebase director${staleCount === 1 ? "y" : "ies"} on startup`
+    );
+  }
+  const cleanupTracker = ttlMs > 0 ? new CodebaseCleanupTracker(ttlMs) : void 0;
   const abortController = new AbortController();
   process.on("SIGINT", () => {
     abortController.abort();
@@ -3645,8 +4007,20 @@ async function startAgent(agentId, platformUrl, agentInfo, reviewDeps, consumpti
     repoConfig: options?.repoConfig,
     roles: options?.roles,
     synthesizeRepos: options?.synthesizeRepos,
-    signal: abortController.signal
+    signal: abortController.signal,
+    cleanupTracker,
+    verbose: options?.verbose,
+    agentOwner: options?.agentOwner,
+    userOrgs: options?.userOrgs
   });
+  if (cleanupTracker && cleanupTracker.size > 0) {
+    const finalSwept = await cleanupTracker.sweep(cleanupWorktree);
+    if (finalSwept > 0) {
+      log(
+        `${icons.info} Cleaned up ${finalSwept} codebase director${finalSwept === 1 ? "y" : "ies"} on shutdown`
+      );
+    }
+  }
   if (deps.usageTracker) {
     log(deps.usageTracker.formatSummary(deps.usageLimits ?? usageLimits));
   }
@@ -3679,9 +4053,12 @@ async function startAgentRouter() {
     throw err;
   }
   const storedAuth = loadAuth();
+  const agentOwner = storedAuth?.github_username;
   if (storedAuth) {
     logger.log(`Authenticated as ${storedAuth.github_username}`);
   }
+  const repoConfig = agentConfig?.repos;
+  const userOrgs = repoConfig?.mode === "private" ? await fetchUserOrgs(oauthToken) : /* @__PURE__ */ new Set();
   const codebaseDir = resolveCodebaseDir(agentConfig?.codebase_dir, config.codebaseDir);
   const reviewDeps = {
     commandTemplate: commandTemplate ?? "",
@@ -3711,20 +4088,22 @@ async function startAgentRouter() {
       maxConsecutiveErrors: config.maxConsecutiveErrors,
       routerRelay: router,
       reviewOnly: agentConfig?.review_only,
-      repoConfig: agentConfig?.repos,
+      repoConfig,
       roles,
       synthesizeRepos: agentConfig?.synthesize_repos,
       label,
       authToken: oauthToken,
       onTokenRefresh: () => getValidToken(config.platformUrl),
+      agentOwner,
+      userOrgs,
       usageLimits: config.usageLimits,
-      versionOverride
+      versionOverride,
+      codebaseTtl: config.codebaseTtl
     }
   );
   router.stop();
 }
-function startAgentByIndex(config, agentIndex, pollIntervalMs, oauthToken, versionOverride) {
-  const agentId = crypto2.randomUUID();
+function startAgentByIndex(config, agentIndex, pollIntervalMs, oauthToken, versionOverride, verbose, instancesOverride, agentOwner, userOrgs) {
   let commandTemplate;
   let agentConfig;
   if (config.agents && config.agents.length > agentIndex) {
@@ -3744,58 +4123,78 @@ function startAgentByIndex(config, agentIndex, pollIntervalMs, oauthToken, versi
     );
     return null;
   }
+  const instanceCount = instancesOverride ?? agentConfig?.instances ?? 1;
   const codebaseDir = resolveCodebaseDir(agentConfig?.codebase_dir, config.codebaseDir);
   const reviewDeps = {
     commandTemplate,
     maxDiffSizeKb: config.maxDiffSizeKb,
     codebaseDir
   };
-  const isRouter = agentConfig?.router === true;
-  let routerRelay;
-  if (isRouter) {
-    routerRelay = new RouterRelay();
-    routerRelay.start();
-  }
-  const session = createSessionTracker();
-  const usageTracker = new UsageTracker();
   const model = agentConfig?.model ?? "unknown";
   const tool = agentConfig?.tool ?? "unknown";
   const thinking = agentConfig?.thinking;
   const roles = agentConfig ? computeRoles(agentConfig) : void 0;
-  const agentPromise = startAgent(
-    agentId,
-    config.platformUrl,
-    { model, tool, thinking },
-    reviewDeps,
-    { agentId, session, usageTracker, usageLimits: config.usageLimits },
-    {
-      pollIntervalMs,
-      maxConsecutiveErrors: config.maxConsecutiveErrors,
-      routerRelay,
-      reviewOnly: agentConfig?.review_only,
-      repoConfig: agentConfig?.repos,
-      roles,
-      synthesizeRepos: agentConfig?.synthesize_repos,
-      label,
-      authToken: oauthToken,
-      onTokenRefresh: () => getValidToken(config.platformUrl),
-      usageLimits: config.usageLimits,
-      versionOverride
+  const session = createSessionTracker();
+  const usageTracker = new UsageTracker();
+  const promises = [];
+  for (let inst = 0; inst < instanceCount; inst++) {
+    const agentId = crypto2.randomUUID();
+    const instanceLabel = instanceCount > 1 ? `${label}#${inst + 1}` : label;
+    const isRouter = agentConfig?.router === true;
+    let routerRelay;
+    if (isRouter) {
+      routerRelay = new RouterRelay();
+      routerRelay.start();
     }
-  ).finally(() => {
-    routerRelay?.stop();
-  });
-  return agentPromise;
+    const agentPromise = startAgent(
+      agentId,
+      config.platformUrl,
+      { model, tool, thinking },
+      reviewDeps,
+      { agentId, session, usageTracker, usageLimits: config.usageLimits },
+      {
+        pollIntervalMs,
+        maxConsecutiveErrors: config.maxConsecutiveErrors,
+        routerRelay,
+        reviewOnly: agentConfig?.review_only,
+        repoConfig: agentConfig?.repos,
+        roles,
+        synthesizeRepos: agentConfig?.synthesize_repos,
+        label: instanceLabel,
+        authToken: oauthToken,
+        onTokenRefresh: () => getValidToken(config.platformUrl),
+        usageLimits: config.usageLimits,
+        versionOverride,
+        codebaseTtl: config.codebaseTtl,
+        verbose,
+        agentOwner,
+        userOrgs
+      }
+    ).finally(() => {
+      routerRelay?.stop();
+    });
+    promises.push(agentPromise);
+  }
+  return promises;
 }
 var agentCommand = new Command("agent").description("Manage review agents");
 agentCommand.command("start").description("Start agents in polling mode").option("--poll-interval <seconds>", "Poll interval in seconds", "10").option("--agent <index>", "Agent index from config.toml (0-based)", "0").option("--all", "Start all configured agents concurrently").option(
   "--version-override <value>",
   "Cloudflare Workers version override (e.g. opencara-server=abc123)"
-).action(
+).option("-v, --verbose", "Log tool stdout/stderr after each review/summary for debugging").option("--instances <count>", "Number of concurrent instances per agent (overrides config)").action(
   async (opts) => {
     const config = loadConfig();
     const pollIntervalMs = parseInt(opts.pollInterval, 10) * 1e3;
     const versionOverride = opts.versionOverride || process.env.OPENCARA_VERSION_OVERRIDE || null;
+    let instancesOverride;
+    if (opts.instances !== void 0) {
+      if (!/^[1-9]\d*$/.test(opts.instances)) {
+        console.error("--instances must be a positive integer");
+        process.exit(1);
+        return;
+      }
+      instancesOverride = parseInt(opts.instances, 10);
+    }
     let oauthToken;
     try {
       oauthToken = await getValidToken(config.platformUrl);
@@ -3808,22 +4207,35 @@ agentCommand.command("start").description("Start agents in polling mode").option
       throw err;
     }
     const storedAuth = loadAuth();
+    const agentOwner = storedAuth?.github_username;
     if (storedAuth) {
       console.log(`Authenticated as ${storedAuth.github_username}`);
     }
+    const needsOrgs = config.agents?.some((a) => a.repos?.mode === "private") ?? false;
+    const userOrgs = needsOrgs ? await fetchUserOrgs(oauthToken) : /* @__PURE__ */ new Set();
     if (opts.all) {
       if (!config.agents || config.agents.length === 0) {
         console.error("No agents configured in ~/.opencara/config.toml");
         process.exit(1);
         return;
       }
-      console.log(`Starting ${config.agents.length} agent(s)...`);
+      console.log(`Starting ${config.agents.length} agent config(s)...`);
       const promises = [];
       let startFailed = false;
       for (let i = 0; i < config.agents.length; i++) {
-        const p = startAgentByIndex(config, i, pollIntervalMs, oauthToken, versionOverride);
-        if (p) {
-          promises.push(p);
+        const agentPromises = startAgentByIndex(
+          config,
+          i,
+          pollIntervalMs,
+          oauthToken,
+          versionOverride,
+          opts.verbose,
+          instancesOverride,
+          agentOwner,
+          userOrgs
+        );
+        if (agentPromises) {
+          promises.push(...agentPromises);
         } else {
           startFailed = true;
         }
@@ -3838,7 +4250,7 @@ agentCommand.command("start").description("Start agents in polling mode").option
           "One or more agents could not start (see warnings above). Continuing with the rest."
         );
       }
-      console.log(`${promises.length} agent(s) running. Press Ctrl+C to stop all.
+      console.log(`${promises.length} agent instance(s) running. Press Ctrl+C to stop all.
 `);
       const results = await Promise.allSettled(promises);
       const failures = results.filter((r) => r.status === "rejected");
@@ -3858,18 +4270,29 @@ agentCommand.command("start").description("Start agents in polling mode").option
         process.exit(1);
         return;
       }
-      const p = startAgentByIndex(
+      const agentPromises = startAgentByIndex(
         config,
         agentIndex,
         pollIntervalMs,
         oauthToken,
-        versionOverride
+        versionOverride,
+        opts.verbose,
+        instancesOverride,
+        agentOwner,
+        userOrgs
       );
-      if (!p) {
+      if (!agentPromises) {
         process.exit(1);
         return;
       }
-      await p;
+      const results = await Promise.allSettled(agentPromises);
+      const failures = results.filter((r) => r.status === "rejected");
+      if (failures.length > 0) {
+        for (const f of failures) {
+          console.error(`Agent instance failed: ${f.reason}`);
+        }
+        process.exit(1);
+      }
     }
   }
 );
@@ -4005,8 +4428,8 @@ var PER_PAGE = 100;
 var OPEN_MARKER = "<!-- opencara-dedup-index:open -->";
 var RECENT_MARKER = "<!-- opencara-dedup-index:recent -->";
 var ARCHIVED_MARKER = "<!-- opencara-dedup-index:archived -->";
-async function fetchRepoFile(owner, repo, path7, token, fetchFn = fetch) {
-  const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path7}`;
+async function fetchRepoFile(owner, repo, path9, token, fetchFn = fetch) {
+  const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path9}`;
   const res = await fetchFn(url, {
     headers: {
       Authorization: `Bearer ${token}`,
@@ -4014,7 +4437,7 @@ async function fetchRepoFile(owner, repo, path7, token, fetchFn = fetch) {
     }
   });
   if (res.status === 404) return null;
-  if (!res.ok) throw new Error(`GitHub API error: ${res.status} fetching ${path7}`);
+  if (!res.ok) throw new Error(`GitHub API error: ${res.status} fetching ${path9}`);
   return res.text();
 }
 async function fetchAllPRs(owner, repo, token, fetchFn = fetch, log) {
@@ -4572,7 +4995,7 @@ var statusCommand = new Command4("status").description("Show agent config, conne
 });
 
 // src/index.ts
-var program = new Command5().name("opencara").description("OpenCara \u2014 distributed AI code review agent").version("0.18.4");
+var program = new Command5().name("opencara").description("OpenCara \u2014 distributed AI code review agent").version("0.18.6");
 program.addCommand(agentCommand);
 program.addCommand(authCommand());
 program.addCommand(dedupCommand());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencara",
-  "version": "0.18.4",
+  "version": "0.18.6",
   "description": "Distributed AI code review agent — poll, review, and submit PR reviews using your own AI tools",
   "type": "module",
   "license": "MIT",