@hasna/loops 0.4.2 → 0.4.4

package/dist/index.js

@@ -3841,6 +3841,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) {
@@ -3982,7 +4166,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",
@@ -4056,7 +4240,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",
@@ -8231,6 +8415,515 @@ if (import.meta.main) {
   });
 }
 
+// src/lib/migration.ts
+import { createHash as createHash3 } from "crypto";
+import { hostname as hostname2 } 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: hostname2()
+    },
+    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/sdk/index.ts
 class LoopsClient {
   store;
@@ -8306,6 +8999,18 @@ class LoopsClient {
     const result = await runLoopNow({ store: this.store, idOrName, runnerId: this.runnerId });
     return result.run;
   }
+  exportBundle(opts = {}) {
+    return exportLoopsMigrationBundle(this.store, opts);
+  }
+  planImport(bundle, opts = {}) {
+    return buildImportMigrationPlan(this.store, bundle, opts);
+  }
+  importBundle(bundle, opts = {}) {
+    return applyImportMigrationBundle(this.store, bundle, opts);
+  }
+  planSelfHostedMigration(opts = {}) {
+    return buildSelfHostedMigrationPlan(this.store, { ...opts, operation: opts.operation ?? "self-hosted-migrate" });
+  }
   close() {
     if (this.ownStore)
       this.store.close();
@@ -8557,12 +9262,12 @@ function createSqliteLoopStorage(path) {
 }
 
 // src/lib/storage/postgres-schema.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 var POSTGRES_MIGRATION_LEDGER_TABLE = "open_loops_schema_migrations";
 function checksumStorageSql(sql) {
   const normalized = sql.trim().replace(/\r\n/g, `
 `);
-  return `sha256:${createHash3("sha256").update(normalized).digest("hex")}`;
+  return `sha256:${createHash4("sha256").update(normalized).digest("hex")}`;
 }
 function migration(id, sql) {
   return Object.freeze({ id, sql: sql.trim(), checksum: checksumStorageSql(sql) });
@@ -9058,7 +9763,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" })
     ]
@@ -9099,8 +9803,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"),
@@ -9231,29 +9933,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) {
@@ -9290,19 +9991,10 @@ function worktreeContextFragment(plan) {
 function shellQuote2(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-function todosEnvPrefix(todosDbPath) {
-  return todosDbPath ? `TODOS_DB_PATH=${shellQuote2(todosDbPath)} HASNA_TODOS_DB_PATH=${shellQuote2(todosDbPath)} ` : "";
-}
-function todosCommand(todosProjectPath, todosDbPath) {
-  return `${todosEnvPrefix(todosDbPath)}todos --project ${todosProjectPath}`;
-}
-function shellTodosCommand(todosProjectPath, todosDbPath) {
-  return `${todosEnvPrefix(todosDbPath)}todos --project ${shellQuote2(todosProjectPath)}`;
-}
-function sourceTaskGateCommand(todosProjectPath, taskId, todosDbPath) {
+function sourceTaskGateCommand(todosProjectPath, taskId) {
   return [
     "set -euo pipefail",
-    `${shellTodosCommand(todosProjectPath, todosDbPath)} --json inspect ${shellQuote2(taskId)} >/dev/null`,
+    `todos --project ${shellQuote2(todosProjectPath)} --json inspect ${shellQuote2(taskId)} >/dev/null`,
     `printf "source task %s resolved in todos project %s\\n" ${shellQuote2(taskId)} ${shellQuote2(todosProjectPath)}`
   ].join(`
 `);
@@ -9362,10 +10054,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 ${shellQuote2(taskId)})"`,
+    `task_json="$(todos --project ${shellQuote2(todosProjectPath)} --json inspect ${shellQuote2(taskId)})"`,
     `TASK_JSON="$task_json" STAGE=${shellQuote2(stage)} bun - <<'BUN'`,
     LIFECYCLE_GATE_SCRIPT_HEAD,
     `const goMarker = ${JSON.stringify(goMarker)};`,
@@ -9381,7 +10073,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 || '';",
@@ -9399,8 +10090,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}`);",
@@ -9529,7 +10219,6 @@ function prHandoffCommand(opts) {
     `export OPENLOOPS_PR_HANDOFF_ARTIFACT=${shellQuote2(opts.artifactPath)}`,
     `export OPENLOOPS_PR_HANDOFF_TASK_ID=${shellQuote2(opts.taskId)}`,
     `export OPENLOOPS_PR_HANDOFF_TODOS_PROJECT=${shellQuote2(opts.todosProjectPath)}`,
-    opts.todosDbPath ? `export OPENLOOPS_PR_HANDOFF_TODOS_DB_PATH=${shellQuote2(opts.todosDbPath)}` : undefined,
     `export OPENLOOPS_PR_HANDOFF_WORKTREE=${shellQuote2(opts.worktreeCwd)}`,
     `export OPENLOOPS_PR_HANDOFF_WORKTREE_ROOT=${shellQuote2(opts.worktreeRoot)}`,
     `export OPENLOOPS_PR_HANDOFF_EXPECTED_BRANCH=${shellQuote2(opts.expectedBranch)}`,
@@ -9540,7 +10229,7 @@ function prHandoffCommand(opts) {
     "bun - <<'BUN'",
     PR_HANDOFF_SCRIPT,
     "BUN"
-  ].filter((line) => Boolean(line)).join(`
+  ].join(`
 `);
 }
 // src/lib/templates-custom.ts
@@ -10130,12 +10819,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
@@ -10147,7 +10836,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
@@ -10156,7 +10845,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",
@@ -10166,7 +10855,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 ?? ""
@@ -10253,7 +10941,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,
@@ -10264,17 +10951,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,
@@ -10287,9 +10972,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,
@@ -10304,7 +10989,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,
@@ -10324,7 +11009,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,
@@ -10336,7 +11020,6 @@ function renderTaskLifecycleWorkflow(input) {
     routeProjectPath: input.routeProjectPath,
     projectGroup: input.projectGroup,
     todosProjectPath,
-    todosDbPath,
     worktree: worktreeContextFragment(plan)
   };
   const handoffArtifactPath = prHandoffArtifactPath(plan, input.taskId);
@@ -10350,8 +11033,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.",
     "",
@@ -10360,7 +11043,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"),
@@ -10388,7 +11071,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
@@ -10397,8 +11080,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,
@@ -10407,7 +11090,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",
@@ -10421,7 +11104,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"),
@@ -10440,7 +11122,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"),
@@ -10456,7 +11137,7 @@ function renderTaskLifecycleWorkflow(input) {
     }
   ];
   if (input.prHandoff) {
-    steps.push(prHandoffStep(input, plan, todosProjectPath, todosDbPath));
+    steps.push(prHandoffStep(input, plan, todosProjectPath));
   }
   steps.push({
     id: "verifier",
@@ -10681,7 +11362,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),
@@ -10746,7 +11426,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
     });
@@ -11041,7 +11720,9 @@ function buildScriptInventoryReport(store, opts = {}) {
 export {
   workflowExecutionOrder,
   workflowBodyFromJson,
+  validateLoopsMigrationBundle,
   tick,
+  selfHostedControlPlaneSummary,
   runLoopNow,
   runGoal,
   runDoctor,
@@ -11053,8 +11734,10 @@ export {
   renderLoopTemplate,
   renderEventWorkerVerifierWorkflow,
   renderBoundedAgentWorkerVerifierWorkflow,
+  registerSelfHostedRunner,
   refreshLoopMachine,
   readyNodeKeys,
+  publicMigrationBundle,
   preflightWorkflow,
   preflightTarget,
   parseDuration,
@@ -11062,6 +11745,7 @@ export {
   openAutomationsRuntimeBinding,
   normalizeLoopDeploymentMode,
   nextCronRun,
+  migrationHash,
   loops,
   loopControlPlaneConfig,
   listToolsForCli,
@@ -11070,6 +11754,7 @@ export {
   isTerminal as isGoalTerminal,
   initialNextRun,
   getLoopTemplate,
+  exportLoopsMigrationBundle,
   expectationForLoop,
   executeWorkflow,
   executeTarget,
@@ -11082,11 +11767,14 @@ export {
   computeNextAfter,
   classifyRunFailure,
   checksumStorageSql,
+  buildSelfHostedMigrationPlan,
   buildScriptInventoryReport,
   buildNameHygieneReport,
+  buildImportMigrationPlan,
   buildHealthReport,
   buildDuplicateOverlapReport,
   buildDeploymentStatus,
+  applyImportMigrationBundle,
   ValidationError,
   TODOS_TASK_WORKER_VERIFIER_TEMPLATE_ID,
   Store,
@@ -11098,6 +11786,7 @@ export {
   LoopNotFoundError,
   LoopArchivedError,
   LOOP_DEPLOYMENT_MODES,
+  LOOPS_MIGRATION_SCHEMA,
   LOOPS_MCP_TOOLS,
   EVENT_WORKER_VERIFIER_TEMPLATE_ID,
   CodedError,