@hasna/loops 0.4.2 → 0.4.4

package/dist/cli/index.js

@@ -3843,6 +3843,190 @@ class Store {
     const row = status ? this.db.query("SELECT COUNT(*) AS count FROM loop_runs WHERE status = ?").get(status) : this.db.query("SELECT COUNT(*) AS count FROM loop_runs").get();
     return row?.count ?? 0;
   }
+  exportMigrationRows(opts = {}) {
+    const includeRuns = opts.includeRuns ?? true;
+    const workflows = this.db.query("SELECT * FROM workflow_specs ORDER BY created_at ASC, id ASC").all().map(rowToWorkflow);
+    const loops = this.db.query("SELECT * FROM loops ORDER BY created_at ASC, id ASC").all().map(rowToLoop);
+    const runs = includeRuns ? this.db.query("SELECT * FROM loop_runs ORDER BY created_at ASC, id ASC").all().map(rowToRun) : [];
+    return { schemaVersion: SCHEMA_USER_VERSION, workflows, loops, runs, checks: this.migrationChecks() };
+  }
+  countTable(table) {
+    const row = this.db.query(`SELECT COUNT(*) AS count FROM ${table}`).get();
+    return row?.count ?? 0;
+  }
+  migrationChecks() {
+    const now = nowIso();
+    return {
+      unsupportedCounts: {
+        workflowInvocations: this.countTable("workflow_invocations"),
+        workflowWorkItems: this.countTable("workflow_work_items"),
+        workflowRuns: this.countTable("workflow_runs"),
+        workflowStepRuns: this.countTable("workflow_step_runs"),
+        workflowEvents: this.countTable("workflow_events"),
+        goals: this.countTable("goals"),
+        goalPlanNodes: this.countTable("goal_plan_nodes"),
+        goalRuns: this.countTable("goal_runs")
+      },
+      volatileCounts: {
+        daemonLeases: this.countTable("daemon_lease"),
+        activeDaemonLeases: this.db.query("SELECT COUNT(*) AS count FROM daemon_lease WHERE expires_at > ?").get(now)?.count ?? 0,
+        runningLoopRuns: this.db.query("SELECT COUNT(*) AS count FROM loop_runs WHERE status = 'running'").get()?.count ?? 0,
+        runningWorkflowRuns: this.db.query("SELECT COUNT(*) AS count FROM workflow_runs WHERE status = 'running'").get()?.count ?? 0,
+        runningWorkflowStepRuns: this.db.query("SELECT COUNT(*) AS count FROM workflow_step_runs WHERE status = 'running'").get()?.count ?? 0,
+        leasedWorkflowWorkItems: this.db.query("SELECT COUNT(*) AS count FROM workflow_work_items WHERE lease_expires_at IS NOT NULL OR status IN ('admitted', 'running')").get()?.count ?? 0
+      }
+    };
+  }
+  upsertMigrationWorkflow(workflow, opts = {}) {
+    const existing = this.getWorkflow(workflow.id);
+    if (existing && !opts.replace)
+      return existing;
+    this.db.query(`INSERT INTO workflow_specs (id, name, description, version, status, goal_json, steps_json, created_at, updated_at)
+         VALUES ($id, $name, $description, $version, $status, $goal, $steps, $created, $updated)
+         ON CONFLICT(id) DO UPDATE SET
+           name=$name,
+           description=$description,
+           version=$version,
+           status=$status,
+           goal_json=$goal,
+           steps_json=$steps,
+           created_at=$created,
+           updated_at=$updated`).run({
+      $id: workflow.id,
+      $name: workflow.name,
+      $description: workflow.description ?? null,
+      $version: workflow.version,
+      $status: workflow.status,
+      $goal: workflow.goal ? JSON.stringify(workflow.goal) : null,
+      $steps: JSON.stringify(workflow.steps),
+      $created: workflow.createdAt,
+      $updated: workflow.updatedAt
+    });
+    const imported = this.getWorkflow(workflow.id);
+    if (!imported)
+      throw new Error(`workflow not found after migration import: ${workflow.id}`);
+    return imported;
+  }
+  upsertMigrationLoop(loop, opts = {}) {
+    const existing = this.getLoop(loop.id);
+    if (existing && !opts.replace)
+      return existing;
+    this.assertNoNestedWorkflowGoal(loop.target, loop.goal);
+    this.db.query(`INSERT INTO loops (id, name, description, status, archived_at, archived_from_status, schedule_json, target_json,
+          goal_json, machine_json, next_run_at, retry_scheduled_for, catch_up, catch_up_limit, overlap, max_attempts,
+          retry_delay_ms, lease_ms, expires_at, created_at, updated_at)
+         VALUES ($id, $name, $description, $status, $archivedAt, $archivedFromStatus, $schedule, $target,
+          $goal, $machine, $nextRun, $retrySlot, $catchUp, $catchUpLimit, $overlap, $maxAttempts,
+          $retryDelay, $leaseMs, $expiresAt, $created, $updated)
+         ON CONFLICT(id) DO UPDATE SET
+           name=$name,
+           description=$description,
+           status=$status,
+           archived_at=$archivedAt,
+           archived_from_status=$archivedFromStatus,
+           schedule_json=$schedule,
+           target_json=$target,
+           goal_json=$goal,
+           machine_json=$machine,
+           next_run_at=$nextRun,
+           retry_scheduled_for=$retrySlot,
+           catch_up=$catchUp,
+           catch_up_limit=$catchUpLimit,
+           overlap=$overlap,
+           max_attempts=$maxAttempts,
+           retry_delay_ms=$retryDelay,
+           lease_ms=$leaseMs,
+           expires_at=$expiresAt,
+           created_at=$created,
+           updated_at=$updated`).run({
+      $id: loop.id,
+      $name: loop.name,
+      $description: loop.description ?? null,
+      $status: loop.status,
+      $archivedAt: loop.archivedAt ?? null,
+      $archivedFromStatus: loop.archivedFromStatus ?? null,
+      $schedule: JSON.stringify(loop.schedule),
+      $target: JSON.stringify(loop.target),
+      $goal: loop.goal ? JSON.stringify(loop.goal) : null,
+      $machine: loop.machine ? JSON.stringify(loop.machine) : null,
+      $nextRun: loop.nextRunAt ?? null,
+      $retrySlot: loop.retryScheduledFor ?? null,
+      $catchUp: loop.catchUp,
+      $catchUpLimit: loop.catchUpLimit,
+      $overlap: loop.overlap,
+      $maxAttempts: loop.maxAttempts,
+      $retryDelay: loop.retryDelayMs,
+      $leaseMs: loop.leaseMs,
+      $expiresAt: loop.expiresAt ?? null,
+      $created: loop.createdAt,
+      $updated: loop.updatedAt
+    });
+    const imported = this.getLoop(loop.id);
+    if (!imported)
+      throw new Error(`loop not found after migration import: ${loop.id}`);
+    return imported;
+  }
+  upsertMigrationRun(run, opts = {}) {
+    if (run.status === "running")
+      throw new ValidationError(`cannot import running run ${run.id}`);
+    const existing = this.getRun(run.id);
+    if (existing && !opts.replace)
+      return existing;
+    this.db.query(`INSERT INTO loop_runs (id, loop_id, loop_name, scheduled_for, attempt, status, started_at, finished_at,
+          claimed_by, claim_token, lease_expires_at, pid, pgid, process_started_at, exit_code, duration_ms,
+          stdout, stderr, error, goal_run_id, created_at, updated_at)
+         VALUES ($id, $loopId, $loopName, $scheduledFor, $attempt, $status, $startedAt, $finishedAt,
+          $claimedBy, NULL, $leaseExpiresAt, $pid, $pgid, $processStartedAt, $exitCode, $durationMs,
+          $stdout, $stderr, $error, $goalRunId, $created, $updated)
+         ON CONFLICT(id) DO UPDATE SET
+           loop_id=$loopId,
+           loop_name=$loopName,
+           scheduled_for=$scheduledFor,
+           attempt=$attempt,
+           status=$status,
+           started_at=$startedAt,
+           finished_at=$finishedAt,
+           claimed_by=$claimedBy,
+           claim_token=NULL,
+           lease_expires_at=$leaseExpiresAt,
+           pid=$pid,
+           pgid=$pgid,
+           process_started_at=$processStartedAt,
+           exit_code=$exitCode,
+           duration_ms=$durationMs,
+           stdout=$stdout,
+           stderr=$stderr,
+           error=$error,
+           goal_run_id=$goalRunId,
+           created_at=$created,
+           updated_at=$updated`).run({
+      $id: run.id,
+      $loopId: run.loopId,
+      $loopName: run.loopName,
+      $scheduledFor: run.scheduledFor,
+      $attempt: run.attempt,
+      $status: run.status,
+      $startedAt: run.startedAt ?? null,
+      $finishedAt: run.finishedAt ?? null,
+      $claimedBy: run.claimedBy ?? null,
+      $leaseExpiresAt: run.leaseExpiresAt ?? null,
+      $pid: run.pid ?? null,
+      $pgid: run.pgid ?? null,
+      $processStartedAt: run.processStartedAt ?? null,
+      $exitCode: run.exitCode ?? null,
+      $durationMs: run.durationMs ?? null,
+      $stdout: scrubbedOrNull(run.stdout),
+      $stderr: scrubbedOrNull(run.stderr),
+      $error: scrubbedOrNull(run.error),
+      $goalRunId: run.goalRunId ?? null,
+      $created: run.createdAt,
+      $updated: run.updatedAt
+    });
+    const imported = this.getRun(run.id);
+    if (!imported)
+      throw new Error(`run not found after migration import: ${run.id}`);
+    return imported;
+  }
   pruneHistory(opts) {
     const { maxAgeDays, keepPerLoop } = opts;
     if (maxAgeDays === undefined && keepPerLoop === undefined) {
@@ -3984,7 +4168,7 @@ class Store {
 // package.json
 var package_default = {
   name: "@hasna/loops",
-  version: "0.4.2",
+  version: "0.4.4",
   description: "Persistent local loop and workflow runner for deterministic commands and headless AI coding agents",
   type: "module",
   main: "dist/index.js",
@@ -4058,7 +4242,7 @@ var package_default = {
     prepare: "test -d dist || bun run build",
     "dev:cli": "bun run src/cli/index.ts",
     "dev:daemon": "bun run src/daemon/index.ts",
-    prepublishOnly: "bun run build && bun run test:boundary"
+    prepublishOnly: "bun run build && bun run typecheck && bun test && bun run test:boundary"
   },
   keywords: [
     "loops",
@@ -4251,7 +4435,7 @@ function deploymentStatusLine(status) {
 
 // src/cli/index.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync3, readFileSync as readFileSync10, rmSync as rmSync7, statSync as statSync2 } from "fs";
+import { existsSync as existsSync10, readdirSync as readdirSync3, readFileSync as readFileSync10, rmSync as rmSync7, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
 import { join as join11 } from "path";
 import { Database as Database3 } from "bun:sqlite";
 import { Command } from "commander";
@@ -7984,6 +8168,515 @@ function runDoctor(store) {
   };
 }
 
+// src/lib/migration.ts
+import { createHash as createHash3 } from "crypto";
+import { hostname as hostname3 } from "os";
+var LOOPS_MIGRATION_SCHEMA = "open-loops.migration/v1";
+function canonicalize(value) {
+  if (Array.isArray(value))
+    return value.map((entry) => canonicalize(entry));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, canonicalize(entry)]));
+  }
+  return value;
+}
+function migrationHash(value) {
+  return createHash3("sha256").update(JSON.stringify(canonicalize(value))).digest("hex");
+}
+function pushBlocker(rows, resource, id, reason, name) {
+  rows.push({ resource, id, name, action: "blocked", reason });
+}
+function checksToBlockers(checks, prefix, warnings = []) {
+  const rows = [];
+  for (const [name, count] of Object.entries(checks.unsupportedCounts)) {
+    if (count > 0) {
+      pushBlocker(rows, "remote", `${prefix}:unsupported:${name}`, `${prefix} ${name} has ${count} rows; this migration bundle does not preserve that table yet`);
+    }
+  }
+  for (const [name, count] of Object.entries(checks.volatileCounts)) {
+    if (name === "daemonLeases") {
+      if (count > 0)
+        warnings.push(`${prefix} daemon_lease has ${count} volatile rows; they are intentionally not exported as authority`);
+      continue;
+    }
+    if (count > 0) {
+      pushBlocker(rows, "remote", `${prefix}:volatile:${name}`, `${prefix} ${name} has ${count} rows; stop or finish active work before no-loss migration`);
+    }
+  }
+  return rows;
+}
+function sanitizeCommandEnv(value, blockers, resource, id, name) {
+  const copy = structuredClone(value);
+  const target = copy.target;
+  if (target && typeof target === "object" && !Array.isArray(target) && target.type === "command") {
+    const commandTarget = target;
+    if (commandTarget.env && Object.keys(commandTarget.env).length > 0) {
+      commandTarget.env = Object.fromEntries(Object.keys(commandTarget.env).map((key) => [key, "[redacted]"]));
+      pushBlocker(blockers, resource, id, "command target env values are redacted and cannot be imported as a no-loss row", name);
+    }
+  }
+  return copy;
+}
+function sanitizeWorkflow(workflow, blockers) {
+  const copy = structuredClone(workflow);
+  copy.steps = copy.steps.map((step) => {
+    if (step.target.type !== "command" || !step.target.env || Object.keys(step.target.env).length === 0)
+      return step;
+    pushBlocker(blockers, "workflow", workflow.id, `workflow step ${step.id} command env values are redacted and cannot be imported as a no-loss row`, workflow.name);
+    return {
+      ...step,
+      target: {
+        ...step.target,
+        env: Object.fromEntries(Object.keys(step.target.env).map((key) => [key, "[redacted]"]))
+      }
+    };
+  });
+  return copy;
+}
+function sanitizeExportRows(rows) {
+  const blockers = [];
+  const warnings = [];
+  blockers.push(...checksToBlockers(rows.checks, "source", warnings));
+  const workflows = rows.workflows.map((workflow) => sanitizeWorkflow(workflow, blockers));
+  const loops = rows.loops.map((loop) => sanitizeCommandEnv(loop, blockers, "loop", loop.id, loop.name));
+  const beforeScrub = JSON.stringify({ workflows, loops, runs: rows.runs });
+  const data = scrubSecretsDeep({ workflows, loops, runs: rows.runs });
+  if (JSON.stringify(data) !== beforeScrub) {
+    warnings.push("secret-looking strings were scrubbed from the export bundle; treat this as non-importable unless every scrub is expected");
+    pushBlocker(blockers, "remote", "secret-scrub", "secret-looking strings were scrubbed from the export bundle");
+  }
+  return { data, blockers, warnings };
+}
+function exportLoopsMigrationBundle(store, opts = {}) {
+  const rows = store.exportMigrationRows({ includeRuns: opts.includeRuns ?? true });
+  const sanitized = sanitizeExportRows(rows);
+  const bundleBody = {
+    schema: LOOPS_MIGRATION_SCHEMA,
+    packageVersion: packageVersion(),
+    exportedAt: new Date().toISOString(),
+    source: {
+      backend: "sqlite",
+      schemaVersion: rows.schemaVersion,
+      hostname: hostname3()
+    },
+    checks: rows.checks,
+    importable: sanitized.blockers.length === 0,
+    counts: {
+      workflows: sanitized.data.workflows.length,
+      loops: sanitized.data.loops.length,
+      runs: sanitized.data.runs.length
+    },
+    data: sanitized.data,
+    blockers: sanitized.blockers,
+    warnings: sanitized.warnings
+  };
+  return {
+    ...bundleBody,
+    hash: migrationHash(bundleBody)
+  };
+}
+function validateLoopsMigrationBundle(value) {
+  if (!value || typeof value !== "object")
+    throw new ValidationError("migration bundle must be a JSON object");
+  const bundle = value;
+  if (bundle.schema !== LOOPS_MIGRATION_SCHEMA)
+    throw new ValidationError(`unsupported migration bundle schema: ${String(bundle.schema)}`);
+  if (!bundle.data || !Array.isArray(bundle.data.workflows) || !Array.isArray(bundle.data.loops) || !Array.isArray(bundle.data.runs)) {
+    throw new ValidationError("migration bundle data must include workflows, loops, and runs arrays");
+  }
+  if (!bundle.checks || !bundle.counts || !bundle.source || !bundle.hash)
+    throw new ValidationError("migration bundle is missing required metadata");
+  const typed = bundle;
+  assertMigrationBundleIntegrity(typed);
+  return typed;
+}
+function assertMigrationBundleIntegrity(bundle) {
+  const { hash: _hash, ...body } = bundle;
+  const expectedHash = migrationHash(body);
+  if (bundle.hash !== expectedHash)
+    throw new ValidationError("migration bundle hash mismatch");
+}
+function rowPlanSummary(plan) {
+  const count = (action) => plan.rows.filter((row) => row.action === action).length;
+  return {
+    dryRun: plan.dryRun,
+    replace: plan.replace,
+    importable: plan.importable,
+    workflows: plan.rows.filter((row) => row.resource === "workflow").length,
+    loops: plan.rows.filter((row) => row.resource === "loop").length,
+    runs: plan.rows.filter((row) => row.resource === "run").length,
+    insert: count("insert"),
+    update: count("update"),
+    skip: count("skip"),
+    conflict: count("conflict"),
+    blocked: count("blocked")
+  };
+}
+function finalizePlan(plan) {
+  return { ...plan, summary: rowPlanSummary(plan) };
+}
+function compareResource(current, incoming, opts) {
+  const incomingHash = migrationHash(incoming);
+  if (!current)
+    return { resource: opts.resource, id: opts.id, name: opts.name, action: "insert", incomingHash };
+  const currentHash = migrationHash(current);
+  if (currentHash === incomingHash)
+    return { resource: opts.resource, id: opts.id, name: opts.name, action: "skip", incomingHash, currentHash };
+  return {
+    resource: opts.resource,
+    id: opts.id,
+    name: opts.name,
+    action: opts.replace ? "update" : "conflict",
+    reason: opts.replace ? "existing row differs and --replace was requested" : "existing row differs; rerun with --replace to update",
+    incomingHash,
+    currentHash
+  };
+}
+function buildImportMigrationPlan(store, bundle, opts = {}) {
+  assertMigrationBundleIntegrity(bundle);
+  const includeRuns = opts.includeRuns ?? true;
+  const replace = opts.replace ?? false;
+  const rows = [];
+  const warnings = [...bundle.warnings ?? []];
+  rows.push(...checksToBlockers(store.exportMigrationRows({ includeRuns: false }).checks, "destination", warnings));
+  if (!bundle.importable || bundle.blockers.length > 0) {
+    rows.push(...bundle.blockers.map((row) => ({ ...row, action: "blocked" })));
+  }
+  const workflowIds = new Set(bundle.data.workflows.map((workflow) => workflow.id));
+  const loopIds = new Set(bundle.data.loops.map((loop) => loop.id));
+  for (const workflow of bundle.data.workflows) {
+    const redactedStep = workflow.steps.find((step) => step.target.type === "command" && step.target.env && Object.values(step.target.env).includes("[redacted]"));
+    if (redactedStep) {
+      rows.push({
+        resource: "workflow",
+        id: workflow.id,
+        name: workflow.name,
+        action: "blocked",
+        reason: `workflow step ${redactedStep.id} has redacted command env values`,
+        incomingHash: migrationHash(workflow)
+      });
+      continue;
+    }
+    const activeNameCollision = store.listWorkflows({ status: "active" }).find((current) => current.name === workflow.name && current.id !== workflow.id);
+    if (workflow.status === "active" && activeNameCollision) {
+      rows.push({
+        resource: "workflow",
+        id: workflow.id,
+        name: workflow.name,
+        action: "conflict",
+        reason: `active workflow name collides with existing workflow ${activeNameCollision.id}`,
+        incomingHash: migrationHash(workflow),
+        currentHash: migrationHash(activeNameCollision)
+      });
+      continue;
+    }
+    rows.push(compareResource(store.getWorkflow(workflow.id), workflow, { replace, resource: "workflow", id: workflow.id, name: workflow.name }));
+  }
+  for (const loop of bundle.data.loops) {
+    if (loop.target.type === "command" && loop.target.env && Object.values(loop.target.env).includes("[redacted]")) {
+      rows.push({
+        resource: "loop",
+        id: loop.id,
+        name: loop.name,
+        action: "blocked",
+        reason: "loop has redacted command env values",
+        incomingHash: migrationHash(loop)
+      });
+      continue;
+    }
+    if (loop.target.type === "workflow" && !workflowIds.has(loop.target.workflowId) && !store.getWorkflow(loop.target.workflowId)) {
+      rows.push({
+        resource: "loop",
+        id: loop.id,
+        name: loop.name,
+        action: "blocked",
+        reason: `workflow target ${loop.target.workflowId} is not present in bundle or destination store`,
+        incomingHash: migrationHash(loop)
+      });
+      continue;
+    }
+    rows.push(compareResource(store.getLoop(loop.id), loop, { replace, resource: "loop", id: loop.id, name: loop.name }));
+  }
+  if (includeRuns) {
+    for (const run of bundle.data.runs) {
+      if (run.status === "running") {
+        rows.push({
+          resource: "run",
+          id: run.id,
+          name: run.loopName,
+          action: "blocked",
+          reason: "running rows carry volatile lease/process ownership and must finish before import",
+          incomingHash: migrationHash(run)
+        });
+        continue;
+      }
+      if (!loopIds.has(run.loopId) && !store.getLoop(run.loopId)) {
+        rows.push({
+          resource: "run",
+          id: run.id,
+          name: run.loopName,
+          action: "blocked",
+          reason: `loop ${run.loopId} is not present in bundle or destination store`,
+          incomingHash: migrationHash(run)
+        });
+        continue;
+      }
+      const slot = store.getRunBySlot(run.loopId, run.scheduledFor);
+      if (slot && slot.id !== run.id) {
+        rows.push({
+          resource: "run",
+          id: run.id,
+          name: run.loopName,
+          action: "conflict",
+          reason: `scheduled slot already belongs to run ${slot.id}`,
+          incomingHash: migrationHash(run),
+          currentHash: migrationHash(slot)
+        });
+        continue;
+      }
+      rows.push(compareResource(store.getRun(run.id), run, { replace, resource: "run", id: run.id, name: run.loopName }));
+    }
+  } else if (bundle.data.runs.length > 0) {
+    warnings.push("run history is present in the bundle but --no-runs was requested");
+  }
+  const plan = finalizePlan({
+    schema: LOOPS_MIGRATION_SCHEMA,
+    operation: "import",
+    dryRun: opts.dryRun ?? true,
+    replace,
+    importable: bundle.importable && rows.every((row) => row.action !== "blocked" && row.action !== "conflict"),
+    rows,
+    warnings
+  });
+  return { ...plan, importable: plan.summary.blocked === 0 && plan.summary.conflict === 0 };
+}
+function applyImportMigrationBundle(store, bundle, opts = {}) {
+  const plan = buildImportMigrationPlan(store, bundle, { ...opts, dryRun: false });
+  if (plan.summary.blocked > 0 || plan.summary.conflict > 0 || !plan.importable) {
+    throw new ValidationError(`migration import is not safe to apply: blocked=${plan.summary.blocked} conflict=${plan.summary.conflict}`);
+  }
+  const applied = { workflows: 0, loops: 0, runs: 0 };
+  let appliedPlan = plan;
+  store.writeTransaction(() => {
+    appliedPlan = buildImportMigrationPlan(store, bundle, { ...opts, dryRun: false });
+    if (appliedPlan.summary.blocked > 0 || appliedPlan.summary.conflict > 0 || !appliedPlan.importable) {
+      throw new ValidationError(`destination store changed before import apply: blocked=${appliedPlan.summary.blocked} conflict=${appliedPlan.summary.conflict}`);
+    }
+    for (const workflow of bundle.data.workflows) {
+      const row = appliedPlan.rows.find((entry) => entry.resource === "workflow" && entry.id === workflow.id);
+      if (row?.action === "insert" || row?.action === "update") {
+        store.upsertMigrationWorkflow(workflow, { replace: opts.replace });
+        applied.workflows += 1;
+      }
+    }
+    for (const loop of bundle.data.loops) {
+      const row = appliedPlan.rows.find((entry) => entry.resource === "loop" && entry.id === loop.id);
+      if (row?.action === "insert" || row?.action === "update") {
+        store.upsertMigrationLoop(loop, { replace: opts.replace });
+        applied.loops += 1;
+      }
+    }
+    if (opts.includeRuns ?? true) {
+      for (const run of bundle.data.runs) {
+        const row = appliedPlan.rows.find((entry) => entry.resource === "run" && entry.id === run.id);
+        if (row?.action === "insert" || row?.action === "update") {
+          store.upsertMigrationRun(run, { replace: opts.replace });
+          applied.runs += 1;
+        }
+      }
+    }
+  });
+  return { plan: appliedPlan, applied };
+}
+function envValue2(env, keys) {
+  for (const key of keys) {
+    const value = env[key]?.trim();
+    if (value)
+      return value;
+  }
+  return;
+}
+function resolveApiConfig(opts) {
+  const env = opts.env ?? process.env;
+  return {
+    apiUrl: opts.apiUrl ?? envValue2(env, ["LOOPS_API_URL", "HASNA_LOOPS_API_URL", "LOOPS_CLOUD_API_URL", "HASNA_LOOPS_CLOUD_API_URL"]),
+    token: opts.apiToken ?? envValue2(env, ["LOOPS_API_TOKEN", "HASNA_LOOPS_API_TOKEN", "LOOPS_CLOUD_TOKEN", "HASNA_LOOPS_CLOUD_TOKEN"])
+  };
+}
+function isLocalApiUrl(value) {
+  try {
+    return ["127.0.0.1", "localhost", "::1"].includes(new URL(value).hostname);
+  } catch {
+    return false;
+  }
+}
+function endpoint(base, path) {
+  return new URL(path.replace(/^\//, ""), base.endsWith("/") ? base : `${base}/`).toString();
+}
+async function requestJson(fetchImpl, config, path, init = {}) {
+  const response = await fetchImpl(endpoint(config.apiUrl, path), {
+    ...init,
+    headers: {
+      ...init.body ? { "content-type": "application/json" } : {},
+      ...config.token ? { authorization: `Bearer ${config.token}` } : {},
+      ...init.headers
+    }
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok)
+    throw new Error(typeof payload.error === "string" ? payload.error : `loops-api request failed: ${response.status}`);
+  return payload;
+}
+async function fetchRemotePreview(opts) {
+  const config = resolveApiConfig(opts);
+  const warnings = [];
+  if (!config.apiUrl) {
+    warnings.push("LOOPS_API_URL or HASNA_LOOPS_API_URL is required to inspect a self-hosted control plane");
+    return { loops: [], runs: [], warnings };
+  }
+  if (!isLocalApiUrl(config.apiUrl) && !config.token) {
+    warnings.push("non-local self-hosted APIs require LOOPS_API_TOKEN or HASNA_LOOPS_API_TOKEN");
+    return { loops: [], runs: [], warnings };
+  }
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const loopsPayload = await requestJson(fetchImpl, { apiUrl: config.apiUrl, token: config.token }, "/v1/loops?includeArchived=true&limit=1000");
+  const runsPayload = opts.includeRuns === false ? { runs: [] } : await requestJson(fetchImpl, { apiUrl: config.apiUrl, token: config.token }, "/v1/runs?limit=1000");
+  return {
+    loops: Array.isArray(loopsPayload.loops) ? loopsPayload.loops : [],
+    runs: Array.isArray(runsPayload.runs) ? runsPayload.runs : [],
+    warnings
+  };
+}
+async function buildSelfHostedMigrationPlan(store, opts) {
+  const bundle = exportLoopsMigrationBundle(store, { includeRuns: opts.includeRuns ?? true });
+  const remote = await fetchRemotePreview(opts);
+  const rows = [...bundle.blockers.map((row) => ({ ...row, action: "blocked" }))];
+  const warnings = [
+    ...bundle.warnings,
+    ...remote.warnings,
+    "self-hosted remote apply is preview-only until the control plane exposes id-preserving workflow/loop/run import endpoints"
+  ];
+  if (opts.operation === "self-hosted-pull") {
+    for (const entry of remote.loops) {
+      const value = entry && typeof entry === "object" ? entry : {};
+      const id = typeof value.id === "string" ? value.id : `remote-loop:${rows.length}`;
+      rows.push({
+        resource: "loop",
+        id,
+        name: typeof value.name === "string" ? value.name : undefined,
+        action: "blocked",
+        reason: "remote loop pull needs a full id-preserving export/import endpoint; /v1/loops returns public redacted rows only",
+        currentHash: migrationHash(entry)
+      });
+    }
+    for (const entry of remote.runs) {
+      const value = entry && typeof entry === "object" ? entry : {};
+      const id = typeof value.id === "string" ? value.id : `remote-run:${rows.length}`;
+      rows.push({
+        resource: "run",
+        id,
+        name: typeof value.loopName === "string" ? value.loopName : undefined,
+        action: "blocked",
+        reason: "remote run-history pull needs an id-preserving export/import endpoint; /v1/runs returns public redacted rows only",
+        currentHash: migrationHash(entry)
+      });
+    }
+    const plan2 = finalizePlan({
+      schema: LOOPS_MIGRATION_SCHEMA,
+      operation: opts.operation,
+      dryRun: true,
+      replace: false,
+      importable: false,
+      rows,
+      warnings
+    });
+    return { ...plan2, importable: false };
+  }
+  const remoteLoopsByName = new Map(remote.loops.map((entry) => entry && typeof entry === "object" ? entry : undefined).filter((entry) => typeof entry?.name === "string").map((entry) => [String(entry.name), entry]));
+  for (const workflow of bundle.data.workflows) {
+    rows.push({
+      resource: "workflow",
+      id: workflow.id,
+      name: workflow.name,
+      action: "blocked",
+      reason: "self-hosted API does not expose id-preserving workflow import/list endpoints yet",
+      incomingHash: migrationHash(workflow)
+    });
+  }
+  for (const loop of bundle.data.loops) {
+    const remoteLoop = remoteLoopsByName.get(loop.name);
+    rows.push({
+      resource: "loop",
+      id: loop.id,
+      name: loop.name,
+      action: "blocked",
+      reason: remoteLoop ? `remote loop name exists (${String(remoteLoop.id ?? "unknown id")}); exact id-preserving comparison is not available` : "normal self-hosted loop create would generate a new id; waiting for id-preserving import endpoint",
+      incomingHash: migrationHash(loop),
+      currentHash: remoteLoop ? migrationHash(remoteLoop) : undefined
+    });
+  }
+  if (opts.includeRuns ?? true) {
+    for (const run of bundle.data.runs) {
+      rows.push({
+        resource: "run",
+        id: run.id,
+        name: run.loopName,
+        action: "blocked",
+        reason: "self-hosted API does not expose run-history import endpoints; remote runners should create new run rows",
+        incomingHash: migrationHash(run)
+      });
+    }
+  }
+  const plan = finalizePlan({
+    schema: LOOPS_MIGRATION_SCHEMA,
+    operation: opts.operation,
+    dryRun: true,
+    replace: false,
+    importable: false,
+    rows,
+    warnings
+  });
+  return { ...plan, importable: false };
+}
+async function registerSelfHostedRunner(opts) {
+  const config = resolveApiConfig(opts);
+  if (!config.apiUrl)
+    throw new ValidationError("LOOPS_API_URL or --api-url is required");
+  if (!isLocalApiUrl(config.apiUrl) && !config.token)
+    throw new ValidationError("non-local self-hosted APIs require LOOPS_API_TOKEN or HASNA_LOOPS_API_TOKEN");
+  const payload = await requestJson(opts.fetchImpl ?? fetch, { apiUrl: config.apiUrl, token: config.token }, "/v1/runners/register", {
+    method: "POST",
+    body: JSON.stringify({
+      runnerId: opts.runnerId,
+      machineId: opts.machineId,
+      labels: opts.labels ?? {},
+      capabilities: opts.capabilities ?? {}
+    })
+  });
+  return {
+    ok: payload.ok === true,
+    runner: payload.runner && typeof payload.runner === "object" ? payload.runner : {}
+  };
+}
+function publicMigrationBundle(bundle) {
+  return {
+    ...bundle,
+    data: {
+      workflows: bundle.data.workflows.map(publicWorkflow),
+      loops: bundle.data.loops.map(publicLoop),
+      runs: bundle.data.runs.map((run) => publicRun(run, false, { redactError: true }))
+    }
+  };
+}
+function selfHostedControlPlaneSummary(env = process.env) {
+  const config = loopControlPlaneConfig(env);
+  return {
+    apiUrl: config.apiUrl,
+    databaseUrlPresent: config.databaseUrlPresent,
+    authTokenPresent: config.apiAuthTokenPresent
+  };
+}
+
 // src/lib/hygiene.ts
 import { basename as basename3 } from "path";
 import { homedir as homedir3 } from "os";
@@ -8321,7 +9014,6 @@ var BUILTIN_TEMPLATE_SUMMARIES = [
       { name: "taskTitle", description: "Human-readable task title." },
       projectPathVariable(),
       { name: "todosProjectPath", description: "Todos storage project path used in worker/verifier commands." },
-      { name: "todosDbPath", description: "Optional exact Todos DB path used via TODOS_DB_PATH/HASNA_TODOS_DB_PATH." },
       ...routeScopeVariables(),
       ...workerVerifierAgentVariables({ addDirs: true, branchNoun: "task/event" })
     ]
@@ -8362,8 +9054,6 @@ var BUILTIN_TEMPLATE_SUMMARIES = [
     variables: [
       { name: "taskId", required: true, description: "Todos task id." },
       projectPathVariable(),
-      { name: "todosProjectPath", description: "Todos storage project path used in lifecycle commands." },
-      { name: "todosDbPath", description: "Optional exact Todos DB path used via TODOS_DB_PATH/HASNA_TODOS_DB_PATH." },
       { name: "authProfilePool", description: "Comma-separated Codewith profiles for worker/verifier rotation." },
       roleAuthProfileVariable("triage"),
       roleAuthProfileVariable("planner"),
@@ -8494,29 +9184,28 @@ function verifierRuntimeGuidance(input) {
   ].join(`
 `);
 }
-function todosInspectLine(todosProjectPath, taskId, todosDbPath) {
-  return `- Inspect first: ${todosCommand(todosProjectPath, todosDbPath)} inspect ${taskId}`;
+function todosInspectLine(todosProjectPath, taskId) {
+  return `- Inspect first: todos --project ${todosProjectPath} inspect ${taskId}`;
 }
-function todosStartLine(todosProjectPath, taskId, todosDbPath) {
-  return `- Claim/start if appropriate: ${todosCommand(todosProjectPath, todosDbPath)} start ${taskId}`;
+function todosStartLine(todosProjectPath, taskId) {
+  return `- Claim/start if appropriate: todos --project ${todosProjectPath} start ${taskId}`;
 }
-function todosEvidenceLine(todosProjectPath, taskId, placeholder, todosDbPath) {
-  return `- Record evidence: ${todosCommand(todosProjectPath, todosDbPath)} comment ${taskId} "<${placeholder}>"`;
+function todosEvidenceLine(todosProjectPath, taskId, placeholder) {
+  return `- Record evidence: todos --project ${todosProjectPath} comment ${taskId} "<${placeholder}>"`;
 }
-function todosVerificationLine(todosProjectPath, taskId, todosDbPath) {
-  return `- Record verification: ${todosCommand(todosProjectPath, todosDbPath)} comment ${taskId} "<verification evidence or blocker>"`;
+function todosVerificationLine(todosProjectPath, taskId) {
+  return `- Record verification: todos --project ${todosProjectPath} comment ${taskId} "<verification evidence or blocker>"`;
 }
-function todosDoneLine(todosProjectPath, taskId, todosDbPath) {
-  return `- If valid and complete: ${todosCommand(todosProjectPath, todosDbPath)} done ${taskId}`;
+function todosDoneLine(todosProjectPath, taskId) {
+  return `- If valid and complete: todos --project ${todosProjectPath} done ${taskId}`;
 }
-function todosExactCommandsFragment(todosProjectPath, taskId, commandLines, todosDbPath) {
+function todosExactCommandsFragment(todosProjectPath, taskId, commandLines) {
   return [
     `Todos project path: ${todosProjectPath}`,
-    todosDbPath ? `Todos DB path: ${todosDbPath}` : undefined,
     "Use these exact todos commands so worktree cwd inference cannot attach to the wrong project:",
-    todosInspectLine(todosProjectPath, taskId, todosDbPath),
+    todosInspectLine(todosProjectPath, taskId),
     ...commandLines
-  ].filter((line) => Boolean(line));
+  ];
 }
 function worktreePrompt(plan) {
   if (plan.enabled) {
@@ -8553,19 +9242,10 @@ function worktreeContextFragment(plan) {
 function shellQuote3(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-function todosEnvPrefix(todosDbPath) {
-  return todosDbPath ? `TODOS_DB_PATH=${shellQuote3(todosDbPath)} HASNA_TODOS_DB_PATH=${shellQuote3(todosDbPath)} ` : "";
-}
-function todosCommand(todosProjectPath, todosDbPath) {
-  return `${todosEnvPrefix(todosDbPath)}todos --project ${todosProjectPath}`;
-}
-function shellTodosCommand(todosProjectPath, todosDbPath) {
-  return `${todosEnvPrefix(todosDbPath)}todos --project ${shellQuote3(todosProjectPath)}`;
-}
-function sourceTaskGateCommand(todosProjectPath, taskId, todosDbPath) {
+function sourceTaskGateCommand(todosProjectPath, taskId) {
   return [
     "set -euo pipefail",
-    `${shellTodosCommand(todosProjectPath, todosDbPath)} --json inspect ${shellQuote3(taskId)} >/dev/null`,
+    `todos --project ${shellQuote3(todosProjectPath)} --json inspect ${shellQuote3(taskId)} >/dev/null`,
     `printf "source task %s resolved in todos project %s\\n" ${shellQuote3(taskId)} ${shellQuote3(todosProjectPath)}`
   ].join(`
 `);
@@ -8625,10 +9305,10 @@ var LIFECYCLE_GATE_SCRIPT_TAIL = [
   "console.log(`task lifecycle ${stage} gate passed for ${task.id || task.taskId || 'task'} status=${status || 'unknown'}`);"
 ].join(`
 `);
-function lifecycleGateCommand(todosProjectPath, taskId, stage, goMarker, blockedMarker, todosDbPath) {
+function lifecycleGateCommand(todosProjectPath, taskId, stage, goMarker, blockedMarker) {
   return [
     "set -euo pipefail",
-    `task_json="$(${shellTodosCommand(todosProjectPath, todosDbPath)} --json inspect ${shellQuote3(taskId)})"`,
+    `task_json="$(todos --project ${shellQuote3(todosProjectPath)} --json inspect ${shellQuote3(taskId)})"`,
     `TASK_JSON="$task_json" STAGE=${shellQuote3(stage)} bun - <<'BUN'`,
     LIFECYCLE_GATE_SCRIPT_HEAD,
     `const goMarker = ${JSON.stringify(goMarker)};`,
@@ -8644,7 +9324,6 @@ var PR_HANDOFF_SCRIPT = [
   "const artifactPath = process.env.OPENLOOPS_PR_HANDOFF_ARTIFACT || '';",
   "const taskId = process.env.OPENLOOPS_PR_HANDOFF_TASK_ID || '';",
   "const todosProject = process.env.OPENLOOPS_PR_HANDOFF_TODOS_PROJECT || '';",
-  "const todosDbPath = process.env.OPENLOOPS_PR_HANDOFF_TODOS_DB_PATH || '';",
   "const fallbackWorktree = process.env.OPENLOOPS_PR_HANDOFF_WORKTREE || process.cwd();",
   "const expectedRoot = process.env.OPENLOOPS_PR_HANDOFF_WORKTREE_ROOT || fallbackWorktree;",
   "const expectedBranch = process.env.OPENLOOPS_PR_HANDOFF_EXPECTED_BRANCH || '';",
@@ -8662,8 +9341,7 @@ var PR_HANDOFF_SCRIPT = [
   "};",
   "const run = (command, args, options = {}) => spawnSync(command, args, { encoding: 'utf8', ...options });",
   "const todosArgs = (...args) => todosProject ? ['--project', todosProject, ...args] : args;",
-  "const todosEnv = todosDbPath ? { ...process.env, TODOS_DB_PATH: todosDbPath, HASNA_TODOS_DB_PATH: todosDbPath } : process.env;",
-  "const todos = (...args) => run(todosBin, todosArgs(...args), { env: todosEnv });",
+  "const todos = (...args) => run(todosBin, todosArgs(...args));",
   "const comment = (text) => {",
   "  const result = todos('comment', taskId, text);",
   "  if (result.status !== 0) console.error(`failed to comment original task: ${result.stderr || result.stdout || result.status}`);",
@@ -8792,7 +9470,6 @@ function prHandoffCommand(opts) {
     `export OPENLOOPS_PR_HANDOFF_ARTIFACT=${shellQuote3(opts.artifactPath)}`,
     `export OPENLOOPS_PR_HANDOFF_TASK_ID=${shellQuote3(opts.taskId)}`,
     `export OPENLOOPS_PR_HANDOFF_TODOS_PROJECT=${shellQuote3(opts.todosProjectPath)}`,
-    opts.todosDbPath ? `export OPENLOOPS_PR_HANDOFF_TODOS_DB_PATH=${shellQuote3(opts.todosDbPath)}` : undefined,
     `export OPENLOOPS_PR_HANDOFF_WORKTREE=${shellQuote3(opts.worktreeCwd)}`,
     `export OPENLOOPS_PR_HANDOFF_WORKTREE_ROOT=${shellQuote3(opts.worktreeRoot)}`,
     `export OPENLOOPS_PR_HANDOFF_EXPECTED_BRANCH=${shellQuote3(opts.expectedBranch)}`,
@@ -8803,7 +9480,7 @@ function prHandoffCommand(opts) {
     "bun - <<'BUN'",
     PR_HANDOFF_SCRIPT,
     "BUN"
-  ].filter((line) => Boolean(line)).join(`
+  ].join(`
 `);
 }
 // src/lib/templates-custom.ts
@@ -9393,12 +10070,12 @@ function commandStep(opts) {
     ...opts.blockedExitCodes ? { blockedExitCodes: opts.blockedExitCodes } : {}
   };
 }
-function sourceTaskGateStep(todosProjectPath, taskId, plan, description, todosDbPath) {
+function sourceTaskGateStep(todosProjectPath, taskId, plan, description) {
   return commandStep({
     id: "source-task-gate",
     name: "Source Task Gate",
     description,
-    command: sourceTaskGateCommand(todosProjectPath, taskId, todosDbPath),
+    command: sourceTaskGateCommand(todosProjectPath, taskId),
     cwd: plan.originalCwd,
     timeoutMs: 60000,
     blockedExitCodes: GATE_BLOCKED_EXIT_CODES
@@ -9410,7 +10087,7 @@ function lifecycleGateStep(opts) {
     name: opts.stage === "triage" ? "Triage Gate" : "Planner Gate",
     description: opts.description,
     dependsOn: opts.dependsOn,
-    command: lifecycleGateCommand(opts.todosProjectPath, opts.taskId, opts.stage, opts.goMarker, opts.blockedMarker, opts.todosDbPath),
+    command: lifecycleGateCommand(opts.todosProjectPath, opts.taskId, opts.stage, opts.goMarker, opts.blockedMarker),
     cwd: opts.plan.originalCwd,
     timeoutMs: 2 * 60000,
     blockedExitCodes: GATE_BLOCKED_EXIT_CODES
@@ -9419,7 +10096,7 @@ function lifecycleGateStep(opts) {
 function prHandoffArtifactPath(plan, taskId) {
   return join7(plan.cwd, ".openloops", "pr-handoff", `${slugSegment(taskId, "task")}.json`);
 }
-function prHandoffStep(input, plan, todosProjectPath, todosDbPath) {
+function prHandoffStep(input, plan, todosProjectPath) {
   return commandStep({
     id: "pr-handoff",
     name: "PR Handoff",
@@ -9429,7 +10106,6 @@ function prHandoffStep(input, plan, todosProjectPath, todosDbPath) {
       artifactPath: prHandoffArtifactPath(plan, input.taskId),
       taskId: input.taskId,
       todosProjectPath,
-      todosDbPath,
       worktreeCwd: plan.cwd,
       worktreeRoot: plan.path ?? plan.cwd,
       expectedBranch: plan.branch ?? ""
@@ -9516,7 +10192,6 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
   if (!input.projectPath?.trim())
     throw new Error("projectPath is required");
   const todosProjectPath = input.todosProjectPath ?? input.routeProjectPath ?? input.projectPath;
-  const todosDbPath = input.todosDbPath;
   const plan = worktreePlan(input, input.taskId);
   const taskContext = {
     taskId: input.taskId,
@@ -9527,17 +10202,15 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     projectPath: input.projectPath,
     routeProjectPath: input.routeProjectPath,
     projectGroup: input.projectGroup,
-    todosProjectPath: input.todosProjectPath ?? (input.todosDbPath ? todosProjectPath : undefined),
-    todosDbPath,
     worktree: worktreeContextFragment(plan)
   };
   const workerPrompt = [
     ...goalHeaderFragment(`Complete todos task ${input.taskId} in ${input.projectPath}.`, "worker", "task"),
     worktreePrompt(plan),
     ...todosExactCommandsFragment(todosProjectPath, input.taskId, [
-      todosStartLine(todosProjectPath, input.taskId, todosDbPath),
-      todosEvidenceLine(todosProjectPath, input.taskId, "concise evidence and blockers", todosDbPath)
-    ], todosDbPath),
+      todosStartLine(todosProjectPath, input.taskId),
+      todosEvidenceLine(todosProjectPath, input.taskId, "concise evidence and blockers")
+    ]),
     "Investigate first before changing files. Use the todos CLI as the source of truth for the task.",
     "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.",
     NO_TMUX_DISPATCH_FRAGMENT,
@@ -9550,9 +10223,9 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     ...goalHeaderFragment(`Verify todos task ${input.taskId} after the worker step.`, "verifier", "task"),
     worktreePrompt(plan),
     ...todosExactCommandsFragment(todosProjectPath, input.taskId, [
-      todosVerificationLine(todosProjectPath, input.taskId, todosDbPath),
-      todosDoneLine(todosProjectPath, input.taskId, todosDbPath)
-    ], todosDbPath),
+      todosVerificationLine(todosProjectPath, input.taskId),
+      todosDoneLine(todosProjectPath, input.taskId)
+    ]),
     adversarialReviewFragment("the task, repository state, commits, tests, and worker evidence", TASK_REVIEW_FOCUS),
     verifierRuntimeGuidance(input),
     TASK_VERIFIER_DECISION_FRAGMENT,
@@ -9567,7 +10240,7 @@ function renderTodosTaskWorkerVerifierWorkflow(input) {
     description: `Task-triggered worker/verifier workflow for ${taskLabel(input)}`,
     version: 1,
     steps: [
-      sourceTaskGateStep(todosProjectPath, input.taskId, plan, "Fail before worker execution when the source todos task is not resolvable.", todosDbPath),
+      sourceTaskGateStep(todosProjectPath, input.taskId, plan, "Fail before worker execution when the source todos task is not resolvable."),
       ...workerVerifierSteps({
         input,
         seed: input.taskId,
@@ -9587,7 +10260,6 @@ function renderTaskLifecycleWorkflow(input) {
   if (!input.projectPath?.trim())
     throw new Error("projectPath is required");
   const todosProjectPath = input.todosProjectPath ?? input.routeProjectPath ?? input.projectPath;
-  const todosDbPath = input.todosDbPath;
   const plan = worktreePlan(input, input.taskId);
   const taskContext = {
     taskId: input.taskId,
@@ -9599,7 +10271,6 @@ function renderTaskLifecycleWorkflow(input) {
     routeProjectPath: input.routeProjectPath,
     projectGroup: input.projectGroup,
     todosProjectPath,
-    todosDbPath,
     worktree: worktreeContextFragment(plan)
   };
   const handoffArtifactPath = prHandoffArtifactPath(plan, input.taskId);
@@ -9613,8 +10284,8 @@ function renderTaskLifecycleWorkflow(input) {
   const shared = [
     worktreePrompt(plan),
     ...todosExactCommandsFragment(todosProjectPath, input.taskId, [
-      todosEvidenceLine(todosProjectPath, input.taskId, "concise evidence, decision, or blocker", todosDbPath)
-    ], todosDbPath),
+      todosEvidenceLine(todosProjectPath, input.taskId, "concise evidence, decision, or blocker")
+    ]),
     NO_TMUX_DISPATCH_FRAGMENT,
     "Preserve unrelated user changes and keep scope tied to the task acceptance criteria.",
     "",
@@ -9623,7 +10294,7 @@ function renderTaskLifecycleWorkflow(input) {
   ].join(`
 `);
   const gateMarker = (stage, state) => `openloops:${stage}=${state} task=${input.taskId}${input.eventId ? ` event=${input.eventId}` : ""}`;
-  const blockTaskCommand = `${todosEnvPrefix(todosDbPath)}todos --project ${todosProjectPath} update ${input.taskId} --status blocked`;
+  const blockTaskCommand = `todos --project ${todosProjectPath} update ${input.taskId} --status blocked`;
   const gateStopFragment = (stage, stops) => `The deterministic ${stage} gate will stop ${stops} unless the latest ${stage} marker is the exact go marker and the task has no blocked/completed/done/cancelled/failed/archived/no-auto/manual/approval-required state.`;
   const triagePrompt = [
     ...goalHeaderFragment(`Triage todos task ${input.taskId} for safe automated execution.`, "triage", "lifecycle"),
@@ -9651,7 +10322,7 @@ function renderTaskLifecycleWorkflow(input) {
   const workerPrompt = [
     ...goalHeaderFragment(`Complete todos task ${input.taskId} according to the planner evidence.`, "worker", "lifecycle"),
     shared,
-    todosStartLine(todosProjectPath, input.taskId, todosDbPath),
+    todosStartLine(todosProjectPath, input.taskId),
     "Read the triage and planner comments first. Implement only the scoped task, run focused validation, and record changed files, commits, evidence, blockers, and residual risks.",
     input.prHandoff ? `When only GitHub network access is blocked after a successful commit/validation, record the handoff artifact at ${handoffArtifactPath} instead of repeatedly retrying push/PR creation.` : undefined,
     WORKER_LEAVES_COMPLETION_FRAGMENT
@@ -9660,8 +10331,8 @@ function renderTaskLifecycleWorkflow(input) {
   const verifierPrompt = [
     ...goalHeaderFragment(`Verify todos task ${input.taskId} after the full lifecycle worker step.`, "verifier", "lifecycle"),
     shared,
-    todosVerificationLine(todosProjectPath, input.taskId, todosDbPath),
-    todosDoneLine(todosProjectPath, input.taskId, todosDbPath),
+    todosVerificationLine(todosProjectPath, input.taskId),
+    todosDoneLine(todosProjectPath, input.taskId),
     adversarialReviewFragment("triage, plan, worker evidence, repo state, commits, tests, and acceptance criteria", TASK_REVIEW_FOCUS),
     verifierRuntimeGuidance(input),
     input.prHandoff ? `If ${handoffArtifactPath} exists and there is no PR URL evidence, verify that the PR handoff step queued or completed a bounded handoff; leave the original task open or blocked until PR evidence is recorded.` : undefined,
@@ -9670,7 +10341,7 @@ function renderTaskLifecycleWorkflow(input) {
   ].filter(Boolean).join(`
 `);
   const steps = [
-    sourceTaskGateStep(todosProjectPath, input.taskId, plan, "Fail before lifecycle agents execute when the source todos task is not resolvable.", todosDbPath),
+    sourceTaskGateStep(todosProjectPath, input.taskId, plan, "Fail before lifecycle agents execute when the source todos task is not resolvable."),
     {
       id: "triage",
       name: "Triage",
@@ -9684,7 +10355,6 @@ function renderTaskLifecycleWorkflow(input) {
       description: "Stop the lifecycle before planning when triage blocked or disallowed automation.",
       dependsOn: ["triage"],
       todosProjectPath,
-      todosDbPath,
       taskId: input.taskId,
       goMarker: gateMarker("triage", "go"),
       blockedMarker: gateMarker("triage", "blocked"),
@@ -9703,7 +10373,6 @@ function renderTaskLifecycleWorkflow(input) {
       description: "Stop the lifecycle before implementation when planning blocked or disallowed automation.",
       dependsOn: ["planner"],
       todosProjectPath,
-      todosDbPath,
       taskId: input.taskId,
       goMarker: gateMarker("planner", "go"),
       blockedMarker: gateMarker("planner", "blocked"),
@@ -9719,7 +10388,7 @@ function renderTaskLifecycleWorkflow(input) {
     }
   ];
   if (input.prHandoff) {
-    steps.push(prHandoffStep(input, plan, todosProjectPath, todosDbPath));
+    steps.push(prHandoffStep(input, plan, todosProjectPath));
   }
   steps.push({
     id: "verifier",
@@ -9944,7 +10613,6 @@ function renderLifecycleBoundedTemplate(id, values) {
       taskTitle: values.taskTitle,
       taskDescription: values.taskDescription,
       todosProjectPath: values.todosProjectPath ?? values.todosProject,
-      todosDbPath: values.todosDbPath,
       triageAuthProfile: values.triageAuthProfile,
       plannerAuthProfile: values.plannerAuthProfile,
       triageAccount: accountVar(values.triageAccount, values.accountTool),
@@ -10009,7 +10677,6 @@ function renderBuiltinLoopTemplate(id, values) {
       taskTitle: values.taskTitle,
       taskDescription: values.taskDescription,
       todosProjectPath: values.todosProjectPath ?? values.todosProject,
-      todosDbPath: values.todosDbPath,
       eventId: values.eventId,
       eventType: values.eventType
     });
@@ -10169,7 +10836,7 @@ function collectValues(value, previous = []) {
   return previous;
 }
 // src/lib/route/fields.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function eventData(event) {
   const data = event.data;
   if (data && typeof data === "object" && !Array.isArray(data))
@@ -10189,10 +10856,10 @@ function slugSegment2(value, fallback = "event") {
   return value.toLowerCase().replace(/[^a-z0-9._:-]+/g, "-").replace(/^-|-$/g, "").slice(0, 80) || fallback;
 }
 function stableSuffix(value) {
-  return createHash3("sha256").update(value).digest("hex").slice(0, 12);
+  return createHash4("sha256").update(value).digest("hex").slice(0, 12);
 }
 function stableHash(parts) {
-  return createHash3("sha256").update(parts.map((part) => JSON.stringify(part)).join(`
+  return createHash4("sha256").update(parts.map((part) => JSON.stringify(part)).join(`
 `)).digest("hex").slice(0, 16);
 }
 function taskEventField(data, keys) {
@@ -10457,8 +11124,7 @@ function writeRouteEvidence(kind, value, evidenceDir) {
   mkdirSync9(evidenceDir, { recursive: true, mode: 448 });
   const stamp = new Date().toISOString().replace(/[-:]/g, "").replace(/\./g, "");
   const evidencePath = join9(evidenceDir, `${kind}-${stamp}-${randomUUID().slice(0, 8)}.json`);
-  const encoded = scrubSecrets(JSON.stringify(scrubSecretsDeep(value), null, 2));
-  writeFileSync5(evidencePath, encoded, { mode: 384, flag: "wx" });
+  writeFileSync5(evidencePath, JSON.stringify(value, null, 2), { mode: 384, flag: "wx" });
   return evidencePath;
 }
 function selectRouteItems(items, maxActions, cursorKey, fingerprintOf) {
@@ -11054,70 +11720,6 @@ function todosTaskRouteTemplateId(opts) {
   }
   return id;
 }
-function sourceCandidateRecords(data, metadata) {
-  const records = [data, metadata];
-  for (const record of [data, metadata]) {
-    const sourceTask = objectField2(record.source_task) ?? objectField2(record.sourceTask);
-    if (sourceTask)
-      records.push(sourceTask);
-  }
-  return records;
-}
-function sourceStringField(records, keys) {
-  for (const record of records) {
-    for (const key of keys) {
-      const value = stringField2(record[key]);
-      if (value)
-        return value;
-    }
-  }
-  return;
-}
-function sourceBooleanField(records, keys) {
-  for (const record of records) {
-    for (const key of keys) {
-      const value = record[key];
-      if (typeof value === "boolean")
-        return value;
-      if (value === "true" || value === "1" || value === 1)
-        return true;
-      if (value === "false" || value === "0" || value === 0)
-        return false;
-    }
-  }
-  return;
-}
-function todosTaskSourceRef(data, metadata, taskId) {
-  const records = sourceCandidateRecords(data, metadata);
-  const sourceTaskKey = sourceStringField(records, ["source_task_key", "sourceTaskKey"]);
-  const sourceStoreId = sourceStringField(records, ["source_store_id", "sourceStoreId"]);
-  const sourceRepoPath = sourceStringField(records, ["source_repo_path", "sourceRepoPath"]);
-  const sourceDbPath = sourceStringField(records, ["source_db_path", "sourceDbPath"]);
-  const sourceSelectedByInput = sourceBooleanField(records, ["source_selected_by_input", "sourceSelectedByInput"]);
-  const idempotencySource = sourceTaskKey ? "source_task_key" : sourceStoreId ? "source_store_id" : "legacy_task_id";
-  return {
-    sourceTaskKey,
-    sourceStoreId,
-    sourceRepoPath,
-    sourceDbPath,
-    sourceSelectedByInput,
-    idempotencySource,
-    idempotencyKey: sourceTaskKey ? `todos-task:${sourceTaskKey}` : sourceStoreId ? `todos-task:${sourceStoreId}:${taskId}` : `todos-task:${taskId}`
-  };
-}
-function publicSourceTask(sourceTask) {
-  if (!sourceTask.sourceTaskKey && !sourceTask.sourceStoreId && !sourceTask.sourceRepoPath && !sourceTask.sourceDbPath && sourceTask.sourceSelectedByInput === undefined) {
-    return;
-  }
-  return {
-    source_task_key: sourceTask.sourceTaskKey,
-    source_store_id: sourceTask.sourceStoreId,
-    source_repo_path: sourceTask.sourceRepoPath,
-    source_db_path: sourceTask.sourceDbPath,
-    source_selected_by_input: sourceTask.sourceSelectedByInput,
-    idempotency_source: sourceTask.idempotencySource
-  };
-}
 async function readEventEnvelopeInput(opts = {}) {
   const raw = opts.eventJson ?? (opts.eventFile ? readFileSync8(opts.eventFile, "utf8") : process.env.HASNA_EVENT_JSON || await Bun.stdin.text());
   const event = JSON.parse(raw);
@@ -11294,13 +11896,11 @@ function routeTodosTaskEvent(event, opts) {
   const taskId = taskEventField(data, ["id", "task_id", "taskId"]);
   if (!taskId)
     throw new ValidationError("todos task event is missing task id in data.id, data.task_id, data.task.id, or data.payload.id");
-  const sourceTask = todosTaskSourceRef(data, metadata, taskId);
-  const sourceTaskPublic = publicSourceTask(sourceTask);
   const eligibility = taskRouteEligibility(data, metadata);
   if (!eligibility.eligible) {
     return {
       kind: "skipped",
-      value: { skipped: true, reason: eligibility.reason, event, taskId, eligibility, sourceTask: sourceTaskPublic },
+      value: { skipped: true, reason: eligibility.reason, event, taskId, eligibility },
       human: `skipped task ${taskId}: ${eligibility.reason}`
     };
   }
@@ -11315,11 +11915,11 @@ function routeTodosTaskEvent(event, opts) {
     "project_canonical_path",
     "cwd"
   ]);
-  const projectPath = dataProjectPath ?? metadataProjectPath ?? sourceTask.sourceRepoPath ?? opts.projectPath ?? process.cwd();
+  const projectPath = dataProjectPath ?? metadataProjectPath ?? opts.projectPath ?? process.cwd();
   const routeProjectPath = normalizeRoutePath(projectPath) ?? resolve7(projectPath);
   const projectGroup = routeProjectGroup(opts.projectGroup, data, metadata);
   const throttleLimits = routeThrottleLimitsFromOpts(opts);
-  const idempotencyKey = sourceTask.idempotencyKey;
+  const idempotencyKey = `todos-task:${taskId}`;
   const idempotencySuffix = stableSuffix(idempotencyKey);
   const namePrefix = opts.namePrefix ?? "event:todos-task";
   const workflowName = `${namePrefix}:${taskId.slice(0, 8)}:${idempotencySuffix}:workflow`;
@@ -11332,7 +11932,7 @@ function routeTodosTaskEvent(event, opts) {
         const existingLoop = existingItem.loopId ? store.getLoop(existingItem.loopId) : undefined;
         const existingWorkflow = existingItem.workflowId ? store.getWorkflow(existingItem.workflowId) : undefined;
         const existingInvocation = store.getWorkflowInvocation(existingItem.invocationId);
-        return dedupedRoutePrint({ event, idempotencyKey, dedupeValueExtras: sourceTaskPublic ? { sourceTask: sourceTaskPublic } : {} }, { existingItem, existingLoop, existingWorkflow, invocation: existingInvocation });
+        return dedupedRoutePrint({ event, idempotencyKey, dedupeValueExtras: {} }, { existingItem, existingLoop, existingWorkflow, invocation: existingInvocation });
       }
     } finally {
       store.close();
@@ -11395,14 +11995,12 @@ function routeTodosTaskEvent(event, opts) {
     prHandoff: templateId === TASK_LIFECYCLE_TEMPLATE_ID ? Boolean(opts.prHandoff) : false,
     eventId: event.id,
     eventType: event.type,
-    todosProjectPath: sourceTask.sourceRepoPath ?? opts.todosProject,
-    todosDbPath: sourceTask.sourceDbPath
+    todosProjectPath: opts.todosProject
   };
   const workflowContext = {
     name: workflowName,
     type: "todos-task-event-workflow",
-    event: event.id,
-    sourceTask: sourceTaskPublic
+    event: event.id
   };
   let workflowBody = templateId === TASK_LIFECYCLE_TEMPLATE_ID ? renderTaskLifecycleWorkflow(workflowInput) : renderTodosTaskWorkerVerifierWorkflow(workflowInput);
   workflowBody.name = workflowName;
@@ -11415,13 +12013,13 @@ function routeTodosTaskEvent(event, opts) {
       kind: "event",
       id: event.id,
       dedupeKey: idempotencyKey,
-      raw: { type: event.type, source: event.source, subject: event.subject, sourceTask: sourceTaskPublic }
+      raw: { type: event.type, source: event.source, subject: event.subject }
     },
     subjectRef: {
       kind: "task",
       id: taskId,
       path: routeProjectPath,
-      raw: { title: taskTitle, description: taskDescription, sourceTask: sourceTaskPublic }
+      raw: { title: taskTitle, description: taskDescription }
     },
     intent: "route",
     scope: {
@@ -11434,8 +12032,7 @@ function routeTodosTaskEvent(event, opts) {
       accountPolicy: providerRouting.authProfilePool?.length || providerRouting.accountPool?.length ? "pool" : hasExplicitRoleAccount ? "role-explicit" : "single",
       providerRouting: providerRoutingPublic(providerRouting),
       prReviewRouting: prReviewRouting.required ? prReviewRouting : undefined,
-      concurrencyGroup: projectGroup ?? routeProjectPath,
-      sourceTask: sourceTaskPublic
+      concurrencyGroup: projectGroup ?? routeProjectPath
     },
     outputPolicy: {
       report: "always",
@@ -11460,10 +12057,9 @@ function routeTodosTaskEvent(event, opts) {
     humanSubject: `task ${taskId}`,
     valueExtras: {
       providerRouting: providerRoutingPublic(providerRouting),
-      prReviewRouting: prReviewRouting.required ? prReviewRouting : undefined,
-      sourceTask: sourceTaskPublic
+      prReviewRouting: prReviewRouting.required ? prReviewRouting : undefined
     },
-    dedupeValueExtras: sourceTaskPublic ? { sourceTask: sourceTaskPublic } : {}
+    dedupeValueExtras: {}
   });
 }
 function routeGenericEvent(event, opts) {
@@ -11600,7 +12196,7 @@ function runLocalCommand(command, args, opts = {}) {
     encoding: "utf8",
     timeout: opts.timeoutMs ?? 30000,
     maxBuffer: opts.maxBuffer ?? 8 * 1024 * 1024,
-    env: { ...process.env, ...opts.env }
+    env: process.env
   });
   return {
     ok: result.status === 0,
@@ -11667,66 +12263,8 @@ function taskField(task, keys) {
   }
   return;
 }
-function booleanTaskField(task, keys) {
-  for (const key of keys) {
-    const value = task[key];
-    if (typeof value === "boolean")
-      return value;
-    if (value === "true" || value === "1" || value === 1)
-      return true;
-    if (value === "false" || value === "0" || value === 0)
-      return false;
-  }
-  return;
-}
-function normalizedSourceRoots(opts) {
-  return listFromRepeatedOpts(opts.todosSourceRoot) ?? [];
-}
-function normalizedSourceStores(opts) {
-  return listFromRepeatedOpts(opts.todosSourceStore) ?? [];
-}
-function normalizedSourceIncludes(opts) {
-  return listFromRepeatedOpts(opts.todosSourceInclude) ?? [];
-}
-function normalizedSourceExcludes(opts) {
-  return listFromRepeatedOpts(opts.todosSourceExclude) ?? [];
-}
-function hasTodosSourceOptions(opts) {
-  return Boolean(normalizedSourceRoots(opts).length || normalizedSourceStores(opts).length || normalizedSourceIncludes(opts).length || normalizedSourceExcludes(opts).length);
-}
-function taskSourceIdentity(task, taskId) {
-  const sourceTaskKey = taskField(task, ["source_task_key", "sourceTaskKey"]);
-  const sourceStoreId = taskField(task, ["source_store_id", "sourceStoreId"]);
-  const identity = sourceTaskKey ?? (sourceStoreId && taskId ? `${sourceStoreId}:${taskId}` : undefined);
-  return {
-    sourceTaskKey,
-    sourceStoreId,
-    sourceRepoPath: taskField(task, ["source_repo_path", "sourceRepoPath"]),
-    sourceDbPath: taskField(task, ["source_db_path", "sourceDbPath"]),
-    sourceSelectedByInput: booleanTaskField(task, ["source_selected_by_input", "sourceSelectedByInput"]),
-    idempotencyIdentity: identity
-  };
-}
-function publicSourceTaskIdentity(source) {
-  if (!source.sourceTaskKey && !source.sourceStoreId && !source.sourceRepoPath && !source.sourceDbPath && source.sourceSelectedByInput === undefined) {
-    return;
-  }
-  return {
-    source_task_key: source.sourceTaskKey,
-    source_store_id: source.sourceStoreId,
-    source_repo_path: source.sourceRepoPath,
-    source_db_path: source.sourceDbPath,
-    source_selected_by_input: source.sourceSelectedByInput
-  };
-}
-function taskListValues(task) {
-  const values = [
-    taskField(task, ["task_list_id", "taskListId", "task_list_slug", "taskListSlug", "task_list_name", "taskListName"]),
-    stringField2(task.task_list?.id),
-    stringField2(task.task_list?.slug),
-    stringField2(task.task_list?.name)
-  ].filter((value) => Boolean(value));
-  return [...new Set(values)];
+function taskListId(task) {
+  return taskField(task, ["task_list_id", "taskListId"]) ?? stringField2(task.task_list?.id);
 }
 function taskProjectId(task) {
   return taskField(task, ["project_id", "projectId"]);
@@ -11740,14 +12278,12 @@ function taskProjectPath(task) {
   const metadata = objectField2(task.metadata) ?? {};
   return taskField(task, ["project_path", "projectPath"]) ?? taskEventField(metadata, ["project_path", "projectPath", "project_canonical_path"]) ?? taskDescriptionProjectPath(task) ?? taskField(task, ["working_dir", "workingDir", "cwd"]) ?? taskEventField(metadata, ["working_dir", "workingDir", "cwd"]);
 }
-function taskDrainEvent(task, opts = {}) {
+function taskDrainEvent(task) {
   const taskId = taskField(task, ["id", "task_id", "taskId"]);
   if (!taskId)
     throw new Error("todos ready returned a task without an id");
   const metadata = objectField2(task.metadata) ?? {};
   const workingDir = taskProjectPath(task);
-  const sourceIdentity = taskSourceIdentity(task, taskId);
-  const sourceTask = publicSourceTaskIdentity(sourceIdentity);
   const data = {
     ...task,
     id: taskId,
@@ -11757,21 +12293,14 @@ function taskDrainEvent(task, opts = {}) {
     tags: tagsFromValue2(task.tags),
     metadata
   };
-  if (opts.sourceRouteEligible) {
-    data.route_enabled = true;
-    data.route_enabled_by = "source_route_state";
-  }
   if (workingDir) {
     data.working_dir = workingDir;
     data.project_path = taskField(task, ["project_path", "projectPath"]) ?? workingDir;
     data.cwd = taskField(task, ["cwd"]) ?? workingDir;
   }
-  if (sourceTask)
-    data.source_task = sourceTask;
-  const eventId = sourceIdentity.idempotencyIdentity ? `drain-todos-task-${slugSegment2(taskId, "task")}-${stableSuffix(sourceIdentity.idempotencyIdentity)}` : `drain-todos-task-${taskId}`;
   const time = new Date().toISOString();
   return {
-    id: eventId,
+    id: `drain-todos-task-${taskId}`,
     type: "task.created",
     source: "@hasna/todos",
     subject: taskId,
@@ -11782,8 +12311,6 @@ function taskDrainEvent(task, opts = {}) {
     metadata: {
       ...metadata,
       ...workingDir ? { working_dir: workingDir, project_path: data.project_path, cwd: data.cwd } : {},
-      ...sourceTask,
-      ...sourceTask ? { source_task: sourceTask } : {},
       drained_by: "@hasna/loops",
       drained_from: "todos ready"
     }
@@ -11792,7 +12319,6 @@ function taskDrainEvent(task, opts = {}) {
 function compactDrainResult(result) {
   const value = result.value;
   const event = objectField2(value.event);
-  const sourceTask = objectField2(value.sourceTask) ?? objectField2(objectField2(event?.metadata)?.source_task) ?? objectField2(objectField2(event?.data)?.source_task);
   const loop = objectField2(value.loop);
   const workflow = objectField2(value.workflow);
   const throttle = objectField2(value.throttle);
@@ -11809,75 +12335,26 @@ function compactDrainResult(result) {
     workflowId: stringField2(workflow?.id),
     workflowName: stringField2(workflow?.name),
     providerRouting,
-    sourceTask,
     requeue,
     queuedAtSource: value.queuedAtSource
   };
 }
-function numberField2(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function parseTodosReadyJson(stdout) {
-  try {
-    return JSON.parse(stdout || "[]");
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`failed to parse todos ready --json output (${stdout.length} bytes): ${message}`);
-  }
-}
-function loadReadyTodosTasks(opts, scanLimit, sourceMode) {
-  const sourceRoots = normalizedSourceRoots(opts);
-  const sourceStores = normalizedSourceStores(opts);
-  const sourceIncludes = normalizedSourceIncludes(opts);
-  const sourceExcludes = normalizedSourceExcludes(opts);
-  if (sourceMode && !sourceRoots.length && !sourceStores.length) {
-    throw new ValidationError("source discovery requires at least one --todos-source-root or --todos-source-store");
-  }
-  const args = sourceMode ? ["--json", "ready"] : ["--project", opts.todosProject ?? defaultLoopsProject(), "--json", "ready"];
-  if (sourceMode) {
-    for (const root of sourceRoots)
-      args.push("--source-root", root);
-    for (const store of sourceStores)
-      args.push("--source-store", store);
-    for (const pattern of sourceIncludes)
-      args.push("--include", pattern);
-    for (const pattern of sourceExcludes)
-      args.push("--exclude", pattern);
-  }
-  args.push("--limit", String(scanLimit));
+function loadReadyTodosTasks(opts, scanLimit) {
+  const todosProject = opts.todosProject ?? defaultLoopsProject();
+  const args = ["--project", todosProject, "--json", "ready", "--limit", String(scanLimit)];
   const result = runLocalCommandWithStdoutFile("todos", args, { timeoutMs: 60000, maxBuffer: 64 * 1024 * 1024 });
   if (!result.ok)
     throw new Error(result.stderr || result.error || "todos ready failed");
-  const parsed = parseTodosReadyJson(result.stdout);
-  if (!sourceMode) {
-    if (!Array.isArray(parsed))
-      throw new Error("todos ready --json returned a non-array value");
-    return { tasks: parsed, sourceMode, sourceRoots, sourceStores, sourceIncludes, sourceExcludes };
-  }
-  const response = objectField2(parsed);
-  if (!response)
-    throw new Error("todos ready --json source discovery returned a non-object value");
-  if (response.schema_version !== "todos.task_route_sources.v1") {
-    throw new Error(`todos ready source discovery returned unsupported schema_version: ${String(response.schema_version)}`);
-  }
-  if (!Array.isArray(response.candidates))
-    throw new Error("todos ready source discovery returned missing candidates array");
-  return {
-    tasks: response.candidates,
-    sourceMode,
-    sourceRoots,
-    sourceStores,
-    sourceIncludes,
-    sourceExcludes,
-    sourceDiscovery: {
-      schemaVersion: "todos.task_route_sources.v1",
-      stores: Array.isArray(response.stores) ? response.stores : undefined,
-      errors: Array.isArray(response.errors) ? response.errors : undefined,
-      totalCandidateCount: numberField2(response.total_candidate_count),
-      returnedCandidateCount: numberField2(response.returned_candidate_count),
-      truncated: typeof response.truncated === "boolean" ? response.truncated : undefined
-    }
-  };
+  let parsed;
+  try {
+    parsed = JSON.parse(result.stdout || "[]");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`failed to parse todos ready --json output (${result.stdout.length} bytes): ${message}`);
+  }
+  if (!Array.isArray(parsed))
+    throw new Error("todos ready --json returned a non-array value");
+  return parsed;
 }
 function resolveTaskListFilter(todosProject, filter) {
   const wanted = filter?.trim();
@@ -11893,7 +12370,7 @@ function resolveTaskListFilter(todosProject, filter) {
 function taskMatchesDrainFilters(task, filters) {
   if (filters.projectId && taskProjectId(task) !== filters.projectId)
     return false;
-  if (filters.taskList && !taskListValues(task).includes(filters.taskList))
+  if (filters.taskListId && taskListId(task) !== filters.taskListId)
     return false;
   if (filters.projectPathPrefix) {
     const path = taskProjectPath(task);
@@ -11931,77 +12408,19 @@ function skippedDrainTask(task, event, reason, extra = {}) {
 function isSkippableDrainRouteError(message) {
   return message.startsWith("worktreeMode=required but projectPath is not an existing git repository:");
 }
-function sourceRouteState(task) {
-  return objectField2(task.route_state) ?? objectField2(task.routeState);
-}
-function sourceRouteReason(routeState) {
-  const reasons = routeState?.reasons;
-  const firstReason = Array.isArray(reasons) ? stringField2(reasons[0]) : undefined;
-  return stringField2(routeState?.reason) ?? stringField2(routeState?.eligibility_reason) ?? stringField2(routeState?.eligibilityReason) ?? firstReason;
-}
-function sourceRouteEligibility(task) {
-  const routeState = sourceRouteState(task);
-  if (routeState?.eligible === true)
-    return { eligible: true, routeState };
-  const reason = sourceRouteReason(routeState) ?? "source route_state.eligible is not true";
-  return { eligible: false, reason, routeState };
-}
-function sourceTaskMutationTarget(todosProject, task, opts = {}) {
-  const source = taskSourceIdentity(task, taskField(task, ["id", "task_id", "taskId"]));
-  if (source.sourceDbPath) {
-    return {
-      argsPrefix: source.sourceRepoPath ? ["--project", source.sourceRepoPath] : [],
-      env: {
-        TODOS_DB_PATH: source.sourceDbPath,
-        HASNA_TODOS_DB_PATH: source.sourceDbPath
-      },
-      project: source.sourceRepoPath,
-      sourceDbPath: source.sourceDbPath,
-      sourceRepoPath: source.sourceRepoPath,
-      sourceStoreId: source.sourceStoreId
-    };
-  }
-  if (source.sourceRepoPath) {
-    return {
-      argsPrefix: ["--project", source.sourceRepoPath],
-      project: source.sourceRepoPath,
-      sourceRepoPath: source.sourceRepoPath,
-      sourceStoreId: source.sourceStoreId
-    };
-  }
-  if (opts.sourceMode)
-    return;
-  const project = todosProject ?? defaultLoopsProject();
-  return { argsPrefix: ["--project", project], project };
-}
-function markInvalidDrainTaskNonRouteable(todosProject, task, reason, opts = {}) {
+function markInvalidDrainTaskNonRouteable(todosProject, task, reason) {
   const taskId = taskField(task, ["id", "task_id", "taskId"]);
   if (!taskId)
     return { attempted: false, reason: "task id missing" };
   const comment = `OpenLoops route blocked for task ${taskId}: ${reason}. Added no-auto and removed auto:route so route drains do not repeatedly route this task until its project path is fixed.`;
-  const target = sourceTaskMutationTarget(todosProject, task, { sourceMode: opts.sourceMode });
-  if (!target) {
-    return {
-      attempted: false,
-      taskId,
-      reason: "source task missing source_db_path or source_repo_path; refusing to update router/default Todos store"
-    };
-  }
-  const commentResult = runLocalCommand("todos", [...target.argsPrefix, "comment", taskId, comment], { timeoutMs: 30000, env: target.env });
-  const tagResult = runLocalCommand("todos", [...target.argsPrefix, "tag", taskId, "no-auto"], { timeoutMs: 30000, env: target.env });
-  const untagResult = runLocalCommand("todos", [...target.argsPrefix, "untag", taskId, "auto:route"], { timeoutMs: 30000, env: target.env });
+  const commentResult = runLocalCommand("todos", ["--project", todosProject, "comment", taskId, comment], { timeoutMs: 30000 });
+  const tagResult = runLocalCommand("todos", ["--project", todosProject, "tag", taskId, "no-auto"], { timeoutMs: 30000 });
+  const untagResult = runLocalCommand("todos", ["--project", todosProject, "untag", taskId, "auto:route"], { timeoutMs: 30000 });
   const ok = commentResult.ok && tagResult.ok && untagResult.ok;
   return {
     ok,
     attempted: true,
     taskId,
-    target: {
-      project: target.project,
-      source_db_path: target.sourceDbPath,
-      source_repo_path: target.sourceRepoPath,
-      source_store_id: target.sourceStoreId,
-      used_db_env: Boolean(target.sourceDbPath)
-    },
     error: ok ? undefined : "one or more source task updates failed; inspect per-command results",
     comment: todosMutationSummary(commentResult),
     tagNoAuto: todosMutationSummary(tagResult),
@@ -12010,19 +12429,17 @@ function markInvalidDrainTaskNonRouteable(todosProject, task, reason, opts = {})
 }
 function drainTodosTaskRoutes(opts) {
   const maxDispatch = positiveInteger(opts.maxDispatch ?? "1", "--max-dispatch") ?? 1;
-  const sourceMode = hasTodosSourceOptions(opts);
-  const todosProject = sourceMode ? opts.todosProject : opts.todosProject ?? defaultLoopsProject();
+  const todosProject = opts.todosProject ?? defaultLoopsProject();
   const requiredTags = splitList(opts.tags ?? opts.tag) ?? [];
-  const taskListFilter = sourceMode ? opts.taskList?.trim() : resolveTaskListFilter(todosProject ?? defaultLoopsProject(), opts.taskList);
+  const taskListFilter = resolveTaskListFilter(todosProject, opts.taskList);
   const candidateLimit = positiveInteger(opts.limit ?? "50", "--limit") ?? 50;
   const hasPostFilters = Boolean(opts.todosProjectId || taskListFilter || opts.projectPathPrefix || requiredTags.length);
   const defaultScanLimit = hasPostFilters ? Math.max(candidateLimit, 500) : candidateLimit;
   const scanLimit = positiveInteger(opts.scanLimit ?? String(defaultScanLimit), "--scan-limit") ?? defaultScanLimit;
-  const loaded = loadReadyTodosTasks(opts, scanLimit, sourceMode);
-  const ready = loaded.tasks;
+  const ready = loadReadyTodosTasks(opts, scanLimit);
   const filteredCandidates = ready.filter((task) => taskMatchesDrainFilters(task, {
     projectId: opts.todosProjectId,
-    taskList: taskListFilter,
+    taskListId: taskListFilter,
     projectPathPrefix: opts.projectPathPrefix,
     tags: requiredTags
   }));
@@ -12035,25 +12452,13 @@ function drainTodosTaskRoutes(opts) {
     let event;
     let result;
     try {
-      let sourceEligibility;
-      if (sourceMode) {
-        sourceEligibility = sourceRouteEligibility(task);
-        if (!sourceEligibility.eligible) {
-          result = skippedDrainTask(task, undefined, sourceEligibility.reason ?? "source route_state.eligible is not true", {
-            sourceRouteState: sourceEligibility.routeState,
-            sourceTask: publicSourceTaskIdentity(taskSourceIdentity(task, taskField(task, ["id", "task_id", "taskId"])))
-          });
-          results.push(result);
-          continue;
-        }
-      }
-      event = taskDrainEvent(task, { sourceRouteEligible: sourceEligibility?.eligible === true });
+      event = taskDrainEvent(task);
       result = routeTodosTaskEvent(event, opts);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (!isSkippableDrainRouteError(message))
         throw error;
-      const sourceTaskUpdate = opts.dryRun ? { attempted: false, reason: "dry-run" } : markInvalidDrainTaskNonRouteable(todosProject, task, message, { sourceMode });
+      const sourceTaskUpdate = opts.dryRun ? { attempted: false, reason: "dry-run" } : markInvalidDrainTaskNonRouteable(todosProject, task, message);
       result = skippedDrainTask(task, event, redact(message, 640) ?? "route task failed", { sourceTaskUpdate });
     }
     results.push(result);
@@ -12063,12 +12468,6 @@ function drainTodosTaskRoutes(opts) {
   const report = {
     drainedAt: new Date().toISOString(),
     todosProject,
-    sourceMode,
-    sourceRoots: loaded.sourceRoots,
-    sourceStores: loaded.sourceStores,
-    sourceIncludes: loaded.sourceIncludes,
-    sourceExcludes: loaded.sourceExcludes,
-    sourceDiscovery: loaded.sourceDiscovery,
     templateId: todosTaskRouteTemplateId(opts),
     todosProjectId: opts.todosProjectId,
     taskList: opts.taskList,
@@ -12081,14 +12480,14 @@ function drainTodosTaskRoutes(opts) {
     scanned: ready.length,
     candidates: candidates.length,
     filteredCandidates: filteredCandidates.length,
-    scanExhausted: sourceMode ? Boolean(loaded.sourceDiscovery?.truncated) || ready.length >= scanLimit && filteredCandidates.length < candidateLimit : ready.length >= scanLimit && filteredCandidates.length < candidateLimit,
+    scanExhausted: ready.length >= scanLimit && filteredCandidates.length < candidateLimit,
     considered: results.length,
     created: results.filter((result) => result.kind === "created" && !result.value.deduped).length,
     deduped: results.filter((result) => result.kind === "deduped").length,
     throttled: results.filter((result) => result.kind === "throttled").length,
     skipped: results.filter((result) => result.kind === "skipped").length,
     maxDispatch,
-    source: sourceMode ? "todos ready source discovery" : "todos ready",
+    source: "todos ready",
     dryRun: Boolean(opts.dryRun),
     results: results.map((result) => ({ kind: result.kind, ...result.value }))
   };
@@ -12096,12 +12495,6 @@ function drainTodosTaskRoutes(opts) {
   const value = opts.compact ? {
     drainedAt: report.drainedAt,
     todosProject: report.todosProject,
-    sourceMode: report.sourceMode,
-    sourceRoots: report.sourceRoots,
-    sourceStores: report.sourceStores,
-    sourceIncludes: report.sourceIncludes,
-    sourceExcludes: report.sourceExcludes,
-    sourceDiscovery: report.sourceDiscovery,
     templateId: report.templateId,
     todosProjectId: report.todosProjectId,
     taskList: report.taskList,
@@ -12127,7 +12520,7 @@ function drainTodosTaskRoutes(opts) {
     results: results.map(compactDrainResult)
   } : { ...report, evidencePath };
   return {
-    value: scrubSecretsDeep(value),
+    value,
     human: `drained todos ready queue: considered=${report.considered} created=${report.created} deduped=${report.deduped} throttled=${report.throttled} skipped=${report.skipped}`
   };
 }
@@ -12405,34 +12798,6 @@ var EVENT_INPUT_OPTION_SPECS = [
   { flags: "--event-json <json>", key: "eventJson", kind: "value", description: "read event envelope JSON from this string instead of stdin/HASNA_EVENT_JSON" }
 ];
 var DRAIN_FILTER_OPTION_SPECS = [
-  {
-    flags: "--todos-source-root <path>",
-    key: "todosSourceRoot",
-    kind: "repeat",
-    description: "scan todos route candidates discovered under this source root; may be repeated",
-    serializeValue: (opts) => listFromRepeatedOpts(opts.todosSourceRoot)
-  },
-  {
-    flags: "--todos-source-store <path>",
-    key: "todosSourceStore",
-    kind: "repeat",
-    description: "scan this explicit todos source store path; may be repeated",
-    serializeValue: (opts) => listFromRepeatedOpts(opts.todosSourceStore)
-  },
-  {
-    flags: "--todos-source-include <pattern>",
-    key: "todosSourceInclude",
-    kind: "repeat",
-    description: "include source discovery entries matching this pattern; may be repeated",
-    serializeValue: (opts) => listFromRepeatedOpts(opts.todosSourceInclude)
-  },
-  {
-    flags: "--todos-source-exclude <pattern>",
-    key: "todosSourceExclude",
-    kind: "repeat",
-    description: "exclude source discovery entries matching this pattern; may be repeated",
-    serializeValue: (opts) => listFromRepeatedOpts(opts.todosSourceExclude)
-  },
   { flags: "--todos-project-id <id>", key: "todosProjectId", kind: "value", description: "filter todos ready output to one todos project id" },
   { flags: "--task-list <id-or-slug>", key: "taskList", kind: "value", description: "filter ready tasks to one task-list id, slug, or name" },
   { flags: "--project-path-prefix <path>", key: "projectPathPrefix", kind: "value", description: "filter ready tasks to a project/repo path prefix" },
@@ -12931,6 +13296,53 @@ function parseVars(values) {
   }
   return vars;
 }
+function parseJsonFile(file) {
+  try {
+    return JSON.parse(readFileSync10(file, "utf8"));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new ValidationError(`failed to read JSON file ${file}: ${reason}`);
+  }
+}
+function parseStringMap(values, flag) {
+  const result = {};
+  for (const value of values ?? []) {
+    const index = value.indexOf("=");
+    if (index <= 0)
+      throw new ValidationError(`invalid ${flag} value, expected key=value: ${value}`);
+    result[value.slice(0, index)] = value.slice(index + 1);
+  }
+  return result;
+}
+function parseJsonMap(values, flag) {
+  const result = {};
+  for (const value of values ?? []) {
+    const index = value.indexOf("=");
+    if (index <= 0)
+      throw new ValidationError(`invalid ${flag} value, expected key=json-or-string: ${value}`);
+    const raw = value.slice(index + 1);
+    try {
+      result[value.slice(0, index)] = JSON.parse(raw);
+    } catch {
+      result[value.slice(0, index)] = raw;
+    }
+  }
+  return result;
+}
+function printMigrationPlan(plan, opts = {}) {
+  if (isJson() || opts.json) {
+    console.log(JSON.stringify(plan, null, 2));
+    return;
+  }
+  console.log(`${plan.operation} dryRun=${plan.dryRun} workflows=${plan.summary.workflows} loops=${plan.summary.loops} runs=${plan.summary.runs} ` + `insert=${plan.summary.insert} update=${plan.summary.update} skip=${plan.summary.skip} conflict=${plan.summary.conflict} blocked=${plan.summary.blocked}`);
+  for (const warning of plan.warnings)
+    console.log(`warn ${warning}`);
+  for (const row of plan.rows) {
+    if (row.action !== "blocked" && row.action !== "conflict")
+      continue;
+    console.log(`${row.action} ${row.resource}:${row.name ?? row.id} ${row.reason ?? ""}`.trim());
+  }
+}
 function backupLoopsDatabase(reason) {
   return backupDatabase({ reason, keep: 3 }).path;
 }
@@ -13019,6 +13431,104 @@ var goal = program.command("goal").description("inspect goal runs");
 program.command("mode").description("show the active OpenLoops deployment mode").option("--json", "print JSON").action(runAction(deploymentStatusCommand()));
 var selfHosted = program.command("self-hosted").alias("selfhosted").description("inspect the self-hosted OpenLoops contract");
 selfHosted.command("status").option("--json", "print JSON").action(runAction(deploymentStatusCommand("self_hosted")));
+program.command("export").description("export a local OpenLoops migration bundle").requiredOption("--file <path>", "write bundle JSON to this path").option("--dry-run", "preview the bundle without writing the file").option("--no-runs", "omit loop run history from the bundle").option("--allow-redacted", "write a redacted non-importable bundle when env/secrets must be removed").option("--json", "print JSON").action(runAction((opts) => {
+  const store = new Store;
+  try {
+    const bundle = exportLoopsMigrationBundle(store, { includeRuns: opts.runs });
+    if (!opts.dryRun && !bundle.importable && !opts.allowRedacted) {
+      throw new ValidationError("export is not no-loss because redactions/blockers are present; rerun with --allow-redacted to write a redacted bundle");
+    }
+    if (!opts.dryRun)
+      writeFileSync6(opts.file, `${JSON.stringify(bundle, null, 2)}
+`, { mode: 384 });
+    const output = {
+      ok: true,
+      dryRun: Boolean(opts.dryRun),
+      file: opts.file,
+      bundle: publicMigrationBundle(bundle)
+    };
+    if (isJson() || opts.json)
+      console.log(JSON.stringify(output, null, 2));
+    else {
+      console.log(`${opts.dryRun ? "would export" : "exported"} ${opts.file} workflows=${bundle.counts.workflows} loops=${bundle.counts.loops} runs=${bundle.counts.runs}`);
+      for (const warning of bundle.warnings)
+        console.log(`warn ${warning}`);
+    }
+  } finally {
+    store.close();
+  }
+}));
+program.command("import <file>").description("preview or apply a local OpenLoops migration bundle").option("--apply", "apply the import; default is a dry-run preview").option("--replace", "update existing rows whose ids match but hashes differ").option("--no-runs", "ignore loop run history in the bundle").option("--json", "print JSON").action(runAction((file, opts) => {
+  const bundle = validateLoopsMigrationBundle(parseJsonFile(file));
+  const store = new Store;
+  try {
+    if (!opts.apply) {
+      printMigrationPlan(buildImportMigrationPlan(store, bundle, {
+        includeRuns: opts.runs,
+        replace: opts.replace,
+        dryRun: true
+      }), opts);
+      return;
+    }
+    const plan = buildImportMigrationPlan(store, bundle, {
+      includeRuns: opts.runs,
+      replace: opts.replace,
+      dryRun: false
+    });
+    if (plan.summary.blocked > 0 || plan.summary.conflict > 0 || !plan.importable) {
+      printMigrationPlan(plan, opts);
+      throw new ValidationError(`refusing to import unsafe bundle: blocked=${plan.summary.blocked} conflict=${plan.summary.conflict}`);
+    }
+    const backupPath = backupLoopsDatabase("migration-import");
+    const result = applyImportMigrationBundle(store, bundle, {
+      includeRuns: opts.runs,
+      replace: opts.replace,
+      dryRun: false
+    });
+    const output = { ok: true, backupPath, ...result };
+    if (isJson() || opts.json)
+      console.log(JSON.stringify(output, null, 2));
+    else {
+      console.log(`imported workflows=${result.applied.workflows} loops=${result.applied.loops} runs=${result.applied.runs}${backupPath ? ` backup=${backupPath}` : ""}`);
+    }
+  } finally {
+    store.close();
+  }
+}));
+function selfHostedMigrationCommand(operation) {
+  return runAction(async (opts) => {
+    const store = new Store;
+    try {
+      const plan = await buildSelfHostedMigrationPlan(store, {
+        operation,
+        apiUrl: opts.apiUrl,
+        includeRuns: opts.runs
+      });
+      printMigrationPlan(plan, opts);
+    } finally {
+      store.close();
+    }
+  });
+}
+selfHosted.command("migrate").description("preview local-to-self-hosted migration actions").option("--api-url <url>", "self-hosted control-plane API URL").option("--dry-run", "preview only; self-hosted migrate does not apply remote changes yet").option("--no-runs", "omit loop run history from the preview").option("--json", "print JSON").action(selfHostedMigrationCommand("self-hosted-migrate"));
+selfHosted.command("push").description("preview local rows that would be pushed to self-hosted").option("--api-url <url>", "self-hosted control-plane API URL").option("--dry-run", "preview only; self-hosted push does not apply remote changes yet").option("--no-runs", "omit loop run history from the preview").option("--json", "print JSON").action(selfHostedMigrationCommand("self-hosted-push"));
+selfHosted.command("pull").description("preview self-hosted rows that would be pulled locally").option("--api-url <url>", "self-hosted control-plane API URL").option("--dry-run", "preview only; self-hosted pull does not apply local changes yet").option("--no-runs", "omit loop run history from the preview").option("--json", "print JSON").action(selfHostedMigrationCommand("self-hosted-pull"));
+selfHosted.command("runner-register").description("register this machine as a self-hosted runner").requiredOption("--runner-id <id>", "stable runner id").option("--api-url <url>", "self-hosted control-plane API URL").option("--machine-id <id>", "OpenMachines machine id").option("--label <key=value>", "runner label; may be repeated or comma-separated", collectValues, []).option("--capability <key=json>", "runner capability; may be repeated or comma-separated", collectValues, []).option("--dry-run", "preview registration without posting").option("--apply", "post the registration to the control plane").option("--json", "print JSON").action(runAction(async (opts) => {
+  if (opts.apply && opts.dryRun)
+    throw new ValidationError("use either --apply or --dry-run, not both");
+  const request = {
+    apiUrl: opts.apiUrl,
+    runnerId: opts.runnerId,
+    machineId: opts.machineId,
+    labels: parseStringMap(listFromRepeatedOpts(opts.label), "--label"),
+    capabilities: parseJsonMap(listFromRepeatedOpts(opts.capability), "--capability")
+  };
+  const result = opts.apply ? await registerSelfHostedRunner(request) : { ok: true, dryRun: true, runner: request };
+  if (isJson() || opts.json)
+    console.log(JSON.stringify(result, null, 2));
+  else
+    console.log(`${opts.apply ? "registered" : "would register"} runner ${String(opts.runnerId)}`);
+}));
 var cloud = program.command("cloud").description("inspect the hosted OpenLoops contract");
 cloud.command("status").option("--json", "print JSON").action(runAction(deploymentStatusCommand("cloud")));
 function formatTemplateVariable(template, name) {