@hasna/loops 0.4.10 → 0.4.11

package/CHANGELOG.md

@@ -5,6 +5,51 @@ documented in this file. Version entries are generated from the
 conventional-commit git history; one commit maps to one released patch version
 unless noted.
 
+## 0.4.11 (2026-07-05)
+
+Scheduler fairness and PR-route hygiene: fast command loops no longer starve
+behind long agent workers, PR tasks dedupe by GitHub identity, and merged/closed
+PR routes close themselves out of the queue.
+
+### Fixed
+
+- **Daemon scheduler — separated concurrency lanes:** the daemon shared a single
+  concurrency pool, so long agent/workflow workers (minutes to over an hour) could
+  occupy every slot and starve fast command loops (monitors, digests, syncs) —
+  even the merge router starved. Command-target and agent/workflow-target loops
+  now draw from independent claim budgets. New env `LOOPS_DAEMON_COMMAND_CONCURRENCY`
+  (default 4) and `LOOPS_DAEMON_AGENT_CONCURRENCY` (default 8); the legacy
+  `LOOPS_DAEMON_CONCURRENCY` / `--concurrency` still work as the agent-lane knob for
+  back-compat, and new `--command-concurrency` / `--agent-concurrency` daemon flags
+  are added. A saturated lane no longer consumes the other lane's budget.
+- **Todos-task routing — PR fingerprint dedupe:** the repos registry maps several
+  local checkouts to one GitHub repo, so a single PR was minted as 2-3 duplicate
+  todos tasks (distinct ids + checkout paths) that each dispatched a full worker.
+  PR-subject tasks now dedupe by a stable `owner/repo#number` fingerprint (from an
+  explicit PR fingerprint field or a canonical PR URL / `github-pr:` handle,
+  lowercased) instead of the `(source-path, task-id)` key, collapsing the
+  duplicates to one work item. Non-PR tasks keep the path/id key (no false dedupe).
+- **Todos-task routing — freshness skip closes the task:** 0.4.10's freshness gate
+  stopped dispatching a worker for a merged/closed PR but left the task pending +
+  route-opted-in, so every drain tick re-skipped it forever. On a definitive
+  MERGED/CLOSED freshness skip the drain now marks the source task done and strips
+  its `auto:route`/`route:enabled` opt-in so it leaves the queue. Only fires when
+  gh/metadata definitively reports MERGED/CLOSED; never on dry-run.
+
+## 0.4.10 (2026-07-05)
+
+Hotfix bundle for the PR-merge drain pipeline.
+
+### Fixed
+
+- **Todos-task drain:** re-admit a terminal work item whose todos task is still
+  actionable (bounded by a redispatch cap + per-attempt backoff) instead of
+  deduping it away forever, so real task work keeps dispatching.
+- **PR review gate:** freshness gate skips merge/review routes for already
+  merged/closed PRs; normalize `app/<slug>` and `<slug>[bot]` bot logins so
+  bot-authored PRs resolve an author instead of hard-failing the format check.
+- **Runtime/store:** cap persisted run stdout/stderr; project path resolution fix.
+
 ## 0.4.9 (2026-07-04)
 
 Unblock the PR-merge pipeline: task-lifecycle/route workers now dispatch real

package/dist/api/index.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.10",
+  version: "0.4.11",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",

package/dist/cli/index.js

@@ -4237,7 +4237,7 @@ class Store {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.10",
+  version: "0.4.11",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -6969,6 +6969,9 @@ function buildHealthReport(store, opts = {}) {
 }
 
 // src/lib/scheduler.ts
+function loopLane(loop) {
+  return loop.target.type === "command" ? "command" : "agent";
+}
 function manualRunScheduledFor(loop, now = new Date) {
   if (loop.archivedAt)
     return now.toISOString();
@@ -7361,14 +7364,23 @@ function claimDueRuns(deps) {
   const maxClaims = Math.max(0, deps.maxClaims ?? Number.POSITIVE_INFINITY);
   if (maxClaims === 0)
     return { claims, claimed, completed: [], skipped, recovered, expired };
+  const laneLimits = deps.laneLimits;
+  const laneClaims = { command: 0, agent: 0 };
+  const laneCap = (lane) => laneLimits === undefined ? Number.POSITIVE_INFINITY : Math.max(0, laneLimits[lane] ?? Number.POSITIVE_INFINITY);
+  const laneFull = (lane) => laneClaims[lane] >= laneCap(lane);
   for (const loop of deps.store.dueLoops(now)) {
     if (claims.length >= maxClaims)
       break;
+    const lane = loopLane(loop);
+    if (laneFull(lane))
+      continue;
     const plan = dueSlots(loop, now);
     let loopSkips = 0;
     for (const slot of plan.slots) {
       if (claims.length >= maxClaims)
         break;
+      if (laneFull(lane))
+        break;
       if (loopSkips >= MAX_SKIPS_PER_LOOP_PER_TICK)
         break;
       const run = claimSlot(deps, loop, slot);
@@ -7377,6 +7389,7 @@ function claimDueRuns(deps) {
       if ("loop" in run) {
         claims.push(run);
         claimed.push(run.run);
+        laneClaims[lane] += 1;
       } else if (run.status === "skipped") {
         skipped.push(run);
         loopSkips += 1;
@@ -7648,13 +7661,23 @@ function intervalFromEnv() {
   const value = Number(raw);
   return Number.isFinite(value) && value > 0 ? value : undefined;
 }
-function concurrencyFromEnv() {
-  const raw = process.env.LOOPS_DAEMON_CONCURRENCY;
+function positiveIntEnv(name) {
+  const raw = process.env[name];
   if (!raw)
     return;
   const value = Number(raw);
   return Number.isInteger(value) && value > 0 ? value : undefined;
 }
+function concurrencyFromEnv() {
+  return positiveIntEnv("LOOPS_DAEMON_CONCURRENCY");
+}
+var DEFAULT_COMMAND_CONCURRENCY = 4;
+var DEFAULT_AGENT_CONCURRENCY = 8;
+function resolveLaneConcurrency(opts = {}) {
+  const command = Math.max(1, opts.commandConcurrency ?? positiveIntEnv("LOOPS_DAEMON_COMMAND_CONCURRENCY") ?? DEFAULT_COMMAND_CONCURRENCY);
+  const agent = Math.max(1, opts.agentConcurrency ?? opts.concurrency ?? positiveIntEnv("LOOPS_DAEMON_AGENT_CONCURRENCY") ?? concurrencyFromEnv() ?? DEFAULT_AGENT_CONCURRENCY);
+  return { command, agent };
+}
 var DAEMON_LOG_MAX_BYTES = 50 * 1024 * 1024;
 var DAEMON_LOG_KEEP = 2;
 function daemonLogLine(message) {
@@ -7700,7 +7723,7 @@ async function runDaemon(opts = {}) {
   const runnerId = `${hostname2()}:${process.pid}:${leaseId}`;
   const intervalMs = opts.intervalMs ?? intervalFromEnv() ?? 1000;
   const leaseTtlMs = opts.leaseTtlMs ?? Math.max(60000, intervalMs * 10);
-  const concurrency = Math.max(1, opts.concurrency ?? concurrencyFromEnv() ?? 4);
+  const laneConcurrency = resolveLaneConcurrency(opts);
   const log = opts.log ?? defaultDaemonLog;
   const sleep = opts.sleep ?? realSleep;
   const lease = store.acquireDaemonLease({
@@ -7712,12 +7735,13 @@ async function runDaemon(opts = {}) {
   if (!lease)
     throw new Error("another loops daemon holds the database lease");
   writePid(process.pid, pidPath);
-  log(`started pid=${process.pid} interval=${intervalMs}ms lease=${leaseId}`);
+  log(`started pid=${process.pid} interval=${intervalMs}ms lease=${leaseId} ` + `command_concurrency=${laneConcurrency.command} agent_concurrency=${laneConcurrency.agent}`);
   let stopFlag = false;
   let leaseLost = false;
   let leaseEpoch = 0;
   let runAbort = new AbortController;
   const activeRuns = new Map;
+  const activeByLane = { command: 0, agent: 0 };
   const requestStop = (message) => {
     stopFlag = true;
     if (!runAbort.signal.aborted)
@@ -7810,7 +7834,12 @@ async function runDaemon(opts = {}) {
     log(`run ${finalRun.id} ${finalRun.status} loop=${claim.loop.id}`);
   };
   const startClaim = (claim) => {
-    const task = executeDaemonRun(claim).catch((err) => log(`run ${claim.run.id} error: ${err instanceof Error ? err.message : String(err)}`)).finally(() => activeRuns.delete(claim.run.id));
+    const lane = loopLane(claim.loop);
+    activeByLane[lane] += 1;
+    const task = executeDaemonRun(claim).catch((err) => log(`run ${claim.run.id} error: ${err instanceof Error ? err.message : String(err)}`)).finally(() => {
+      activeRuns.delete(claim.run.id);
+      activeByLane[lane] -= 1;
+    });
     activeRuns.set(claim.run.id, task);
   };
   try {
@@ -7846,19 +7875,23 @@ async function runDaemon(opts = {}) {
       onTickError: (err) => log(`tick error: ${err instanceof Error ? err.message : String(err)}`),
       tickFn: async () => {
         ensureLease();
-        const available = Math.max(0, concurrency - activeRuns.size);
+        const laneLimits = {
+          command: Math.max(0, laneConcurrency.command - activeByLane.command),
+          agent: Math.max(0, laneConcurrency.agent - activeByLane.agent)
+        };
         const result = claimDueRuns({
           store,
           runnerId,
           daemonLeaseId: leaseId,
           beforeRun: () => ensureLease(),
-          maxClaims: available
+          maxClaims: laneLimits.command + laneLimits.agent,
+          laneLimits
         });
         for (const claim of result.claims)
           startClaim(claim);
         const changed = result.claims.length + result.skipped.length + result.recovered.length + result.expired.length;
         if (changed > 0) {
-          log(`tick claimed=${result.claims.length} active=${activeRuns.size} skipped=${result.skipped.length} recovered=${result.recovered.length} expired=${result.expired.length}`);
+          log(`tick claimed=${result.claims.length} active=${activeRuns.size} (command=${activeByLane.command} agent=${activeByLane.agent}) skipped=${result.skipped.length} recovered=${result.recovered.length} expired=${result.expired.length}`);
         }
         await reapAbandoned(result.recovered);
       }
@@ -11513,6 +11546,37 @@ function prReferenceFrom(text) {
     return { owner: short[1], repo: short[2], number: Number(short[3]) };
   return;
 }
+var PR_FINGERPRINT_FIELDS = [
+  "pr_fingerprint",
+  "prFingerprint",
+  "github_pr",
+  "githubPr",
+  "github_pr_fingerprint",
+  "githubPrFingerprint",
+  "pull_request_fingerprint",
+  "pullRequestFingerprint"
+];
+function prFingerprint(ref) {
+  return `${ref.owner.toLowerCase()}/${ref.repo.toLowerCase()}#${ref.number}`;
+}
+function prFingerprintFromField(value) {
+  if (!value)
+    return;
+  const match = /([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)#(\d+)/.exec(value);
+  return match ? prFingerprint({ owner: match[1], repo: match[2], number: Number(match[3]) }) : undefined;
+}
+function prFingerprintFromTask(data, metadata) {
+  const records = [...taskEventRecords(data, metadata), ...automationRecords(data, metadata)];
+  for (const field of PR_FINGERPRINT_FIELDS) {
+    for (const value of routeFieldValues(records, field)) {
+      const fingerprint = prFingerprintFromField(value);
+      if (fingerprint)
+        return fingerprint;
+    }
+  }
+  const ref = prReferenceFrom(routeEvidenceText(records));
+  return ref ? prFingerprint(ref) : undefined;
+}
 function ghAuthorResolver(ref) {
   const result = spawnSync7("gh", ["pr", "view", String(ref.number), "--repo", `${ref.owner}/${ref.repo}`, "--json", "author", "-q", ".author.login"], { encoding: "utf8", timeout: 20000 });
   if (result.error || result.status !== 0)
@@ -11588,7 +11652,9 @@ function prReviewRoutingDecision(data, metadata, opts, resolveAuthor = ghAuthorR
       allowed: false,
       reason: `PR is already ${prState.toLowerCase()}; skipping merge/review route (freshness gate)`,
       reviewers: [],
-      signals: [...signals, "pr-not-open"]
+      signals: [...signals, "pr-not-open"],
+      freshnessSkip: true,
+      prState
     };
   }
   const reviewers = githubLogins([
@@ -12045,7 +12111,8 @@ function routeTodosTaskEvent(event, opts) {
   const projectGroup = routeProjectGroup(opts.projectGroup, data, metadata);
   const throttleLimits = routeThrottleLimitsFromOpts(opts);
   const sourceProjectIdempotencyPrefix = sourceTodosProjectPath ? normalizeRoutePath(sourceTodosProjectPath) ?? resolve7(sourceTodosProjectPath) : undefined;
-  const idempotencyKey = sourceProjectIdempotencyPrefix ? `todos-task:${sourceProjectIdempotencyPrefix}:${taskId}` : `todos-task:${taskId}`;
+  const prFingerprint2 = prFingerprintFromTask(data, metadata);
+  const idempotencyKey = prFingerprint2 ? `todos-task:pr:${prFingerprint2}` : sourceProjectIdempotencyPrefix ? `todos-task:${sourceProjectIdempotencyPrefix}:${taskId}` : `todos-task:${taskId}`;
   const idempotencySuffix = stableSuffix(idempotencyKey);
   const namePrefix = opts.namePrefix ?? "event:todos-task";
   const workflowName = `${namePrefix}:${taskId.slice(0, 8)}:${idempotencySuffix}:workflow`;
@@ -12077,7 +12144,8 @@ function routeTodosTaskEvent(event, opts) {
         event,
         taskId,
         routeError: true,
-        prReviewRouting
+        prReviewRouting,
+        ...prReviewRouting.freshnessSkip ? { freshnessSkip: true, prState: prReviewRouting.prState } : {}
       },
       human: `skipped task ${taskId}: ${prReviewRouting.reason}`
     };
@@ -12638,6 +12706,31 @@ function markInvalidDrainTaskNonRouteable(sourceTodosProject, task, reason) {
     untagAutoRoute: todosMutationSummary(untagResult)
   };
 }
+function isFreshnessSkip(result) {
+  return result.kind === "skipped" && result.value.freshnessSkip === true;
+}
+function closeFreshnessSkippedTask(sourceTodosProject, task, reason) {
+  const taskId = taskField(task, ["id", "task_id", "taskId"]);
+  if (!taskId)
+    return { attempted: false, reason: "task id missing" };
+  const comment = `OpenLoops freshness gate closed this task: ${reason}. The referenced PR is already merged/closed, so the ` + `merge/review route will not dispatch a worker. Marked done and removed auto:route/route:enabled so drains stop re-skipping it.`;
+  const commentResult = runLocalCommand("todos", ["--project", sourceTodosProject, "comment", taskId, comment], { timeoutMs: 30000 });
+  const doneResult = runLocalCommand("todos", ["--project", sourceTodosProject, "done", taskId, "--notes", "PR already merged/closed; closed by OpenLoops freshness gate"], { timeoutMs: 30000 });
+  const untagAutoRoute = runLocalCommand("todos", ["--project", sourceTodosProject, "untag", taskId, "auto:route"], { timeoutMs: 30000 });
+  const untagRouteEnabled = runLocalCommand("todos", ["--project", sourceTodosProject, "untag", taskId, "route:enabled"], { timeoutMs: 30000 });
+  const leftQueue = doneResult.ok || untagAutoRoute.ok || untagRouteEnabled.ok;
+  return {
+    ok: leftQueue,
+    attempted: true,
+    taskId,
+    action: "freshness-close",
+    error: leftQueue ? undefined : "task could not be closed or untagged; inspect per-command results",
+    comment: todosMutationSummary(commentResult),
+    done: todosMutationSummary(doneResult),
+    untagAutoRoute: todosMutationSummary(untagAutoRoute),
+    untagRouteEnabled: todosMutationSummary(untagRouteEnabled)
+  };
+}
 function drainTodosTaskRoutes(opts) {
   const maxDispatch = positiveInteger(opts.maxDispatch ?? "1", "--max-dispatch") ?? 1;
   const todosProject = opts.todosProject ?? defaultLoopsProject();
@@ -12679,6 +12772,12 @@ function drainTodosTaskRoutes(opts) {
         result = skippedDrainTask(task, event, redact(message, 640) ?? "route task failed", { fatal: true });
       }
     }
+    if (!opts.dryRun && isFreshnessSkip(result)) {
+      const sourceTaskProject = opts.todosProjectsFromRegistry ? taskField(task, ["source_project_path", "sourceProjectPath"]) ?? todosProject : todosProject;
+      const reason = stringField(result.value.reason) ?? "PR already merged/closed (freshness gate)";
+      const sourceTaskUpdate = closeFreshnessSkippedTask(sourceTaskProject, task, reason);
+      result = { ...result, value: { ...result.value, sourceTaskUpdate } };
+    }
     results.push(result);
     if (result.kind === "created")
       created += 1;
@@ -12704,6 +12803,7 @@ function drainTodosTaskRoutes(opts) {
     deduped: results.filter((result) => result.kind === "deduped").length,
     throttled: results.filter((result) => result.kind === "throttled").length,
     skipped: results.filter((result) => result.kind === "skipped").length,
+    freshnessClosed: results.filter((result) => isFreshnessSkip(result) && result.value.sourceTaskUpdate?.attempted === true).length,
     fatal: results.filter((result) => result.value.fatal === true).length,
     maxDispatch,
     source: "todos ready",
@@ -12732,6 +12832,7 @@ function drainTodosTaskRoutes(opts) {
     deduped: report.deduped,
     throttled: report.throttled,
     skipped: report.skipped,
+    freshnessClosed: report.freshnessClosed,
     fatal: report.fatal,
     maxDispatch: report.maxDispatch,
     source: report.source,
@@ -12741,7 +12842,7 @@ function drainTodosTaskRoutes(opts) {
   } : { ...report, evidencePath };
   return {
     value,
-    human: `drained todos ready queue: considered=${report.considered} created=${report.created} deduped=${report.deduped} throttled=${report.throttled} skipped=${report.skipped} fatal=${report.fatal}`
+    human: `drained todos ready queue: considered=${report.considered} created=${report.created} deduped=${report.deduped} throttled=${report.throttled} skipped=${report.skipped} freshnessClosed=${report.freshnessClosed} fatal=${report.fatal}`
   };
 }
 // src/lib/route/route-tasks.ts

package/dist/daemon/daemon.d.ts

@@ -1,9 +1,15 @@
+import { type SchedulerLane } from "../lib/scheduler.js";
 import { Store } from "../lib/store.js";
 import type { ExecutorResult, Loop, LoopRun } from "../types.js";
 export interface RunDaemonOptions {
     intervalMs?: number;
     leaseTtlMs?: number;
+    /** Legacy single-pool knob; back-compat alias for the agent/workflow lane budget. */
     concurrency?: number;
+    /** Claim budget for command-target loops (fast loops). Default 4. */
+    commandConcurrency?: number;
+    /** Claim budget for agent/workflow-target loops (long workers). Default 8; `concurrency`/LOOPS_DAEMON_CONCURRENCY still set it. */
+    agentConcurrency?: number;
     store?: Store;
     pidPath?: string;
     execute?: (loop: Loop, run: LoopRun) => Promise<ExecutorResult>;
@@ -13,6 +19,18 @@ export interface RunDaemonOptions {
     signal?: AbortSignal;
     reapGraceMs?: number;
 }
+export declare const DEFAULT_COMMAND_CONCURRENCY = 4;
+export declare const DEFAULT_AGENT_CONCURRENCY = 8;
+/**
+ * Resolve the two separated concurrency lanes. Command loops (fast) and
+ * agent/workflow loops (long workers) get independent budgets so a saturated
+ * agent lane cannot starve command loops. Precedence per lane is explicit opt >
+ * lane env > legacy knob > default. The legacy `concurrency` opt and
+ * `LOOPS_DAEMON_CONCURRENCY` env stay wired to the agent lane (the dominant
+ * consumer / historical "total" knob), so existing deployments keep their
+ * heavy-lane capacity and simply gain a reserved command lane on top.
+ */
+export declare function resolveLaneConcurrency(opts?: Pick<RunDaemonOptions, "concurrency" | "commandConcurrency" | "agentConcurrency">): Record<SchedulerLane, number>;
 export declare const DAEMON_LOG_MAX_BYTES: number;
 export declare const DAEMON_LOG_KEEP = 2;
 export declare function daemonLogLine(message: string): string;

package/dist/daemon/index.js

@@ -6705,6 +6705,9 @@ async function executeLoopTarget(store, loop, run, opts = {}) {
 }
 
 // src/lib/scheduler.ts
+function loopLane(loop) {
+  return loop.target.type === "command" ? "command" : "agent";
+}
 function manualRunScheduledFor(loop, now = new Date) {
   if (loop.archivedAt)
     return now.toISOString();
@@ -7097,14 +7100,23 @@ function claimDueRuns(deps) {
   const maxClaims = Math.max(0, deps.maxClaims ?? Number.POSITIVE_INFINITY);
   if (maxClaims === 0)
     return { claims, claimed, completed: [], skipped, recovered, expired };
+  const laneLimits = deps.laneLimits;
+  const laneClaims = { command: 0, agent: 0 };
+  const laneCap = (lane) => laneLimits === undefined ? Number.POSITIVE_INFINITY : Math.max(0, laneLimits[lane] ?? Number.POSITIVE_INFINITY);
+  const laneFull = (lane) => laneClaims[lane] >= laneCap(lane);
   for (const loop of deps.store.dueLoops(now)) {
     if (claims.length >= maxClaims)
       break;
+    const lane = loopLane(loop);
+    if (laneFull(lane))
+      continue;
     const plan = dueSlots(loop, now);
     let loopSkips = 0;
     for (const slot of plan.slots) {
       if (claims.length >= maxClaims)
         break;
+      if (laneFull(lane))
+        break;
       if (loopSkips >= MAX_SKIPS_PER_LOOP_PER_TICK)
         break;
       const run = claimSlot(deps, loop, slot);
@@ -7113,6 +7125,7 @@ function claimDueRuns(deps) {
       if ("loop" in run) {
         claims.push(run);
         claimed.push(run.run);
+        laneClaims[lane] += 1;
       } else if (run.status === "skipped") {
         skipped.push(run);
         loopSkips += 1;
@@ -7381,13 +7394,23 @@ function intervalFromEnv() {
   const value = Number(raw);
   return Number.isFinite(value) && value > 0 ? value : undefined;
 }
-function concurrencyFromEnv() {
-  const raw = process.env.LOOPS_DAEMON_CONCURRENCY;
+function positiveIntEnv(name) {
+  const raw = process.env[name];
   if (!raw)
     return;
   const value = Number(raw);
   return Number.isInteger(value) && value > 0 ? value : undefined;
 }
+function concurrencyFromEnv() {
+  return positiveIntEnv("LOOPS_DAEMON_CONCURRENCY");
+}
+var DEFAULT_COMMAND_CONCURRENCY = 4;
+var DEFAULT_AGENT_CONCURRENCY = 8;
+function resolveLaneConcurrency(opts = {}) {
+  const command = Math.max(1, opts.commandConcurrency ?? positiveIntEnv("LOOPS_DAEMON_COMMAND_CONCURRENCY") ?? DEFAULT_COMMAND_CONCURRENCY);
+  const agent = Math.max(1, opts.agentConcurrency ?? opts.concurrency ?? positiveIntEnv("LOOPS_DAEMON_AGENT_CONCURRENCY") ?? concurrencyFromEnv() ?? DEFAULT_AGENT_CONCURRENCY);
+  return { command, agent };
+}
 var DAEMON_LOG_MAX_BYTES = 50 * 1024 * 1024;
 var DAEMON_LOG_KEEP = 2;
 function daemonLogLine(message) {
@@ -7433,7 +7456,7 @@ async function runDaemon(opts = {}) {
   const runnerId = `${hostname2()}:${process.pid}:${leaseId}`;
   const intervalMs = opts.intervalMs ?? intervalFromEnv() ?? 1000;
   const leaseTtlMs = opts.leaseTtlMs ?? Math.max(60000, intervalMs * 10);
-  const concurrency = Math.max(1, opts.concurrency ?? concurrencyFromEnv() ?? 4);
+  const laneConcurrency = resolveLaneConcurrency(opts);
   const log = opts.log ?? defaultDaemonLog;
   const sleep = opts.sleep ?? realSleep;
   const lease = store.acquireDaemonLease({
@@ -7445,12 +7468,13 @@ async function runDaemon(opts = {}) {
   if (!lease)
     throw new Error("another loops daemon holds the database lease");
   writePid(process.pid, pidPath);
-  log(`started pid=${process.pid} interval=${intervalMs}ms lease=${leaseId}`);
+  log(`started pid=${process.pid} interval=${intervalMs}ms lease=${leaseId} ` + `command_concurrency=${laneConcurrency.command} agent_concurrency=${laneConcurrency.agent}`);
   let stopFlag = false;
   let leaseLost = false;
   let leaseEpoch = 0;
   let runAbort = new AbortController;
   const activeRuns = new Map;
+  const activeByLane = { command: 0, agent: 0 };
   const requestStop = (message) => {
     stopFlag = true;
     if (!runAbort.signal.aborted)
@@ -7543,7 +7567,12 @@ async function runDaemon(opts = {}) {
     log(`run ${finalRun.id} ${finalRun.status} loop=${claim.loop.id}`);
   };
   const startClaim = (claim) => {
-    const task = executeDaemonRun(claim).catch((err) => log(`run ${claim.run.id} error: ${err instanceof Error ? err.message : String(err)}`)).finally(() => activeRuns.delete(claim.run.id));
+    const lane = loopLane(claim.loop);
+    activeByLane[lane] += 1;
+    const task = executeDaemonRun(claim).catch((err) => log(`run ${claim.run.id} error: ${err instanceof Error ? err.message : String(err)}`)).finally(() => {
+      activeRuns.delete(claim.run.id);
+      activeByLane[lane] -= 1;
+    });
     activeRuns.set(claim.run.id, task);
   };
   try {
@@ -7579,19 +7608,23 @@ async function runDaemon(opts = {}) {
       onTickError: (err) => log(`tick error: ${err instanceof Error ? err.message : String(err)}`),
       tickFn: async () => {
         ensureLease();
-        const available = Math.max(0, concurrency - activeRuns.size);
+        const laneLimits = {
+          command: Math.max(0, laneConcurrency.command - activeByLane.command),
+          agent: Math.max(0, laneConcurrency.agent - activeByLane.agent)
+        };
         const result = claimDueRuns({
           store,
           runnerId,
           daemonLeaseId: leaseId,
           beforeRun: () => ensureLease(),
-          maxClaims: available
+          maxClaims: laneLimits.command + laneLimits.agent,
+          laneLimits
         });
         for (const claim of result.claims)
           startClaim(claim);
         const changed = result.claims.length + result.skipped.length + result.recovered.length + result.expired.length;
         if (changed > 0) {
-          log(`tick claimed=${result.claims.length} active=${activeRuns.size} skipped=${result.skipped.length} recovered=${result.recovered.length} expired=${result.expired.length}`);
+          log(`tick claimed=${result.claims.length} active=${activeRuns.size} (command=${activeByLane.command} agent=${activeByLane.agent}) skipped=${result.skipped.length} recovered=${result.recovered.length} expired=${result.expired.length}`);
         }
         await reapAbandoned(result.recovered);
       }
@@ -7752,7 +7785,7 @@ function enableStartup(result) {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.10",
+  version: "0.4.11",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -7883,7 +7916,12 @@ function packageVersion() {
 // src/daemon/index.ts
 var program = new Command;
 program.name("loops-daemon").description("OpenLoops daemon helper").version(packageVersion());
-program.command("run").option("--interval-ms <ms>", "tick interval", (value) => Number(value)).option("--concurrency <n>", "maximum loop runs to execute concurrently", (value) => Number(value)).action(async (opts) => runDaemon({ intervalMs: opts.intervalMs, concurrency: opts.concurrency }));
+program.command("run").option("--interval-ms <ms>", "tick interval", (value) => Number(value)).option("--concurrency <n>", "legacy total knob; sets the agent/workflow lane budget", (value) => Number(value)).option("--command-concurrency <n>", "claim budget for command-target loops (default 4)", (value) => Number(value)).option("--agent-concurrency <n>", "claim budget for agent/workflow-target loops (default 8)", (value) => Number(value)).action(async (opts) => runDaemon({
+  intervalMs: opts.intervalMs,
+  concurrency: opts.concurrency,
+  commandConcurrency: opts.commandConcurrency,
+  agentConcurrency: opts.agentConcurrency
+}));
 program.command("start").action(async () => {
   const result = await startDaemon({ cliEntry: process.argv[1] ?? "loops-daemon", args: ["run"] });
   console.log(JSON.stringify(result, null, 2));

package/dist/index.js

@@ -4235,7 +4235,7 @@ class Store {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.10",
+  version: "0.4.11",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -7286,6 +7286,9 @@ async function executeLoopTarget(store, loop, run, opts = {}) {
 }
 
 // src/lib/scheduler.ts
+function loopLane(loop) {
+  return loop.target.type === "command" ? "command" : "agent";
+}
 function manualRunScheduledFor(loop, now = new Date) {
   if (loop.archivedAt)
     return now.toISOString();
@@ -7678,14 +7681,23 @@ function claimDueRuns(deps) {
   const maxClaims = Math.max(0, deps.maxClaims ?? Number.POSITIVE_INFINITY);
   if (maxClaims === 0)
     return { claims, claimed, completed: [], skipped, recovered, expired };
+  const laneLimits = deps.laneLimits;
+  const laneClaims = { command: 0, agent: 0 };
+  const laneCap = (lane) => laneLimits === undefined ? Number.POSITIVE_INFINITY : Math.max(0, laneLimits[lane] ?? Number.POSITIVE_INFINITY);
+  const laneFull = (lane) => laneClaims[lane] >= laneCap(lane);
   for (const loop of deps.store.dueLoops(now)) {
     if (claims.length >= maxClaims)
       break;
+    const lane = loopLane(loop);
+    if (laneFull(lane))
+      continue;
     const plan = dueSlots(loop, now);
     let loopSkips = 0;
     for (const slot of plan.slots) {
       if (claims.length >= maxClaims)
         break;
+      if (laneFull(lane))
+        break;
       if (loopSkips >= MAX_SKIPS_PER_LOOP_PER_TICK)
         break;
       const run = claimSlot(deps, loop, slot);
@@ -7694,6 +7706,7 @@ function claimDueRuns(deps) {
       if ("loop" in run) {
         claims.push(run);
         claimed.push(run.run);
+        laneClaims[lane] += 1;
       } else if (run.status === "skipped") {
         skipped.push(run);
         loopSkips += 1;

package/dist/lib/mode.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.10",
+  version: "0.4.11",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",

package/dist/lib/route/pr-review.d.ts

@@ -7,6 +7,10 @@ export interface PrReviewRoutingDecision {
     reviewers: string[];
     selectedReviewer?: string;
     signals: string[];
+    /** Set when the route was skipped because the PR is definitively MERGED/CLOSED. */
+    freshnessSkip?: boolean;
+    /** Resolved PR lifecycle state (e.g. MERGED/CLOSED) when the freshness gate fired. */
+    prState?: string;
 }
 /** A GitHub PR reference resolvable to `owner/repo#number`. */
 export interface PrReference {
@@ -25,4 +29,16 @@ export interface PrLiveState {
 export type PrStateResolver = (ref: PrReference) => PrLiveState | undefined;
 /** Extracts a concrete owner/repo/number PR reference from route evidence text. */
 export declare function prReferenceFrom(text: string): PrReference | undefined;
+/** Canonical `owner/repo#number`, lowercased for case-stable dedupe. */
+export declare function prFingerprint(ref: PrReference): string;
+/**
+ * Stable GitHub `owner/repo#number` fingerprint for a PR-subject task. The repos
+ * registry maps several local checkouts to one GitHub repo, so a single PR is
+ * minted as 2-3 duplicate todos tasks (distinct ids + distinct checkout paths).
+ * Keying dedupe on this fingerprint collapses them to one work item instead of
+ * burning a full worker cycle per checkout. Prefers an explicit PR fingerprint
+ * field, then a canonical PR URL / `github-pr:` handle in route evidence;
+ * returns undefined for tasks with no concrete PR reference (keep path/id keying).
+ */
+export declare function prFingerprintFromTask(data: Record<string, unknown>, metadata: Record<string, unknown>): string | undefined;
 export declare function prReviewRoutingDecision(data: Record<string, unknown>, metadata: Record<string, unknown>, opts: TodosTaskRouteOptions, resolveAuthor?: PrAuthorResolver, resolveState?: PrStateResolver): PrReviewRoutingDecision;

package/dist/lib/scheduler.d.ts

@@ -29,6 +29,18 @@ export interface ClaimedLoopRun {
 export interface ClaimDueRunsResult extends TickResult {
     claims: ClaimedLoopRun[];
 }
+/**
+ * Scheduler concurrency lanes. Command-target loops are typically fast
+ * (monitors, digests, syncs); agent/workflow-target loops are long-running
+ * headless workers (minutes to over an hour). They draw from separate claim
+ * budgets so a saturated agent lane cannot starve fast command loops (and vice
+ * versa) — the single shared pool let long workers monopolize every slot.
+ */
+export type SchedulerLane = "command" | "agent";
+/** The concurrency lane a loop's target belongs to. */
+export declare function loopLane(loop: Loop): SchedulerLane;
+/** Remaining claim budget per lane for a single `claimDueRuns` pass. */
+export type LaneLimits = Partial<Record<SchedulerLane, number>>;
 export declare function manualRunScheduledFor(loop: Loop, now?: Date): string;
 export declare function shouldAdvanceManualRun(loop: Loop, scheduledFor: string, now?: Date): boolean;
 export type ManualRunSource = "ad_hoc" | "due_slot" | "retry_slot";
@@ -121,5 +133,6 @@ export declare function executeClaimedRun(deps: {
 }): Promise<LoopRun>;
 export declare function claimDueRuns(deps: SchedulerDeps & {
     maxClaims?: number;
+    laneLimits?: LaneLimits;
 }): ClaimDueRunsResult;
 export declare function tick(deps: SchedulerDeps): Promise<TickResult>;

package/dist/mcp/index.js

@@ -7021,6 +7021,9 @@ async function executeLoopTarget(store, loop, run, opts = {}) {
 }
 
 // src/lib/scheduler.ts
+function loopLane(loop) {
+  return loop.target.type === "command" ? "command" : "agent";
+}
 function manualRunScheduledFor(loop, now = new Date) {
   if (loop.archivedAt)
     return now.toISOString();
@@ -7413,14 +7416,23 @@ function claimDueRuns(deps) {
   const maxClaims = Math.max(0, deps.maxClaims ?? Number.POSITIVE_INFINITY);
   if (maxClaims === 0)
     return { claims, claimed, completed: [], skipped, recovered, expired };
+  const laneLimits = deps.laneLimits;
+  const laneClaims = { command: 0, agent: 0 };
+  const laneCap = (lane) => laneLimits === undefined ? Number.POSITIVE_INFINITY : Math.max(0, laneLimits[lane] ?? Number.POSITIVE_INFINITY);
+  const laneFull = (lane) => laneClaims[lane] >= laneCap(lane);
   for (const loop of deps.store.dueLoops(now)) {
     if (claims.length >= maxClaims)
       break;
+    const lane = loopLane(loop);
+    if (laneFull(lane))
+      continue;
     const plan = dueSlots(loop, now);
     let loopSkips = 0;
     for (const slot of plan.slots) {
       if (claims.length >= maxClaims)
         break;
+      if (laneFull(lane))
+        break;
       if (loopSkips >= MAX_SKIPS_PER_LOOP_PER_TICK)
         break;
       const run = claimSlot(deps, loop, slot);
@@ -7429,6 +7441,7 @@ function claimDueRuns(deps) {
       if ("loop" in run) {
         claims.push(run);
         claimed.push(run.run);
+        laneClaims[lane] += 1;
       } else if (run.status === "skipped") {
         skipped.push(run);
         loopSkips += 1;
@@ -7468,7 +7481,7 @@ async function tick(deps) {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.10",
+  version: "0.4.11",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",

package/dist/runner/index.js

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.10",
+  version: "0.4.11",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",

package/dist/sdk/index.js

@@ -4235,7 +4235,7 @@ class Store {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.10",
+  version: "0.4.11",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -7792,6 +7792,9 @@ async function executeLoopTarget(store, loop, run, opts = {}) {
 }
 
 // src/lib/scheduler.ts
+function loopLane(loop) {
+  return loop.target.type === "command" ? "command" : "agent";
+}
 function manualRunScheduledFor(loop, now = new Date) {
   if (loop.archivedAt)
     return now.toISOString();
@@ -8184,14 +8187,23 @@ function claimDueRuns(deps) {
   const maxClaims = Math.max(0, deps.maxClaims ?? Number.POSITIVE_INFINITY);
   if (maxClaims === 0)
     return { claims, claimed, completed: [], skipped, recovered, expired };
+  const laneLimits = deps.laneLimits;
+  const laneClaims = { command: 0, agent: 0 };
+  const laneCap = (lane) => laneLimits === undefined ? Number.POSITIVE_INFINITY : Math.max(0, laneLimits[lane] ?? Number.POSITIVE_INFINITY);
+  const laneFull = (lane) => laneClaims[lane] >= laneCap(lane);
   for (const loop of deps.store.dueLoops(now)) {
     if (claims.length >= maxClaims)
       break;
+    const lane = loopLane(loop);
+    if (laneFull(lane))
+      continue;
     const plan = dueSlots(loop, now);
     let loopSkips = 0;
     for (const slot of plan.slots) {
       if (claims.length >= maxClaims)
         break;
+      if (laneFull(lane))
+        break;
       if (loopSkips >= MAX_SKIPS_PER_LOOP_PER_TICK)
         break;
       const run = claimSlot(deps, loop, slot);
@@ -8200,6 +8212,7 @@ function claimDueRuns(deps) {
       if ("loop" in run) {
         claims.push(run);
         claimed.push(run.run);
+        laneClaims[lane] += 1;
       } else if (run.status === "skipped") {
         skipped.push(run);
         loopSkips += 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/loops",
-  "version": "0.4.10",
+  "version": "0.4.11",
   "description": "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   "type": "module",
   "main": "dist/index.js",