@hasna/todos 0.11.64 → 0.11.66

package/dist/cli/index.js

@@ -6914,38 +6914,7 @@ var init_task_lists = __esm(() => {
   init_projects();
 });
 
-// src/lib/shared-events.ts
-function taskEventData(task, extra = {}) {
-  return {
-    id: task.id,
-    task_id: task.id,
-    short_id: task.short_id,
-    title: task.title,
-    description: task.description,
-    status: task.status,
-    priority: task.priority,
-    project_id: task.project_id,
-    parent_id: task.parent_id,
-    plan_id: task.plan_id,
-    task_list_id: task.task_list_id,
-    agent_id: task.agent_id,
-    assigned_to: task.assigned_to,
-    session_id: task.session_id,
-    working_dir: task.working_dir,
-    tags: task.tags,
-    metadata: task.metadata,
-    version: task.version,
-    created_at: task.created_at,
-    updated_at: task.updated_at,
-    started_at: task.started_at,
-    completed_at: task.completed_at,
-    due_at: task.due_at,
-    requires_approval: task.requires_approval,
-    approved_by: task.approved_by,
-    approved_at: task.approved_at,
-    ...extra
-  };
-}
+// src/lib/task-route-contract.ts
 function booleanField(value) {
   if (typeof value === "boolean")
     return value;
@@ -6967,21 +6936,31 @@ function booleanField(value) {
 function objectField(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
-function firstBoolean(records, keys) {
+function collectBooleans(records, keys) {
+  const values = [];
   for (const record of records) {
+    if (!record)
+      continue;
     for (const key of keys) {
       const value = booleanField(record[key]);
       if (value !== undefined)
-        return value;
+        values.push(value);
     }
   }
-  return;
+  return values;
 }
-function routingAutomationMetadata(task) {
-  const automation = objectField(task.metadata.automation);
-  const records = [task.metadata];
-  if (automation)
-    records.push(automation);
+function mergedBoolean(records, keys, trueWins) {
+  const values = collectBooleans(records, keys);
+  if (values.length === 0)
+    return;
+  if (trueWins)
+    return values.some(Boolean);
+  return values.includes(false) ? false : true;
+}
+function routingAutomationMetadata(task, taskList) {
+  const taskAutomation = objectField(task.metadata.automation);
+  const taskListAutomation = taskList ? objectField(taskList.metadata.automation) : undefined;
+  const records = [task.metadata, taskAutomation, taskList?.metadata, taskListAutomation];
   const result = {};
   const aliases = [
     ["allowed", ["allowed", "automation_allowed", "automationAllowed"]],
@@ -6992,7 +6971,7 @@ function routingAutomationMetadata(task) {
     ["approval_required", ["approval_required", "approvalRequired"]]
   ];
   for (const [canonical, keys] of aliases) {
-    const value = firstBoolean(records, keys);
+    const value = mergedBoolean(records, keys, canonical !== "allowed");
     if (value !== undefined)
       result[canonical] = value;
   }
@@ -7000,23 +6979,91 @@ function routingAutomationMetadata(task) {
     result.requires_approval = true;
   return Object.keys(result).length > 0 ? result : undefined;
 }
+function routeEnabledForTask(task, taskList) {
+  const explicit = booleanField(task.metadata.route_enabled);
+  if (explicit !== undefined)
+    return explicit;
+  if (task.tags.includes("auto:route") || task.tags.includes("route:enabled"))
+    return true;
+  const taskListDefault = taskList ? booleanField(taskList.metadata.route_enabled) : undefined;
+  if (taskListDefault !== undefined)
+    return taskListDefault;
+  return;
+}
+function stringField(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+function workflowPointersFromMetadata(metadata) {
+  const nested = objectField(metadata.workflow_invocation) ?? objectField(metadata.workflow) ?? {};
+  return {
+    current_workflow_invocation_id: stringField(metadata.current_workflow_invocation_id) ?? stringField(nested.current_workflow_invocation_id) ?? stringField(nested.invocation_id),
+    current_run_id: stringField(metadata.current_run_id) ?? stringField(nested.current_run_id) ?? stringField(nested.run_id),
+    latest_manifest_path: stringField(metadata.latest_manifest_path) ?? stringField(nested.latest_manifest_path) ?? stringField(nested.manifest_path),
+    latest_evaluation_path: stringField(metadata.latest_evaluation_path) ?? stringField(nested.latest_evaluation_path) ?? stringField(nested.evaluation_path),
+    workflow_state: stringField(metadata.workflow_state) ?? stringField(nested.workflow_state) ?? stringField(nested.state)
+  };
+}
+function compactWorkflowPointers(pointers) {
+  return Object.fromEntries(Object.entries(pointers).filter(([, value]) => typeof value === "string" && value.length > 0));
+}
+function classifyProjectKind(path) {
+  return path.includes("/hasna/opensource/") ? "open-source" : "unknown";
+}
+function isWorktreePath(path) {
+  return path.includes("/.codewith/worktrees/") || path.includes("/.worktrees/");
+}
+function inferRootProjectId(project) {
+  return isWorktreePath(project.path) ? null : project.id;
+}
+var TODOS_TASK_ROUTE_STATE_SCHEMA_VERSION = "todos.task_route_state.v1", TASK_WORKFLOW_POINTER_SCHEMA_VERSION = "todos.task_workflow_pointer.v1";
+
+// src/lib/shared-events.ts
+function taskEventData(task, extra = {}) {
+  return {
+    id: task.id,
+    task_id: task.id,
+    short_id: task.short_id,
+    title: task.title,
+    description: task.description,
+    status: task.status,
+    priority: task.priority,
+    project_id: task.project_id,
+    parent_id: task.parent_id,
+    plan_id: task.plan_id,
+    task_list_id: task.task_list_id,
+    agent_id: task.agent_id,
+    assigned_to: task.assigned_to,
+    session_id: task.session_id,
+    working_dir: task.working_dir,
+    tags: task.tags,
+    metadata: task.metadata,
+    version: task.version,
+    created_at: task.created_at,
+    updated_at: task.updated_at,
+    started_at: task.started_at,
+    completed_at: task.completed_at,
+    due_at: task.due_at,
+    requires_approval: task.requires_approval,
+    approved_by: task.approved_by,
+    approved_at: task.approved_at,
+    ...extra
+  };
+}
 function taskEventMetadata(task) {
   const metadata = {
     package: "@hasna/todos",
     todos_event_schema_version: 1,
+    route_state_schema_version: TODOS_TASK_ROUTE_STATE_SCHEMA_VERSION,
     task_id: task.id,
     task_short_id: task.short_id,
     project_id: task.project_id,
     task_list_id: task.task_list_id,
     working_dir: task.working_dir
   };
-  const routeEnabled = booleanField(task.metadata.route_enabled);
-  if (routeEnabled !== undefined) {
-    metadata.route_enabled = routeEnabled;
-  }
-  const automation = routingAutomationMetadata(task);
-  if (automation) {
-    metadata.automation = automation;
+  const pointers = workflowPointersFromMetadata(task.metadata);
+  for (const [key, value] of Object.entries(pointers)) {
+    if (value)
+      metadata[key] = value;
   }
   try {
     const project = task.project_id ? getProject(task.project_id) : null;
@@ -7045,18 +7092,20 @@ function taskEventMetadata(task) {
       metadata.task_list_project_id = taskList.project_id;
       metadata.task_list_is_project_default = Boolean(project?.task_list_id && taskList.slug === project.task_list_id);
     }
+    const routeEnabled = routeEnabledForTask(task, taskList);
+    if (routeEnabled !== undefined) {
+      metadata.route_enabled = routeEnabled;
+    }
+    const automation = routingAutomationMetadata(task, taskList);
+    if (automation) {
+      metadata.automation = automation;
+      metadata.route_blocked_by_no_auto = automation.no_auto === true;
+      metadata.route_blocked_by_manual = automation.manual === true || automation.manual_required === true;
+      metadata.route_blocked_by_approval = (automation.requires_approval === true || automation.approval_required === true) && !task.approved_by;
+    }
   } catch {}
   return metadata;
 }
-function classifyProjectKind(path) {
-  return path.includes("/hasna/opensource/") ? "open-source" : "unknown";
-}
-function isWorktreePath(path) {
-  return path.includes("/.codewith/worktrees/") || path.includes("/.worktrees/");
-}
-function inferRootProjectId(project) {
-  return isWorktreePath(project.path) ? null : project.id;
-}
 function readMachineLocalPath(project) {
   const machineId = process.env["TODOS_MACHINE_ID"];
   if (!machineId)
@@ -12298,6 +12347,184 @@ var init_helpers = __esm(() => {
   };
 });
 
+// src/lib/task-routing.ts
+var exports_task_routing = {};
+__export(exports_task_routing, {
+  setTaskWorkflowPointers: () => setTaskWorkflowPointers,
+  getTaskRouteState: () => getTaskRouteState
+});
+function classifyProjectKind2(path) {
+  if (!path)
+    return null;
+  return path.includes("/hasna/opensource/") ? "open-source" : "unknown";
+}
+function machineLocalPath(project, db) {
+  const machineId = process.env["TODOS_MACHINE_ID"];
+  if (!machineId)
+    return null;
+  try {
+    const row = db.query("SELECT path FROM project_machine_paths WHERE project_id = ? AND machine_id = ?").get(project.id, machineId);
+    return row?.path ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveProject(task, db) {
+  const project = task.project_id ? getProject(task.project_id, db) : null;
+  const projectPath = project ? machineLocalPath(project, db) ?? project.path : task.working_dir;
+  return { project, projectPath: projectPath ?? null };
+}
+function resolveTaskList(task, project, db) {
+  if (task.task_list_id) {
+    return getTaskList(task.task_list_id, db) ?? (project ? getTaskListBySlug(task.task_list_id, project.id, db) : null);
+  }
+  if (project?.task_list_id) {
+    return getTaskListBySlug(project.task_list_id, project.id, db);
+  }
+  return null;
+}
+function isTerminal(status) {
+  return status === "completed" || status === "cancelled" || status === "failed";
+}
+function routeConcurrencyKey(task, project, taskList, projectPath) {
+  if (project?.id)
+    return `project:${project.id}`;
+  if (taskList?.id)
+    return `task-list:${taskList.id}`;
+  if (projectPath)
+    return `path:${projectPath}`;
+  return `task:${task.id}`;
+}
+function getTaskRouteState(taskOrId, db) {
+  const d = db || getDatabase();
+  const task = typeof taskOrId === "string" ? getTask(taskOrId, d) : taskOrId;
+  if (!task)
+    throw new Error(`Task not found: ${taskOrId}`);
+  const { project, projectPath } = resolveProject(task, d);
+  const taskList = resolveTaskList(task, project, d);
+  const automation = routingAutomationMetadata(task, taskList) ?? {};
+  const routeEnabled = routeEnabledForTask(task, taskList) === true;
+  const tagOptIn = task.tags.includes("auto:route") || task.tags.includes("route:enabled");
+  const locked = Boolean(task.locked_by && !isLockExpired(task.locked_at));
+  const blockers = getBlockingDeps(task.id, d);
+  const blocked = blockers.length > 0;
+  const terminal = isTerminal(task.status);
+  const requiresApproval = automation.requires_approval === true || task.requires_approval === true;
+  const approvalRequired = automation.approval_required === true;
+  const approved = Boolean(task.approved_by);
+  const gates = {
+    route_enabled: routeEnabled,
+    tag_opt_in: tagOptIn,
+    no_auto: automation.no_auto === true,
+    manual: automation.manual === true,
+    manual_required: automation.manual_required === true,
+    requires_approval: requiresApproval,
+    approval_required: approvalRequired,
+    approved,
+    locked,
+    blocked,
+    terminal
+  };
+  const reasons = [];
+  if (task.status !== "pending")
+    reasons.push("task_not_pending");
+  if (terminal)
+    reasons.push("task_terminal");
+  if (!routeEnabled)
+    reasons.push("route_not_enabled");
+  if (locked)
+    reasons.push("task_locked");
+  if (blocked)
+    reasons.push("task_blocked");
+  if (gates.no_auto)
+    reasons.push("no_auto");
+  if (gates.manual)
+    reasons.push("manual");
+  if (gates.manual_required)
+    reasons.push("manual_required");
+  if (requiresApproval && !approved)
+    reasons.push("requires_approval");
+  if (approvalRequired && !approved)
+    reasons.push("approval_required");
+  if (automation.allowed === false)
+    reasons.push("automation_disallowed");
+  return {
+    schema_version: TODOS_TASK_ROUTE_STATE_SCHEMA_VERSION,
+    task_id: task.id,
+    task_short_id: task.short_id,
+    status: task.status,
+    eligible: reasons.length === 0,
+    reasons,
+    blockers: blockers.map((blocker) => ({
+      id: blocker.id,
+      short_id: blocker.short_id,
+      title: blocker.title,
+      status: blocker.status
+    })),
+    gates,
+    automation: Object.keys(automation).length > 0 ? automation : null,
+    route: {
+      project_id: project?.id ?? task.project_id,
+      project_path: projectPath,
+      working_dir: task.working_dir ?? projectPath,
+      project_kind: classifyProjectKind2(projectPath),
+      task_list_id: taskList?.id ?? task.task_list_id,
+      task_list_slug: taskList?.slug ?? null,
+      task_list_name: taskList?.name ?? null,
+      concurrency_key: routeConcurrencyKey(task, project, taskList, projectPath)
+    },
+    pointers: workflowPointersFromMetadata(task.metadata)
+  };
+}
+function setTaskWorkflowPointers(taskId, input, db) {
+  const d = db || getDatabase();
+  const task = getTask(taskId, d);
+  if (!task)
+    throw new Error(`Task not found: ${taskId}`);
+  const previous = workflowPointersFromMetadata(task.metadata);
+  const next = compactWorkflowPointers({
+    current_workflow_invocation_id: pointerPatch(previous.current_workflow_invocation_id, input, "current_workflow_invocation_id"),
+    current_run_id: pointerPatch(previous.current_run_id, input, "current_run_id"),
+    latest_manifest_path: pointerPatch(previous.latest_manifest_path, input, "latest_manifest_path"),
+    latest_evaluation_path: pointerPatch(previous.latest_evaluation_path, input, "latest_evaluation_path"),
+    workflow_state: pointerPatch(previous.workflow_state, input, "workflow_state")
+  });
+  const timestamp = now();
+  const {
+    current_workflow_invocation_id,
+    current_run_id,
+    latest_manifest_path,
+    latest_evaluation_path,
+    workflow_state,
+    workflow_invocation,
+    ...baseMetadata
+  } = task.metadata;
+  const metadata = {
+    ...baseMetadata,
+    ...next,
+    workflow_invocation: {
+      schema_version: TASK_WORKFLOW_POINTER_SCHEMA_VERSION,
+      ...next,
+      updated_at: timestamp,
+      updated_by: input.actor ?? null
+    }
+  };
+  return updateTask(task.id, { version: task.version, metadata }, d);
+}
+function pointerPatch(previous, input, key) {
+  if (!Object.prototype.hasOwnProperty.call(input, key))
+    return previous;
+  const value = input[key];
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+var init_task_routing = __esm(() => {
+  init_database();
+  init_projects();
+  init_task_crud();
+  init_task_lifecycle();
+  init_task_lists();
+});
+
 // src/cli/commands/task-commands.ts
 var exports_task_commands = {};
 __export(exports_task_commands, {
@@ -12367,6 +12594,11 @@ function parseJsonValue(value) {
     return value;
   }
 }
+function pointerOption(value, clear) {
+  if (value !== undefined)
+    return value;
+  return clear ? null : undefined;
+}
 function parseTags(value) {
   return value ? value.split(",").map((tag) => tag.trim()).filter(Boolean) : undefined;
 }
@@ -12485,6 +12717,63 @@ function registerTaskCommands(program2) {
       console.log(formatTaskLine(result.task));
     }
   });
+  task.command("route-state <id>").description("Show deterministic routing eligibility and workflow pointers for a task").action(async (id) => {
+    const globalOpts = program2.opts();
+    const resolvedId = resolveTaskId(id);
+    const { getTaskRouteState: getTaskRouteState2 } = await Promise.resolve().then(() => (init_task_routing(), exports_task_routing));
+    let state;
+    try {
+      state = getTaskRouteState2(resolvedId);
+    } catch (e) {
+      handleError(e);
+    }
+    if (globalOpts.json) {
+      output(state, true);
+      return;
+    }
+    console.log(chalk2.bold("Task route state"));
+    console.log(`  ${chalk2.dim("Task:")}       ${state.task_short_id || state.task_id.slice(0, 8)}`);
+    console.log(`  ${chalk2.dim("Eligible:")}   ${state.eligible ? chalk2.green("yes") : chalk2.yellow("no")}`);
+    console.log(`  ${chalk2.dim("Reasons:")}    ${state.reasons.length > 0 ? state.reasons.join(", ") : "none"}`);
+    console.log(`  ${chalk2.dim("Route:")}      ${state.route.concurrency_key}`);
+    if (state.pointers.current_workflow_invocation_id) {
+      console.log(`  ${chalk2.dim("Invocation:")} ${state.pointers.current_workflow_invocation_id}`);
+    }
+    if (state.pointers.current_run_id) {
+      console.log(`  ${chalk2.dim("Run:")}        ${state.pointers.current_run_id}`);
+    }
+    if (state.pointers.latest_manifest_path) {
+      console.log(`  ${chalk2.dim("Manifest:")}   ${state.pointers.latest_manifest_path}`);
+    }
+  });
+  task.command("workflow-pointers <id>").description("Update OpenLoops workflow invocation/run artifact pointers on a task").option("--invocation <id>", "Current workflow invocation ID").option("--run <id>", "Current workflow run ID").option("--manifest <path>", "Latest run manifest path").option("--evaluation <path>", "Latest evaluator artifact path").option("--state <state>", "Human-visible workflow state").option("--actor <agent>", "Agent or workflow updating the pointers").option("--clear", "Clear all workflow pointers before applying explicit pointer values").option("--clear-invocation", "Clear current workflow invocation ID").option("--clear-run", "Clear current workflow run ID").option("--clear-manifest", "Clear latest run manifest path").option("--clear-evaluation", "Clear latest evaluator artifact path").option("--clear-state", "Clear human-visible workflow state").action(async (id, opts) => {
+    const globalOpts = program2.opts();
+    const resolvedId = resolveTaskId(id);
+    const { getTaskRouteState: getTaskRouteState2, setTaskWorkflowPointers: setTaskWorkflowPointers2 } = await Promise.resolve().then(() => (init_task_routing(), exports_task_routing));
+    let taskResult;
+    try {
+      taskResult = setTaskWorkflowPointers2(resolvedId, {
+        current_workflow_invocation_id: pointerOption(opts.invocation, Boolean(opts.clear || opts.clearInvocation)),
+        current_run_id: pointerOption(opts.run, Boolean(opts.clear || opts.clearRun)),
+        latest_manifest_path: pointerOption(opts.manifest, Boolean(opts.clear || opts.clearManifest)),
+        latest_evaluation_path: pointerOption(opts.evaluation, Boolean(opts.clear || opts.clearEvaluation)),
+        workflow_state: pointerOption(opts.state, Boolean(opts.clear || opts.clearState)),
+        actor: opts.actor || globalOpts.agent || "cli"
+      });
+    } catch (e) {
+      handleError(e);
+    }
+    const state = getTaskRouteState2(taskResult.id);
+    if (globalOpts.json) {
+      output({ task: taskResult, route_state: state }, true);
+      return;
+    }
+    console.log(chalk2.green("Workflow pointers updated:"));
+    console.log(formatTaskLine(taskResult));
+    if (state.pointers.latest_manifest_path) {
+      console.log(`  ${chalk2.dim("Manifest:")} ${state.pointers.latest_manifest_path}`);
+    }
+  });
   program2.command("list").description("List tasks").option("-s, --status <status>", "Filter by status").option("-p, --priority <priority>", "Filter by priority").option("--assigned <agent>", "Filter by assigned agent").option("--tags <tags>", "Filter by tags (comma-separated)").option("--tag <tags>", "Filter by tags (alias for --tags)").option("-a, --all", "Show all tasks (including completed/cancelled)").option("--list <id>", "Filter by task list ID").option("--task-list <id>", "Filter by task list ID (alias for --list)").option("--project-name <name>", "Filter by project name").option("--agent-name <name>", "Filter by agent name/assigned").option("--sort <field>", "Sort by: updated, created, priority, status").option("--format <fmt>", "Output format: table (default), compact, csv, json").option("--due-today", "Only tasks due today or earlier").option("--overdue", "Only overdue tasks (past due_at)").option("--recurring", "Only recurring tasks").option("--limit <n>", "Max tasks to return").action((opts) => {
     const globalOpts = program2.opts();
     opts.tags = opts.tags || opts.tag;
@@ -15097,7 +15386,19 @@ function bootstrapProject(options = {}, db) {
   }
   setMachineLocalPath(project.id, discovery.projectPath, d);
   const beforeTaskList = d.query("SELECT id FROM task_lists WHERE project_id = ? AND slug = ?").get(project.id, taskListSlug);
-  const taskList = ensureTaskList(`${project.name} Tasks`, taskListSlug, project.id, d);
+  let taskList = ensureTaskList(`${project.name} Tasks`, taskListSlug, project.id, d);
+  if (options.routeEnabled && taskList.metadata.route_enabled !== true) {
+    taskList = updateTaskList(taskList.id, {
+      metadata: {
+        ...taskList.metadata,
+        route_enabled: true,
+        automation: {
+          ...taskList.metadata.automation && typeof taskList.metadata.automation === "object" && !Array.isArray(taskList.metadata.automation) ? taskList.metadata.automation : {},
+          no_auto: false
+        }
+      }
+    }, d);
+  }
   const createdSources = [];
   for (const source of [
     addSourceOnce(project.id, "local", "Project root", discovery.projectPath, { role: "project-root" }, d),
@@ -16703,7 +17004,7 @@ function buildSearchFilters(query, opts, projectId) {
   return Object.fromEntries(Object.entries(filters).filter(([, value]) => value !== undefined));
 }
 function registerProjectCommands(program2) {
-  program2.command("project-bootstrap [path]").description("Discover a local workspace and initialize project task state").option("--name <name>", "Project display name").option("--task-list <slug>", "Default task list slug").option("--dry-run", "Show discovery without writing local state").action(async (inputPath, opts) => {
+  program2.command("project-bootstrap [path]").description("Discover a local workspace and initialize project task state").option("--name <name>", "Project display name").option("--task-list <slug>", "Default task list slug").option("--route-enabled", "Mark the default task list as eligible for OpenLoops task-created routing").option("--dry-run", "Show discovery without writing local state").action(async (inputPath, opts) => {
     const globalOpts = program2.opts();
     try {
       const { bootstrapProject: bootstrapProject2 } = await Promise.resolve().then(() => (init_project_bootstrap(), exports_project_bootstrap));
@@ -16711,6 +17012,7 @@ function registerProjectCommands(program2) {
         path: inputPath || globalOpts.project || process.cwd(),
         name: opts.name,
         taskListSlug: opts.taskList,
+        routeEnabled: Boolean(opts.routeEnabled),
         dryRun: opts.dryRun
       });
       if (globalOpts.json) {
@@ -16732,6 +17034,8 @@ function registerProjectCommands(program2) {
         console.log(`  ${chalk4.dim("Project:")}    ${result.project.id.slice(0, 8)} ${result.created.project ? "(created)" : "(existing)"}`);
       if (result.taskList)
         console.log(`  ${chalk4.dim("Task list:")}  ${result.taskList.slug} ${result.created.taskList ? "(created)" : "(existing)"}`);
+      if (result.taskList?.metadata.route_enabled === true)
+        console.log(`  ${chalk4.dim("Routing:")}    route-enabled`);
       if (result.created.sources.length > 0) {
         console.log(`  ${chalk4.dim("Sources:")}    ${result.created.sources.join(", ")}`);
       }
@@ -37700,7 +38004,7 @@ function limitValue(value) {
     return 20;
   return Math.max(1, Math.min(500, Math.trunc(value)));
 }
-function isTerminal(task) {
+function isTerminal2(task) {
   return task.status === "completed" || task.status === "failed" || task.status === "cancelled";
 }
 function sameAgent(task, agentId) {
@@ -37742,7 +38046,7 @@ function summarizeTask(task) {
 function overdueTasks(tasks, nowIso) {
   const now4 = Date.parse(nowIso);
   return tasks.filter((task) => {
-    if (isTerminal(task) || !task.due_at)
+    if (isTerminal2(task) || !task.due_at)
       return false;
     const due = Date.parse(task.due_at);
     return Number.isFinite(due) && due < now4;
@@ -50321,7 +50625,8 @@ Repairs`));
     });
     const limited2 = ready.slice(0, parseInt(opts.limit, 10));
     if (opts.json || globalOpts.json) {
-      console.log(JSON.stringify(limited2));
+      const { getTaskRouteState: getTaskRouteState2 } = await Promise.resolve().then(() => (init_task_routing(), exports_task_routing));
+      console.log(JSON.stringify(limited2.map((task2) => ({ ...task2, route_state: getTaskRouteState2(task2, db) }))));
       return;
     }
     if (limited2.length === 0) {
@@ -52790,7 +53095,7 @@ __export(exports_dispatch2, {
 });
 import chalk9 from "chalk";
 function registerDispatchCommands(program2) {
-  const dispatchCmd = program2.command("dispatch").description("Send tasks or task lists to a tmux window").argument("<target>", "tmux target: window, session:window, or session:window.pane").option("--tasks <ids>", "Comma-separated task IDs to dispatch").option("--list <id>", "Task list ID or slug to dispatch").option("--filter-status <statuses>", "Comma-separated task statuses to include (default: pending)", "pending").option("--delay <ms>", "Delay in ms between message and Enter (auto-calculated if omitted)", parseInt).option("--at <datetime>", "ISO datetime to schedule the dispatch").option("--multiple <targets>", "Comma-separated list of additional tmux targets (fan-out)").option("--stagger <ms>", "Delay between targets when using --multiple (default: 500ms)", parseInt).option("--confirm-busy", "Send even if the target tmux pane appears busy").option("--dry-run", "Preview the formatted message without sending").action(async (target, opts) => {
+  const dispatchCmd = program2.command("dispatch").description("Legacy/emergency only: send tasks or task lists to a tmux window after explicit human choice").argument("<target>", "legacy/emergency tmux target: window, session:window, or session:window.pane").option("--tasks <ids>", "Comma-separated task IDs to dispatch").option("--list <id>", "Task list ID or slug to dispatch").option("--filter-status <statuses>", "Comma-separated task statuses to include (default: pending)", "pending").option("--delay <ms>", "Delay in ms between message and Enter (auto-calculated if omitted)", parseInt).option("--at <datetime>", "ISO datetime to schedule the dispatch").option("--multiple <targets>", "Comma-separated list of additional legacy/emergency tmux targets (fan-out)").option("--stagger <ms>", "Delay between targets when using --multiple (default: 500ms)", parseInt).option("--confirm-busy", "Send even if the target tmux pane appears busy").option("--dry-run", "Preview the formatted message without sending").action(async (target, opts) => {
     const globalOpts = program2.opts();
     const useJson = globalOpts.json;
     const db = getDatabase();