@hasna/loops 0.3.19 → 0.3.21

package/README.md

@@ -309,6 +309,7 @@ loops health route-tasks --project ~/.hasna/loops --task-list loop-error-self-he
 loops hygiene names --json
 loops hygiene duplicates --json
 loops hygiene scripts --json
+loops hygiene route-tasks --checks duplicates,scripts --project ~/.hasna/loops --task-list openloops-hygiene
 ```
 
 `health` and `expectations` classify latest-run failures with stable
@@ -322,6 +323,11 @@ renames only with `--apply`. Apply mode writes a SQLite backup under
 `<LOOPS_DATA_DIR>/backups` before changing loop names. `hygiene duplicates`
 groups loops with the same normalized name, cwd, and schedule. `hygiene scripts`
 inventories loops whose command still references `~/.hasna/loops/scripts`.
+`hygiene route-tasks` upserts deduped Todos tasks for hygiene findings with
+stable fingerprints and `no_tmux_dispatch=true` metadata. Route commands use a
+package-managed cursor under `<LOOPS_DATA_DIR>/route-cursors.json` so bounded
+`--max-actions` runs advance through all findings over repeated scheduled runs
+instead of reprocessing only the first batch.
 
 Archive loops when retiring old automation but preserving history:
 

package/dist/cli/index.js

@@ -4757,6 +4757,7 @@ function recommendedTask(loop, run, failure, route) {
     `Status: ${run.status}`,
     `Classification: ${failure.classification}`,
     `Fingerprint: ${failure.fingerprint}`,
+    `No-tmux routing: Do not dispatch or paste prompts into tmux panes; use task-triggered headless worker/verifier workflows only.`,
     route.cwd ? `Route cwd: ${route.cwd}` : undefined,
     route.provider ? `Provider: ${route.provider}` : undefined,
     failure.evidence.error ? `Error:
@@ -5091,7 +5092,7 @@ function buildScriptInventoryReport(store, opts = {}) {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.3.19",
+  version: "0.3.21",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -5332,6 +5333,7 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     "You are the worker agent for a task-triggered OpenLoops workflow.",
     "Investigate first before changing files. Use the todos CLI as the source of truth for the task.",
     "Claim/start the task if appropriate, inspect the repository/project state, implement only the task scope, run focused validation, preserve unrelated user changes, and update the task with comments, evidence, changed files, commits, and blockers.",
+    "Do not dispatch or paste prompts into tmux panes. If additional work is required, create or update deduped todos tasks so task-created routing can start a fresh headless workflow.",
     "Do not mark the task complete unless the work is genuinely done and validated.",
     "",
     `Task context JSON: ${compactJson(taskContext)}`
@@ -5343,6 +5345,7 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     "You are the verifier agent for a task-triggered OpenLoops workflow.",
     "Use fresh context. Inspect the task, repository state, commits, tests, and worker evidence. Act as an adversarial reviewer focused on correctness, regressions, missing tests, security, and incomplete requirements.",
     "If the work is valid, record verification evidence in todos and mark/leave the task in the correct completed state according to the todos CLI. If it is not valid, add precise follow-up tasks or comments and leave the original task open or blocked with clear evidence.",
+    "Do not dispatch or paste prompts into tmux panes. If additional work is required, create or update deduped todos tasks so task-created routing can start a fresh headless workflow.",
     "Do not make broad unrelated changes. Only apply tiny verification fixes when they are necessary and low risk; otherwise create follow-up tasks.",
     "",
     `Task context JSON: ${compactJson(taskContext)}`
@@ -5757,6 +5760,57 @@ function backupLoopsDatabase(reason) {
   }
   return backupPath;
 }
+function stableHash(parts) {
+  return createHash2("sha256").update(parts.map((part) => JSON.stringify(part)).join(`
+`)).digest("hex").slice(0, 16);
+}
+function routeCursorsPath() {
+  return join3(dataDir(), "route-cursors.json");
+}
+function readRouteCursors() {
+  const path = routeCursorsPath();
+  if (!existsSync3(path))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeRouteCursor(key, lastFingerprint) {
+  if (!lastFingerprint)
+    return;
+  const cursors = readRouteCursors();
+  cursors[key] = { lastFingerprint, updatedAt: new Date().toISOString() };
+  writeFileSync3(routeCursorsPath(), JSON.stringify(cursors, null, 2), { mode: 384 });
+}
+function selectRouteItems(items, maxActions, cursorKey, fingerprintOf) {
+  const total = items.length;
+  const boundedMax = Math.max(0, Math.floor(Number.isFinite(maxActions) ? maxActions : 0));
+  if (total === 0 || boundedMax === 0) {
+    return { selected: [], cursor: { key: cursorKey, total, maxActions: boundedMax, startIndex: 0 } };
+  }
+  const cursors = readRouteCursors();
+  const previousFingerprint = cursors[cursorKey]?.lastFingerprint;
+  const previousIndex = previousFingerprint ? items.findIndex((item) => fingerprintOf(item) === previousFingerprint) : -1;
+  const startIndex = previousIndex >= 0 ? (previousIndex + 1) % total : 0;
+  const selected = [];
+  const count = Math.min(boundedMax, total);
+  for (let index = 0;index < count; index += 1)
+    selected.push(items[(startIndex + index) % total]);
+  return {
+    selected,
+    cursor: {
+      key: cursorKey,
+      total,
+      maxActions: boundedMax,
+      previousFingerprint,
+      startIndex,
+      lastFingerprint: selected.length ? fingerprintOf(selected[selected.length - 1]) : undefined
+    }
+  };
+}
 function eventData(event) {
   const data = event.data;
   if (data && typeof data === "object" && !Array.isArray(data))
@@ -5838,6 +5892,36 @@ function booleanLike(value) {
 function hasTruthyField(records, keys) {
   return records.some((record) => keys.some((key) => booleanLike(record[key])));
 }
+function automationRecords(data, metadata) {
+  const records = [];
+  const dataAutomation = nestedObject(data, "automation");
+  if (dataAutomation)
+    records.push(dataAutomation);
+  const dataTask = nestedObject(data, "task");
+  const dataTaskAutomation = dataTask ? nestedObject(dataTask, "automation") : undefined;
+  if (dataTaskAutomation)
+    records.push(dataTaskAutomation);
+  const dataPayload = nestedObject(data, "payload");
+  const payloadAutomation = dataPayload ? nestedObject(dataPayload, "automation") : undefined;
+  if (payloadAutomation)
+    records.push(payloadAutomation);
+  const payloadTask = dataPayload ? nestedObject(dataPayload, "task") : undefined;
+  const payloadTaskAutomation = payloadTask ? nestedObject(payloadTask, "automation") : undefined;
+  if (payloadTaskAutomation)
+    records.push(payloadTaskAutomation);
+  const dataMetadata = nestedObject(data, "metadata");
+  const dataMetadataAutomation = dataMetadata ? nestedObject(dataMetadata, "automation") : undefined;
+  if (dataMetadataAutomation)
+    records.push(dataMetadataAutomation);
+  const metadataAutomation = nestedObject(metadata, "automation");
+  if (metadataAutomation)
+    records.push(metadataAutomation);
+  const metadataTask = nestedObject(metadata, "task");
+  const metadataTaskAutomation = metadataTask ? nestedObject(metadataTask, "automation") : undefined;
+  if (metadataTaskAutomation)
+    records.push(metadataTaskAutomation);
+  return records;
+}
 function tagsFromValue(value) {
   if (Array.isArray(value))
     return value.map((entry) => String(entry).trim()).filter(Boolean);
@@ -5856,7 +5940,7 @@ function taskEventTags(records) {
 function taskRouteEligibility(data, metadata) {
   const records = taskEventRecords(data, metadata);
   const tags = taskEventTags(records);
-  const hasRouteOptIn = tags.includes("auto:route") || hasTruthyField(records, ["route_enabled", "routeEnabled", "automation_allowed", "automationAllowed", "allowed"]);
+  const hasRouteOptIn = tags.includes("auto:route") || hasTruthyField(records, ["route_enabled", "routeEnabled", "automation_allowed", "automationAllowed"]) || hasTruthyField(automationRecords(data, metadata), ["allowed"]);
   if (!hasRouteOptIn)
     return { eligible: false, reason: "missing explicit route opt-in", tags };
   const status = taskEventField(data, ["status", "task_status", "taskStatus"])?.toLowerCase();
@@ -6513,9 +6597,10 @@ health.command("route-tasks").description("upsert deduped todos tasks for failed
   const store = new Store;
   try {
     const report = buildHealthReport(store, { limit: Number(opts.limit), includeInactive: Boolean(opts.includeInactive) });
-    const failures = report.expectations.filter((entry) => !entry.ok && entry.recommendedTask).slice(0, Number(opts.maxActions));
+    const failures = report.expectations.filter((entry) => !entry.ok && entry.recommendedTask);
+    const selection = selectRouteItems(failures, Number(opts.maxActions), `health:${stableHash([opts.project, opts.taskList, opts.limit, Boolean(opts.includeInactive)])}`, (expectation) => expectation.recommendedTask.dedupeKey);
     const listId = opts.dryRun ? undefined : ensureTodosTaskList(opts.project, opts.taskList, "Loop Error Self Heal", "Deduped OpenLoops health expectation failures routed by loops health route-tasks.");
-    const actions = failures.map((expectation) => {
+    const actions = selection.selected.map((expectation) => {
       const task = expectation.recommendedTask;
       const metadata = {
         source: "openloops.health.route-tasks",
@@ -6557,7 +6642,15 @@ health.command("route-tasks").description("upsert deduped todos tasks for failed
       }
       return { action: "upserted", fingerprint: task.dedupeKey, task: JSON.parse(result.stdout || "{}") };
     });
-    const routed = { ok: actions.every((action) => action.action !== "upsert-failed"), inspected: report.summary.loops, failures: failures.length, actions };
+    const routed = {
+      ok: actions.every((action) => action.action !== "upsert-failed"),
+      inspected: report.summary.loops,
+      failures: failures.length,
+      routing: selection.cursor,
+      actions
+    };
+    if (!opts.dryRun && routed.ok)
+      writeRouteCursor(selection.cursor.key, selection.cursor.lastFingerprint);
     if (isJson() || opts.json)
       console.log(JSON.stringify(routed, null, 2));
     else {
@@ -6572,28 +6665,171 @@ health.command("route-tasks").description("upsert deduped todos tasks for failed
   }
 });
 var hygiene = program.command("hygiene").description("deterministic OpenLoops hygiene checks and safe repairs");
+var HYGIENE_CHECKS = ["names", "duplicates", "scripts"];
+function parseHygieneChecks(value) {
+  if (!value || value === "all")
+    return HYGIENE_CHECKS;
+  const checks = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+  const invalid = checks.filter((entry) => !HYGIENE_CHECKS.includes(entry));
+  if (invalid.length > 0)
+    throw new Error(`invalid hygiene check(s): ${invalid.join(", ")}`);
+  return [...new Set(checks)];
+}
+function buildHygieneRouteTasks(store, opts) {
+  const checked = { names: 0, duplicates: 0, scripts: 0 };
+  const tasks = [];
+  const limit = opts.limit ?? 1000;
+  if (opts.checks.includes("names")) {
+    const report = buildNameHygieneReport(store, { includeInactive: opts.includeInactive, limit });
+    checked.names = report.checked;
+    for (const change of report.changes.filter((entry) => entry.changed)) {
+      const fingerprint = `openloops:hygiene:names:${change.id}:${stableHash([change.oldName, change.newName])}`;
+      tasks.push({
+        check: "names",
+        title: `OpenLoops hygiene: rename loop ${change.oldName}`,
+        description: [
+          `OpenLoops name hygiene found a non-canonical loop name.`,
+          `Loop: ${change.oldName} (${change.id})`,
+          `Expected name: ${change.newName}`,
+          `Scope: ${change.scope} / ${change.scopeSlug}`,
+          `Fingerprint: ${fingerprint}`,
+          "",
+          "Acceptance:",
+          "- Confirm the canonical name is correct for the loop scope.",
+          "- Rename through OpenLoops CLI/API so ids, schedules, run history, and metadata are preserved.",
+          "- Do not dispatch work by tmux."
+        ].join(`
+`),
+        priority: "low",
+        tags: ["openloops", "hygiene", "name-hygiene"],
+        fingerprint,
+        metadata: {
+          source: "openloops.hygiene.route-tasks",
+          check: "names",
+          loop_id: change.id,
+          old_name: change.oldName,
+          new_name: change.newName,
+          scope: change.scope,
+          scope_slug: change.scopeSlug,
+          no_tmux_dispatch: true
+        }
+      });
+    }
+  }
+  if (opts.checks.includes("duplicates")) {
+    const report = buildDuplicateOverlapReport(store, { includeInactive: opts.includeInactive, limit });
+    checked.duplicates = report.checked;
+    for (const group of report.groups) {
+      const loopIds = group.loops.map((loop) => loop.id).sort();
+      const fingerprint = `openloops:hygiene:duplicates:${stableHash([group.key, loopIds])}`;
+      tasks.push({
+        check: "duplicates",
+        title: `OpenLoops hygiene: duplicate/overlapping loops - ${group.baseName}`,
+        description: [
+          `OpenLoops duplicate/overlap hygiene found multiple loops with the same normalized name, cwd, and schedule.`,
+          `Base name: ${group.baseName}`,
+          group.cwd ? `Cwd: ${group.cwd}` : undefined,
+          `Schedule: ${group.schedule}`,
+          `Fingerprint: ${fingerprint}`,
+          "",
+          "Loops:",
+          ...group.loops.map((loop) => `- ${loop.id} ${loop.status} ${loop.name}`),
+          "",
+          "Acceptance:",
+          "- Decide the authoritative active loop.",
+          "- Archive or retarget superseded loops through OpenLoops CLI/API while preserving history.",
+          "- Do not dispatch work by tmux."
+        ].filter(Boolean).join(`
+`),
+        priority: group.loops.some((loop) => loop.status === "active") ? "medium" : "low",
+        tags: ["openloops", "hygiene", "duplicate-overlap"],
+        fingerprint,
+        metadata: {
+          source: "openloops.hygiene.route-tasks",
+          check: "duplicates",
+          base_name: group.baseName,
+          cwd: group.cwd,
+          schedule: group.schedule,
+          loop_ids: loopIds,
+          no_tmux_dispatch: true
+        }
+      });
+    }
+  }
+  if (opts.checks.includes("scripts")) {
+    const report = buildScriptInventoryReport(store, { includeInactive: opts.includeInactive, limit, scriptsDir: opts.scriptsDir });
+    checked.scripts = report.checked;
+    for (const loop of report.loops) {
+      const fingerprint = `openloops:hygiene:scripts:${loop.id}:${stableHash([loop.command])}`;
+      tasks.push({
+        check: "scripts",
+        title: `OpenLoops hygiene: replace script-backed loop ${loop.name}`,
+        description: [
+          `OpenLoops script inventory found a loop still backed by a local script command.`,
+          `Loop: ${loop.name} (${loop.id})`,
+          `Status: ${loop.status}`,
+          loop.cwd ? `Cwd: ${loop.cwd}` : undefined,
+          `Command: ${loop.command}`,
+          `Fingerprint: ${fingerprint}`,
+          "",
+          "Acceptance:",
+          "- Replace this loop with a package-level CLI/API/template abstraction when one exists.",
+          "- If no abstraction exists, create/update the owning repo task instead of adding another local script.",
+          "- Archive superseded loops through OpenLoops CLI/API and preserve history.",
+          "- Do not dispatch work by tmux."
+        ].filter(Boolean).join(`
+`),
+        priority: loop.status === "active" ? "medium" : "low",
+        tags: ["openloops", "hygiene", "script-backed-loop"],
+        fingerprint,
+        metadata: {
+          source: "openloops.hygiene.route-tasks",
+          check: "scripts",
+          loop_id: loop.id,
+          loop_name: loop.name,
+          loop_status: loop.status,
+          cwd: loop.cwd,
+          script_matches: loop.scriptMatches,
+          no_tmux_dispatch: true
+        }
+      });
+    }
+  }
+  return { checked, findings: tasks.length, tasks };
+}
 hygiene.command("names").description("check or apply canonical machine-/repo-prefixed loop names").option("--apply", "rename loops in-place").option("--include-stopped", "include stopped loops").option("--include-inactive", "include stopped, expired, and archived loops").option("--limit <n>", "maximum loops to inspect", "1000").option("--json", "print JSON").action((opts) => {
   const store = new Store;
   try {
-    const backupPath = opts.apply ? backupLoopsDatabase("name-hygiene") : undefined;
     const report = buildNameHygieneReport(store, {
-      apply: Boolean(opts.apply),
+      apply: false,
       includeStopped: Boolean(opts.includeStopped),
       includeInactive: Boolean(opts.includeInactive),
       limit: Number(opts.limit)
     });
-    const output = backupPath ? { ...report, backupPath } : report;
+    let outputReport = report;
+    const backupPath = opts.apply && report.changed > 0 ? backupLoopsDatabase("name-hygiene") : undefined;
+    if (opts.apply && report.changed > 0) {
+      outputReport = buildNameHygieneReport(store, {
+        apply: true,
+        includeStopped: Boolean(opts.includeStopped),
+        includeInactive: Boolean(opts.includeInactive),
+        limit: Number(opts.limit)
+      });
+    } else if (opts.apply) {
+      outputReport = { ...report, applied: true };
+    }
+    const output = backupPath ? { ...outputReport, backupPath } : outputReport;
     if (isJson() || opts.json)
       console.log(JSON.stringify(output, null, 2));
     else {
-      console.log(`hygiene_names checked=${report.checked} changed=${report.changed} applied=${report.applied}`);
+      console.log(`hygiene_names checked=${outputReport.checked} changed=${outputReport.changed} applied=${outputReport.applied}`);
       if (backupPath)
         console.log(`backup=${backupPath}`);
-      for (const change of report.changes.filter((entry) => entry.changed)) {
-        console.log(`${report.applied ? "renamed" : "would-rename"} ${change.id} ${change.oldName} -> ${change.newName}`);
+      for (const change of outputReport.changes.filter((entry) => entry.changed)) {
+        console.log(`${outputReport.applied ? "renamed" : "would-rename"} ${change.id} ${change.oldName} -> ${change.newName}`);
       }
     }
-    if (!report.ok && !report.applied)
+    if (!outputReport.ok && !outputReport.applied)
       process.exitCode = 1;
   } finally {
     store.close();
@@ -6641,6 +6877,73 @@ hygiene.command("scripts").description("inventory loops still backed by local ~/
     store.close();
   }
 });
+hygiene.command("route-tasks").description("upsert deduped todos tasks for hygiene findings").option("--checks <list>", "comma-separated hygiene checks: names,duplicates,scripts,all", "all").option("--project <path>", "todos project path", defaultLoopsProject()).option("--task-list <slug>", "todos task-list slug", "openloops-hygiene").option("--limit <n>", "maximum loops to inspect", "1000").option("--max-actions <n>", "maximum todos tasks to upsert", "10").option("--scripts-dir <path>", "script directory to detect for script inventory").option("--include-inactive", "also route stopped, expired, or archived loops").option("--dry-run", "print intended task upserts without mutating todos").option("--json", "print JSON").action((opts) => {
+  const store = new Store;
+  try {
+    const checks = parseHygieneChecks(opts.checks);
+    const route = buildHygieneRouteTasks(store, {
+      checks,
+      includeInactive: Boolean(opts.includeInactive),
+      limit: Number(opts.limit),
+      scriptsDir: opts.scriptsDir
+    });
+    const selection = selectRouteItems(route.tasks, Number(opts.maxActions), `hygiene:${stableHash([opts.project, opts.taskList, checks, opts.limit, Boolean(opts.includeInactive), opts.scriptsDir ?? ""])}`, (task) => task.fingerprint);
+    const listId = opts.dryRun ? undefined : ensureTodosTaskList(opts.project, opts.taskList, "OpenLoops Hygiene", "Deduped OpenLoops hygiene findings routed by loops hygiene route-tasks.");
+    const actions = selection.selected.map((task) => {
+      if (opts.dryRun) {
+        return { action: "would-upsert", check: task.check, title: task.title, fingerprint: task.fingerprint, priority: task.priority, metadata: task.metadata };
+      }
+      const result = runLocalCommand("todos", [
+        "--project",
+        opts.project,
+        "--json",
+        "task",
+        "upsert",
+        "--fingerprint",
+        task.fingerprint,
+        "--title",
+        task.title,
+        "-d",
+        task.description,
+        "--priority",
+        task.priority,
+        "--status",
+        "pending",
+        "--list",
+        listId,
+        "--tags",
+        task.tags.join(","),
+        "--metadata-json",
+        JSON.stringify(task.metadata)
+      ]);
+      if (!result.ok) {
+        return { action: "upsert-failed", check: task.check, fingerprint: task.fingerprint, error: result.stderr || result.error || result.stdout };
+      }
+      return { action: "upserted", check: task.check, fingerprint: task.fingerprint, task: JSON.parse(result.stdout || "{}") };
+    });
+    const routed = {
+      ok: actions.every((action) => action.action !== "upsert-failed"),
+      checks,
+      checked: route.checked,
+      findings: route.findings,
+      routing: selection.cursor,
+      actions
+    };
+    if (!opts.dryRun && routed.ok)
+      writeRouteCursor(selection.cursor.key, selection.cursor.lastFingerprint);
+    if (isJson() || opts.json)
+      console.log(JSON.stringify(routed, null, 2));
+    else {
+      console.log(`hygiene_route_tasks checks=${checks.join(",")} findings=${routed.findings} actions=${actions.length}`);
+      for (const action of actions)
+        console.log(`${action.action} ${action.fingerprint}`);
+    }
+    if (!routed.ok)
+      process.exitCode = 1;
+  } finally {
+    store.close();
+  }
+});
 program.command("pause <idOrName>").action((idOrName) => updateStatus(idOrName, "paused"));
 program.command("resume <idOrName>").action((idOrName) => updateStatus(idOrName, "active"));
 program.command("stop <idOrName>").action((idOrName) => updateStatus(idOrName, "stopped"));

package/dist/daemon/index.js

@@ -4419,7 +4419,7 @@ function enableStartup(result) {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.3.19",
+  version: "0.3.21",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",

package/dist/index.js

@@ -4268,6 +4268,7 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     "You are the worker agent for a task-triggered OpenLoops workflow.",
     "Investigate first before changing files. Use the todos CLI as the source of truth for the task.",
     "Claim/start the task if appropriate, inspect the repository/project state, implement only the task scope, run focused validation, preserve unrelated user changes, and update the task with comments, evidence, changed files, commits, and blockers.",
+    "Do not dispatch or paste prompts into tmux panes. If additional work is required, create or update deduped todos tasks so task-created routing can start a fresh headless workflow.",
     "Do not mark the task complete unless the work is genuinely done and validated.",
     "",
     `Task context JSON: ${compactJson(taskContext)}`
@@ -4279,6 +4280,7 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     "You are the verifier agent for a task-triggered OpenLoops workflow.",
     "Use fresh context. Inspect the task, repository state, commits, tests, and worker evidence. Act as an adversarial reviewer focused on correctness, regressions, missing tests, security, and incomplete requirements.",
     "If the work is valid, record verification evidence in todos and mark/leave the task in the correct completed state according to the todos CLI. If it is not valid, add precise follow-up tasks or comments and leave the original task open or blocked with clear evidence.",
+    "Do not dispatch or paste prompts into tmux panes. If additional work is required, create or update deduped todos tasks so task-created routing can start a fresh headless workflow.",
     "Do not make broad unrelated changes. Only apply tiny verification fixes when they are necessary and low risk; otherwise create follow-up tasks.",
     "",
     `Task context JSON: ${compactJson(taskContext)}`
@@ -4850,6 +4852,7 @@ function recommendedTask(loop, run, failure, route) {
     `Status: ${run.status}`,
     `Classification: ${failure.classification}`,
     `Fingerprint: ${failure.fingerprint}`,
+    `No-tmux routing: Do not dispatch or paste prompts into tmux panes; use task-triggered headless worker/verifier workflows only.`,
     route.cwd ? `Route cwd: ${route.cwd}` : undefined,
     route.provider ? `Provider: ${route.provider}` : undefined,
     failure.evidence.error ? `Error:

package/docs/USAGE.md

@@ -322,6 +322,7 @@ loops hygiene names --json
 loops hygiene names --apply
 loops hygiene duplicates --json
 loops hygiene scripts --json
+loops hygiene route-tasks --checks names,duplicates,scripts --dry-run --json
 ```
 
 `hygiene names` reports canonical `machine-*` or `repo-<name>-*` loop names and
@@ -329,7 +330,13 @@ only renames when `--apply` is present. Apply mode writes a SQLite backup under
 `<LOOPS_DATA_DIR>/backups` before changing loop names. `hygiene duplicates`
 groups loops with the same normalized name, cwd, and schedule. `hygiene scripts`
 inventories loops whose command still references `~/.hasna/loops/scripts`; use
-it as a migration gate before deleting local scripts.
+it as a migration gate before deleting local scripts. `hygiene route-tasks`
+upserts deduped Todos tasks for hygiene findings with stable fingerprints and
+`no_tmux_dispatch=true` metadata; use `--dry-run --json` before enabling it as a
+production loop. Route commands store a small cursor in
+`<LOOPS_DATA_DIR>/route-cursors.json` so bounded `--max-actions` runs advance
+through all findings over repeated scheduled runs instead of reprocessing only
+the first batch.
 
 Archive loops when retiring old automation but preserving history:
 

package/package.json

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