@gethmy/agent 1.37.0 → 1.38.0

package/dist/index.js

@@ -754,6 +754,9 @@ class BudgetGuard {
     const turns = this.checkCardTurns(cardId);
     if (!turns.allow)
       return turns;
+    const runs = this.checkCardRuns(cardId);
+    if (!runs.allow)
+      return runs;
     return this.checkDailyBudget();
   }
   checkCardTurns(cardId) {
@@ -769,6 +772,19 @@ class BudgetGuard {
       detail: `${spent} of ${cap} turns spent on this card`
     };
   }
+  checkCardRuns(cardId) {
+    const cap = this.config.maxRunsPerCard;
+    if (cap < 0)
+      return { allow: true };
+    const started = this.store.getCardRunStarts(cardId);
+    if (started < cap)
+      return { allow: true };
+    return {
+      allow: false,
+      reason: "card_runs",
+      detail: `${started} of ${cap} run starts spent on this card`
+    };
+  }
   checkDailyBudget() {
     const cap = this.config.dailyBudgetCents;
     if (cap < 0)
@@ -798,6 +814,17 @@ function buildTurnCapComment(spentTurns, cap, legs) {
   ].join(`
 `);
 }
+function buildRunCapComment(runStarts, cap) {
+  return [
+    "**Run backstop reached — over to you.**",
+    `This card has cost ${runStarts} run starts, which is its ceiling of ${cap} (\`budget.maxRunsPerCard\`). I will not pick it up again, and a Continue on it would be refused.`,
+    "",
+    "This ceiling exists as a backstop against a retry loop the attempt budget cannot see — a card that reaches it has been failing repeatedly for reasons worth a look (the run log and the failure history on this card say what killed each run).",
+    "",
+    "Two ways on: reassign the card, which clears the count and hands it back to me fresh, or raise `budget.maxRunsPerCard` in the daemon config if this card genuinely needs the room."
+  ].join(`
+`);
+}
 function buildGaveUpComment(maxAttempts, failures, pauseEnabled) {
   const wayBackIn = pauseEnabled ? "Continue to grant a fresh attempt, or reassign the card." : "Reassign the card to grant a fresh attempt.";
   const lines = [
@@ -1064,6 +1091,22 @@ function validateAutoMergeConfig(config) {
       issues.push(`review.autoMerge.waitMinutes: must be an integer between 1 and 55 (got ${w}) — an interactive agent session goes stale at about an hour, and a command that outlives its session reports into nothing`);
     }
   }
+  if (typeof autoMerge.findingsLoop !== "boolean") {
+    issues.push(`review.autoMerge.findingsLoop: must be true or false (got ${JSON.stringify(autoMerge.findingsLoop)}) — an absent value would switch unattended code editing on or off without saying so`);
+  }
+  const rounds = autoMerge.maxFindingRounds;
+  if (!Number.isInteger(rounds) || rounds < 1) {
+    issues.push(`review.autoMerge.maxFindingRounds: must be an integer >= 1 (got ${rounds}) — the cap is the safety property and has no opt-out`);
+  }
+  if (autoMerge.findingsLoop) {
+    if (!autoMerge.interactive) {
+      issues.push("review.autoMerge.findingsLoop: needs review.autoMerge.interactive — the loop only runs on the interactive merge path, so armed alone it is inert rather than weaker");
+    }
+    const findingAuthors = independent?.findingAuthors;
+    if (!Array.isArray(findingAuthors) || findingAuthors.filter((a) => typeof a === "string" && a.trim()).length === 0) {
+      issues.push("review.autoMerge.independentReview.findingAuthors: must name at least one login while review.autoMerge.findingsLoop is on — it is the only thing separating the review's findings from every other commenter's text, and an empty list parks every round");
+    }
+  }
   if (issues.length > 0) {
     throw new ConfigValidationError(`Invalid agent config — ${issues.join("; ")}`, issues);
   }
@@ -1143,6 +1186,12 @@ function validateBudgetConfig(config) {
     const issue = turns === 0 ? `budget.maxTurnsPerCard: 0 is ambiguous — it could mean "no cap" or "run nothing"` : `budget.maxTurnsPerCard: ${JSON.stringify(turns)} is not a whole number of turns`;
     throw new ConfigValidationError(`Invalid agent config — ${issue}.
 ` + `  Set a positive cap in turns (e.g. 300, ~2.5x the measured median card), or -1 to run with no per-card cap.`, [issue]);
+  }
+  const runs = config.budget.maxRunsPerCard;
+  if (!Number.isInteger(runs) || runs === 0) {
+    const issue = runs === 0 ? `budget.maxRunsPerCard: 0 is ambiguous — it could mean "no cap" or "run nothing"` : `budget.maxRunsPerCard: ${JSON.stringify(runs)} is not a whole number of runs`;
+    throw new ConfigValidationError(`Invalid agent config — ${issue}.
+` + `  Set a positive cap in run starts (e.g. 30, 10x the give-up budget), or -1 to run with no per-card run backstop.`, [issue]);
   }
   const perSpawn = config.sdk?.maxBudgetUsd;
   if (!Number.isFinite(perSpawn)) {
@@ -2461,6 +2510,229 @@ var init_reviewTools = __esm(() => {
     "mcp__harmony__harmony_toggle_subtask"
   ];
 });
+
+// ../harmony-shared/dist/runEventPayloadLimit.js
+function runEventPayloadExceedsLimit(payload, maxBytes = MAX_RUN_EVENT_PAYLOAD_BYTES) {
+  if (payload === null || payload === undefined)
+    return false;
+  let serialized;
+  try {
+    serialized = JSON.stringify(payload);
+  } catch {
+    return true;
+  }
+  if (serialized === undefined)
+    return true;
+  return serialized.length > maxBytes;
+}
+var MAX_RUN_EVENT_PAYLOAD_BYTES = 16000;
+
+// ../harmony-shared/dist/runRedaction.js
+function isSensitivePath(rawPath) {
+  if (typeof rawPath !== "string" || rawPath.length === 0)
+    return false;
+  const path = rawPath.trim().toLowerCase();
+  const segments = path.split(/[\\/]+/).filter((s) => s.length > 0);
+  if (segments.length === 0)
+    return false;
+  for (let i = 0;i < segments.length; i++) {
+    const segment = segments[i];
+    if (!SENSITIVE_SEGMENTS.includes(segment))
+      continue;
+    if (CONFIG_SCOPED_SEGMENTS.has(segment)) {
+      if (i > 0 && segments[i - 1] === ".config")
+        return true;
+      continue;
+    }
+    return true;
+  }
+  const basename = segments[segments.length - 1];
+  if (SENSITIVE_BASENAMES.has(basename))
+    return true;
+  if (basename === ".env" || basename.startsWith(".env."))
+    return true;
+  if (basename.endsWith(".env"))
+    return true;
+  if (SENSITIVE_EXTENSIONS.some((ext) => basename.endsWith(ext)))
+    return true;
+  if (/service[-_]?account.*\.json$/.test(basename))
+    return true;
+  return false;
+}
+function sensitivePathsIn(input, depth = 0) {
+  if (depth > 6)
+    return [];
+  if (typeof input === "string") {
+    return isSensitivePath(input) ? [input] : [];
+  }
+  if (Array.isArray(input)) {
+    return input.flatMap((item) => sensitivePathsIn(item, depth + 1));
+  }
+  if (input !== null && typeof input === "object") {
+    return Object.values(input).flatMap((value) => sensitivePathsIn(value, depth + 1));
+  }
+  return [];
+}
+function redactSecrets(text) {
+  if (typeof text !== "string" || text.length === 0)
+    return text;
+  let out = text;
+  for (const { pattern, replace } of SECRET_PATTERNS) {
+    pattern.lastIndex = 0;
+    out = out.replace(pattern, replace);
+  }
+  return out;
+}
+function truncate(text, max, originalLength) {
+  const total = originalLength ?? text.length;
+  if (total <= max)
+    return text;
+  return `${text.slice(0, max)}… [+${total - max} chars]`;
+}
+function redactThenTruncate(text, max) {
+  const preCap = max * 4 + 64;
+  const scanned = text.length > preCap ? text.slice(0, preCap) : text;
+  return truncate(redactSecrets(scanned), max, text.length);
+}
+function redactStructure(value, depth = 0) {
+  if (depth > 6)
+    return REDACTION_MARK;
+  if (typeof value === "string") {
+    return redactThenTruncate(value, MAX_INPUT_STRING_CHARS);
+  }
+  if (Array.isArray(value)) {
+    return value.slice(0, 20).map((item) => redactStructure(item, depth + 1));
+  }
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, item] of Object.entries(value)) {
+      out[key] = redactStructure(item, depth + 1);
+    }
+    return out;
+  }
+  return value;
+}
+function redactToolCall(args) {
+  const sensitive = sensitivePathsIn(args.input);
+  if (sensitive.length > 0) {
+    return { withheld: "sensitive-path" };
+  }
+  const result = {};
+  if (args.input !== undefined) {
+    let input = redactStructure(args.input);
+    let serialized;
+    try {
+      serialized = JSON.stringify(input) ?? "";
+    } catch {
+      serialized = "";
+      input = REDACTION_MARK;
+    }
+    if (serialized.length > MAX_INPUT_CHARS) {
+      input = truncate(serialized, MAX_INPUT_CHARS);
+    }
+    result.input = input;
+  }
+  if (typeof args.output === "string" && args.output.length > 0) {
+    result.output = redactThenTruncate(args.output, MAX_OUTPUT_CHARS);
+  }
+  return result;
+}
+var MAX_INPUT_CHARS = 2000, MAX_OUTPUT_CHARS = 4000, MAX_INPUT_STRING_CHARS = 600, REDACTION_MARK = "«redacted»", SENSITIVE_SEGMENTS, CONFIG_SCOPED_SEGMENTS, SENSITIVE_BASENAMES, SENSITIVE_EXTENSIONS, SECRET_PATTERNS;
+var init_runRedaction = __esm(() => {
+  SENSITIVE_SEGMENTS = [
+    ".ssh",
+    ".gnupg",
+    ".aws",
+    ".codex",
+    ".gemini",
+    ".docker",
+    ".kube",
+    ".hmy",
+    ".harmony-mcp",
+    ".password-store",
+    ".claude",
+    "gh",
+    "gcloud",
+    "op",
+    "anthropic"
+  ];
+  CONFIG_SCOPED_SEGMENTS = new Set([
+    "gh",
+    "gcloud",
+    "op",
+    "anthropic"
+  ]);
+  SENSITIVE_BASENAMES = new Set([
+    ".netrc",
+    "_netrc",
+    ".npmrc",
+    ".pgpass",
+    ".git-credentials",
+    ".htpasswd",
+    ".claude.json",
+    "credentials",
+    ".credentials",
+    "credentials.json",
+    ".credentials.json",
+    "credentials.yml",
+    "credentials.yaml",
+    "auth.json",
+    ".auth.json",
+    "secrets",
+    "secrets.json",
+    "secrets.yaml",
+    "secrets.yml",
+    "id_rsa",
+    "id_dsa",
+    "id_ecdsa",
+    "id_ed25519",
+    "known_hosts"
+  ]);
+  SENSITIVE_EXTENSIONS = [
+    ".pem",
+    ".key",
+    ".p12",
+    ".pfx",
+    ".keystore",
+    ".jks",
+    ".asc",
+    ".gpg"
+  ];
+  SECRET_PATTERNS = [
+    {
+      pattern: /-----BEGIN[^-]*PRIVATE KEY-----[\s\S]*?-----END[^-]*-----/g,
+      replace: REDACTION_MARK
+    },
+    { pattern: /\bhmy_at_[A-Za-z0-9_-]{8,}/g, replace: REDACTION_MARK },
+    { pattern: /\bhmy_[A-Za-z0-9_-]{8,}/g, replace: REDACTION_MARK },
+    { pattern: /\bsk-(?:ant-)?[A-Za-z0-9_-]{16,}/g, replace: REDACTION_MARK },
+    { pattern: /\bgh[pousr]_[A-Za-z0-9]{16,}/g, replace: REDACTION_MARK },
+    { pattern: /\bgithub_pat_[A-Za-z0-9_]{20,}/g, replace: REDACTION_MARK },
+    { pattern: /\bxox[abprs]-[A-Za-z0-9-]{10,}/g, replace: REDACTION_MARK },
+    { pattern: /\bAKIA[0-9A-Z]{16}\b/g, replace: REDACTION_MARK },
+    { pattern: /\bAIza[0-9A-Za-z_-]{20,}/g, replace: REDACTION_MARK },
+    {
+      pattern: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
+      replace: REDACTION_MARK
+    },
+    {
+      pattern: /\b(Bearer|Basic|Token)\s+[A-Za-z0-9._~+/=-]{12,}/gi,
+      replace: `$1 ${REDACTION_MARK}`
+    },
+    {
+      pattern: /(\w{1,32}:\/\/)[^/\s:@]+:[^/\s@]+@/g,
+      replace: `$1${REDACTION_MARK}@`
+    },
+    {
+      pattern: /\b([A-Za-z0-9_]{0,40}(?:TOKEN|SECRET|PASSWORD|PASSWD|APIKEY|API_KEY|ACCESS_KEY|PRIVATE_KEY|CREDENTIAL|AUTH)[A-Za-z0-9_]{0,40})\s*[=:]\s*(?:"[^"]*"|'[^']*'|`[^`]*`|[^\s,;)}\]]+)/gi,
+      replace: `$1=${REDACTION_MARK}`
+    },
+    {
+      pattern: /(--?(?:password|passwd|token|api-?key|secret|auth)(?:=|\s+))(?:"[^"]*"|'[^']*'|[^\s]+)/gi,
+      replace: `$1${REDACTION_MARK}`
+    }
+  ];
+});
 // ../harmony-shared/dist/stageHandoff.js
 function isFanoutHandoffItem(value) {
   if (typeof value !== "object" || value === null)
@@ -2655,6 +2927,7 @@ var init_dist = __esm(() => {
   init_projectTemplates();
   init_realtimeChannel();
   init_reviewTools();
+  init_runRedaction();
   init_stageHandoff();
   init_types();
 });
@@ -2967,11 +3240,15 @@ function agentIdentifier(workerId) {
 function endStatusForCancel(reason) {
   return reason === "human_stop" ? "cancelled" : "paused";
 }
-var DEFAULT_AGENT_CONFIG, IN_PROGRESS_COLUMN = "In Progress", NEED_REVIEW_LABEL = "Need Review", NEED_REVIEW_LABEL_COLOR = "#f59e0b", AGENT_NAME = "Harmony Agent", DAEMON_IDENTIFIER_BASE = "harmony-daemon", NOTICE_IDENTIFIER;
+var DEFAULT_FINDING_AUTHORS, DEFAULT_AGENT_CONFIG, IN_PROGRESS_COLUMN = "In Progress", NEED_REVIEW_LABEL = "Need Review", NEED_REVIEW_LABEL_COLOR = "#f59e0b", AGENT_NAME = "Harmony Agent", DAEMON_IDENTIFIER_BASE = "harmony-daemon", NOTICE_IDENTIFIER;
 var init_types2 = __esm(() => {
   init_board_review();
   init_contract_phase();
   init_plan_phase();
+  DEFAULT_FINDING_AUTHORS = [
+    "claude",
+    "github-actions[bot]"
+  ];
   DEFAULT_AGENT_CONFIG = {
     poolSize: 6,
     maxTimeout: 5400000,
@@ -3050,6 +3327,8 @@ var init_types2 = __esm(() => {
         enabled: false,
         interactive: false,
         waitMinutes: 20,
+        findingsLoop: false,
+        maxFindingRounds: 2,
         strategy: "squash",
         deleteBranch: true,
         requireGreenCi: true,
@@ -3069,7 +3348,8 @@ var init_types2 = __esm(() => {
           enabled: true,
           label: "ci-review",
           checkName: "review",
-          verdict: { enabled: true, checkName: "review-verdict" }
+          verdict: { enabled: true, checkName: "review-verdict" },
+          findingAuthors: [...DEFAULT_FINDING_AUTHORS]
         }
       }
     },
@@ -3077,6 +3357,7 @@ var init_types2 = __esm(() => {
       maxAttemptsPerCard: 3,
       dailyBudgetCents: 40000,
       maxTurnsPerCard: 300,
+      maxRunsPerCard: 30,
       pause: {
         enabled: true,
         waitHours: 24,
@@ -3290,6 +3571,7 @@ var init_config = __esm(() => {
 // src/config-dir-migration.ts
 import {
   existsSync,
+  lstatSync,
   mkdirSync,
   readdirSync,
   renameSync,
@@ -3324,27 +3606,84 @@ function migrateConfigDir(opts = {}) {
       log6.info(TAG6, `Moved ${from} to ${to}`);
       return { outcome: "moved", ...empty };
     }
-    for (const entry of readdirSync(from)) {
-      const target = join2(to, entry);
-      if (existsSync(target)) {
-        skipped.push(entry);
-        continue;
-      }
-      renameSync(join2(from, entry), target);
-      moved.push(entry);
-    }
+    mergeDirInto(from, to, "", moved, skipped, 0);
     if (moved.length === 0 && skipped.length === 0) {
       return { outcome: "nothing-to-do", moved, skipped };
     }
-    log6.info(TAG6, `Merged ${from} into ${to}: ${moved.length} moved` + (skipped.length > 0 ? `, ${skipped.length} left in place (already present at the target): ${skipped.join(", ")}` : ""));
+    log6.info(TAG6, `Merged ${from} into ${to}: ${moved.length} moved` + (skipped.length > 0 ? `, ${skipped.length} left in place (already present at the target): ${nameSample(skipped)}` : ""));
     return { outcome: "merged", moved, skipped };
   } catch (err) {
     const error = err instanceof Error ? err.message : String(err);
-    log6.warn(TAG6, `Could not migrate ${from} to ${to}: ${error}.` + (moved.length > 0 ? ` ${moved.length} entr${moved.length === 1 ? "y" : "ies"} already moved: ${moved.join(", ")}. Re-run to finish; nothing is deleted.` : ` Nothing was moved; the daemon reads the old config through the fallback.`));
+    log6.warn(TAG6, `Could not migrate ${from} to ${to}: ${error}.` + (moved.length > 0 ? ` ${moved.length} entr${moved.length === 1 ? "y" : "ies"} already moved: ${nameSample(moved)}. Re-run to finish; nothing is deleted.` : ` Nothing was moved; the daemon reads the old config through the fallback.`));
     return { outcome: "failed", moved, skipped, error };
   }
 }
-var TAG6 = "config-migration";
+function mergeDirInto(fromDir, toDir, rel, moved, skipped, depth) {
+  for (const entry of readdirSync(fromDir, { withFileTypes: true })) {
+    const source = join2(fromDir, entry.name);
+    const target = join2(toDir, entry.name);
+    const relPath = join2(rel, entry.name);
+    if (entry.isDirectory()) {
+      if (!lexists(target)) {
+        renameSync(source, target);
+        if (recordMovedLeaves(target, relPath, moved) === 0) {
+          moved.push(`${relPath}/`);
+        }
+        continue;
+      }
+      const targetIsDir = isRealDirectory(target);
+      if (!targetIsDir || depth >= MAX_MERGE_DEPTH) {
+        skipped.push(`${relPath}/`);
+        continue;
+      }
+      mergeDirInto(source, target, relPath, moved, skipped, depth + 1);
+      continue;
+    }
+    if (lexists(target)) {
+      skipped.push(relPath);
+      continue;
+    }
+    renameSync(source, target);
+    moved.push(relPath);
+  }
+}
+function recordMovedLeaves(dir, rel, moved) {
+  let leaves = 0;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const relPath = join2(rel, entry.name);
+    if (entry.isDirectory()) {
+      const below = recordMovedLeaves(join2(dir, entry.name), relPath, moved);
+      if (below === 0)
+        moved.push(`${relPath}/`);
+      leaves += below;
+      continue;
+    }
+    moved.push(relPath);
+    leaves += 1;
+  }
+  return leaves;
+}
+function lexists(path) {
+  try {
+    lstatSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isRealDirectory(path) {
+  try {
+    return lstatSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function nameSample(paths, limit = 10) {
+  if (paths.length <= limit)
+    return paths.join(", ");
+  return `${paths.slice(0, limit).join(", ")} … and ${paths.length - limit} more`;
+}
+var TAG6 = "config-migration", MAX_MERGE_DEPTH = 32;
 var init_config_dir_migration = __esm(() => {
   init_paths();
 });
@@ -3614,7 +3953,7 @@ function resolveDaemonUserId(userEmail, members, apiKeyUserId) {
 // src/ci-patch-trees.ts
 import { execFileSync as execFileSync2 } from "node:child_process";
 import {
-  lstatSync,
+  lstatSync as lstatSync2,
   mkdirSync as mkdirSync2,
   mkdtempSync,
   readdirSync as readdirSync2,
@@ -3747,7 +4086,7 @@ function safeDestination(clean, path) {
   for (const part of parts.slice(0, -1)) {
     probe = join3(probe, part);
     try {
-      if (lstatSync(probe).isSymbolicLink()) {
+      if (lstatSync2(probe).isSymbolicLink()) {
         throw new Error(`the repair's destination passes through a symlink in the checkout (${path}) — refusing to write through it`);
       }
     } catch (err) {
@@ -3773,6 +4112,7 @@ import {
   extractPrUrl,
   GIT_NO_HOOKS as GIT_NO_HOOKS3,
   installCommand,
+  isPrUrlOnOrigin,
   log as log9,
   removeWorktreeHoldingBranch,
   resolvePrHeadBranch
@@ -3863,9 +4203,48 @@ async function resolveReviewBranch(description, cwd) {
   if (!prUrl)
     return { kind: "none" };
   const provider = detectGitProvider(cwd);
+  if (!isPrUrlOnOrigin(prUrl, cwd, provider)) {
+    return {
+      kind: "skip",
+      reason: `cannot prove ${prUrl} is a pull request on this checkout's own origin (provider: ${provider}) — the PR: line is editable board data, so nothing was read from it`
+    };
+  }
   const resolved = await resolvePrHeadBranch(prUrl, cwd, provider);
   return resolved;
 }
+function assessPrReviewContinuity(opts) {
+  const { repoRoot, branch, reviewedSha } = opts;
+  if (!reviewedSha)
+    return { kind: "ok" };
+  let head;
+  try {
+    execFileSync3("git", [...GIT_NO_HOOKS3, "fetch", "origin", branch], {
+      cwd: repoRoot,
+      stdio: "pipe",
+      timeout: 60000
+    });
+    head = execFileSync3("git", [...GIT_NO_HOOKS3, "rev-parse", "FETCH_HEAD"], {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 1e4
+    }).trim();
+  } catch (err) {
+    return {
+      kind: "skip",
+      reason: `could not read origin/${branch} to check review continuity: ${gitErrorDetail(err)}`
+    };
+  }
+  try {
+    execFileSync3("git", [...GIT_NO_HOOKS3, "merge-base", "--is-ancestor", reviewedSha, head], { cwd: repoRoot, stdio: "pipe", timeout: 1e4 });
+    return { kind: "ok" };
+  } catch (err) {
+    return {
+      kind: "skip",
+      reason: `the recorded Reviewed-SHA ${reviewedSha} is not contained in origin/${branch} (head ${head}) — the PR: line points at a head this card's review history never built (${gitErrorDetail(err) || "not an ancestor"})`
+    };
+  }
+}
 function reviewedFromPrUrl(description) {
   if (extractBranchFromDescription(description))
     return null;
@@ -4509,12 +4888,15 @@ var init_ci_repair = __esm(() => {
 
 // src/auto-merge.ts
 import {
+  countBlockingReviewVerdicts,
   extractCiReviewRequestedSha,
   extractReviewedSha,
   getPrStatus,
   isPrOnOrigin as isPrOnOrigin2,
   log as log13,
   mergePullRequest,
+  readHeadCommitTime,
+  readPrFindings,
   requestIndependentReview,
   upsertCiReviewRequestedSha
 } from "@gethmy/harness";
@@ -4563,6 +4945,15 @@ function decideAutoMergeAction(input) {
         case "clean":
           break;
         case "blocking":
+          if (config.findingsLoop) {
+            const rounds = input.blockingVerdictRounds;
+            if (rounds !== undefined && rounds <= config.maxFindingRounds) {
+              return "report-findings";
+            }
+            if (rounds !== undefined && Number.isFinite(rounds)) {
+              return "stamp-findings-exhausted";
+            }
+          }
           return "stamp-review-findings";
         case "pending":
           return "wait";
@@ -4591,6 +4982,9 @@ async function stampCiFailure(client, card) {
 async function stampReviewFindings(client, card) {
   await stampForHumanOnce(client, card, "Independent review posted blocking findings");
 }
+async function stampFindingsExhausted(client, card, maxRounds) {
+  await stampForHumanOnce(client, card, `Findings loop spent its ${maxRounds} round${maxRounds === 1 ? "" : "s"} and the review still objects`);
+}
 async function stampReviewIncomplete(client, card) {
   await stampForHumanOnce(client, card, "Independent review did not complete (no verdict)");
 }
@@ -4609,7 +5003,7 @@ async function attemptAutoMerge(deps) {
   const gate = driver === "interactive" ? autoMerge.interactive : autoMerge.enabled;
   if (!gate)
     return "disabled";
-  if (driver === "interactive" && !isPrOnOrigin2(prUrl, cwd)) {
+  if (!isPrOnOrigin2(prUrl, cwd)) {
     log13.warn(TAG13, `#${card.short_id} refusing to merge ${prUrl} — it is not a pull request on this checkout's own origin. The card's PR: line is editable board data; nothing was read from that URL.`);
     return "foreign-pr";
   }
@@ -4637,6 +5031,9 @@ async function attemptAutoMerge(deps) {
     enabled: true,
     ...driver === "interactive" && independent.enabled ? { reReviewOnBranchChange: false } : {}
   };
+  const countRounds = driver === "interactive" && autoMerge.findingsLoop && independent.enabled && independent.verdict.enabled && reviewVerdict === "blocking";
+  const blockingVerdictRounds = countRounds ? await countBlockingReviewVerdicts(prUrl, cwd, provider, independent.verdict.checkName) : undefined;
+  const headCommitTime = countRounds ? await readHeadCommitTime(prUrl, cwd, provider) : null;
   const action = decideAutoMergeAction({
     ciStatus,
     headSha,
@@ -4644,7 +5041,8 @@ async function attemptAutoMerge(deps) {
     config: decisionConfig,
     independentReview,
     reviewVerdict,
-    reviewRequestedSha
+    reviewRequestedSha,
+    blockingVerdictRounds
   });
   switch (action) {
     case "wait":
@@ -4672,6 +5070,28 @@ async function attemptAutoMerge(deps) {
       log13.info(TAG13, `#${card.short_id} the independent review posted blocking findings ("${independent.verdict.checkName}" is red) — holding the merge and flagging for a human. The findings are on the PR: fix them and push (the new head is reviewed afresh), or merge it yourself once you have judged them.`);
       await stampReviewFindings(client, card);
       return action;
+    case "report-findings": {
+      const report = await readPrFindings(prUrl, cwd, provider, {
+        authors: independent.findingAuthors ?? [],
+        ...headCommitTime ? { since: headCommitTime } : {}
+      });
+      if (!report.readable) {
+        log13.warn(TAG13, `#${card.short_id} the independent review posted blocking findings but none could be read from ${independent.findingAuthors?.join(", ") || "no configured reviewer"} — holding the merge and flagging for a human instead of acting on a partial or empty list.`);
+        await stampReviewFindings(client, card);
+        return "stamp-review-findings";
+      }
+      log13.info(TAG13, `#${card.short_id} the independent review posted blocking findings ("${independent.verdict.checkName}" is red) — reporting ${report.items.length} finding(s) for verification, round ${blockingVerdictRounds} of ${autoMerge.maxFindingRounds}.`);
+      deps.onFindings?.({
+        report,
+        round: blockingVerdictRounds ?? 0,
+        maxRounds: autoMerge.maxFindingRounds
+      });
+      return action;
+    }
+    case "stamp-findings-exhausted":
+      log13.info(TAG13, `#${card.short_id} the findings loop spent its ${autoMerge.maxFindingRounds} round(s) and "${independent.verdict.checkName}" is still red — holding the merge for a person. The findings were read and acted on; what ran out is the round budget, so pushing another fix will park again.`);
+      await stampFindingsExhausted(client, card, autoMerge.maxFindingRounds);
+      return action;
     case "stamp-review-incomplete":
       log13.info(TAG13, `#${card.short_id} the independent review did not complete ("${independent.checkName}" is red, no verdict) — holding the merge and flagging for a human. Re-request it with a remove-then-add of "${independent.label}"; the per-head ledger stops this daemon buying a second pass itself.`);
       await stampReviewIncomplete(client, card);
@@ -6169,7 +6589,7 @@ var init_completion = __esm(() => {
 
 // src/progress-tracker.ts
 import { log as log21 } from "@gethmy/harness";
-function truncate(str, max) {
+function truncate2(str, max) {
   return str.length > max ? `${str.slice(0, max - 3)}...` : str;
 }
 
@@ -6354,7 +6774,7 @@ class ProgressTracker {
     const firstLine = (end === -1 ? trimmed : trimmed.slice(0, end)).trim();
     if (firstLine.length >= 10 && firstLine.length <= 200) {
       if (ACTION_PREFIX.test(firstLine)) {
-        this.lastAction = truncate(firstLine, MAX_TASK_LENGTH);
+        this.lastAction = truncate2(firstLine, MAX_TASK_LENGTH);
       }
     }
   }
@@ -6413,16 +6833,16 @@ class ProgressTracker {
       }
       case "Grep": {
         const pattern = this.extractString(input, "pattern");
-        return pattern ? `Searching for "${truncate(pattern, 40)}"` : "Searching code";
+        return pattern ? `Searching for "${truncate2(pattern, 40)}"` : "Searching code";
       }
       case "Bash": {
         const cmd = this.extractString(input, "command");
-        return cmd ? `Running: ${truncate(cmd.split(`
+        return cmd ? `Running: ${truncate2(cmd.split(`
 `)[0], 80)}` : "Running command";
       }
       case "Agent": {
         const desc = this.extractString(input, "description");
-        return desc ? `Sub-agent: ${truncate(desc, 60)}` : "Delegating to sub-agent";
+        return desc ? `Sub-agent: ${truncate2(desc, 60)}` : "Delegating to sub-agent";
       }
       default: {
         if (name.startsWith("mcp__harmony__harmony_")) {
@@ -6471,7 +6891,7 @@ class ProgressTracker {
       agentIdentifier: this.sessionIdentifier,
       agentName: AGENT_NAME,
       status: "working",
-      currentTask: truncate(currentTask, MAX_TASK_LENGTH),
+      currentTask: truncate2(currentTask, MAX_TASK_LENGTH),
       progressPercent: this.progress,
       phase: this.phase,
       filesChanged: this.filesEdited.size,
@@ -6489,7 +6909,7 @@ class ProgressTracker {
       this.lastEmittedProgress = this.progress;
       this.runEventSink.recordProgress({
         progressPercent: this.progress,
-        currentTask: truncate(currentTask, MAX_TASK_LENGTH),
+        currentTask: truncate2(currentTask, MAX_TASK_LENGTH),
         phase: this.phase,
         filesChanged: this.filesEdited.size
       });
@@ -6502,7 +6922,7 @@ class ProgressTracker {
     this.heartbeatTimer = setTimeout(() => {
       if (!this.stopped) {
         const task = this.lastAction ? `Still working — ${this.lastAction}` : "Still working...";
-        this.sendUpdate(truncate(task, MAX_TASK_LENGTH));
+        this.sendUpdate(truncate2(task, MAX_TASK_LENGTH));
         this.startHeartbeat();
       }
     }, HEARTBEAT_MS);
@@ -7802,6 +8222,7 @@ class StateStore {
     const rec = this.ensureCard(cardId);
     rec.attempts += 1;
     rec.totalAttempts = (rec.totalAttempts ?? 0) + 1;
+    rec.runStarts = (rec.runStarts ?? 0) + 1;
     rec.lastAttemptAt = Date.now();
     await this.persist();
     return rec.attempts;
@@ -7888,7 +8309,7 @@ class StateStore {
     const rec = this.getCard(cardId);
     if (!rec)
       return;
-    if (rec.attempts === 0 && !rec.ciRepairAttempts && rec.ciRepairParkedAt == null && (!clearTurns || !rec.totalTurns)) {
+    if (rec.attempts === 0 && !rec.ciRepairAttempts && rec.ciRepairParkedAt == null && (!clearTurns || !rec.totalTurns && !rec.runStarts)) {
       return;
     }
     rec.attempts = 0;
@@ -7896,6 +8317,8 @@ class StateStore {
     rec.ciRepairParkedAt = null;
     if (clearTurns)
       rec.totalTurns = 0;
+    if (clearTurns)
+      rec.runStarts = 0;
     await this.persist();
   }
   getCiRepairAttempts(cardId) {
@@ -7968,6 +8391,9 @@ class StateStore {
   getCardTurns(cardId) {
     return this.getCard(cardId)?.totalTurns ?? 0;
   }
+  getCardRunStarts(cardId) {
+    return this.getCard(cardId)?.runStarts ?? 0;
+  }
   getCardCostCents(cardId) {
     return this.getCard(cardId)?.totalCostCents ?? 0;
   }
@@ -8313,6 +8739,7 @@ import {
   collectGateEvidence,
   DevServerReadinessError,
   devServerLaunch,
+  extractReviewedSha as extractReviewedSha2,
   formatDiffSummary,
   GIT_NO_HOOKS as GIT_NO_HOOKS7,
   implementRunContainmentCliArgs,
@@ -8528,6 +8955,18 @@ class ReviewWorker {
           await addLabelByName(this.client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
           return;
         }
+        if (this.config.review.autoMerge.enabled && reviewedFromPrUrl(card.description)) {
+          const continuity = assessPrReviewContinuity({
+            repoRoot,
+            branch: resolution.branch,
+            reviewedSha: extractReviewedSha2(card.description ?? null)
+          });
+          if (continuity.kind === "skip") {
+            log28.warn(this.tag, `#${card.short_id} refusing the PR-derived re-review (${continuity.reason}) — marking for human review (staying in Review)`);
+            await addLabelByName(this.client, card, NEED_REVIEW_LABEL, NEED_REVIEW_LABEL_COLOR);
+            return;
+          }
+        }
         this.branchName = resolution.branch;
         log28.info(this.tag, `Review branch: ${this.branchName}`);
         let reviewSession;
@@ -9291,7 +9730,7 @@ var init_unblock = () => {};
 // src/cli-agent-runner.ts
 import { log as log31 } from "@gethmy/harness";
 function truncateOutput(value) {
-  return value === undefined ? undefined : value.slice(0, MAX_OUTPUT_LEN);
+  return value === undefined ? undefined : value.slice(0, MAX_OUTPUT_CHARS);
 }
 
 class CliAgentRunner {
@@ -9302,6 +9741,10 @@ class CliAgentRunner {
   flushTimer = null;
   flushing = false;
   stopped = false;
+  batchAttempts = 0;
+  nextBatchSize = MAX_BUFFER;
+  withheldToolUses = new Map;
+  pendingWithholdWithoutId;
   constructor(client, cardId, sessionId) {
     this.client = client;
     this.cardId = cardId;
@@ -9311,21 +9754,43 @@ class CliAgentRunner {
     if (this.stopped)
       return;
     parser.on("tool_start", (name, input, toolUseId) => {
+      const redacted = redactToolCall({ input });
+      if (redacted.withheld) {
+        if (toolUseId) {
+          this.withheldToolUses.set(toolUseId, redacted.withheld);
+        } else {
+          this.pendingWithholdWithoutId = redacted.withheld;
+        }
+      }
       this.enqueue({
         kind: "tool_started",
         source: "agent",
-        payload: { toolName: name, toolUseId, input }
+        payload: redacted.withheld ? { toolName: name, toolUseId, withheld: redacted.withheld } : { toolName: name, toolUseId, input: redacted.input }
       });
     });
     parser.on("tool_end", (name, toolUseId, content) => {
+      const withheld = (toolUseId ? this.withheldToolUses.get(toolUseId) : undefined) ?? this.pendingWithholdWithoutId;
+      if (withheld) {
+        if (toolUseId)
+          this.withheldToolUses.delete(toolUseId);
+        this.pendingWithholdWithoutId = undefined;
+        this.enqueue({
+          kind: "tool_ended",
+          source: "agent",
+          payload: {
+            toolName: name,
+            toolUseId,
+            output: `[withheld: ${withheld}]`,
+            withheld
+          }
+        });
+        return;
+      }
+      const redacted = redactToolCall({ output: content });
       this.enqueue({
         kind: "tool_ended",
         source: "agent",
-        payload: {
-          toolName: name,
-          toolUseId,
-          output: content === undefined ? undefined : content.slice(0, MAX_OUTPUT_LEN)
-        }
+        payload: { toolName: name, toolUseId, output: redacted.output }
       });
     });
     parser.on("text", (content) => {
@@ -9426,6 +9891,10 @@ class CliAgentRunner {
   enqueue(body) {
     if (this.stopped)
       return;
+    if (runEventPayloadExceedsLimit(body.payload)) {
+      log31.warn(TAG28, `Dropping oversized ${body.kind} event: payload exceeds ${MAX_RUN_EVENT_PAYLOAD_BYTES} bytes`);
+      return;
+    }
     this.buffer.push({ ...body, createdAt: new Date().toISOString() });
     if (this.buffer.length >= MAX_BUFFER)
       this.flush();
@@ -9440,27 +9909,49 @@ class CliAgentRunner {
     if (this.flushing || this.buffer.length === 0)
       return;
     this.flushing = true;
-    const batch = this.buffer.splice(0, MAX_BUFFER);
+    const batch = this.buffer.splice(0, Math.min(this.nextBatchSize, MAX_BUFFER));
     try {
       await this.client.appendAgentRunEvents(this.cardId, {
         sessionId: this.sessionId,
         events: batch
       });
+      this.batchAttempts = 0;
+      this.nextBatchSize = MAX_BUFFER;
     } catch (err) {
-      log31.warn(TAG28, `Failed to flush run events: ${err}`);
-      this.buffer.unshift(...batch);
-      if (this.buffer.length > MAX_BUFFER) {
-        this.buffer.length = MAX_BUFFER;
+      this.batchAttempts++;
+      if (this.batchAttempts >= MAX_BATCH_ATTEMPTS) {
+        this.batchAttempts = 0;
+        this.requeue(batch);
+        if (batch.length > 1) {
+          this.nextBatchSize = Math.ceil(batch.length / 2);
+          log31.warn(TAG28, `Flush of ${batch.length} run event(s) failed ${MAX_BATCH_ATTEMPTS}×; bisecting to ${this.nextBatchSize}: ${err}`);
+          return;
+        }
+        const dropped = this.buffer.shift();
+        this.nextBatchSize = MAX_BUFFER;
+        log31.warn(TAG28, `Dropping one ${dropped?.kind} event the API refused ${MAX_BATCH_ATTEMPTS}×: ${err}`);
+        return;
       }
+      log31.warn(TAG28, `Failed to flush run events (attempt ${this.batchAttempts}/${MAX_BATCH_ATTEMPTS}): ${err}`);
+      this.requeue(batch);
     } finally {
       this.flushing = false;
     }
   }
+  requeue(batch) {
+    this.buffer.unshift(...batch);
+    if (this.buffer.length > MAX_BUFFER) {
+      this.buffer.length = MAX_BUFFER;
+    }
+  }
   async flushFinal() {
-    for (let i = 0;this.buffer.length > 0 && i < 5; i++) {
+    for (let i = 0;this.buffer.length > 0 && i < FINAL_FLUSH_ATTEMPTS; i++) {
       const before = this.buffer.length;
+      const beforeBatchSize = this.nextBatchSize;
+      const beforeAttempts = this.batchAttempts;
       await this.flush();
-      if (this.buffer.length >= before)
+      const inert = this.buffer.length >= before && this.nextBatchSize >= beforeBatchSize && this.batchAttempts <= beforeAttempts;
+      if (inert)
         break;
     }
   }
@@ -9484,8 +9975,10 @@ function mapCost(cost) {
     durationMs: cost.durationMs
   };
 }
-var TAG28 = "cli-agent-runner", FLUSH_INTERVAL_MS = 2000, MAX_BUFFER = 1000, MAX_TEXT_LEN = 8000, MAX_OUTPUT_LEN = 4000;
-var init_cli_agent_runner = () => {};
+var TAG28 = "cli-agent-runner", FLUSH_INTERVAL_MS = 2000, MAX_BUFFER = 1000, MAX_TEXT_LEN = 8000, MAX_BATCH_ATTEMPTS = 3, FINAL_FLUSH_ATTEMPTS = 40;
+var init_cli_agent_runner = __esm(() => {
+  init_dist();
+});
 
 // src/fanout.ts
 import { log as log32 } from "@gethmy/harness";
@@ -10684,6 +11177,19 @@ class Worker {
       log34.info(this.tag, resuming ? `Resuming #${card.short_id} "${card.title}" with ${this.grantedTurns ?? "the default"} more turns` : `Preparing #${card.short_id} "${card.title}"`);
       const attemptCount = await this.stateStore.incrementAttempt(card.id);
       const isRework = attemptCount > 1;
+      const runStarts = this.stateStore.getCardRunStarts(card.id);
+      const runCap = this.config.budget.maxRunsPerCard;
+      if (crossedTurnCap(runStarts - 1, runStarts, runCap)) {
+        log34.warn(this.tag, `#${card.short_id} reached its per-card run backstop — ${runStarts} of ${runCap} run starts. It will not be picked up again until it is reassigned or the cap is raised.`);
+        try {
+          await this.client.addComment(card.id, buildRunCapComment(runStarts, runCap), {
+            commentType: "blocker",
+            agentSessionId: this.sessionId ?? undefined
+          });
+        } catch (err) {
+          log34.warn(this.tag, `Could not post the run-backstop notice for ${card.id}: ${err instanceof Error ? err.message : err}`);
+        }
+      }
       const recordedBranch = recordedBranchForCard(card.description, card.short_id, [
         this.config.worktree.failedBranchPrefix,
         this.config.worktree.approvedBranchPrefix
@@ -10935,7 +11441,8 @@ class Worker {
       }
       const msg = err instanceof Error ? err.message : String(err);
       const rawStderr = err?.stderr;
-      const errClass = classifyRunError2(typeof rawStderr === "string" && rawStderr ? rawStderr : msg);
+      const errClass = classifyRunError2(typeof rawStderr === "string" && rawStderr ? msg + `
+` + rawStderr : msg);
       const sdkKind = err?.errorKind;
       if (errClass.kind === null && sdkKind != null)
         errClass.kind = sdkKind;
@@ -10943,11 +11450,6 @@ class Worker {
         try {
           this.onApiError?.(errClass);
         } catch {}
-        try {
-          await this.stateStore.decrementAttempt(card.id);
-        } catch (dErr) {
-          log34.warn(this.tag, `Failed to roll back the attempt: ${dErr}`);
-        }
         await this.parkForDecision(card, "account_limit");
         return;
       }
@@ -12683,6 +13185,10 @@ class Pool {
     }
   }
   async enqueue(card, column, labels, subtasks, mode = "implement") {
+    if (card.done || card.archived_at) {
+      log35.debug(TAG32, `#${card.short_id} skipped — ${card.done ? "done" : "archived"} (finished work is never enqueued, #1102)`);
+      return;
+    }
     if (this.isCardKnown(card.id) || this.reservations.has(card.id)) {
       log35.debug(TAG32, `Card ${card.id} already queued, active, or reserved, skipping`);
       return;
@@ -13080,9 +13586,23 @@ I am handing the card back rather than holding it parked. Reassign it — that c
       await this.stopRun(run, "Continue refused: the card is at its per-card turn cap.");
       return;
     }
-    if (run.pauseTrigger !== "account_limit") {
-      await this.stateStore.decrementAttempt(run.cardId);
+    const runsSpent = this.budget.checkCardRuns(run.cardId);
+    if (!runsSpent.allow) {
+      log35.warn(TAG32, `Refusing a Continue on ${run.cardId} — ${runsSpent.detail}. Handing the card back: reassign it to clear the count, or raise budget.maxRunsPerCard.`);
+      try {
+        await this.client.addComment(run.cardId, `**That Continue cannot be granted.** ${runsSpent.detail}, which is this card's run backstop (\`budget.maxRunsPerCard\`), so the implement pipeline would refuse it again the moment it was dispatched.
+
+I am handing the card back rather than holding it parked. Reassign it — that clears the count and starts it fresh — or raise the cap in the daemon config if this card genuinely needs the room. The branch is pushed, so nothing committed is lost.`, {
+          commentType: "blocker",
+          agentSessionId: run.sessionId ?? undefined
+        });
+      } catch (err) {
+        log35.warn(TAG32, `Could not explain the refused Continue on ${run.cardId}: ${err instanceof Error ? err.message : err}`);
+      }
+      await this.stopRun(run, "Continue refused: the card is at its per-card run backstop.");
+      return;
     }
+    await this.stateStore.decrementAttempt(run.cardId);
     const grantedTurns = opts.extraTurns > 0 ? Math.min(opts.extraTurns, MAX_GRANTED_TURNS) : this.config.budget.pause.extraTurns ?? this.defaultTurnsFor(run.pipeline);
     const canSpendConsumption = run.pipeline === "implement" && this.config.runner === "sdk";
     const grantedBudgetUsd = !canSpendConsumption ? null : opts.extraBudgetUsd != null && opts.extraBudgetUsd > 0 ? Math.min(opts.extraBudgetUsd, MAX_GRANTED_BUDGET_USD) : this.config.budget.pause.extraBudgetUsd ?? this.config.sdk?.maxBudgetUsd ?? null;
@@ -13126,6 +13646,7 @@ I am handing the card back rather than holding it parked. Reassign it — that c
           daemonPid: process.pid,
           lastHeartbeatAt: Date.now()
         });
+        await this.stateStore.decrementAttempt(run.cardId);
         try {
           await this.client.updateAgentProgress(run.cardId, {
             ...this.sessionIdentityFor(run),
@@ -13214,6 +13735,20 @@ Reassign the card — that clears the turn count and starts it fresh — or rais
       await this.stopAttemptCap(cardId, "Attempt budget cleared, but the card is at its per-card turn cap.");
       return;
     }
+    const runsSpent = this.budget.checkCardRuns(cardId);
+    if (!runsSpent.allow) {
+      log35.warn(TAG32, `Attempt grant on ${cardId} cannot start a run — ${runsSpent.detail}. Clearing the attempt budget anyway; reassign the card to clear the run count, or raise budget.maxRunsPerCard.`);
+      try {
+        await this.client.addComment(cardId, `**Attempt budget cleared, but this card is at its run backstop.** ${runsSpent.detail}, which is its ceiling (\`budget.maxRunsPerCard\`), so I will not pick it up even with attempts restored.
+
+Reassign the card — that clears the run count and starts it fresh — or raise the cap in the daemon config.`, { commentType: "blocker" });
+      } catch (err) {
+        log35.warn(TAG32, `Could not explain the capped attempt grant on ${cardId}: ${err instanceof Error ? err.message : err}`);
+      }
+      await this.stateStore.resetAttempts(cardId, { clearTurns: false });
+      await this.stopAttemptCap(cardId, "Attempt budget cleared, but the card is at its per-card run backstop.");
+      return;
+    }
     const identity = this.attemptCapIdentityFor(cardId);
     await this.stateStore.resetAttempts(cardId, { clearTurns: false });
     await this.stateStore.clearAwaitingDecision(cardId);
@@ -13274,6 +13809,10 @@ Reassign the card — that clears the turn count and starts it fresh — or rais
         await this.retireUnroutableRuns(card.short_id, cardId);
         return;
       }
+      if (card.done || card.archived_at) {
+        await this.retireUnroutableRuns(card.short_id, cardId, `card is ${card.done ? "done" : "archived"} — finished work is never enqueued (#1102)`);
+        return;
+      }
       const labelMap = buildLabelMap(board.labels ?? []);
       const cardLabels = resolveCardLabels(card, labelMap);
       const subtasks = card.subtasks ?? [];
@@ -13282,12 +13821,12 @@ Reassign the card — that clears the turn count and starts it fresh — or rais
       log35.error(TAG32, `Failed to re-enqueue ${cardId} after a budget decision: ${err}`);
     }
   }
-  async retireUnroutableRuns(shortId, cardId) {
+  async retireUnroutableRuns(shortId, cardId, reason = "column not found on this board") {
     const unended = this.stateStore.getRunsForCard(cardId).filter((r) => r.endedAt === null);
-    log35.warn(TAG32, `#${shortId}: column not found on this board — retiring ${unended.length} run record(s) as foreign/unroutable instead of re-enqueueing`);
+    log35.warn(TAG32, `#${shortId}: ${reason} — retiring ${unended.length} run record(s) instead of re-enqueueing`);
     for (const run of unended) {
       await this.stateStore.endRun(run.runId, "orphaned", {
-        errorMessage: "column not found on this daemon's board at re-enqueue — retired as foreign or unroutable (#1057)"
+        errorMessage: `${reason} at re-enqueue — retired as unroutable (#1057/#1102)`
       });
     }
   }
@@ -14569,7 +15108,7 @@ class Reconciler {
         }
       };
       const assignedCards = cards.filter((c) => {
-        if (c.assigned_agent_id !== this.agentId || c.archived_at)
+        if (c.assigned_agent_id !== this.agentId || c.archived_at || c.done)
           return false;
         const col = columnMap.get(c.column_id);
         return col ? classifyPickup(c, col.name, pickupConfig) !== null : false;
@@ -14878,7 +15417,8 @@ function mergeCardRecords(target, legacy) {
     attempts: Math.max(target.attempts ?? 0, legacy.attempts ?? 0),
     totalAttempts: Math.max(target.totalAttempts ?? 0, legacy.totalAttempts ?? 0),
     totalCostCents: Math.max(target.totalCostCents ?? 0, legacy.totalCostCents ?? 0),
-    totalTurns: Math.max(target.totalTurns ?? 0, legacy.totalTurns ?? 0)
+    totalTurns: Math.max(target.totalTurns ?? 0, legacy.totalTurns ?? 0),
+    runStarts: Math.max(target.runStarts ?? 0, legacy.runStarts ?? 0)
   };
 }
 function mergeDaily(target, legacy) {
@@ -15729,6 +16269,7 @@ var init_worktree_gc = __esm(() => {
 var exports_src = {};
 __export(exports_src, {
   validatePrerequisites: () => validatePrerequisites,
+  tryEnqueueCard: () => tryEnqueueCard,
   main: () => main
 });
 import { execFileSync as execFileSync9 } from "node:child_process";
@@ -16111,6 +16652,10 @@ async function tryEnqueueCard(cardId, client, pool, config, agentId) {
     log48.debug(TAG45, `Card ${cardId} no longer assigned to agent — skipping`);
     return;
   }
+  if (card.done || card.archived_at) {
+    log48.debug(TAG45, `Card ${cardId} is finished — skipping`);
+    return;
+  }
   const board = await client.getBoard(config.projectId, { summary: true });
   const columns = board.columns;
   const column = columns.find((c) => c.id === card.column_id);
@@ -16182,5 +16727,6 @@ init_src();
 
 export {
   validatePrerequisites,
+  tryEnqueueCard,
   main
 };