@gethmy/agent 1.28.2 → 1.29.0

package/dist/cli.js

@@ -584,6 +584,68 @@ var init_board_reviewer = __esm(() => {
   init_board_review();
 });
 
+// src/budget.ts
+function usd(cents) {
+  return `$${(cents / 100).toFixed(2)}`;
+}
+function formatDailyCap(cents) {
+  return cents < 0 ? "no cap" : usd(cents);
+}
+
+class BudgetGuard {
+  config;
+  store;
+  constructor(config, store) {
+    this.config = config;
+    this.store = store;
+  }
+  check(cardId) {
+    const card = this.store.getCard(cardId);
+    if (card && card.attempts >= this.config.maxAttemptsPerCard) {
+      return {
+        allow: false,
+        reason: "max_attempts",
+        detail: `${card.attempts} of ${this.config.maxAttemptsPerCard} attempts exhausted`
+      };
+    }
+    return this.checkDailyBudget();
+  }
+  checkDailyBudget() {
+    const cap = this.config.dailyBudgetCents;
+    if (cap < 0)
+      return { allow: true };
+    const spentCents = this.store.getDailyCostCents();
+    if (spentCents < cap)
+      return { allow: true };
+    return {
+      allow: false,
+      reason: "daily_budget",
+      detail: `${usd(spentCents)} of ${usd(cap)} spent today (UTC)`
+    };
+  }
+}
+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 = [
+    "**Out of attempts — over to you.**",
+    `Stopped after ${maxAttempts} failed attempt${maxAttempts === 1 ? "" : "s"}. ${wayBackIn}`
+  ];
+  if (failures.length > 0) {
+    lines.push("", "Recent failures:");
+    for (const f of failures) {
+      const when = new Date(f.ts).toISOString().replace("T", " ").slice(0, 16);
+      const tag = f.reason ? ` [${f.reason}]` : "";
+      const branch = f.recoveryBranch ? `
+  recover: \`git fetch && git checkout ${f.recoveryBranch}\`` : "";
+      lines.push(`- ${when} UTC${tag} — ${f.summary}${branch}`);
+    }
+  } else {
+    lines.push("", "_No prior failure summaries recorded._");
+  }
+  return lines.join(`
+`);
+}
+
 // ../harmony-shared/dist/agentCommentTrust.js
 function isDaemonAuthoredComment(comment, identity) {
   if (comment.author_type !== "agent")
@@ -2103,6 +2165,13 @@ var init_types2 = __esm(() => {
     pickupColumns: ["To Do"],
     priorityLabels: { urgent: 100, critical: 90, bug: 50 },
     columnBoost: true,
+    ranking: {
+      priorityWeight: 100,
+      successorWeight: 25,
+      successorCap: 4,
+      agePerDayWeight: 5,
+      ageCapDays: 30
+    },
     runner: "sdk",
     completion: {
       createPR: false,
@@ -2189,7 +2258,14 @@ var init_types2 = __esm(() => {
     planning: DEFAULT_PLANNING_CONFIG,
     playbooks: { enabled: true, humanStageColumns: [], metrics: {} },
     contractFirst: DEFAULT_CONTRACT_CONFIG,
-    boardReview: DEFAULT_BOARD_REVIEW_CONFIG
+    boardReview: DEFAULT_BOARD_REVIEW_CONFIG,
+    sweep: {
+      enabled: false,
+      requireLabel: "",
+      trustedAuthors: [],
+      maxProbesPerTick: 5,
+      maxCardsPerSweep: 10
+    }
   };
 });
 
@@ -2259,6 +2335,10 @@ function loadDaemonConfig() {
       ...DEFAULT_AGENT_CONFIG.completion,
       ...agentOverrides.completion ?? {}
     },
+    ranking: {
+      ...DEFAULT_AGENT_CONFIG.ranking,
+      ...agentOverrides.ranking ?? {}
+    },
     claude: {
       ...DEFAULT_AGENT_CONFIG.claude,
       ...agentOverrides.claude ?? {}
@@ -2306,6 +2386,13 @@ function loadDaemonConfig() {
     boardReview: {
       ...DEFAULT_AGENT_CONFIG.boardReview,
       ...agentOverrides.boardReview ?? {}
+    },
+    sweep: {
+      ...DEFAULT_AGENT_CONFIG.sweep,
+      ...agentOverrides.sweep ?? {},
+      trustedAuthors: [
+        ...agentOverrides.sweep?.trustedAuthors ?? DEFAULT_AGENT_CONFIG.sweep.trustedAuthors
+      ]
     }
   };
   if (agent.runner !== "cli" && agent.runner !== "sdk") {
@@ -2349,6 +2436,67 @@ function validateAutoMergeConfig(config) {
     throw new ConfigValidationError(`Invalid agent config — review.autoMerge.strategy "${s}" must be one of: ${valid.join(", ")}`, [`review.autoMerge.strategy: invalid value "${s}"`]);
   }
 }
+function validateSweepConfig(config) {
+  const sweep = config.sweep;
+  const issues = [];
+  if (!Number.isInteger(sweep.maxProbesPerTick) || sweep.maxProbesPerTick < 1) {
+    issues.push(`sweep.maxProbesPerTick: must be an integer >= 1, got ${JSON.stringify(sweep.maxProbesPerTick)}`);
+  }
+  if (!Number.isInteger(sweep.maxCardsPerSweep) || sweep.maxCardsPerSweep === 0) {
+    issues.push(sweep.maxCardsPerSweep === 0 ? `sweep.maxCardsPerSweep: 0 is ambiguous — it could mean "no cap" or "claim nothing". Use a positive number of cards, or -1 to run with no card cap.` : `sweep.maxCardsPerSweep: must be a whole number of cards (positive) or -1 for no cap, got ${JSON.stringify(sweep.maxCardsPerSweep)}`);
+  }
+  if (sweep.enabled && sweep.maxCardsPerSweep < 0 && config.budget.dailyBudgetCents < 0) {
+    issues.push("sweep.enabled: true with no ceiling at all — sweep.maxCardsPerSweep and budget.dailyBudgetCents are both opted out (-1). A self-claiming daemon needs at least one: set a card cap (e.g. 10) or a daily spend cap (e.g. 5000 for $50.00/day).");
+  }
+  if (sweep.enabled && !config.http.enabled) {
+    issues.push("sweep.enabled: true but http.enabled is false — the sweep kill switch IS the local HTTP server (`POST /sweep/stop`, `harmony-agent sweep stop`), so this configuration ships a self-claiming daemon with no way to stop it, and no way to clear a latched card cap either. Set http.enabled: true.");
+  }
+  if (sweep.enabled && config.pickupColumns.length === 0) {
+    issues.push("sweep.enabled: true but pickupColumns is empty — the sweep has no column to claim from");
+  }
+  if (sweep.enabled && config.boardReview.enabled) {
+    const digest = config.boardReview.digestColumn;
+    if (!digest) {
+      issues.push("sweep.enabled and boardReview.enabled are both true but boardReview.digestColumn is empty — the digest would fall back to the first pickup column, where the sweep would claim it and run an implement session on card titles written by other members. Set digestColumn to a column the daemon does not pick up from.");
+    } else if (config.pickupColumns.some((c) => c.toLowerCase() === digest.toLowerCase())) {
+      issues.push(`boardReview.digestColumn: "${digest}" is also a sweep pickup column — the daemon would claim its own digest card and run it. Use a column the daemon does not pick up from.`);
+    }
+  }
+  const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  for (const author of sweep.trustedAuthors) {
+    if (!UUID.test(author)) {
+      issues.push(`sweep.trustedAuthors: "${author}" is not a user id — expected a workspace member's UUID (harmony_get_workspace_members lists them)`);
+    }
+  }
+  if (issues.length > 0) {
+    throw new ConfigValidationError(`Invalid agent config — sweep mode:
+  - ${issues.join(`
+  - `)}`, issues);
+  }
+}
+function validateBudgetConfig(config) {
+  const cents = config.budget.dailyBudgetCents;
+  if (Number.isInteger(cents) && cents !== 0)
+    return;
+  const issue = cents === 0 ? `budget.dailyBudgetCents: 0 is ambiguous — it could mean "no cap" or "spend nothing"` : `budget.dailyBudgetCents: ${cents} is not a whole number of cents`;
+  throw new ConfigValidationError(`Invalid agent config — ${issue}.
+` + `  Set a positive cap in cents (e.g. 5000 for $50.00/day), or -1 to run with no daily cap.`, [issue]);
+}
+function validateRankingConfig(config) {
+  const issues = [];
+  const entries = Object.entries(config.ranking);
+  for (const [key, value] of entries) {
+    if (!Number.isFinite(value) || value < 0) {
+      issues.push(`ranking.${key}: must be a finite number >= 0, got ${JSON.stringify(value)}`);
+    }
+  }
+  if (issues.length > 0) {
+    throw new ConfigValidationError(`Invalid agent config — ranking weights:
+  - ${issues.join(`
+  - `)}
+` + `  Set a term's weight to 0 to switch it off; zeroing priorityWeight, successorWeight and agePerDayWeight reproduces the pre-#979 ordering.`, issues);
+  }
+}
 function columnNames(board) {
   return board.columns.map((c) => c.name);
 }
@@ -2411,6 +2559,13 @@ async function validateColumnReferences(client, projectId, config) {
       where: "boardReview.digestColumn"
     });
   }
+  if (config.sweep.enabled && config.sweep.requireLabel) {
+    const target = config.sweep.requireLabel.toLowerCase();
+    const boardLabels = board.labels ?? [];
+    if (!boardLabels.some((l) => l.name.toLowerCase() === target)) {
+      issues.push(`sweep.requireLabel: label "${config.sweep.requireLabel}" not found on board — the sweep would never claim a card. Known labels: ${boardLabels.map((l) => l.name).join(", ") || "(none)"}`);
+    }
+  }
   for (const { value, where } of required) {
     if (!value)
       continue;
@@ -2420,7 +2575,7 @@ async function validateColumnReferences(client, projectId, config) {
   }
   if (issues.length > 0) {
     const help = `Available columns: ${known.join(", ")}`;
-    throw new ConfigValidationError(`Invalid agent config — the following columns are missing:
+    throw new ConfigValidationError(`Invalid agent config — the following board references are invalid:
   - ${issues.join(`
   - `)}
 ${help}`, issues);
@@ -2546,7 +2701,14 @@ class HttpServer {
     if (method === "GET" && path === "/status") {
       return this.respondStatus(res);
     }
+    if (method === "GET" && path === "/sweep") {
+      return this.respondSweep(res);
+    }
     if (method === "POST") {
+      const sweepCmd = parseSweepCommand(path);
+      if (sweepCmd) {
+        return this.respondSweepCommand(res, sweepCmd);
+      }
       const cmd = parseCommand(path);
       if (cmd) {
         return this.respondCommand(res, cmd.command, cmd.cardId);
@@ -2567,6 +2729,45 @@ class HttpServer {
     res.writeHead(200, { "content-type": "application/json" });
     res.end(JSON.stringify(snapshot));
   }
+  respondSweep(res) {
+    const getSweep = this.opts.getSweep;
+    if (!getSweep) {
+      this.respondSweepUnavailable(res);
+      return;
+    }
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify(getSweep()));
+  }
+  async respondSweepCommand(res, command) {
+    const handle = this.opts.handleSweepCommand;
+    if (!handle) {
+      this.respondSweepUnavailable(res);
+      return;
+    }
+    try {
+      const sweep = await handle(command);
+      res.writeHead(200, { "content-type": "application/json" });
+      res.end(JSON.stringify({
+        ok: true,
+        command,
+        sweep,
+        inFlight: this.opts.getStatus().workers.filter(busy).length
+      }));
+    } catch (err) {
+      res.writeHead(500, { "content-type": "application/json" });
+      res.end(JSON.stringify({
+        error: "sweep_command_failed",
+        detail: err instanceof Error ? err.message : String(err)
+      }));
+    }
+  }
+  respondSweepUnavailable(res) {
+    res.writeHead(404, { "content-type": "application/json" });
+    res.end(JSON.stringify({
+      error: "sweep_unavailable",
+      detail: "this daemon has no sweep control wired"
+    }));
+  }
   async respondCommand(res, command, cardId) {
     try {
       await this.opts.handleCommand(command, cardId);
@@ -2590,6 +2791,13 @@ function parseCommand(path) {
     return null;
   return { command: match[1], cardId: decodeURIComponent(match[2]) };
 }
+function parseSweepCommand(path) {
+  const match = path.match(/^\/sweep\/(stop|resume)$/);
+  return match ? match[1] : null;
+}
+function busy(w) {
+  return w.cardId !== null;
+}
 var TAG3 = "http";
 var init_http_server = () => {};
 
@@ -3060,48 +3268,6 @@ var matchesColumn = (columns, columnName) => {
   return columns.some((name) => name.toLowerCase() === lc);
 };
 
-// src/budget.ts
-class BudgetGuard {
-  config;
-  store;
-  constructor(config, store) {
-    this.config = config;
-    this.store = store;
-  }
-  check(cardId) {
-    const card = this.store.getCard(cardId);
-    if (card && card.attempts >= this.config.maxAttemptsPerCard) {
-      return {
-        allow: false,
-        reason: "max_attempts",
-        detail: `${card.attempts} of ${this.config.maxAttemptsPerCard} attempts exhausted`
-      };
-    }
-    return { allow: true };
-  }
-}
-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 = [
-    "**Out of attempts — over to you.**",
-    `Stopped after ${maxAttempts} failed attempt${maxAttempts === 1 ? "" : "s"}. ${wayBackIn}`
-  ];
-  if (failures.length > 0) {
-    lines.push("", "Recent failures:");
-    for (const f of failures) {
-      const when = new Date(f.ts).toISOString().replace("T", " ").slice(0, 16);
-      const tag = f.reason ? ` [${f.reason}]` : "";
-      const branch = f.recoveryBranch ? `
-  recover: \`git fetch && git checkout ${f.recoveryBranch}\`` : "";
-      lines.push(`- ${when} UTC${tag} — ${f.summary}${branch}`);
-    }
-  } else {
-    lines.push("", "_No prior failure summaries recorded._");
-  }
-  return lines.join(`
-`);
-}
-
 // src/budget-pause.ts
 function classifyRunExit(x) {
   if (x.exitCode === 0)
@@ -3257,6 +3423,45 @@ var init_handback = () => {};
 
 // src/queue.ts
 import { log as log8 } from "@gethmy/harness";
+function scoreCardBreakdown(config, card, column, labels, signals = {}) {
+  const w = config.ranking;
+  const priority = w.priorityWeight * (PRIORITY_STEP[card.priority ?? "medium"] ?? PRIORITY_STEP.medium);
+  let label = 0;
+  for (const l of labels) {
+    const boost = config.priorityLabels[l.name.toLowerCase()] ?? 0;
+    if (boost > label)
+      label = boost;
+  }
+  const columnTerm = config.columnBoost ? Math.max(0, 100 - column.position * 10) : 0;
+  const successorCount = Math.min(Math.max(0, signals.successors ?? 0), Math.max(0, w.successorCap));
+  const successors = w.successorWeight * successorCount;
+  const ageDays = daysInColumn(card, signals.now ?? Date.now());
+  const age = w.agePerDayWeight * Math.min(ageDays, Math.max(0, w.ageCapDays));
+  return {
+    total: priority + label + columnTerm + successors + age,
+    priority,
+    label,
+    column: columnTerm,
+    successors,
+    age,
+    ageDays
+  };
+}
+function scoreCard(config, card, column, labels, signals = {}) {
+  return scoreCardBreakdown(config, card, column, labels, signals).total;
+}
+function daysInColumn(card, now) {
+  const enteredAt = card.column_entered_at;
+  if (!enteredAt)
+    return 0;
+  const entered = Date.parse(enteredAt);
+  if (Number.isNaN(entered))
+    return 0;
+  return Math.max(0, Math.floor((now - entered) / MS_PER_DAY));
+}
+function formatBreakdown(b) {
+  return `score=${b.total} ` + `[priority=${b.priority} label=${b.label} column=${b.column} ` + `successors=${b.successors} age=${b.age} (${b.ageDays}d)]`;
+}
 
 class PriorityQueue {
   config;
@@ -3264,25 +3469,17 @@ class PriorityQueue {
   constructor(config) {
     this.config = config;
   }
-  scoreCard(_card, column, labels) {
-    let score = 0;
-    for (const label of labels) {
-      const boost = this.config.priorityLabels[label.name.toLowerCase()] ?? 0;
-      if (boost > score)
-        score = boost;
-    }
-    if (this.config.columnBoost) {
-      score += Math.max(0, 100 - column.position * 10);
-    }
-    return score;
+  scoreCard(card, column, labels, signals = {}) {
+    return scoreCard(this.config, card, column, labels, signals);
   }
-  enqueue(card, column, labels, mode = "implement") {
+  enqueue(card, column, labels, mode = "implement", signals = {}) {
     const existing = this.items.findIndex((i) => i.cardId === card.id);
     if (existing !== -1) {
       log8.debug(TAG8, `Card #${card.short_id} already queued, updating priority`);
       this.items.splice(existing, 1);
     }
-    const priority = this.scoreCard(card, column, labels);
+    const breakdown = scoreCardBreakdown(this.config, card, column, labels, signals);
+    const priority = breakdown.total;
     const item = {
       cardId: card.id,
       shortId: card.short_id,
@@ -3299,7 +3496,7 @@ class PriorityQueue {
       }
     }
     this.items.splice(insertIdx, 0, item);
-    log8.info(TAG8, `Enqueued #${card.short_id} "${card.title}" (priority=${priority}, pos=${insertIdx}, queue=${this.items.length})`);
+    log8.info(TAG8, `Enqueued #${card.short_id} "${card.title}" (${formatBreakdown(breakdown)}, pos=${insertIdx}, queue=${this.items.length})`);
   }
   dequeue() {
     return this.items.shift() ?? null;
@@ -3328,8 +3525,15 @@ class PriorityQueue {
     return this.items.slice();
   }
 }
-var TAG8 = "queue";
-var init_queue = () => {};
+var TAG8 = "queue", MS_PER_DAY = 86400000, PRIORITY_STEP;
+var init_queue = __esm(() => {
+  PRIORITY_STEP = {
+    low: 0,
+    medium: 1,
+    high: 2,
+    urgent: 3
+  };
+});
 
 // src/episode-writer.ts
 import { log as log9 } from "@gethmy/harness";
@@ -5342,6 +5546,9 @@ import {
 import { homedir as homedir3 } from "node:os";
 import { dirname, join as join3 } from "node:path";
 import { log as log16 } from "@gethmy/harness";
+function emptySweep() {
+  return { claimed: 0, totalClaimed: 0, haltReason: null, haltedAt: null };
+}
 function emptyState() {
   return {
     version: SCHEMA_VERSION,
@@ -5350,7 +5557,8 @@ function emptyState() {
     daemonStartedAt: null,
     runs: [],
     cards: [],
-    daily: []
+    daily: [],
+    sweep: emptySweep()
   };
 }
 function todayUtc() {
@@ -5405,7 +5613,8 @@ class StateStore {
           daemonStartedAt: null,
           runs: [],
           cards: parsed.cards ?? [],
-          daily: parsed.daily ?? []
+          daily: parsed.daily ?? [],
+          sweep: parsed.sweep ?? emptySweep()
         };
       }
       return {
@@ -5415,7 +5624,8 @@ class StateStore {
         daemonStartedAt: parsed.daemonStartedAt ?? null,
         runs: parsed.runs ?? [],
         cards: parsed.cards ?? [],
-        daily: parsed.daily ?? []
+        daily: parsed.daily ?? [],
+        sweep: parsed.sweep ?? emptySweep()
       };
     } catch (err) {
       log16.error(TAG14, `failed to read state file: ${err instanceof Error ? err.message : err}`);
@@ -5668,6 +5878,27 @@ class StateStore {
     this.state.daily = this.state.daily.filter((d) => d.date >= cutoff);
     await this.persist();
   }
+  getSweep() {
+    return { ...this.state.sweep };
+  }
+  async recordSweepClaim() {
+    this.state.sweep.claimed += 1;
+    this.state.sweep.totalClaimed += 1;
+    await this.persist();
+  }
+  async haltSweep(reason) {
+    if (this.state.sweep.haltReason === reason)
+      return;
+    this.state.sweep.haltReason = reason;
+    this.state.sweep.haltedAt = Date.now();
+    await this.persist();
+  }
+  async resumeSweep() {
+    this.state.sweep.claimed = 0;
+    this.state.sweep.haltReason = null;
+    this.state.sweep.haltedAt = null;
+    await this.persist();
+  }
   getDailyCostCents(date) {
     const key = date ?? todayUtc();
     return this.state.daily.find((d) => d.date === key)?.costCents ?? 0;
@@ -6074,6 +6305,14 @@ class ReviewWorker {
       numTurns: cost.numTurns
     };
   }
+  async chargeDailyLedger(cardId) {
+    const { costCents } = this.endLedger();
+    if (costCents <= 0)
+      return;
+    try {
+      await this.stateStore.addCost(cardId, costCents);
+    } catch {}
+  }
   async run(card, column, labels, subtasks) {
     this.aborted = false;
     this.timedOut = false;
@@ -6370,6 +6609,10 @@ ${userPrompt}`;
             const status = this.timedOut ? "failed" : this.state === "error" || this.aborted || this.sessionConflict ? "paused" : "completed";
             await this.stateStore.endRun(this.runId, status, this.sessionConflict ? { errorMessage: "session_conflict", ...this.endLedger() } : this.endLedger());
           }
+          const settled = this.stateStore.getRun(this.runId);
+          if (this.cardId && settled && settled.endedAt !== null) {
+            await this.chargeDailyLedger(this.cardId);
+          }
         } catch {}
       }
       if (this.cardId && this.timedOut && this.config.budget.pause.enabled && this.state !== "parked" && this.state !== "error") {
@@ -6817,20 +7060,21 @@ function isBlockerResolved(blocker, columns) {
   const blockerColumn = columns.find((c) => c.id === blocker.column_id);
   return blockerColumn?.mark_cards_done === true;
 }
-async function getUnresolvedBlockers(client, card, projectId) {
+async function getChainSignals(client, card, projectId, knownColumns) {
   const links = await fetchBlocksLinks(client, card.id);
   if (!links)
-    return null;
+    return { blockers: null, successors: 0 };
+  const successors = links.filter((l) => l.direction === "outgoing" && !l.target_card.done).length;
   const incoming = links.filter((l) => l.direction === "incoming");
   if (incoming.length === 0)
-    return [];
-  const board = await client.getBoard(projectId, { summary: true });
-  const columns = board.columns ?? [];
-  return incoming.filter((l) => !isBlockerResolved(l.target_card, columns)).map((l) => ({
+    return { blockers: [], successors };
+  const columns = knownColumns ?? ((await client.getBoard(projectId, { summary: true })).columns ?? []);
+  const blockers = incoming.filter((l) => !isBlockerResolved(l.target_card, columns)).map((l) => ({
     cardId: l.target_card.id,
     shortId: l.target_card.short_id,
     title: l.target_card.title
   }));
+  return { blockers, successors };
 }
 async function promoteUnblockedSuccessors(completedCard, deps) {
   const links = await fetchBlocksLinks(deps.client, completedCard.id);
@@ -7659,13 +7903,21 @@ async function advanceConvergeLoop(card, stage, stageIndex, def, evaluation, loo
     log24.info(TAG22, `#${card.short_id} LoopExhausted: ${reason}`);
     return { kind: "held_gate_unmet", reason };
   }
+  const guard = await guardStageReclaim(card, `converge-loop iteration of "${stage.name}"`, deps);
+  if (!guard.proceed) {
+    return {
+      kind: "reclaim_refused",
+      reason: guard.reason,
+      released: guard.released
+    };
+  }
   await deps.stateStore.decrementAttempt(card.id).catch(() => {});
   await writeIterationHandoff(card, stage, iteration, maxIterations, evaluation, deps);
   const toColumn = await resolveStageColumnName(deps.client, card, stage) ?? deps.fallbackColumn;
   try {
     await deps.client.addComment(card.id, `Converge loop — ${summary}. Re-running "${stage.name}".`, { commentType: "progress" });
   } catch {}
-  await runTransition(deps.client, card, {
+  await runTransition(deps.client, guard.card, {
     move: { columnName: toColumn },
     addLabels: [{ name: AGENT_LABEL }],
     ...isAgentRunnableOwner(stage.owner) ? { assignAgent: deps.agentId } : {}
@@ -7781,11 +8033,19 @@ async function handleGateUnmet(card, stage, summary, deps) {
     log24.info(TAG22, `#${card.short_id} GateUnmetExhausted: ${reason}`);
     return { kind: "held_gate_unmet", reason };
   }
+  const guard = await guardStageReclaim(card, `gate-unmet re-run of "${stage.name}"`, deps);
+  if (!guard.proceed) {
+    return {
+      kind: "reclaim_refused",
+      reason: guard.reason,
+      released: guard.released
+    };
+  }
   const toColumn = await resolveStageColumnName(deps.client, card, stage) ?? deps.fallbackColumn;
   try {
     await deps.client.addComment(card.id, `Stage gate unmet — re-running "${stage.name}". ${summary}.`, { commentType: "progress" });
   } catch {}
-  await runTransition(deps.client, card, {
+  await runTransition(deps.client, guard.card, {
     move: { columnName: toColumn },
     addLabels: [{ name: AGENT_LABEL }],
     ...isAgentRunnableOwner(stage.owner) ? { assignAgent: deps.agentId } : {}
@@ -7793,6 +8053,38 @@ async function handleGateUnmet(card, stage, summary, deps) {
   log24.info(TAG22, `#${card.short_id} gate unmet for "${stage.name}" — requeued to "${toColumn}" for re-run (attempt ${attempts}/${deps.maxAttempts})`);
   return { kind: "requeued_gate_unmet", toColumn };
 }
+async function guardStageReclaim(card, what, deps) {
+  const { verdict, card: fresh } = await guardedHandback(deps.client, card.id, {
+    agentId: deps.closeoutReleasesAssignment ? null : deps.agentId,
+    workingColumnId: null
+  });
+  const foreign = fresh?.assigned_agent_id && fresh.assigned_agent_id !== deps.agentId ? fresh.assigned_agent_id : null;
+  if (verdict.proceed && !foreign) {
+    return { proceed: true, card: fresh ?? card };
+  }
+  const [reason, detail] = verdict.proceed ? [
+    "reassigned",
+    `the card is assigned to agent ${foreign}, not ${deps.agentId}`
+  ] : [verdict.reason, verdict.detail];
+  const stillOurs = !!fresh && !fresh.archived_at && !foreign && fresh.assigned_agent_id === deps.agentId;
+  let released = false;
+  if (fresh && !fresh.archived_at && !foreign) {
+    try {
+      await runTransition(deps.client, fresh, {
+        removeLabels: [AGENT_LABEL],
+        ...stillOurs ? { assignAgent: null } : {}
+      }, { store: deps.stateStore, runId: deps.runId });
+      released = stillOurs;
+    } catch (err) {
+      log24.warn(TAG22, `#${card.short_id} could not hand the card over after refusing the ${what}: ${err instanceof Error ? err.message : err}${stillOurs ? " — the claim is still ours, so the next reconcile tick may re-pick the card" : ""}`);
+    }
+  }
+  log24.info(TAG22, `#${card.short_id} ${what} refused — ${detail} (${reason})${released ? "; released the daemon's claim so the stage router stops here" : ""}`);
+  try {
+    await deps.client.addComment(card.id, `Stopped the ${what} — ${detail}. The card is not the daemon's to reclaim, so this stage will not re-run until it is assigned back.`, { commentType: "decision" });
+  } catch {}
+  return { proceed: false, reason, released };
+}
 async function holdForHuman(client, card, reason, runId, stateStore, opts = {}) {
   if (!opts.keepAttempts) {
     await stateStore.decrementAttempt(card.id).catch(() => {});
@@ -7820,6 +8112,7 @@ async function holdForHuman(client, card, reason, runId, stateStore, opts = {})
 var TAG22 = "stage-advance", AGENT_LABEL = "agent";
 var init_stage_advance = __esm(() => {
   init_dist();
+  init_handback();
   init_transitions();
 });
 
@@ -8279,6 +8572,10 @@ class Worker {
           case "held_misconfigured":
             this.held = true;
             break;
+          case "reclaim_refused":
+            this.held = true;
+            log25.info(this.tag, `#${card.short_id} stage reclaim refused (${outcome.reason})${outcome.released ? " — released the daemon's claim" : ""}`);
+            break;
           case "advanced":
           case "completed_terminal":
           case "no_advance":
@@ -8942,6 +9239,10 @@ class Worker {
       case "held_misconfigured":
         this.held = true;
         break;
+      case "reclaim_refused":
+        this.held = true;
+        log25.info(this.tag, `#${card.short_id} stage reclaim refused (${outcome.reason})${outcome.released ? " — released the daemon's claim" : ""}`);
+        break;
       case "advanced":
       case "completed_terminal":
       case "no_advance":
@@ -9112,6 +9413,7 @@ ${prompt}`;
         client: this.client,
         stateStore: this.stateStore,
         agentId: this.identity.agentId,
+        closeoutReleasesAssignment: !!this.config.completion.moveToColumn,
         maxAttempts: this.config.budget.maxAttemptsPerCard,
         fallbackColumn: this.config.pickupColumns[0] ?? "To Do",
         sink: this.cliRunner,
@@ -9909,6 +10211,7 @@ class Pool {
       return;
     }
     this.reservations.add(card.id);
+    let chainSuccessors = 0;
     try {
       if (mode === "implement") {
         if (this.authPaused) {
@@ -9925,14 +10228,14 @@ class Pool {
         const decision = this.budget.check(card.id);
         if (!decision.allow) {
           if (decision.reason === "daily_budget") {
-            log26.warn(TAG24, `#${card.short_id} skipped (daily_budget): ${decision.detail}`);
-            await this.emitWaiting(card.id, `Daily budget reached — waiting for reset (${decision.detail})`);
+            await this.denyDailyBudget(card, decision.detail);
           } else {
             log26.debug(TAG24, `#${card.short_id} gave up: ${decision.detail}`);
           }
           return;
         }
-        const blockers = await getUnresolvedBlockers(this.client, card, this.projectId);
+        const { blockers, successors } = await getChainSignals(this.client, card, this.projectId);
+        chainSuccessors = successors;
         if (blockers === null) {
           log26.warn(TAG24, `#${card.short_id} blocker check failed — deferring to next tick`);
           return;
@@ -9943,9 +10246,18 @@ class Pool {
           await this.emitWaiting(card.id, `Blocked by ${list} — waiting for chain`);
           return;
         }
+      } else {
+        const decision = this.budget.checkDailyBudget();
+        if (!decision.allow) {
+          await this.denyDailyBudget(card, decision.detail);
+          return;
+        }
       }
       const queue = mode === "review" ? this.reviewQueue : this.implQueue;
-      queue.enqueue(card, column, labels, mode);
+      queue.enqueue(card, column, labels, mode, {
+        successors: chainSuccessors,
+        now: Date.now()
+      });
       this.cardDataCache.set(card.id, { card, column, labels, subtasks, mode });
       const workers = mode === "review" ? this.reviewWorkers : this.implWorkers;
       const dispatched = this.tryDispatchFor(workers, queue, mode);
@@ -9958,6 +10270,15 @@ class Pool {
       this.reservations.delete(card.id);
     }
   }
+  async denyDailyBudget(card, detail) {
+    const reason = `Daily budget reached — waiting for reset (${detail})`;
+    const line = `#${card.short_id} skipped (daily_budget): ${detail}`;
+    if (this.lastWaitingEmit.get(card.id) === reason)
+      log26.debug(TAG24, line);
+    else
+      log26.warn(TAG24, line);
+    await this.emitWaiting(card.id, reason);
+  }
   lastWaitingEmit = new Map;
   async emitWaiting(cardId, currentTask) {
     if (this.lastWaitingEmit.get(cardId) === currentTask)
@@ -10020,6 +10341,24 @@ class Pool {
   isCardActive(cardId) {
     return hasParkedRun(this.stateStore, cardId) || this.implWorkers.some((w) => w.cardId === cardId && w.isActive) || this.reviewWorkers.some((w) => w.cardId === cardId && w.isActive);
   }
+  hasFreeImplementSlot() {
+    if (this.shuttingDown || this.authPaused)
+      return false;
+    if (this.apiCooldownRemainingMs() > 0)
+      return false;
+    if (this.implQueue.length > 0 || this.reservations.size > 0)
+      return false;
+    return this.implWorkers.some((w) => w.isIdle);
+  }
+  checkBudget(cardId) {
+    return this.budget.check(cardId);
+  }
+  scoreCard(card, column, labels, signals = {}) {
+    return this.implQueue.scoreCard(card, column, labels, signals);
+  }
+  scoreCardBreakdown(card, column, labels, signals = {}) {
+    return scoreCardBreakdown(this.config, card, column, labels, signals);
+  }
   isCardKnown(cardId) {
     return this.implQueue.has(cardId) || this.reviewQueue.has(cardId) || this.isCardActive(cardId);
   }
@@ -10630,9 +10969,9 @@ var init_recovery = __esm(() => {
 
 // src/claim.ts
 import { log as log29 } from "@gethmy/harness";
-async function claimReviewCard(client, cardId, agentId) {
+async function claimUnassignedCard(client, cardId, agentId, opts) {
   try {
-    const { claimed } = await client.claimCard(cardId, agentId);
+    const { claimed } = opts ? await client.claimCard(cardId, agentId, opts) : await client.claimCard(cardId, agentId);
     log29.debug(TAG27, `claim ${cardId} → ${claimed ? "won" : "lost"}`);
     return claimed;
   } catch (err) {
@@ -10673,7 +11012,7 @@ async function reclaimPreReviewStrands(opts) {
   for (const card of cards) {
     if (checked >= maxPerSweep)
       break;
-    if (card.archived_at || !reviewColIds.has(card.column_id) || card.assigned_agent_id != null || card.assignee_id != null || knownCardIds.has(card.id)) {
+    if (card.archived_at || card.done || !reviewColIds.has(card.column_id) || card.assigned_agent_id != null || card.assignee_id != null || knownCardIds.has(card.id)) {
       continue;
     }
     const branch = extractBranchFromDescription(card.description);
@@ -10690,7 +11029,7 @@ async function reclaimPreReviewStrands(opts) {
     const prUrl = resolvePrUrl2(card.description ?? null, branch, cwd, provider);
     if (prUrl)
       continue;
-    const won = await claimReviewCard(client, card.id, agentId);
+    const won = await claimUnassignedCard(client, card.id, agentId);
     if (!won) {
       log30.debug(TAG28, `#${card.short_id} — lost the review claim race, skipping`);
       continue;
@@ -10715,8 +11054,246 @@ var init_strand_recovery = __esm(() => {
   init_types2();
 });
 
+// src/sweep.ts
+import { log as log31 } from "@gethmy/harness";
+function rankSweepCandidates(opts) {
+  const {
+    agentId,
+    cards,
+    columns,
+    labelMap,
+    pickupConfig,
+    approvedLabel,
+    requireLabel,
+    trustedAuthors,
+    knownCardIds,
+    budgetCheck,
+    score
+  } = opts;
+  const now = opts.now ?? Date.now();
+  const columnMap = new Map(columns.map((c) => [c.id, c]));
+  const candidates = [];
+  const skipped = [];
+  const skip = (card, reason, detail) => skipped.push({ cardId: card.id, shortId: card.short_id, reason, detail });
+  for (const card of cards) {
+    if (card.archived_at)
+      continue;
+    const column = columnMap.get(card.column_id);
+    if (!column)
+      continue;
+    if (!matchesColumn(pickupConfig.pickupColumns, column.name))
+      continue;
+    const route = classifyPickup(card, column.name, pickupConfig);
+    if (!route || route.mode !== "implement")
+      continue;
+    if (card.done) {
+      skip(card, "done", "card is marked done");
+      continue;
+    }
+    if (card.assignee_id != null) {
+      skip(card, "human_assignee", "a human is assigned");
+      continue;
+    }
+    if (card.created_by == null || !trustedAuthors.has(card.created_by)) {
+      skip(card, "untrusted_author", card.created_by == null ? "card has no recorded author" : `author ${card.created_by} is not in sweep.trustedAuthors`);
+      continue;
+    }
+    if (card.assigned_agent_id != null) {
+      skip(card, "already_owned", card.assigned_agent_id === agentId ? "already assigned to this agent" : "assigned to another agent");
+      continue;
+    }
+    if (knownCardIds.has(card.id)) {
+      skip(card, "known_to_pool", "already queued or active in this pool");
+      continue;
+    }
+    const labels = resolveCardLabels(card, labelMap);
+    if (requireLabel && !hasLabel(labels, requireLabel)) {
+      skip(card, "require_label", `lacks required label "${requireLabel}"`);
+      continue;
+    }
+    if (hasLabel(labels, NEED_REVIEW_LABEL)) {
+      skip(card, "need_review_label", `has "${NEED_REVIEW_LABEL}"`);
+      continue;
+    }
+    if (approvedLabel && hasLabel(labels, approvedLabel)) {
+      skip(card, "approved_label", `has "${approvedLabel}"`);
+      continue;
+    }
+    const decision = budgetCheck(card.id);
+    if (!decision.allow) {
+      skip(card, "budget", `${decision.reason}: ${decision.detail}`);
+      continue;
+    }
+    const breakdown = score(card, column, labels, {
+      successors: opts.successorCounts?.get(card.id) ?? 0,
+      now
+    });
+    candidates.push({
+      card,
+      column,
+      labels,
+      score: breakdown.total,
+      breakdown
+    });
+  }
+  candidates.sort((a, b) => {
+    if (b.score !== a.score)
+      return b.score - a.score;
+    const pinned = Number(b.card.pinned === true) - Number(a.card.pinned === true);
+    if (pinned !== 0)
+      return pinned;
+    if (a.card.position !== b.card.position) {
+      return a.card.position - b.card.position;
+    }
+    return a.card.short_id - b.card.short_id;
+  });
+  return { candidates, skipped };
+}
+async function sweepForCard(opts) {
+  const { client, projectId, agentId, maxProbes } = opts;
+  const chain2 = new Map;
+  let { candidates, skipped } = rankSweepCandidates(opts);
+  if (candidates.length === 0) {
+    log31.debug(TAG29, `no claimable card (${skipped.length} skipped in a pickup column)`);
+    return { claimed: null, skipped, probed: 0 };
+  }
+  const probeWindow = candidates.slice(0, maxProbes);
+  const successorTermCounts = opts.ranking.successorWeight !== 0 && opts.ranking.successorCap !== 0;
+  if (successorTermCounts && probeWindow.length > 1) {
+    for (const c of probeWindow) {
+      chain2.set(c.card.id, await getChainSignals(client, c.card, projectId, opts.columns));
+    }
+    ({ candidates, skipped } = rankSweepCandidates({
+      ...opts,
+      successorCounts: successorCounts(chain2)
+    }));
+  } else if (successorTermCounts && candidates.length > 1) {
+    log31.debug(TAG29, `blocker depth not ranked — maxProbesPerTick=${maxProbes} leaves nothing to reorder among ${candidates.length} candidates`);
+  }
+  let probed = 0;
+  for (const candidate of candidates) {
+    if (probed >= maxProbes) {
+      log31.debug(TAG29, `probe budget ${maxProbes} spent — ${candidates.length - probed} candidate(s) deferred to the next tick`);
+      break;
+    }
+    probed++;
+    const { card } = candidate;
+    if (await hasLiveSession(client, card.id)) {
+      skipped.push({
+        cardId: card.id,
+        shortId: card.short_id,
+        reason: "live_session",
+        detail: "a live agent session already holds this card"
+      });
+      continue;
+    }
+    let signals = chain2.get(card.id);
+    if (!signals) {
+      signals = await getChainSignals(client, card, projectId, opts.columns);
+      chain2.set(card.id, signals);
+    }
+    const { blockers } = signals;
+    if (blockers === null) {
+      skipped.push({
+        cardId: card.id,
+        shortId: card.short_id,
+        reason: "blockers_unknown",
+        detail: "blocker lookup failed — deferring to the next tick"
+      });
+      continue;
+    }
+    if (blockers.length > 0) {
+      skipped.push({
+        cardId: card.id,
+        shortId: card.short_id,
+        reason: "blocked",
+        detail: `blocked by ${blockers.map((b) => `#${b.shortId}`).join(", ")}`
+      });
+      continue;
+    }
+    const fresh = await refetchCard(client, card.id);
+    if (!fresh) {
+      skipped.push({
+        cardId: card.id,
+        shortId: card.short_id,
+        reason: "recheck_failed",
+        detail: "card re-read failed — deferring to the next tick"
+      });
+      continue;
+    }
+    const recheck = rankSweepCandidates({
+      ...opts,
+      cards: [fresh],
+      successorCounts: successorCounts(chain2)
+    });
+    const verified = recheck.candidates[0];
+    if (!verified) {
+      const reason = recheck.skipped[0];
+      skipped.push({
+        cardId: card.id,
+        shortId: card.short_id,
+        reason: reason?.reason ?? "recheck_out_of_scope",
+        detail: reason ? `changed since the board read — ${reason.detail}` : "no longer in a pickup column"
+      });
+      continue;
+    }
+    const won = await claimUnassignedCard(client, card.id, agentId, {
+      requireUnassigned: true
+    });
+    if (!won) {
+      skipped.push({
+        cardId: card.id,
+        shortId: card.short_id,
+        reason: "claim_lost",
+        detail: "another daemon or a person claimed it first"
+      });
+      continue;
+    }
+    verified.card.assigned_agent_id = agentId;
+    log31.info(TAG29, claimLine(verified, probed, candidates, skipped));
+    return { claimed: verified, skipped, probed };
+  }
+  log31.debug(TAG29, `claimed nothing this sweep (${probed} probed, ${skipped.length} skipped)`);
+  return { claimed: null, skipped, probed };
+}
+function claimLine(claimed, rank, candidates, skipped) {
+  const below = candidates[rank];
+  const versus = candidates.length === 1 ? "the only candidate" : below ? `ahead of #${below.card.short_id} (score=${below.score})` : "last in the ranking";
+  const passedOver = rank > 1 ? `, ${rank - 1} higher-ranked passed over` : "";
+  return `claimed #${claimed.card.short_id} "${claimed.card.title}" ` + `in "${claimed.column.name}" — ${formatBreakdown(claimed.breakdown)}, ` + `rank ${rank} of ${candidates.length}${passedOver}, ${versus}; ` + `${skipped.length} skipped`;
+}
+function successorCounts(chain2) {
+  return new Map([...chain2].map(([id, signals]) => [id, signals.successors]));
+}
+async function refetchCard(client, cardId) {
+  try {
+    const { card } = await client.getCard(cardId);
+    return card ?? null;
+  } catch (err) {
+    log31.warn(TAG29, `re-read failed for ${cardId}: ${err instanceof Error ? err.message : err}`);
+    return null;
+  }
+}
+async function hasLiveSession(client, cardId) {
+  try {
+    const { session } = await client.getAgentSession(cardId);
+    return session != null;
+  } catch (err) {
+    log31.warn(TAG29, `session lookup failed for ${cardId} — treating as busy: ${err instanceof Error ? err.message : err}`);
+    return true;
+  }
+}
+var TAG29 = "sweep";
+var init_sweep = __esm(() => {
+  init_board_helpers();
+  init_claim();
+  init_queue();
+  init_types2();
+  init_unblock();
+});
+
 // src/reconcile.ts
-import { detectGitProvider as detectGitProvider5, log as log31 } from "@gethmy/harness";
+import { detectGitProvider as detectGitProvider5, log as log32 } from "@gethmy/harness";
 
 class Reconciler {
   client;
@@ -10729,16 +11306,19 @@ class Reconciler {
   intervalMs;
   stateStore;
   agentConfig;
+  agentUserId;
+  sweepGuard;
   timer = null;
   lastTickAt = null;
   gitProvider = null;
+  lastSweepStopReported = null;
   get lastTick() {
     return this.lastTickAt;
   }
   get isRunning() {
     return this.timer !== null;
   }
-  constructor(client, pool, projectId, agentId, pickupColumns, reviewColumns, approvedLabel, intervalMs = 60000, stateStore, agentConfig) {
+  constructor(client, pool, projectId, agentId, pickupColumns, reviewColumns, approvedLabel, intervalMs = 60000, stateStore, agentConfig, agentUserId, sweepGuard) {
     this.client = client;
     this.pool = pool;
     this.projectId = projectId;
@@ -10749,6 +11329,8 @@ class Reconciler {
     this.intervalMs = intervalMs;
     this.stateStore = stateStore;
     this.agentConfig = agentConfig;
+    this.agentUserId = agentUserId;
+    this.sweepGuard = sweepGuard;
   }
   start() {
     this.tick();
@@ -10759,7 +11341,7 @@ class Reconciler {
       clearInterval(this.timer);
       this.timer = null;
     }
-    log31.info(TAG29, "Heartbeat stopped");
+    log32.info(TAG30, "Heartbeat stopped");
   }
   async recoverStaleRuns() {
     if (!this.stateStore || !this.agentConfig)
@@ -10770,7 +11352,7 @@ class Reconciler {
     const pool = this.pool;
     for (const run of active) {
       if (isBudgetHeldRun(run)) {
-        log31.info(TAG29, `run ${run.runId} (#${run.cardShortId}) is held for a human budget decision — leaving it`);
+        log32.info(TAG30, `run ${run.runId} (#${run.cardShortId}) is held for a human budget decision — leaving it`);
         continue;
       }
       const foreignDaemon = run.daemonPid !== process.pid;
@@ -10780,7 +11362,7 @@ class Reconciler {
       if (!daemonDead && !(heartbeatStale && ourZombie))
         continue;
       const reason = daemonDead ? `foreign daemon ${run.daemonPid} is dead` : `our worker lost card ${run.cardId} with ${Math.round((now - run.lastHeartbeatAt) / 1000)}s stale heartbeat`;
-      log31.warn(TAG29, `zombie run ${run.runId} (#${run.cardShortId}): ${reason} — recovering`);
+      log32.warn(TAG30, `zombie run ${run.runId} (#${run.cardShortId}): ${reason} — recovering`);
       await recoverRun(run, this.stateStore, this.client, this.agentConfig, {
         runId: run.runId,
         cardId: run.cardId,
@@ -10807,11 +11389,11 @@ class Reconciler {
       const stalledAt = Date.parse(card.updated_at ?? "");
       if (!Number.isFinite(stalledAt) || now - stalledAt < graceMs)
         continue;
-      log31.warn(TAG29, `#${card.short_id} stranded in "${inProgressCol.name}" (no live run) — requeueing to "${pickupCol.name}"`);
+      log32.warn(TAG30, `#${card.short_id} stranded in "${inProgressCol.name}" (no live run) — requeueing to "${pickupCol.name}"`);
       try {
         await this.client.moveCard(card.id, pickupCol.id);
       } catch (err) {
-        log31.error(TAG29, `stranded requeue failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log32.error(TAG30, `stranded requeue failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -10843,7 +11425,7 @@ class Reconciler {
           return;
         const cardLabels = resolveCardLabels(card, labelMap);
         const subtasks = card.subtasks ?? [];
-        log31.info(TAG29, `Enqueuing claimed review card #${card.short_id} (agent-agnostic pickup)`);
+        log32.info(TAG30, `Enqueuing claimed review card #${card.short_id} (agent-agnostic pickup)`);
         await this.pool.enqueue(card, column, cardLabels, subtasks, "review");
       }
     });
@@ -10867,14 +11449,63 @@ class Reconciler {
       const parkedAt = Date.parse(card.updated_at ?? "");
       if (!Number.isFinite(parkedAt) || now - parkedAt < ttlMs)
         continue;
-      log31.warn(TAG29, `#${card.short_id} parked for approval > ${planning.approvalTtlHours}h — auto-releasing to "${pickupCol.name}"`);
+      log32.warn(TAG30, `#${card.short_id} parked for approval > ${planning.approvalTtlHours}h — auto-releasing to "${pickupCol.name}"`);
       try {
         await this.client.moveCard(card.id, pickupCol.id);
       } catch (err) {
-        log31.error(TAG29, `auto-release failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
+        log32.error(TAG30, `auto-release failed for #${card.short_id}: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
+  async sweepForWork(cards, columns, labelMap, pickupConfig) {
+    const sweep = this.agentConfig?.sweep;
+    if (!sweep?.enabled)
+      return;
+    const trustedAuthors = new Set(this.agentUserId ? [...sweep.trustedAuthors, this.agentUserId] : sweep.trustedAuthors);
+    const rankOpts = {
+      agentId: this.agentId,
+      cards,
+      columns,
+      labelMap,
+      pickupConfig,
+      approvedLabel: this.approvedLabel,
+      requireLabel: sweep.requireLabel,
+      trustedAuthors,
+      knownCardIds: this.pool.knownCardIds(),
+      budgetCheck: (cardId) => this.pool.checkBudget(cardId),
+      score: (card, column, labels, signals) => this.pool.scoreCardBreakdown(card, column, labels, signals),
+      now: Date.now()
+    };
+    const verdict = this.sweepGuard?.check() ?? { claiming: true };
+    if (!verdict.claiming) {
+      this.reportSweepStopped(verdict.reason, verdict.detail);
+      return;
+    }
+    this.lastSweepStopReported = null;
+    if (!this.pool.hasFreeImplementSlot()) {
+      log32.debug(TAG30, "sweep skipped — no free implement slot");
+      return;
+    }
+    const { claimed } = await sweepForCard({
+      ...rankOpts,
+      client: this.client,
+      projectId: this.projectId,
+      maxProbes: sweep.maxProbesPerTick,
+      ranking: this.agentConfig?.ranking ?? DEFAULT_AGENT_CONFIG.ranking
+    });
+    if (!claimed)
+      return;
+    await this.sweepGuard?.recordClaim();
+    await this.pool.enqueue(claimed.card, claimed.column, claimed.labels, claimed.card.subtasks ?? [], "implement");
+  }
+  reportSweepStopped(reason, detail) {
+    const line = `sweep stopped claiming — ${detail}`;
+    if (this.lastSweepStopReported === reason)
+      log32.debug(TAG30, line);
+    else
+      log32.warn(TAG30, line);
+    this.lastSweepStopReported = reason;
+  }
   async tick() {
     this.lastTickAt = Date.now();
     try {
@@ -10915,21 +11546,21 @@ class Reconciler {
           const subtasks = card.subtasks ?? [];
           const mode = route.mode;
           if (route.stage) {
-            log31.info(TAG29, `Stage card #${card.short_id} (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement) regardless of column`);
+            log32.info(TAG30, `Stage card #${card.short_id} (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement) regardless of column`);
           }
           if (mode === "review" && this.approvedLabel && hasLabel(cardLabels, this.approvedLabel)) {
-            log31.debug(TAG29, `Skipping #${card.short_id} — already has "${this.approvedLabel}" label`);
+            log32.debug(TAG30, `Skipping #${card.short_id} — already has "${this.approvedLabel}" label`);
             continue;
           }
           if (mode === "review" && hasLabel(cardLabels, NEED_REVIEW_LABEL)) {
-            log31.debug(TAG29, `Skipping #${card.short_id} — has "${NEED_REVIEW_LABEL}" label (needs human)`);
+            log32.debug(TAG30, `Skipping #${card.short_id} — has "${NEED_REVIEW_LABEL}" label (needs human)`);
             continue;
           }
           if (mode === "review" && !qualifiesForAutoReview(card.description)) {
-            log31.debug(TAG29, `Skipping #${card.short_id} — no branch or PR reference (not qualified for auto-review)`);
+            log32.debug(TAG30, `Skipping #${card.short_id} — no branch or PR reference (not qualified for auto-review)`);
             continue;
           }
-          log31.info(TAG29, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — enqueueing`);
+          log32.info(TAG30, `Missed assignment: #${card.short_id} "${card.title}" (${mode}) — enqueueing`);
           await this.pool.enqueue(card, column, cardLabels, subtasks, mode);
         }
       }
@@ -10939,30 +11570,36 @@ class Reconciler {
       try {
         await this.pool.drainBudgetDecisions();
       } catch (err) {
-        log31.error(TAG29, `budget decisions were not drained this tick: ${err instanceof Error ? err.message : err}`);
+        log32.error(TAG30, `budget decisions were not drained this tick: ${err instanceof Error ? err.message : err}`);
       }
       await this.recoverStrandedInProgress(cards, columns, knownCardIds);
       await this.recoverStrandedReview(cards, columns, labelMap, knownCardIds);
       for (const knownId of knownCardIds) {
         if (!allAgentCardIds.has(knownId)) {
-          log31.info(TAG29, `Missed unassign: ${knownId} — removing`);
+          log32.info(TAG30, `Missed unassign: ${knownId} — removing`);
           await this.pool.removeCard(knownId);
         }
       }
       await this.releaseStalledApprovals(cards, columns, knownCardIds);
-      log31.debug(TAG29, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
+      try {
+        await this.sweepForWork(cards, columns, labelMap, pickupConfig);
+      } catch (err) {
+        log32.error(TAG30, `sweep failed this tick: ${err instanceof Error ? err.message : err}`);
+      }
+      log32.debug(TAG30, `Reconciled: ${assignedCards.length} assigned, ${knownCardIds.size} known`);
     } catch (err) {
-      log31.error(TAG29, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
+      log32.error(TAG30, `Heartbeat failed: ${err instanceof Error ? err.message : err}`);
     }
   }
 }
-var TAG29 = "reconcile";
+var TAG30 = "reconcile";
 var init_reconcile = __esm(() => {
   init_board_helpers();
   init_recovery();
   init_review_worktree();
   init_state_store();
   init_strand_recovery();
+  init_sweep();
   init_types2();
 });
 
@@ -10971,7 +11608,7 @@ var exports_startup_banner = {};
 __export(exports_startup_banner, {
   createStartupBanner: () => createStartupBanner
 });
-import { isPretty, log as log32 } from "@gethmy/harness";
+import { isPretty, log as log33 } from "@gethmy/harness";
 function createStartupBanner(config, version) {
   return isPretty() ? prettyBanner(config, version) : jsonBanner(config, version);
 }
@@ -10996,7 +11633,7 @@ function prettyBanner(config, version) {
       checks.push({ kind: "ok", message });
     },
     warn(message) {
-      log32.warn(TAG30, message);
+      log33.warn(TAG31, message);
       checks.push({ kind: "warn", message: message.split(`
 `, 1)[0] });
     },
@@ -11021,25 +11658,25 @@ function prettyBanner(config, version) {
   };
 }
 function jsonBanner(config, version) {
-  log32.info(TAG30, `Harmony Agent Daemon v${version} starting...`);
-  log32.info(TAG30, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Model: ${config.agent.claude.model} | Runner: ${config.agent.runner} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
+  log33.info(TAG31, `Harmony Agent Daemon v${version} starting...`);
+  log33.info(TAG31, `Project: ${config.projectId} | Pool: ${config.agent.poolSize} | Model: ${config.agent.claude.model} | Runner: ${config.agent.runner} | Pickup: ${config.agent.pickupColumns.join(", ")}`);
   if (config.agent.review.enabled) {
-    log32.info(TAG30, `Review: enabled | Columns: ${config.agent.review.pickupColumns.join(", ")} | → ${config.agent.review.moveToColumn} / ${config.agent.review.failColumn}`);
+    log33.info(TAG31, `Review: enabled | Columns: ${config.agent.review.pickupColumns.join(", ")} | → ${config.agent.review.moveToColumn} / ${config.agent.review.failColumn}`);
   }
   let failed = false;
   return {
     setProjectName(_name) {},
     setGitProvider(provider) {
-      log32.info(TAG30, `Git provider: ${provider}`);
+      log33.info(TAG31, `Git provider: ${provider}`);
     },
     setHttpPort(port) {
-      log32.info(TAG30, `HTTP server on port ${port}`);
+      log33.info(TAG31, `HTTP server on port ${port}`);
     },
     check(message) {
-      log32.info(TAG30, message);
+      log33.info(TAG31, message);
     },
     warn(message) {
-      log32.warn(TAG30, message);
+      log33.warn(TAG31, message);
     },
     fail() {
       failed = true;
@@ -11047,7 +11684,7 @@ function jsonBanner(config, version) {
     async ready(message) {
       if (failed)
         return;
-      log32.info(TAG30, message);
+      log33.info(TAG31, message);
     }
   };
 }
@@ -11128,7 +11765,7 @@ function cyan(s) {
 function yellow(s) {
   return `${ANSI.yellow}${s}${ANSI.reset}`;
 }
-var TAG30 = "daemon", RULE_WIDTH = 70, ANSI;
+var TAG31 = "daemon", RULE_WIDTH = 70, ANSI;
 var init_startup_banner = __esm(() => {
   ANSI = {
     reset: "\x1B[0m",
@@ -11229,9 +11866,118 @@ var init_stream_parser_selftest = __esm(() => {
   init_stream_parser();
 });
 
+// src/sweep-guard.ts
+import { log as log34 } from "@gethmy/harness";
+
+class SweepGuard {
+  config;
+  store;
+  checkDailyBudget;
+  constructor(config, store, checkDailyBudget) {
+    this.config = config;
+    this.store = store;
+    this.checkDailyBudget = checkDailyBudget;
+  }
+  check() {
+    const sweep = this.store.getSweep();
+    if (sweep.haltReason) {
+      return {
+        claiming: false,
+        reason: sweep.haltReason,
+        detail: this.describeStop(sweep.haltReason),
+        latched: true
+      };
+    }
+    const cap = this.config.maxCardsPerSweep;
+    if (cap >= 0 && sweep.claimed >= cap) {
+      return {
+        claiming: false,
+        reason: "card_cap",
+        detail: this.describeStop("card_cap"),
+        latched: true
+      };
+    }
+    const daily = this.checkDailyBudget?.();
+    if (daily && !daily.allow) {
+      return {
+        claiming: false,
+        latched: false,
+        reason: "daily_budget",
+        detail: this.describeStop("daily_budget", daily.detail)
+      };
+    }
+    return { claiming: true };
+  }
+  async recordClaim() {
+    await this.store.recordSweepClaim();
+    const verdict = this.check();
+    if (!verdict.claiming && verdict.latched)
+      await this.halt(verdict.reason);
+    return verdict;
+  }
+  async halt(reason) {
+    const already = this.store.getSweep().haltReason === reason;
+    await this.store.haltSweep(reason);
+    if (!already) {
+      const claimed = this.store.getSweep().claimed;
+      log34.info(TAG32, `claiming stopped (${reason}) after ${claimed} claimed`);
+    }
+    return this.snapshot();
+  }
+  async resume() {
+    const before = this.store.getSweep();
+    const was = before.haltReason ? this.describeStop(before.haltReason) : null;
+    await this.store.resumeSweep();
+    if (was)
+      log34.info(TAG32, `claiming resumed by the operator — was stopped: ${was}`);
+    return this.snapshot();
+  }
+  snapshot() {
+    const sweep = this.store.getSweep();
+    const cap = this.config.maxCardsPerSweep;
+    const verdict = this.check();
+    return {
+      enabled: this.config.enabled,
+      claiming: verdict.claiming,
+      haltReason: verdict.claiming ? null : verdict.reason,
+      haltedAt: sweep.haltedAt,
+      claimed: sweep.claimed,
+      maxCardsPerSweep: cap < 0 ? null : cap,
+      totalClaimed: sweep.totalClaimed,
+      detail: verdict.claiming ? null : verdict.detail
+    };
+  }
+  describeStop(reason, budgetDetail) {
+    const claimed = this.store.getSweep().claimed;
+    const cards = `${claimed} card${claimed === 1 ? "" : "s"}`;
+    const resume = "Resume with `harmony-agent sweep resume`.";
+    switch (reason) {
+      case "card_cap":
+        return `card cap reached — ${cards} claimed this sweep, cap is ${this.config.maxCardsPerSweep}. ${resume}`;
+      case "operator":
+        return `stopped by the operator after ${cards}. ${resume}`;
+      case "daily_budget":
+        return `daily spend cap reached${budgetDetail ? ` (${budgetDetail})` : ""} after ${cards} — claiming starts again on its own when the UTC day rolls over.`;
+    }
+  }
+}
+function describeCaps(sweep, dailyBudgetCents) {
+  const cards = sweep.maxCardsPerSweep < 0 ? "no cap" : String(sweep.maxCardsPerSweep);
+  return `cards/sweep ${cards} · spend/day ${formatDailyCap(dailyBudgetCents)}`;
+}
+function sweepBannerLine(config) {
+  const sweep = config.sweep;
+  const scope = sweep.requireLabel ? `cards labelled "${sweep.requireLabel}"` : "unassigned cards";
+  const extra = sweep.trustedAuthors.length;
+  const authors = extra ? `you + ${extra} trusted author${extra === 1 ? "" : "s"}` : "you only";
+  return `Sweep ON — claims ${scope} in ${config.pickupColumns.join(", ")}, ` + `authored by ${authors}; caps: ${describeCaps(sweep, config.budget.dailyBudgetCents)}; ` + `${sweep.maxProbesPerTick} probes/tick`;
+}
+var TAG32 = "sweep";
+var init_sweep_guard = () => {};
+
 // src/watcher.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { isPretty as isPretty2, log as log33 } from "@gethmy/harness";
+import { isPretty as isPretty2, log as log35 } from "@gethmy/harness";
 import { createClient } from "@supabase/supabase-js";
 
 class Watcher {
@@ -11282,7 +12028,7 @@ class Watcher {
   }
   async start() {
     if (!isPretty2()) {
-      log33.info(TAG31, "Connecting to Supabase realtime (broadcast)...");
+      log35.info(TAG33, "Connecting to Supabase realtime (broadcast)...");
     }
     this.supabase = createClient(this.credentials.supabaseUrl, this.credentials.supabaseAnonKey);
     this.subscribeBroadcast();
@@ -11295,7 +12041,7 @@ class Watcher {
     const presenceChannel = this.supabase.channel(`board-presence-${this.projectId}`);
     this.presenceChannel = presenceChannel;
     presenceChannel.on("presence", { event: "sync" }, () => {
-      log33.debug(TAG31, "Presence sync");
+      log35.debug(TAG33, "Presence sync");
     }).subscribe(async (status) => {
       if (gen !== this.presenceGen)
         return;
@@ -11319,13 +12065,13 @@ class Watcher {
         if (trackStatus !== "ok") {
           this.presenceTracked = false;
           if (!this.stopping) {
-            log33.warn(TAG31, `Presence track returned "${trackStatus}" — scheduling reconnect`);
+            log35.warn(TAG33, `Presence track returned "${trackStatus}" — scheduling reconnect`);
             this.schedulePresenceReconnect();
           }
           return;
         }
         if (!isPretty2() || !this.suppressStartupLogs) {
-          log33.info(TAG31, "Presence tracked on board-presence channel");
+          log35.info(TAG33, "Presence tracked on board-presence channel");
         }
         this.presenceTracked = true;
         this.presenceReconnectAttempts = 0;
@@ -11333,7 +12079,7 @@ class Watcher {
       } else if (status === "CHANNEL_ERROR" || status === "TIMED_OUT" || status === "CLOSED") {
         this.presenceTracked = false;
         if (!this.stopping) {
-          log33.warn(TAG31, `Presence subscription ${status} — scheduling reconnect`);
+          log35.warn(TAG33, `Presence subscription ${status} — scheduling reconnect`);
           this.schedulePresenceReconnect();
         }
       }
@@ -11352,7 +12098,7 @@ class Watcher {
   async reconnectPresence() {
     if (this.stopping || !this.supabase)
       return;
-    log33.warn(TAG31, `Reconnecting presence subscription (attempt ${this.presenceReconnectAttempts})`);
+    log35.warn(TAG33, `Reconnecting presence subscription (attempt ${this.presenceReconnectAttempts})`);
     if (this.presenceChannel) {
       const old = this.presenceChannel;
       this.presenceChannel = null;
@@ -11370,13 +12116,13 @@ class Watcher {
       return;
     const gen = ++this.broadcastGen;
     this.channel = this.supabase.channel(`board-${this.projectId}`).on("broadcast", { event: "card_update" }, (msg) => {
-      log33.debug(TAG31, `Broadcast: card_update ${JSON.stringify(msg.payload)}`);
+      log35.debug(TAG33, `Broadcast: card_update ${JSON.stringify(msg.payload)}`);
       this.onCardBroadcast({
         event: "card_update",
         payload: msg.payload ?? {}
       });
     }).on("broadcast", { event: "card_created" }, (msg) => {
-      log33.debug(TAG31, `Broadcast: card_created ${JSON.stringify(msg.payload)}`);
+      log35.debug(TAG33, `Broadcast: card_created ${JSON.stringify(msg.payload)}`);
       this.onCardBroadcast({
         event: "card_created",
         payload: msg.payload ?? {}
@@ -11386,7 +12132,7 @@ class Watcher {
       const cardId = payload.card_id;
       const command = payload.command;
       if (cardId && command) {
-        log33.info(TAG31, `Broadcast: agent_command ${command} for ${cardId}`);
+        log35.info(TAG33, `Broadcast: agent_command ${command} for ${cardId}`);
         this.onAgentCommand?.({ cardId, command });
       }
     }).subscribe((status) => {
@@ -11396,13 +12142,13 @@ class Watcher {
         this.connected = true;
         this.reconnectAttempts = 0;
         if (!isPretty2() || !this.suppressStartupLogs) {
-          log33.info(TAG31, "Broadcast subscription active");
+          log35.info(TAG33, "Broadcast subscription active");
         }
         this.maybeResolveReady();
       } else if (status === "CHANNEL_ERROR" || status === "TIMED_OUT" || status === "CLOSED") {
         this.connected = false;
         if (!this.stopping) {
-          log33.warn(TAG31, `Broadcast subscription ${status} — scheduling reconnect`);
+          log35.warn(TAG33, `Broadcast subscription ${status} — scheduling reconnect`);
           this.scheduleReconnect();
         }
       }
@@ -11421,7 +12167,7 @@ class Watcher {
   async reconnectBroadcast() {
     if (this.stopping || !this.supabase)
       return;
-    log33.warn(TAG31, `Reconnecting broadcast subscription (attempt ${this.reconnectAttempts})`);
+    log35.warn(TAG33, `Reconnecting broadcast subscription (attempt ${this.reconnectAttempts})`);
     if (this.channel) {
       const old = this.channel;
       this.channel = null;
@@ -11458,10 +12204,10 @@ class Watcher {
     }
     this.connected = false;
     this.presenceTracked = false;
-    log33.info(TAG31, "Broadcast subscription stopped");
+    log35.info(TAG33, "Broadcast subscription stopped");
   }
 }
-var TAG31 = "watcher";
+var TAG33 = "watcher";
 var init_watcher = () => {};
 
 // src/worktree-gc.ts
@@ -11475,7 +12221,7 @@ __export(exports_worktree_gc, {
 import { execFileSync as execFileSync6 } from "node:child_process";
 import { existsSync as existsSync4, readdirSync, statSync as statSync2 } from "node:fs";
 import { resolve as resolve2 } from "node:path";
-import { cleanupWorktree as cleanupWorktree4, log as log34 } from "@gethmy/harness";
+import { cleanupWorktree as cleanupWorktree4, log as log36 } from "@gethmy/harness";
 function isTransientGitNetworkError(message) {
   return TRANSIENT_GIT_NETWORK_ERROR.test(message);
 }
@@ -11588,10 +12334,10 @@ function runWorktreeGc(basePath, store, opts = {}) {
     });
   } catch {}
   if (result.removed.length > 0) {
-    log34.info(TAG32, `GC removed ${result.removed.length} orphan worktree(s): ${result.removed.map((p) => p.split("/").pop()).join(", ")}`);
+    log36.info(TAG34, `GC removed ${result.removed.length} orphan worktree(s): ${result.removed.map((p) => p.split("/").pop()).join(", ")}`);
   }
   if (result.errors.length > 0) {
-    log34.warn(TAG32, `GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.path}: ${e.error}`).join("; ")}`);
+    log36.warn(TAG34, `GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.path}: ${e.error}`).join("; ")}`);
   }
   return result;
 }
@@ -11621,7 +12367,7 @@ function pruneFailedRemoteBranches(opts) {
   } catch (err) {
     const detail = gitErrorDetail2(err);
     if (isTransientGitNetworkError(detail)) {
-      log34.debug(TAG32, `Remote branch GC skipped — remote unreachable: ${detail}`);
+      log36.debug(TAG34, `Remote branch GC skipped — remote unreachable: ${detail}`);
       return result;
     }
     result.errors.push({ ref: "fetch", error: detail });
@@ -11660,7 +12406,7 @@ function pruneFailedRemoteBranches(opts) {
       continue;
     }
     if (clock() > sweepDeadline) {
-      log34.debug(TAG32, `Remote branch GC budget spent — removed ${result.removed.length}, remaining deferred to next tick`);
+      log36.debug(TAG34, `Remote branch GC budget spent — removed ${result.removed.length}, remaining deferred to next tick`);
       break;
     }
     try {
@@ -11673,17 +12419,17 @@ function pruneFailedRemoteBranches(opts) {
     } catch (err) {
       const detail = gitErrorDetail2(err);
       if (isTransientGitNetworkError(detail)) {
-        log34.debug(TAG32, `Remote branch GC interrupted — remote unreachable: ${detail}`);
+        log36.debug(TAG34, `Remote branch GC interrupted — remote unreachable: ${detail}`);
         break;
       }
       result.errors.push({ ref, error: detail });
     }
   }
   if (result.removed.length > 0) {
-    log34.info(TAG32, `Pruned ${result.removed.length} stale remote branch(es) under ${opts.prefix}: ${result.removed.join(", ")}`);
+    log36.info(TAG34, `Pruned ${result.removed.length} stale remote branch(es) under ${opts.prefix}: ${result.removed.join(", ")}`);
   }
   if (result.errors.length > 0) {
-    log34.warn(TAG32, `Remote branch GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.ref}: ${e.error}`).join("; ")}`);
+    log36.warn(TAG34, `Remote branch GC had ${result.errors.length} error(s): ${result.errors.map((e) => `${e.ref}: ${e.error}`).join("; ")}`);
   }
   return result;
 }
@@ -11714,13 +12460,13 @@ class WorktreeGc {
     try {
       runWorktreeGc(this.basePath, this.store);
     } catch (err) {
-      log34.warn(TAG32, `GC tick failed: ${err instanceof Error ? err.message : err}`);
+      log36.warn(TAG34, `GC tick failed: ${err instanceof Error ? err.message : err}`);
     }
     if (this.remoteOpts) {
       try {
         pruneFailedRemoteBranches(this.remoteOpts);
       } catch (err) {
-        log34.warn(TAG32, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
+        log36.warn(TAG34, `Remote GC tick failed: ${err instanceof Error ? err.message : err}`);
       }
     }
   }
@@ -11734,7 +12480,7 @@ function getRepoRoot2() {
     return null;
   }
 }
-var TAG32 = "worktree-gc", GIT_NETWORK_TIMEOUT_MS = 30000, GIT_SSH_CONNECT_TIMEOUT_SECS = 10, GIT_PRUNE_SWEEP_BUDGET_MS = 60000, GIT_NETWORK_EXEC, TRANSIENT_GIT_NETWORK_ERROR;
+var TAG34 = "worktree-gc", GIT_NETWORK_TIMEOUT_MS = 30000, GIT_SSH_CONNECT_TIMEOUT_SECS = 10, GIT_PRUNE_SWEEP_BUDGET_MS = 60000, GIT_NETWORK_EXEC, TRANSIENT_GIT_NETWORK_ERROR;
 var init_worktree_gc = __esm(() => {
   GIT_NETWORK_EXEC = {
     timeout: GIT_NETWORK_TIMEOUT_MS,
@@ -11771,7 +12517,7 @@ import { randomUUID as randomUUID3 } from "node:crypto";
 import { createRequire as createRequire3 } from "node:module";
 import {
   detectGitProvider as detectGitProvider6,
-  log as log35,
+  log as log37,
   validateGitProviderCli
 } from "@gethmy/harness";
 async function validatePrerequisites(config, banner) {
@@ -11845,21 +12591,36 @@ async function main() {
   } catch (err) {
     if (err instanceof ConfigValidationError) {
       banner.fail();
-      log35.error(TAG33, err.message);
+      log37.error(TAG35, err.message);
       process.exit(1);
     }
     throw err;
   }
   try {
     validateAutoMergeConfig(config.agent);
+    validateBudgetConfig(config.agent);
+    validateSweepConfig(config.agent);
+    validateRankingConfig(config.agent);
   } catch (err) {
     if (err instanceof ConfigValidationError) {
       banner.fail();
-      log35.error(TAG33, err.message);
+      log37.error(TAG35, err.message);
       process.exit(1);
     }
     throw err;
   }
+  if (config.agent.sweep.enabled) {
+    banner.check(sweepBannerLine(config.agent));
+    try {
+      const { members } = await client.getWorkspaceMembers(config.workspaceId);
+      const count = Array.isArray(members) ? members.length : 0;
+      if (count > 1) {
+        banner.warn(`Sweep is on and this workspace has ${count} members. Any member can edit a trusted author's card or comment on it, and the swept run executes that text with unrestricted Bash on this machine. Enable sweep only where every member is someone you would hand a shell.`);
+      }
+    } catch (err) {
+      log37.debug(TAG35, `workspace member count unavailable for the sweep warning: ${err instanceof Error ? err.message : err}`);
+    }
+  }
   const { agent: registeredAgent } = await client.registerWorkspaceAgent(config.workspaceId, {
     identifier: config.agentIdentifier,
     name: config.agentName,
@@ -11880,6 +12641,13 @@ async function main() {
     const errored = outcomes.filter((o) => o.errors.length).length;
     banner.check(`Recovery: ${outcomes.length} orphan(s) handled${errored > 0 ? `, ${errored} with errors` : ""}`);
   }
+  const sweepGuard = new SweepGuard(config.agent.sweep, stateStore, () => new BudgetGuard(config.agent.budget, stateStore).checkDailyBudget());
+  if (config.agent.sweep.enabled) {
+    const sweepState = sweepGuard.snapshot();
+    if (!sweepState.claiming && sweepState.detail) {
+      banner.warn(`Sweep is NOT claiming — ${sweepState.detail}`);
+    }
+  }
   try {
     const undeclared = await findUndeclaredGateMetrics(client, config.projectId, config.agent);
     for (const finding of undeclared) {
@@ -11900,7 +12668,7 @@ async function main() {
   pool.onCardCompleted = promoteSuccessors;
   const reviewColumns = config.agent.review.enabled ? config.agent.review.pickupColumns : [];
   const approvedLabel = config.agent.review.enabled ? config.agent.review.approvedLabel : "";
-  const reconciler = new Reconciler(client, pool, config.projectId, agentId, config.agent.pickupColumns, reviewColumns, approvedLabel, config.agent.timing.reconcileIntervalMs, stateStore, config.agent);
+  const reconciler = new Reconciler(client, pool, config.projectId, agentId, config.agent.pickupColumns, reviewColumns, approvedLabel, config.agent.timing.reconcileIntervalMs, stateStore, config.agent, agentUserId, sweepGuard);
   let mergeMonitor = null;
   if (config.agent.review.enabled && config.agent.review.mergeMonitor) {
     mergeMonitor = new MergeMonitor(client, config.projectId, config.agent);
@@ -11957,10 +12725,13 @@ async function main() {
         budget: {
           todayCents: stateStore.getDailyCostCents(),
           dailyCapCents: config.agent.budget.dailyBudgetCents
-        }
+        },
+        sweep: sweepGuard.snapshot()
       };
     },
-    handleCommand: (cmd, cardId) => pool.handleAgentCommand(cardId, cmd)
+    handleCommand: (cmd, cardId) => pool.handleAgentCommand(cardId, cmd),
+    handleSweepCommand: (cmd) => cmd === "stop" ? sweepGuard.halt("operator") : sweepGuard.resume(),
+    getSweep: () => sweepGuard.snapshot()
   }) : null;
   const watcher = new Watcher(realtimeCreds, config.projectId, {
     userId: agentUserId,
@@ -11979,7 +12750,7 @@ async function main() {
     if (shuttingDown)
       return;
     shuttingDown = true;
-    log35.info(TAG33, `Received ${signal}, shutting down gracefully...`);
+    log37.info(TAG35, `Received ${signal}, shutting down gracefully...`);
     reconciler.stop();
     mergeMonitor?.stop();
     worktreeGc.stop();
@@ -11990,18 +12761,18 @@ async function main() {
     }
     await watcher.stop();
     await pool.shutdown();
-    log35.info(TAG33, "Daemon stopped.");
+    log37.info(TAG35, "Daemon stopped.");
     process.exit(exitCode);
   };
   process.on("SIGINT", () => shutdown("SIGINT"));
   process.on("SIGTERM", () => shutdown("SIGTERM"));
   process.on("uncaughtException", (err) => {
-    log35.error(TAG33, `Uncaught exception: ${err.message}`);
+    log37.error(TAG35, `Uncaught exception: ${err.message}`);
     exitCode = 1;
     shutdown("uncaughtException");
   });
   process.on("unhandledRejection", (reason) => {
-    log35.error(TAG33, `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
+    log37.error(TAG35, `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`);
     exitCode = 1;
     shutdown("unhandledRejection");
   });
@@ -12060,29 +12831,29 @@ async function handleBroadcast(event, client, pool, config, agentId) {
   if (assignedAgentId === undefined)
     return;
   if (assignedAgentId === agentId) {
-    log35.info(TAG33, `Broadcast: card ${cardId} assigned to agent`);
+    log37.info(TAG35, `Broadcast: card ${cardId} assigned to agent`);
     try {
       await pool.resetAttemptsForReassign(cardId);
       await tryEnqueueCard(cardId, client, pool, config, agentId);
     } catch (err) {
-      log35.error(TAG33, `Failed to process assignment: ${err instanceof Error ? err.message : err}`);
+      log37.error(TAG35, `Failed to process assignment: ${err instanceof Error ? err.message : err}`);
     }
   } else if (pool.isCardKnown(cardId)) {
-    log35.info(TAG33, `Broadcast: card ${cardId} unassigned from agent`);
+    log37.info(TAG35, `Broadcast: card ${cardId} unassigned from agent`);
     await pool.removeCard(cardId);
   }
 }
 async function tryEnqueueCard(cardId, client, pool, config, agentId) {
   const { card } = await client.getCard(cardId);
   if (card.assigned_agent_id !== agentId) {
-    log35.debug(TAG33, `Card ${cardId} no longer assigned to agent — skipping`);
+    log37.debug(TAG35, `Card ${cardId} no longer assigned to agent — 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);
   if (!column) {
-    log35.warn(TAG33, `Column not found for card ${cardId}`);
+    log37.warn(TAG35, `Column not found for card ${cardId}`);
     return;
   }
   const route = classifyPickup(card, column.name, {
@@ -12091,31 +12862,31 @@ async function tryEnqueueCard(cardId, client, pool, config, agentId) {
     playbooks: config.agent.playbooks
   });
   if (!route) {
-    log35.info(TAG33, `Card #${card.short_id} is in "${column.name}", not a pickup/review/stage column — skipping`);
+    log37.info(TAG35, `Card #${card.short_id} is in "${column.name}", not a pickup/review/stage column — skipping`);
     return;
   }
   if (route.stage) {
-    log35.info(TAG33, `Card #${card.short_id} is a playbook stage card (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement pool) regardless of column`);
+    log37.info(TAG35, `Card #${card.short_id} is a playbook stage card (stage "${card.current_stage}") in "${column.name}" — routing to the stage executor (implement pool) regardless of column`);
   }
   const mode = route.mode;
   const labelMap = buildLabelMap(board.labels ?? []);
   const cardLabels = resolveCardLabels(card, labelMap);
   const subtasks = card.subtasks ?? [];
   if (mode === "review" && config.agent.review.approvedLabel && hasLabel(cardLabels, config.agent.review.approvedLabel)) {
-    log35.debug(TAG33, `Card #${card.short_id} already has "${config.agent.review.approvedLabel}" — skipping review`);
+    log37.debug(TAG35, `Card #${card.short_id} already has "${config.agent.review.approvedLabel}" — skipping review`);
     return;
   }
   if (mode === "review" && hasLabel(cardLabels, NEED_REVIEW_LABEL)) {
-    log35.debug(TAG33, `Card #${card.short_id} has "${NEED_REVIEW_LABEL}" label (needs human) — skipping review`);
+    log37.debug(TAG35, `Card #${card.short_id} has "${NEED_REVIEW_LABEL}" label (needs human) — skipping review`);
     return;
   }
   if (mode === "review" && !qualifiesForAutoReview(card.description)) {
-    log35.info(TAG33, `Card #${card.short_id} has no branch or PR reference — skipping auto-review`);
+    log37.info(TAG35, `Card #${card.short_id} has no branch or PR reference — skipping auto-review`);
     return;
   }
   await pool.enqueue(card, column, cardLabels, subtasks, mode);
 }
-var TAG33 = "daemon", BASE_REMOTE = "origin", PKG_VERSION;
+var TAG35 = "daemon", BASE_REMOTE = "origin", PKG_VERSION;
 var init_src = __esm(() => {
   init_base_branch();
   init_board_helpers();
@@ -12133,6 +12904,7 @@ var init_src = __esm(() => {
   init_startup_banner();
   init_state_store();
   init_stream_parser_selftest();
+  init_sweep_guard();
   init_types2();
   init_unblock();
   init_watcher();
@@ -12403,13 +13175,17 @@ var init_run_stats = () => {};
 // src/cli.ts
 import { realpathSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { log as log36 } from "@gethmy/harness";
+import { log as log38 } from "@gethmy/harness";
 var USAGE = `
 Harmony Agent — push-based daemon + ops toolkit.
 
 Usage:
   harmony-agent [run]              Start the daemon (default)
   harmony-agent status             Fetch status from the running daemon
+  harmony-agent sweep [status]     Sweep caps + whether it is claiming
+  harmony-agent sweep stop         Kill switch: halt sweep CLAIMING within one
+                                   heartbeat. In-flight runs are NOT cancelled.
+  harmony-agent sweep resume       Resume claiming and reset the card cap
   harmony-agent health             Exit 0 if daemon is healthy, 1 otherwise
   harmony-agent doctor             Run preflight checks (don't start)
   harmony-agent gc                 One-shot worktree garbage collection
@@ -12446,13 +13222,21 @@ async function httpCall(path, init) {
   const url = `http://${bindAddr}:${port}${path}`;
   return fetch(url, init);
 }
+function formatSweep(sweep) {
+  if (!sweep.enabled)
+    return "off";
+  const cap = sweep.maxCardsPerSweep === null ? "no cap" : String(sweep.maxCardsPerSweep);
+  const counts = `${sweep.claimed}/${cap} claimed this sweep · ${sweep.totalClaimed} total`;
+  return sweep.claiming ? `claiming · ${counts}` : `STOPPED (${sweep.haltReason}) · ${counts}
+         ${sweep.detail ?? ""}`;
+}
 function printStatus(body) {
   const out = process.stdout;
   const uptime = formatDuration(body.uptimeMs);
   out.write(`daemon   ${body.daemonId} (pid ${body.daemonPid}, up ${uptime})
 `);
   const activeCents = body.workers.reduce((sum, w) => sum + (w.costCents ?? 0), 0);
-  out.write(`budget   $${(body.budget.todayCents / 100).toFixed(2)} / $${(body.budget.dailyCapCents / 100).toFixed(2)} today · $${(activeCents / 100).toFixed(2)} in-flight
+  out.write(`budget   $${(body.budget.todayCents / 100).toFixed(2)} / ${formatDailyCap(body.budget.dailyCapCents)} today · $${(activeCents / 100).toFixed(2)} in-flight
 `);
   out.write(`workers  (${body.workers.length})
 `);
@@ -12461,6 +13245,10 @@ function printStatus(body) {
     const br = w.branchName ? ` branch=${w.branchName}` : "";
     const spend = w.costCents ? ` $${(w.costCents / 100).toFixed(2)}` : "";
     out.write(`  #${w.id} ${w.pipeline.padEnd(9)} ${w.state}${card}${br}${spend}
+`);
+  }
+  if (body.sweep) {
+    out.write(`sweep    ${formatSweep(body.sweep)}
 `);
   }
   out.write(`impl queue   (${body.implQueue.length})
@@ -12504,6 +13292,43 @@ async function statusCommand() {
     return 1;
   }
 }
+async function sweepCommand(sub) {
+  const action = sub ?? "status";
+  if (!["status", "stop", "resume"].includes(action)) {
+    process.stderr.write(`unknown sweep subcommand: ${action}
+usage: harmony-agent sweep <status|stop|resume>
+`);
+    return 1;
+  }
+  try {
+    const res = action === "status" ? await httpCall("/sweep") : await httpCall(`/sweep/${action}`, { method: "POST" });
+    if (!res.ok) {
+      const body2 = await res.json().catch(() => null);
+      process.stderr.write(`daemon responded ${res.status} ${res.statusText}${body2?.detail ? ` — ${body2.detail}` : ""}
+`);
+      return 1;
+    }
+    if (action === "status") {
+      const sweep = await res.json();
+      process.stdout.write(`sweep    ${formatSweep(sweep)}
+`);
+      return 0;
+    }
+    const body = await res.json();
+    process.stdout.write(`sweep    ${formatSweep(body.sweep)}
+`);
+    if (action === "stop") {
+      process.stdout.write(body.inFlight > 0 ? `         ${body.inFlight} run(s) already in flight continue to completion — nothing was cancelled.
+` : `         No run was in flight; nothing was cancelled.
+`);
+    }
+    return 0;
+  } catch (err) {
+    process.stderr.write(`could not reach daemon: ${err instanceof Error ? err.message : err}
+`);
+    return 1;
+  }
+}
 async function healthCommand() {
   try {
     const res = await httpCall("/health");
@@ -12884,6 +13709,8 @@ async function dispatch(argv) {
       return 0;
     case "status":
       return statusCommand();
+    case "sweep":
+      return sweepCommand(args[1]);
     case "health":
       return healthCommand();
     case "doctor":
@@ -12924,7 +13751,7 @@ if (isMainModule()) {
     if (code !== 0)
       process.exit(code);
   }).catch((err) => {
-    log36.error("cli", err instanceof Error ? err.message : String(err));
+    log38.error("cli", err instanceof Error ? err.message : String(err));
     process.exit(1);
   });
 }