@hasna/loops 0.4.10 → 0.4.12

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

@@ -1323,6 +1323,7 @@ function rowToWorkflowWorkItem(row) {
     subjectRef: row.subject_ref,
     projectKey: row.project_key ?? undefined,
     projectGroup: row.project_group ?? undefined,
+    routeScope: row.route_scope ?? undefined,
     priority: row.priority,
     status: row.status,
     attempts: row.attempts,
@@ -1603,6 +1604,13 @@ class Store {
           this.addColumnIfMissing("loop_runs", "claim_token", "TEXT");
           this.db.exec("CREATE INDEX IF NOT EXISTS idx_runs_claim_token ON loop_runs(claim_token) WHERE claim_token IS NOT NULL");
         }
+      },
+      {
+        id: "0008_work_item_route_scope",
+        apply: () => {
+          this.addColumnIfMissing("workflow_work_items", "route_scope", "TEXT");
+          this.db.exec("CREATE INDEX IF NOT EXISTS idx_workflow_work_items_scope ON workflow_work_items(route_scope, status)");
+        }
       }
     ];
   }
@@ -1750,6 +1758,7 @@ class Store {
         subject_ref TEXT NOT NULL,
         project_key TEXT,
         project_group TEXT,
+        route_scope TEXT,
         priority INTEGER NOT NULL,
         status TEXT NOT NULL,
         attempts INTEGER NOT NULL,
@@ -1767,6 +1776,13 @@ class Store {
       CREATE INDEX IF NOT EXISTS idx_workflow_work_items_project ON workflow_work_items(project_key, status);
       CREATE INDEX IF NOT EXISTS idx_workflow_work_items_group ON workflow_work_items(project_group, status);
       CREATE INDEX IF NOT EXISTS idx_workflow_work_items_invocation ON workflow_work_items(invocation_id);
+      -- idx_workflow_work_items_scope (route_scope, status) is created ONLY by
+      -- migration 0008_work_item_route_scope, never here: this baseline DDL
+      -- re-runs on EVERY open (0001 is not skip-guarded), and on a pre-0008
+      -- database the CREATE TABLE above is a no-op, so an index on route_scope
+      -- here would execute before the column exists and crash the open
+      -- ("no such column: route_scope"). New columns may be folded into the
+      -- CREATE TABLE (fresh-db only); their indexes must live in the migration.
 
       CREATE TABLE IF NOT EXISTS workflow_step_runs (
         id TEXT PRIMARY KEY,
@@ -2558,10 +2574,10 @@ class Store {
     const id = genId();
     const status = input.status ?? "queued";
     this.db.query(`INSERT INTO workflow_work_items (id, route_key, idempotency_key, invocation_id, source_type, source_ref,
-          subject_ref, project_key, project_group, priority, status, attempts, next_attempt_at, lease_expires_at,
+          subject_ref, project_key, project_group, route_scope, priority, status, attempts, next_attempt_at, lease_expires_at,
           workflow_id, loop_id, workflow_run_id, last_reason, created_at, updated_at)
          VALUES ($id, $routeKey, $idempotencyKey, $invocationId, $sourceType, $sourceRef, $subjectRef,
-          $projectKey, $projectGroup, $priority, $status, 0, $nextAttemptAt, NULL, NULL, NULL, NULL,
+          $projectKey, $projectGroup, $routeScope, $priority, $status, 0, $nextAttemptAt, NULL, NULL, NULL, NULL,
           $lastReason, $created, $updated)
          ON CONFLICT(route_key, idempotency_key) DO UPDATE SET
           invocation_id=excluded.invocation_id,
@@ -2570,6 +2586,7 @@ class Store {
           subject_ref=excluded.subject_ref,
           project_key=excluded.project_key,
           project_group=excluded.project_group,
+          route_scope=excluded.route_scope,
           priority=excluded.priority,
           status=CASE
             WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled')
@@ -2611,6 +2628,7 @@ class Store {
       $subjectRef: input.subjectRef,
       $projectKey: input.projectKey ?? null,
       $projectGroup: input.projectGroup ?? null,
+      $routeScope: input.routeScope ?? null,
       $priority: input.priority ?? 0,
       $status: status,
       $nextAttemptAt: input.nextAttemptAt ?? null,
@@ -2648,11 +2666,21 @@ class Store {
   countActiveWorkflowWorkItems(args = {}) {
     const active = ["admitted", "running"];
     const placeholders = active.map(() => "?").join(",");
-    const global = this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders})`).get(...active)?.count ?? 0;
+    const routeScope = args.routeScope?.trim() || undefined;
+    const global = routeScope ? this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders}) AND route_scope = ?`).get(...active, routeScope)?.count ?? 0 : this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders})`).get(...active)?.count ?? 0;
     const project = args.projectKey ? this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders}) AND project_key = ?`).get(...active, args.projectKey)?.count ?? 0 : 0;
     const projectGroup = args.projectGroup ? this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders}) AND project_group = ?`).get(...active, args.projectGroup)?.count ?? 0 : undefined;
     return { global, project, ...projectGroup !== undefined ? { projectGroup } : {} };
   }
+  countRunningWorkflowStepsByAuthProfile() {
+    const rows = this.db.query("SELECT account_profile, COUNT(*) AS count FROM workflow_step_runs WHERE status = 'running' AND account_profile IS NOT NULL GROUP BY account_profile").all();
+    const counts = {};
+    for (const row of rows) {
+      if (row.account_profile)
+        counts[row.account_profile] = row.count;
+    }
+    return counts;
+  }
   requeueWorkflowWorkItem(id, patch = {}) {
     const current = this.getWorkflowWorkItem(id);
     if (!current)
@@ -3088,6 +3116,9 @@ class Store {
       }
       input.workflow.steps.forEach((step, sequence) => {
         const account = step.account ?? step.target.account;
+        const agentTarget = step.target.type === "agent" ? step.target : undefined;
+        const resolvedProfile = account?.profile ?? agentTarget?.authProfile ?? null;
+        const resolvedTool = account?.tool ?? (agentTarget?.authProfile ? agentTarget.provider : null);
         this.db.query(`INSERT INTO workflow_step_runs (id, workflow_run_id, step_id, sequence, status, started_at, finished_at,
               exit_code, pid, duration_ms, stdout, stderr, error, account_profile, account_tool, created_at, updated_at)
              VALUES ($id, $workflowRunId, $stepId, $sequence, 'pending', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
@@ -3096,8 +3127,8 @@ class Store {
           $workflowRunId: runId,
           $stepId: step.id,
           $sequence: sequence,
-          $accountProfile: account?.profile ?? null,
-          $accountTool: account?.tool ?? null,
+          $accountProfile: resolvedProfile,
+          $accountTool: resolvedTool,
           $created: now,
           $updated: now
         });
@@ -6705,6 +6736,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 +7131,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 +7156,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 +7425,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 +7487,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 +7499,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 +7598,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 +7639,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 +7816,7 @@ function enableStartup(result) {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.10",
+  version: "0.4.12",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -7883,7 +7947,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

@@ -1321,6 +1321,7 @@ function rowToWorkflowWorkItem(row) {
     subjectRef: row.subject_ref,
     projectKey: row.project_key ?? undefined,
     projectGroup: row.project_group ?? undefined,
+    routeScope: row.route_scope ?? undefined,
     priority: row.priority,
     status: row.status,
     attempts: row.attempts,
@@ -1601,6 +1602,13 @@ class Store {
           this.addColumnIfMissing("loop_runs", "claim_token", "TEXT");
           this.db.exec("CREATE INDEX IF NOT EXISTS idx_runs_claim_token ON loop_runs(claim_token) WHERE claim_token IS NOT NULL");
         }
+      },
+      {
+        id: "0008_work_item_route_scope",
+        apply: () => {
+          this.addColumnIfMissing("workflow_work_items", "route_scope", "TEXT");
+          this.db.exec("CREATE INDEX IF NOT EXISTS idx_workflow_work_items_scope ON workflow_work_items(route_scope, status)");
+        }
       }
     ];
   }
@@ -1748,6 +1756,7 @@ class Store {
         subject_ref TEXT NOT NULL,
         project_key TEXT,
         project_group TEXT,
+        route_scope TEXT,
         priority INTEGER NOT NULL,
         status TEXT NOT NULL,
         attempts INTEGER NOT NULL,
@@ -1765,6 +1774,13 @@ class Store {
       CREATE INDEX IF NOT EXISTS idx_workflow_work_items_project ON workflow_work_items(project_key, status);
       CREATE INDEX IF NOT EXISTS idx_workflow_work_items_group ON workflow_work_items(project_group, status);
       CREATE INDEX IF NOT EXISTS idx_workflow_work_items_invocation ON workflow_work_items(invocation_id);
+      -- idx_workflow_work_items_scope (route_scope, status) is created ONLY by
+      -- migration 0008_work_item_route_scope, never here: this baseline DDL
+      -- re-runs on EVERY open (0001 is not skip-guarded), and on a pre-0008
+      -- database the CREATE TABLE above is a no-op, so an index on route_scope
+      -- here would execute before the column exists and crash the open
+      -- ("no such column: route_scope"). New columns may be folded into the
+      -- CREATE TABLE (fresh-db only); their indexes must live in the migration.
 
       CREATE TABLE IF NOT EXISTS workflow_step_runs (
         id TEXT PRIMARY KEY,
@@ -2556,10 +2572,10 @@ class Store {
     const id = genId();
     const status = input.status ?? "queued";
     this.db.query(`INSERT INTO workflow_work_items (id, route_key, idempotency_key, invocation_id, source_type, source_ref,
-          subject_ref, project_key, project_group, priority, status, attempts, next_attempt_at, lease_expires_at,
+          subject_ref, project_key, project_group, route_scope, priority, status, attempts, next_attempt_at, lease_expires_at,
           workflow_id, loop_id, workflow_run_id, last_reason, created_at, updated_at)
          VALUES ($id, $routeKey, $idempotencyKey, $invocationId, $sourceType, $sourceRef, $subjectRef,
-          $projectKey, $projectGroup, $priority, $status, 0, $nextAttemptAt, NULL, NULL, NULL, NULL,
+          $projectKey, $projectGroup, $routeScope, $priority, $status, 0, $nextAttemptAt, NULL, NULL, NULL, NULL,
           $lastReason, $created, $updated)
          ON CONFLICT(route_key, idempotency_key) DO UPDATE SET
           invocation_id=excluded.invocation_id,
@@ -2568,6 +2584,7 @@ class Store {
           subject_ref=excluded.subject_ref,
           project_key=excluded.project_key,
           project_group=excluded.project_group,
+          route_scope=excluded.route_scope,
           priority=excluded.priority,
           status=CASE
             WHEN workflow_work_items.status IN ('succeeded', 'admitted', 'running', 'failed', 'dead_letter', 'cancelled')
@@ -2609,6 +2626,7 @@ class Store {
       $subjectRef: input.subjectRef,
       $projectKey: input.projectKey ?? null,
       $projectGroup: input.projectGroup ?? null,
+      $routeScope: input.routeScope ?? null,
       $priority: input.priority ?? 0,
       $status: status,
       $nextAttemptAt: input.nextAttemptAt ?? null,
@@ -2646,11 +2664,21 @@ class Store {
   countActiveWorkflowWorkItems(args = {}) {
     const active = ["admitted", "running"];
     const placeholders = active.map(() => "?").join(",");
-    const global = this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders})`).get(...active)?.count ?? 0;
+    const routeScope = args.routeScope?.trim() || undefined;
+    const global = routeScope ? this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders}) AND route_scope = ?`).get(...active, routeScope)?.count ?? 0 : this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders})`).get(...active)?.count ?? 0;
     const project = args.projectKey ? this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders}) AND project_key = ?`).get(...active, args.projectKey)?.count ?? 0 : 0;
     const projectGroup = args.projectGroup ? this.db.query(`SELECT COUNT(*) AS count FROM workflow_work_items WHERE status IN (${placeholders}) AND project_group = ?`).get(...active, args.projectGroup)?.count ?? 0 : undefined;
     return { global, project, ...projectGroup !== undefined ? { projectGroup } : {} };
   }
+  countRunningWorkflowStepsByAuthProfile() {
+    const rows = this.db.query("SELECT account_profile, COUNT(*) AS count FROM workflow_step_runs WHERE status = 'running' AND account_profile IS NOT NULL GROUP BY account_profile").all();
+    const counts = {};
+    for (const row of rows) {
+      if (row.account_profile)
+        counts[row.account_profile] = row.count;
+    }
+    return counts;
+  }
   requeueWorkflowWorkItem(id, patch = {}) {
     const current = this.getWorkflowWorkItem(id);
     if (!current)
@@ -3086,6 +3114,9 @@ class Store {
       }
       input.workflow.steps.forEach((step, sequence) => {
         const account = step.account ?? step.target.account;
+        const agentTarget = step.target.type === "agent" ? step.target : undefined;
+        const resolvedProfile = account?.profile ?? agentTarget?.authProfile ?? null;
+        const resolvedTool = account?.tool ?? (agentTarget?.authProfile ? agentTarget.provider : null);
         this.db.query(`INSERT INTO workflow_step_runs (id, workflow_run_id, step_id, sequence, status, started_at, finished_at,
               exit_code, pid, duration_ms, stdout, stderr, error, account_profile, account_tool, created_at, updated_at)
              VALUES ($id, $workflowRunId, $stepId, $sequence, 'pending', NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
@@ -3094,8 +3125,8 @@ class Store {
           $workflowRunId: runId,
           $stepId: step.id,
           $sequence: sequence,
-          $accountProfile: account?.profile ?? null,
-          $accountTool: account?.tool ?? null,
+          $accountProfile: resolvedProfile,
+          $accountTool: resolvedTool,
           $created: now,
           $updated: now
         });
@@ -4235,7 +4266,7 @@ class Store {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.10",
+  version: "0.4.12",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -7286,6 +7317,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 +7712,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 +7737,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;
@@ -9533,6 +9577,10 @@ CREATE TABLE IF NOT EXISTS audit_events (
 );
 CREATE INDEX IF NOT EXISTS idx_audit_events_subject ON audit_events(subject_type, subject_id, created_at DESC);
 CREATE INDEX IF NOT EXISTS idx_audit_events_action ON audit_events(action, created_at DESC);
+    `),
+  migration("0004_work_item_route_scope", `
+ALTER TABLE workflow_work_items ADD COLUMN IF NOT EXISTS route_scope TEXT;
+CREATE INDEX IF NOT EXISTS idx_workflow_work_items_scope ON workflow_work_items(route_scope, status);
     `)
 ]);
 
@@ -10187,6 +10235,79 @@ function prHandoffCommand(opts) {
   ].join(`
 `);
 }
+
+// src/lib/route/profile-pool.ts
+function stableIndex(seed, size) {
+  let hash = 2166136261;
+  for (let i = 0;i < seed.length; i += 1) {
+    hash ^= seed.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return Math.abs(hash >>> 0) % size;
+}
+function poolRoleOffset(role) {
+  if (role === "worker")
+    return 0;
+  if (role === "verifier")
+    return 1;
+  if (role === "planner")
+    return 2;
+  return 3;
+}
+function selectLeastLoadedProfile(pool, loadCounts, anchor, exclude) {
+  const size = pool.length;
+  let best;
+  let bestExcluded = true;
+  let bestLoad = Number.POSITIVE_INFINITY;
+  for (let k = 0;k < size; k += 1) {
+    const profile = pool[(anchor + k) % size];
+    const excluded = exclude.has(profile);
+    const load = loadCounts[profile] ?? 0;
+    if (best === undefined) {
+      best = profile;
+      bestExcluded = excluded;
+      bestLoad = load;
+      continue;
+    }
+    const better = excluded === bestExcluded ? load < bestLoad : !excluded && bestExcluded;
+    if (better) {
+      best = profile;
+      bestExcluded = excluded;
+      bestLoad = load;
+    }
+  }
+  return best;
+}
+var ROLE_PRIORITY = ["worker", "verifier", "planner", "triage"];
+function assignPoolAuthProfiles(input) {
+  const pool = input.pool.filter((entry) => entry.trim().length > 0);
+  if (pool.length === 0)
+    return { profiles: {}, deferred: false, minLoad: 0 };
+  const minLoad = pool.reduce((min, profile) => Math.min(min, input.loadCounts[profile] ?? 0), Number.POSITIVE_INFINITY);
+  const guard = input.maxPerProfile !== undefined && input.maxPerProfile > 0;
+  if (guard && minLoad >= input.maxPerProfile) {
+    return {
+      profiles: {},
+      deferred: true,
+      minLoad,
+      reason: `per-profile active limit reached (all ${pool.length} pool members >= ${input.maxPerProfile} running; min ${minLoad})`
+    };
+  }
+  const workerIndex = stableIndex(input.seed, pool.length);
+  const rolesToAssign = ROLE_PRIORITY.filter((role) => input.roles.includes(role));
+  for (const role of input.roles)
+    if (!rolesToAssign.includes(role))
+      rolesToAssign.push(role);
+  const profiles = {};
+  const taken = new Set;
+  for (const role of rolesToAssign) {
+    const anchor = (workerIndex + poolRoleOffset(role)) % pool.length;
+    const profile = selectLeastLoadedProfile(pool, input.loadCounts, anchor, taken);
+    profiles[role] = profile;
+    taken.add(profile);
+  }
+  return { profiles, deferred: false, minLoad: Number.isFinite(minLoad) ? minLoad : 0 };
+}
 // src/lib/templates-custom.ts
 import { existsSync as existsSync5, lstatSync as lstatSync2, mkdirSync as mkdirSync6, readdirSync, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
 import { join as join6, resolve as resolve3 } from "path";
@@ -10582,25 +10703,13 @@ function parseDeterministicTimeoutMs(raw, fallbackMs, label = "timeoutMs") {
     throw new Error(`${label} must be a positive integer number of milliseconds`);
   return value;
 }
-function stableIndex(seed, size) {
-  let hash = 2166136261;
-  for (let i = 0;i < seed.length; i += 1) {
-    hash ^= seed.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return Math.abs(hash >>> 0) % size;
-}
 function rolePoolValue(pool, seed, role) {
   if (!pool?.length)
     return;
   const workerIndex = stableIndex(seed, pool.length);
-  if (role === "worker" || pool.length === 1)
+  if (pool.length === 1)
     return pool[workerIndex];
-  if (role === "verifier")
-    return pool[(workerIndex + 1) % pool.length];
-  if (role === "planner")
-    return pool[(workerIndex + 2) % pool.length];
-  return pool[(workerIndex + 3) % pool.length];
+  return pool[(workerIndex + poolRoleOffset(role)) % pool.length];
 }
 function authProfileForRole(input, role, seed) {
   if (role === "triage" && input.triageAuthProfile)
@@ -10770,7 +10879,8 @@ function agentTarget(input, prompt, role, seed, plan) {
     allowlist: input.manualBreakGlass ? { enforcement: "metadata_only", commands: ["manual-break-glass"] } : undefined,
     routing: {
       projectPath: input.routeProjectPath ?? input.projectPath,
-      ...input.projectGroup ? { projectGroup: input.projectGroup } : {}
+      ...input.projectGroup ? { projectGroup: input.projectGroup } : {},
+      role
     },
     account: accountForRole(input, role, seed),
     timeoutMs: agentTimeoutMs(input),

package/dist/lib/mode.js

@@ -2,7 +2,7 @@
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.10",
+  version: "0.4.12",
   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;