@cleocode/cleo 2026.3.44 → 2026.3.46

package/dist/mcp/index.js

@@ -9123,7 +9123,7 @@ var init_tasks_schema = __esm({
       "supersedes"
     ];
     LIFECYCLE_TRANSITION_TYPES = ["automatic", "manual", "forced"];
-    EXTERNAL_LINK_TYPES = ["created", "matched", "manual"];
+    EXTERNAL_LINK_TYPES = ["created", "matched", "manual", "transferred"];
     SYNC_DIRECTIONS = ["inbound", "outbound", "bidirectional"];
     tasks = sqliteTable(
       "tasks",
@@ -10583,7 +10583,9 @@ function getBrainDbPath(cwd) {
 function resolveBrainMigrationsFolder() {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname3(__filename);
-  return join7(__dirname, "..", "..", "migrations", "drizzle-brain");
+  const isBundled = __dirname.endsWith("/dist") || __dirname.endsWith("\\dist");
+  const pkgRoot = isBundled ? join7(__dirname, "..") : join7(__dirname, "..", "..");
+  return join7(pkgRoot, "migrations", "drizzle-brain");
 }
 function tableExists(nativeDb, tableName) {
   const result = nativeDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
@@ -10827,7 +10829,9 @@ function getNexusDbPath() {
 function resolveNexusMigrationsFolder() {
   const __filename = fileURLToPath2(import.meta.url);
   const __dirname = dirname4(__filename);
-  return join8(__dirname, "..", "..", "migrations", "drizzle-nexus");
+  const isBundled = __dirname.endsWith("/dist") || __dirname.endsWith("\\dist");
+  const pkgRoot = isBundled ? join8(__dirname, "..") : join8(__dirname, "..", "..");
+  return join8(pkgRoot, "migrations", "drizzle-nexus");
 }
 function tableExists2(nativeDb, tableName) {
   const result = nativeDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
@@ -11018,7 +11022,7 @@ function getDbPath(cwd) {
   return join9(getCleoDirAbsolute(cwd), DB_FILENAME3);
 }
 async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
-  const log9 = getLogger("sqlite");
+  const log10 = getLogger("sqlite");
   try {
     const countResult = nativeDb.prepare("SELECT COUNT(*) as cnt FROM tasks").get();
     const taskCount = countResult?.cnt ?? 0;
@@ -11039,7 +11043,7 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
     if (backupTaskCount < MIN_BACKUP_TASK_COUNT) {
       return;
     }
-    log9.warn(
+    log10.warn(
       { dbPath, backupPath: newestBackup.path, backupTasks: backupTaskCount },
       `Empty database detected with ${backupTaskCount}-task backup available. Auto-recovering from backup. This likely happened because git-tracked WAL/SHM files were overwritten during a branch switch (T5188).`
     );
@@ -11057,7 +11061,7 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
     const tempPath = dbPath + ".recovery-tmp";
     copyFileSync3(newestBackup.path, tempPath);
     renameSync(tempPath, dbPath);
-    log9.info(
+    log10.info(
       { dbPath, backupPath: newestBackup.path, restoredTasks: backupTaskCount },
       "Database auto-recovered from backup successfully."
     );
@@ -11067,7 +11071,7 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
     runMigrations(restoredNativeDb, restoredDb);
     _db2 = restoredDb;
   } catch (err) {
-    log9.error({ err, dbPath }, "Auto-recovery from backup failed. Continuing with empty database.");
+    log10.error({ err, dbPath }, "Auto-recovery from backup failed. Continuing with empty database.");
   }
 }
 async function getDb(cwd) {
@@ -11098,7 +11102,7 @@ async function getDb(cwd) {
         const { execFileSync: execFileSync14 } = await import("node:child_process");
         const gitCwd = resolve3(dbPath, "..", "..");
         const filesToCheck = [dbPath, dbPath + "-wal", dbPath + "-shm"];
-        const log9 = getLogger("sqlite");
+        const log10 = getLogger("sqlite");
         for (const fileToCheck of filesToCheck) {
           try {
             execFileSync14("git", ["ls-files", "--error-unmatch", fileToCheck], {
@@ -11106,7 +11110,7 @@ async function getDb(cwd) {
               stdio: "pipe"
             });
             const basename19 = fileToCheck.split(/[\\/]/).pop();
-            log9.warn(
+            log10.warn(
               { path: fileToCheck },
               `${basename19} is tracked by project git \u2014 this risks data loss on branch switch. Run: git rm --cached ${fileToCheck.replace(gitCwd + sep, "")} (see ADR-013, T5188)`
             );
@@ -11128,7 +11132,9 @@ async function getDb(cwd) {
 function resolveMigrationsFolder() {
   const __filename = fileURLToPath3(import.meta.url);
   const __dirname = dirname5(__filename);
-  return join9(__dirname, "..", "..", "migrations", "drizzle-tasks");
+  const isBundled = __dirname.endsWith("/dist") || __dirname.endsWith("\\dist");
+  const pkgRoot = isBundled ? join9(__dirname, "..") : join9(__dirname, "..", "..");
+  return join9(pkgRoot, "migrations", "drizzle-tasks");
 }
 function tableExists3(nativeDb, tableName) {
   const result = nativeDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
@@ -14396,6 +14402,37 @@ function buildExportPackage(tasks2, options) {
     relationshipGraph
   };
 }
+function exportSingle(taskId, allTasks, projectName) {
+  const task = allTasks.find((t) => t.id === taskId);
+  if (!task) return null;
+  return buildExportPackage([task], {
+    mode: "single",
+    rootTaskIds: [taskId],
+    includeChildren: false,
+    projectName
+  });
+}
+function exportSubtree(rootId, allTasks, projectName) {
+  const root = allTasks.find((t) => t.id === rootId);
+  if (!root) return null;
+  const collected = /* @__PURE__ */ new Map();
+  const queue = [rootId];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    const task = allTasks.find((t) => t.id === id);
+    if (!task || collected.has(id)) continue;
+    collected.set(id, task);
+    const children = allTasks.filter((t) => t.parentId === id);
+    queue.push(...children.map((c) => c.id));
+  }
+  const tasks2 = [...collected.values()];
+  return buildExportPackage(tasks2, {
+    mode: "subtree",
+    rootTaskIds: [rootId],
+    includeChildren: true,
+    projectName
+  });
+}
 var EXPORT_FORMAT_VERSION;
 var init_export2 = __esm({
   "packages/core/src/store/export.ts"() {
@@ -14856,20 +14893,7 @@ function topologicalSort(tasks2) {
   }
   return sorted;
 }
-async function importTasksPackage(params) {
-  const { file: file2 } = params;
-  try {
-    await access2(file2, fsConstants2.R_OK);
-  } catch {
-    throw new Error(`Export file not found: ${file2}`);
-  }
-  const content = await readFile4(file2, "utf-8");
-  let exportPkg;
-  try {
-    exportPkg = JSON.parse(content);
-  } catch {
-    throw new Error(`Invalid JSON in: ${file2}`);
-  }
+async function importFromPackage(exportPkg, options = {}) {
   if (exportPkg._meta?.format !== "cleo-export") {
     throw new Error(
       `Invalid export format (expected 'cleo-export', got '${exportPkg._meta?.format}')`
@@ -14878,16 +14902,16 @@ async function importTasksPackage(params) {
   if (!exportPkg.tasks?.length) {
     throw new Error("Export package contains no tasks");
   }
-  const accessor = await getAccessor(params.cwd);
+  const accessor = await getAccessor(options.cwd);
   const { tasks: existingTasks } = await accessor.queryTasks({});
-  const onConflict = params.onConflict ?? "fail";
-  const onMissingDep = params.onMissingDep ?? "strip";
-  const force = params.force ?? false;
-  const parentId = params.parent;
-  const phaseOverride = params.phase;
-  const addLabel = params.addLabel;
-  const resetStatus = params.resetStatus;
-  const addProvenance = params.provenance !== false;
+  const onConflict = options.onConflict ?? "fail";
+  const onMissingDep = options.onMissingDep === "fail" ? "fail" : "strip";
+  const force = options.force ?? false;
+  const parentId = options.parent;
+  const phaseOverride = options.phase;
+  const addLabel = options.addLabel;
+  const resetStatus = options.resetStatus;
+  const addProvenance = options.provenance !== false;
   if (parentId) {
     const parentExists = existingTasks.some((t) => t.id === parentId);
     if (!parentExists) {
@@ -14956,7 +14980,7 @@ async function importTasksPackage(params) {
     existingTitles.add(remapped.title.toLowerCase());
     existingIds.add(remapped.id);
   }
-  if (params.dryRun) {
+  if (options.dryRun) {
     return {
       imported: transformed.length,
       skipped: skipped.length,
@@ -14976,6 +15000,33 @@ async function importTasksPackage(params) {
     idRemap: idRemapJson
   };
 }
+async function importTasksPackage(params) {
+  const { file: file2 } = params;
+  try {
+    await access2(file2, fsConstants2.R_OK);
+  } catch {
+    throw new Error(`Export file not found: ${file2}`);
+  }
+  const content = await readFile4(file2, "utf-8");
+  let exportPkg;
+  try {
+    exportPkg = JSON.parse(content);
+  } catch {
+    throw new Error(`Invalid JSON in: ${file2}`);
+  }
+  return importFromPackage(exportPkg, {
+    cwd: params.cwd,
+    dryRun: params.dryRun,
+    parent: params.parent,
+    phase: params.phase,
+    addLabel: params.addLabel,
+    provenance: params.provenance,
+    resetStatus: params.resetStatus,
+    onConflict: params.onConflict,
+    onMissingDep: params.onMissingDep === "placeholder" ? "strip" : params.onMissingDep,
+    force: params.force
+  });
+}
 var init_import_tasks = __esm({
   "packages/core/src/admin/import-tasks.ts"() {
     "use strict";
@@ -34542,7 +34593,7 @@ async function ensureInjection(projectRoot) {
     }
   }
   const agentsMdPath = join36(projectRoot, "AGENTS.md");
-  const agentsMdLines = ["@~/.cleo/templates/CLEO-INJECTION.md"];
+  const agentsMdLines = ["@~/.agents/AGENTS.md"];
   const projectContextPath = join36(projectRoot, ".cleo", "project-context.json");
   if (existsSync33(projectContextPath)) {
     agentsMdLines.push("@.cleo/project-context.json");
@@ -34555,7 +34606,8 @@ async function ensureInjection(projectRoot) {
   if (contributorBlock) {
     agentsMdLines.push(contributorBlock);
   }
-  const agentsAction = await inject2(agentsMdPath, agentsMdLines.join("\n"));
+  const agentsMdContent = agentsMdLines.join("\n");
+  const agentsAction = await inject2(agentsMdPath, agentsMdContent);
   actions.push(`AGENTS.md CLEO content (${agentsAction})`);
   const content = getInjectionTemplateContent();
   if (content) {
@@ -34570,8 +34622,9 @@ async function ensureInjection(projectRoot) {
   try {
     const globalAgentsDir = getAgentsHome();
     const globalAgentsMd = join36(globalAgentsDir, "AGENTS.md");
+    const globalHubContent = "@~/.cleo/templates/CLEO-INJECTION.md";
     await mkdir4(globalAgentsDir, { recursive: true });
-    await inject2(globalAgentsMd, "@~/.cleo/templates/CLEO-INJECTION.md");
+    await inject2(globalAgentsMd, globalHubContent);
   } catch {
   }
   return {
@@ -35079,7 +35132,7 @@ async function ensureProjectContext(projectRoot, opts) {
   try {
     const schemaPath = join37(
       dirname8(fileURLToPath4(import.meta.url)),
-      "../../schemas/project-context.schema.json"
+      "../schemas/project-context.schema.json"
     );
     if (existsSync34(schemaPath)) {
       const AjvModule2 = await import("ajv");
@@ -35520,11 +35573,9 @@ async function ensureGlobalTemplates() {
   return { action: "created", path: injectionPath };
 }
 async function ensureGlobalScaffold() {
-  const { ensureGlobalSchemas: ensureGlobalSchemas2 } = await Promise.resolve().then(() => (init_schema_management(), schema_management_exports));
   const home = await ensureGlobalHome();
-  const schemas = ensureGlobalSchemas2();
   const templates2 = await ensureGlobalTemplates();
-  return { home, schemas, templates: templates2 };
+  return { home, templates: templates2 };
 }
 function checkGlobalHome() {
   const cleoHome = getCleoHome();
@@ -35658,7 +35709,7 @@ metrics/
 .backups/
 backups/
 `;
-    REQUIRED_GLOBAL_SUBDIRS = ["schemas", "templates"];
+    REQUIRED_GLOBAL_SUBDIRS = ["logs", "templates"];
   }
 });
 
@@ -43370,6 +43421,338 @@ var init_sharing = __esm({
   }
 });
 
+// packages/core/src/reconciliation/link-store.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { and as and5, eq as eq8 } from "drizzle-orm";
+async function getLinksByProvider(providerId, cwd) {
+  const db = await getDb(cwd);
+  const rows = await db.select().from(externalTaskLinks).where(eq8(externalTaskLinks.providerId, providerId));
+  return rows.map(rowToLink);
+}
+async function getLinkByExternalId(providerId, externalId, cwd) {
+  const db = await getDb(cwd);
+  const rows = await db.select().from(externalTaskLinks).where(
+    and5(
+      eq8(externalTaskLinks.providerId, providerId),
+      eq8(externalTaskLinks.externalId, externalId)
+    )
+  );
+  return rows.length > 0 ? rowToLink(rows[0]) : null;
+}
+async function getLinksByTaskId(taskId, cwd) {
+  const db = await getDb(cwd);
+  const rows = await db.select().from(externalTaskLinks).where(eq8(externalTaskLinks.taskId, taskId));
+  return rows.map(rowToLink);
+}
+async function createLink(params, cwd) {
+  const db = await getDb(cwd);
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const id = randomUUID4();
+  await db.insert(externalTaskLinks).values({
+    id,
+    taskId: params.taskId,
+    providerId: params.providerId,
+    externalId: params.externalId,
+    externalUrl: params.externalUrl ?? null,
+    externalTitle: params.externalTitle ?? null,
+    linkType: params.linkType,
+    syncDirection: params.syncDirection ?? "inbound",
+    metadataJson: params.metadata ? JSON.stringify(params.metadata) : "{}",
+    linkedAt: now2,
+    lastSyncAt: now2
+  });
+  return {
+    id,
+    taskId: params.taskId,
+    providerId: params.providerId,
+    externalId: params.externalId,
+    externalUrl: params.externalUrl ?? null,
+    externalTitle: params.externalTitle ?? null,
+    linkType: params.linkType,
+    syncDirection: params.syncDirection ?? "inbound",
+    metadata: params.metadata,
+    linkedAt: now2,
+    lastSyncAt: now2
+  };
+}
+async function touchLink(linkId, updates, cwd) {
+  const db = await getDb(cwd);
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const values = { lastSyncAt: now2 };
+  if (updates?.externalTitle !== void 0) {
+    values.externalTitle = updates.externalTitle;
+  }
+  if (updates?.metadata !== void 0) {
+    values.metadataJson = JSON.stringify(updates.metadata);
+  }
+  await db.update(externalTaskLinks).set(values).where(eq8(externalTaskLinks.id, linkId));
+}
+async function removeLinksByProvider(providerId, cwd) {
+  const db = await getDb(cwd);
+  const result = await db.delete(externalTaskLinks).where(eq8(externalTaskLinks.providerId, providerId));
+  return Number(result.changes);
+}
+function rowToLink(row) {
+  return {
+    id: row.id,
+    taskId: row.taskId,
+    providerId: row.providerId,
+    externalId: row.externalId,
+    externalUrl: row.externalUrl,
+    externalTitle: row.externalTitle,
+    linkType: row.linkType,
+    syncDirection: row.syncDirection,
+    metadata: row.metadataJson ? JSON.parse(row.metadataJson) : void 0,
+    linkedAt: row.linkedAt,
+    lastSyncAt: row.lastSyncAt
+  };
+}
+var init_link_store = __esm({
+  "packages/core/src/reconciliation/link-store.ts"() {
+    "use strict";
+    init_sqlite2();
+    init_tasks_schema();
+  }
+});
+
+// packages/core/src/nexus/transfer.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+async function previewTransfer(params) {
+  return executeTransferInternal({ ...params, dryRun: true });
+}
+async function executeTransfer(params) {
+  return executeTransferInternal(params);
+}
+async function executeTransferInternal(params) {
+  const {
+    taskIds,
+    sourceProject: sourceProjectRef,
+    targetProject: targetProjectRef,
+    mode = "copy",
+    scope = "subtree",
+    onConflict = "rename",
+    onMissingDep = "strip",
+    provenance = true,
+    targetParent,
+    transferBrain = false,
+    dryRun = false
+  } = params;
+  if (!taskIds.length) {
+    throw new Error("No task IDs specified for transfer");
+  }
+  const sourceProject = await nexusGetProject(sourceProjectRef);
+  if (!sourceProject) {
+    throw new Error(`Source project not found: ${sourceProjectRef}`);
+  }
+  const targetProject = await nexusGetProject(targetProjectRef);
+  if (!targetProject) {
+    throw new Error(`Target project not found: ${targetProjectRef}`);
+  }
+  if (sourceProject.hash === targetProject.hash) {
+    throw new Error("Source and target projects must be different");
+  }
+  await requirePermission(sourceProject.hash, "read", "nexus.transfer");
+  await requirePermission(targetProject.hash, "write", "nexus.transfer");
+  const sourceAccessor = await getAccessor(sourceProject.path);
+  const { tasks: allSourceTasks } = await sourceAccessor.queryTasks({});
+  const exportPackages = [];
+  for (const taskId of taskIds) {
+    const pkg = scope === "subtree" ? exportSubtree(taskId, allSourceTasks, sourceProject.name) : exportSingle(taskId, allSourceTasks, sourceProject.name);
+    if (!pkg) {
+      throw new Error(`Task not found in source project: ${taskId}`);
+    }
+    exportPackages.push(pkg);
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  const mergedTasks = [];
+  for (const pkg of exportPackages) {
+    for (const task of pkg.tasks) {
+      if (!seenIds.has(task.id)) {
+        seenIds.add(task.id);
+        mergedTasks.push(task);
+      }
+    }
+  }
+  const mergedPkg = { ...exportPackages[0] };
+  mergedPkg.tasks = mergedTasks;
+  mergedPkg._meta = { ...mergedPkg._meta, taskCount: mergedTasks.length };
+  const importResult = await importFromPackage(mergedPkg, {
+    cwd: targetProject.path,
+    dryRun,
+    parent: targetParent,
+    provenance,
+    onConflict,
+    onMissingDep
+  });
+  const entries = mergedTasks.map((t) => ({
+    sourceId: t.id,
+    targetId: importResult.idRemap[t.id] ?? t.id,
+    title: t.title,
+    type: t.type ?? "task"
+  }));
+  const manifest = {
+    sourceProject: sourceProject.name,
+    targetProject: targetProject.name,
+    mode,
+    scope,
+    entries,
+    idRemap: importResult.idRemap,
+    brainObservationsTransferred: 0
+  };
+  const result = {
+    dryRun,
+    transferred: importResult.imported,
+    skipped: importResult.skipped,
+    archived: 0,
+    linksCreated: 0,
+    brainObservationsTransferred: 0,
+    manifest
+  };
+  if (dryRun) {
+    return result;
+  }
+  let linksCreated = 0;
+  const targetAccessor = await getAccessor(targetProject.path);
+  const { tasks: targetTasks } = await targetAccessor.queryTasks({});
+  const targetTaskIds = new Set(targetTasks.map((t) => t.id));
+  for (const entry of entries) {
+    if (importResult.idRemap[entry.sourceId] && targetTaskIds.has(entry.targetId)) {
+      await createLink(
+        {
+          taskId: entry.targetId,
+          providerId: `nexus:${sourceProject.name}`,
+          externalId: entry.sourceId,
+          externalTitle: entry.title,
+          linkType: "transferred",
+          syncDirection: "inbound",
+          metadata: {
+            transferMode: mode,
+            transferScope: scope,
+            sourceProject: sourceProject.name,
+            transferredAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        },
+        targetProject.path
+      );
+      linksCreated++;
+      await createLink(
+        {
+          taskId: entry.sourceId,
+          providerId: `nexus:${targetProject.name}`,
+          externalId: entry.targetId,
+          externalTitle: entry.title,
+          linkType: "transferred",
+          syncDirection: "outbound",
+          metadata: {
+            transferMode: mode,
+            transferScope: scope,
+            targetProject: targetProject.name,
+            transferredAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        },
+        sourceProject.path
+      );
+      linksCreated++;
+    }
+  }
+  result.linksCreated = linksCreated;
+  try {
+    const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
+    const { nexusAuditLog: nexusAuditLog2 } = await Promise.resolve().then(() => (init_nexus_schema(), nexus_schema_exports));
+    const db = await getNexusDb2();
+    await db.insert(nexusAuditLog2).values({
+      id: randomUUID5(),
+      action: "transfer",
+      projectHash: sourceProject.hash,
+      projectId: sourceProject.projectId,
+      domain: "nexus",
+      operation: "transfer",
+      success: 1,
+      detailsJson: JSON.stringify({
+        sourceProject: sourceProject.name,
+        targetProject: targetProject.name,
+        mode,
+        scope,
+        taskCount: result.transferred,
+        idRemap: importResult.idRemap
+      })
+    });
+  } catch (err) {
+    log6.warn({ err }, "nexus transfer audit write failed");
+  }
+  if (mode === "move") {
+    let archived = 0;
+    for (const entry of entries) {
+      if (importResult.idRemap[entry.sourceId]) {
+        try {
+          await sourceAccessor.archiveSingleTask(entry.sourceId, {
+            archivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            archiveReason: `Transferred to ${targetProject.name} as ${entry.targetId}`
+          });
+          archived++;
+        } catch (err) {
+          log6.warn({ err, taskId: entry.sourceId }, "failed to archive source task after transfer");
+        }
+      }
+    }
+    result.archived = archived;
+  }
+  if (transferBrain) {
+    let brainTransferred = 0;
+    try {
+      const sourceBrainDb = await getBrainDb(sourceProject.path);
+      const targetBrainDb = await getBrainDb(targetProject.path);
+      const sourceBrain = new BrainDataAccessor(sourceBrainDb);
+      const targetBrain = new BrainDataAccessor(targetBrainDb);
+      for (const entry of entries) {
+        if (!importResult.idRemap[entry.sourceId]) continue;
+        const links = await sourceBrain.getLinksForTask(entry.sourceId);
+        for (const link of links) {
+          if (link.memoryType !== "observation") continue;
+          const observation = await sourceBrain.getObservation(link.memoryId);
+          if (!observation) continue;
+          const newObsId = `O-${randomUUID5().slice(0, 8)}`;
+          await targetBrain.addObservation({
+            ...observation,
+            id: newObsId,
+            createdAt: observation.createdAt,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19)
+          });
+          await targetBrain.addLink({
+            memoryType: "observation",
+            memoryId: newObsId,
+            taskId: entry.targetId,
+            linkType: "applies_to",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19)
+          });
+          brainTransferred++;
+        }
+      }
+    } catch (err) {
+      log6.warn({ err }, "brain observation transfer failed");
+    }
+    result.brainObservationsTransferred = brainTransferred;
+    result.manifest.brainObservationsTransferred = brainTransferred;
+  }
+  return result;
+}
+var log6;
+var init_transfer = __esm({
+  "packages/core/src/nexus/transfer.ts"() {
+    "use strict";
+    init_import_tasks();
+    init_logger();
+    init_link_store();
+    init_brain_accessor();
+    init_brain_sqlite();
+    init_data_accessor();
+    init_export2();
+    init_permissions();
+    init_registry3();
+    log6 = getLogger("nexus:transfer");
+  }
+});
+
 // packages/core/src/nexus/index.ts
 var nexus_exports = {};
 __export(nexus_exports, {
@@ -43382,6 +43765,7 @@ __export(nexus_exports, {
   checkPermissionDetail: () => checkPermissionDetail,
   criticalPath: () => criticalPath,
   discoverRelated: () => discoverRelated,
+  executeTransfer: () => executeTransfer,
   extractKeywords: () => extractKeywords2,
   generateProjectHash: () => generateProjectHash,
   getCurrentProject: () => getCurrentProject,
@@ -43405,6 +43789,7 @@ __export(nexus_exports, {
   orphanDetection: () => orphanDetection,
   parseQuery: () => parseQuery,
   permissionLevel: () => permissionLevel,
+  previewTransfer: () => previewTransfer,
   readRegistry: () => readRegistry,
   readRegistryRequired: () => readRegistryRequired,
   requirePermission: () => requirePermission,
@@ -43427,6 +43812,7 @@ var init_nexus = __esm({
     init_query3();
     init_registry3();
     init_sharing();
+    init_transfer();
   }
 });
 
@@ -44927,100 +45313,6 @@ var init_pipeline = __esm({
   }
 });
 
-// packages/core/src/reconciliation/link-store.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import { and as and5, eq as eq8 } from "drizzle-orm";
-async function getLinksByProvider(providerId, cwd) {
-  const db = await getDb(cwd);
-  const rows = await db.select().from(externalTaskLinks).where(eq8(externalTaskLinks.providerId, providerId));
-  return rows.map(rowToLink);
-}
-async function getLinkByExternalId(providerId, externalId, cwd) {
-  const db = await getDb(cwd);
-  const rows = await db.select().from(externalTaskLinks).where(
-    and5(
-      eq8(externalTaskLinks.providerId, providerId),
-      eq8(externalTaskLinks.externalId, externalId)
-    )
-  );
-  return rows.length > 0 ? rowToLink(rows[0]) : null;
-}
-async function getLinksByTaskId(taskId, cwd) {
-  const db = await getDb(cwd);
-  const rows = await db.select().from(externalTaskLinks).where(eq8(externalTaskLinks.taskId, taskId));
-  return rows.map(rowToLink);
-}
-async function createLink(params, cwd) {
-  const db = await getDb(cwd);
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const id = randomUUID4();
-  await db.insert(externalTaskLinks).values({
-    id,
-    taskId: params.taskId,
-    providerId: params.providerId,
-    externalId: params.externalId,
-    externalUrl: params.externalUrl ?? null,
-    externalTitle: params.externalTitle ?? null,
-    linkType: params.linkType,
-    syncDirection: params.syncDirection ?? "inbound",
-    metadataJson: params.metadata ? JSON.stringify(params.metadata) : "{}",
-    linkedAt: now2,
-    lastSyncAt: now2
-  });
-  return {
-    id,
-    taskId: params.taskId,
-    providerId: params.providerId,
-    externalId: params.externalId,
-    externalUrl: params.externalUrl ?? null,
-    externalTitle: params.externalTitle ?? null,
-    linkType: params.linkType,
-    syncDirection: params.syncDirection ?? "inbound",
-    metadata: params.metadata,
-    linkedAt: now2,
-    lastSyncAt: now2
-  };
-}
-async function touchLink(linkId, updates, cwd) {
-  const db = await getDb(cwd);
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const values = { lastSyncAt: now2 };
-  if (updates?.externalTitle !== void 0) {
-    values.externalTitle = updates.externalTitle;
-  }
-  if (updates?.metadata !== void 0) {
-    values.metadataJson = JSON.stringify(updates.metadata);
-  }
-  await db.update(externalTaskLinks).set(values).where(eq8(externalTaskLinks.id, linkId));
-}
-async function removeLinksByProvider(providerId, cwd) {
-  const db = await getDb(cwd);
-  const result = await db.delete(externalTaskLinks).where(eq8(externalTaskLinks.providerId, providerId));
-  return Number(result.changes);
-}
-function rowToLink(row) {
-  return {
-    id: row.id,
-    taskId: row.taskId,
-    providerId: row.providerId,
-    externalId: row.externalId,
-    externalUrl: row.externalUrl,
-    externalTitle: row.externalTitle,
-    linkType: row.linkType,
-    syncDirection: row.syncDirection,
-    metadata: row.metadataJson ? JSON.parse(row.metadataJson) : void 0,
-    linkedAt: row.linkedAt,
-    lastSyncAt: row.lastSyncAt
-  };
-}
-var init_link_store = __esm({
-  "packages/core/src/reconciliation/link-store.ts"() {
-    "use strict";
-    init_sqlite2();
-    init_tasks_schema();
-  }
-});
-
 // packages/core/src/memory/auto-extract.ts
 var auto_extract_exports = {};
 __export(auto_extract_exports, {
@@ -46587,8 +46879,8 @@ var init_release_config = __esm({
 // packages/core/src/release/ci.ts
 import { existsSync as existsSync60, mkdirSync as mkdirSync12, readFileSync as readFileSync42, writeFileSync as writeFileSync6 } from "node:fs";
 import { dirname as dirname13, join as join63 } from "node:path";
-function getPlatformPath(platform3) {
-  return PLATFORM_PATHS[platform3];
+function getPlatformPath(platform5) {
+  return PLATFORM_PATHS[platform5];
 }
 function detectCIPlatform(projectDir) {
   const dir = projectDir ?? process.cwd();
@@ -46682,10 +46974,10 @@ workflows:
               only: /^v.*/
 `;
 }
-function generateCIConfig(platform3, cwd) {
+function generateCIConfig(platform5, cwd) {
   const releaseConfig = loadReleaseConfig(cwd);
   const gates = releaseConfig.gates.map((g) => ({ name: g.name, command: g.command }));
-  switch (platform3) {
+  switch (platform5) {
     case "github-actions":
       return generateGitHubActions({ gates });
     case "gitlab-ci":
@@ -46694,10 +46986,10 @@ function generateCIConfig(platform3, cwd) {
       return generateCircleCI({ gates });
   }
 }
-function writeCIConfig(platform3, options = {}) {
+function writeCIConfig(platform5, options = {}) {
   const projectDir = options.projectDir ?? process.cwd();
-  const outputPath = join63(projectDir, getPlatformPath(platform3));
-  const content = generateCIConfig(platform3, projectDir);
+  const outputPath = join63(projectDir, getPlatformPath(platform5));
+  const content = generateCIConfig(platform5, projectDir);
   if (options.dryRun) {
     return { action: "would_write", path: outputPath, content };
   }
@@ -46705,9 +46997,9 @@ function writeCIConfig(platform3, options = {}) {
   writeFileSync6(outputPath, content, "utf-8");
   return { action: "wrote", path: outputPath, content };
 }
-function validateCIConfig(platform3, projectDir) {
+function validateCIConfig(platform5, projectDir) {
   const dir = projectDir ?? process.cwd();
-  const configPath = join63(dir, getPlatformPath(platform3));
+  const configPath = join63(dir, getPlatformPath(platform5));
   if (!existsSync60(configPath)) {
     return { valid: false, exists: false, errors: ["Config file not found"] };
   }
@@ -48410,239 +48702,1463 @@ var init_capability_matrix = __esm({
     CAPABILITY_MATRIX = [
       // === Tasks Domain ===
       // Query operations
-      { domain: "tasks", operation: "show", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "list", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "find", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "tree", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "blockers", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "depends", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "analyze", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "next", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "plan", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "relates", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "complexity.estimate", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "history", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "current", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "label.list", gateway: "query", mode: "native" },
+      { domain: "tasks", operation: "show", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      { domain: "tasks", operation: "list", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      { domain: "tasks", operation: "find", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      {
+        domain: "tasks",
+        operation: "tree",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "blockers",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "depends",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "analyze",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      { domain: "tasks", operation: "next", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      { domain: "tasks", operation: "plan", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      {
+        domain: "tasks",
+        operation: "relates",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "complexity.estimate",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "history",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "current",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tasks",
+        operation: "label.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "tasks", operation: "add", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "update", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "complete", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "cancel", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "delete", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "archive", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "restore", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "reparent", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "reorder", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "relates.add", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "start", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "stop", gateway: "mutate", mode: "native" },
+      { domain: "tasks", operation: "add", gateway: "mutate", mode: "native", preferredChannel: "mcp" },
+      {
+        domain: "tasks",
+        operation: "update",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tasks",
+        operation: "complete",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tasks",
+        operation: "cancel",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "delete",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "archive",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "restore",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "reparent",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "reorder",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "relates.add",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "start",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tasks",
+        operation: "stop",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
       // Sync sub-domain (provider-agnostic task reconciliation)
-      { domain: "tasks", operation: "sync.reconcile", gateway: "mutate", mode: "native" },
-      { domain: "tasks", operation: "sync.links", gateway: "query", mode: "native" },
-      { domain: "tasks", operation: "sync.links.remove", gateway: "mutate", mode: "native" },
+      {
+        domain: "tasks",
+        operation: "sync.reconcile",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "sync.links",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tasks",
+        operation: "sync.links.remove",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Session Domain ===
       // Query operations
-      { domain: "session", operation: "status", gateway: "query", mode: "native" },
-      { domain: "session", operation: "list", gateway: "query", mode: "native" },
-      { domain: "session", operation: "show", gateway: "query", mode: "native" },
-      { domain: "session", operation: "decision.log", gateway: "query", mode: "native" },
-      { domain: "session", operation: "context.drift", gateway: "query", mode: "native" },
-      { domain: "session", operation: "handoff.show", gateway: "query", mode: "native" },
-      { domain: "session", operation: "briefing.show", gateway: "query", mode: "native" },
-      { domain: "session", operation: "find", gateway: "query", mode: "native" },
+      {
+        domain: "session",
+        operation: "status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "session",
+        operation: "list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "decision.log",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "context.drift",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "handoff.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "session",
+        operation: "briefing.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "session",
+        operation: "find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "session", operation: "start", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "end", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "resume", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "suspend", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "gc", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "record.decision", gateway: "mutate", mode: "native" },
-      { domain: "session", operation: "record.assumption", gateway: "mutate", mode: "native" },
+      {
+        domain: "session",
+        operation: "start",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "session",
+        operation: "end",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "session",
+        operation: "resume",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "suspend",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "gc",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "record.decision",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "session",
+        operation: "record.assumption",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Admin Domain ===
       // Query operations
-      { domain: "admin", operation: "version", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "health", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "config.show", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "stats", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "context", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "runtime", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "job", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "dash", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "log", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "sequence", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "help", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "token", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "export", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "adr.show", gateway: "query", mode: "native" },
-      { domain: "admin", operation: "adr.find", gateway: "query", mode: "native" },
+      {
+        domain: "admin",
+        operation: "version",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "health",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "config.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "stats",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "context",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "runtime",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "job",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      { domain: "admin", operation: "dash", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      {
+        domain: "admin",
+        operation: "log",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "sequence",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      { domain: "admin", operation: "help", gateway: "query", mode: "native", preferredChannel: "mcp" },
+      {
+        domain: "admin",
+        operation: "token",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "export",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "adr.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "adr.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      { domain: "admin", operation: "map", gateway: "query", mode: "native", preferredChannel: "mcp" },
       // Mutate operations
-      { domain: "admin", operation: "init", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "config.set", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "backup", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "migrate", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "cleanup", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "safestop", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "inject.generate", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "job.cancel", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "install.global", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "token", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "health", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "detect", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "import", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "context.inject", gateway: "mutate", mode: "native" },
-      { domain: "admin", operation: "adr.sync", gateway: "mutate", mode: "native" },
+      {
+        domain: "admin",
+        operation: "init",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "config.set",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "backup",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "migrate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "cleanup",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "safestop",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "inject.generate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "job.cancel",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "install.global",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "token",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "health",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "detect",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "import",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "context.inject",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "adr.sync",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "admin",
+        operation: "map",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Check Domain ===
       // Query operations
-      { domain: "check", operation: "schema", gateway: "query", mode: "native" },
-      { domain: "check", operation: "protocol", gateway: "query", mode: "native" },
-      { domain: "check", operation: "task", gateway: "query", mode: "native" },
-      { domain: "check", operation: "manifest", gateway: "query", mode: "native" },
-      { domain: "check", operation: "output", gateway: "query", mode: "native" },
-      { domain: "check", operation: "compliance.summary", gateway: "query", mode: "native" },
-      { domain: "check", operation: "test", gateway: "query", mode: "native" },
-      { domain: "check", operation: "coherence", gateway: "query", mode: "native" },
-      { domain: "check", operation: "gate.status", gateway: "query", mode: "native" },
-      { domain: "check", operation: "archive.stats", gateway: "query", mode: "native" },
-      { domain: "check", operation: "grade", gateway: "query", mode: "native" },
-      { domain: "check", operation: "grade.list", gateway: "query", mode: "native" },
-      { domain: "check", operation: "chain.validate", gateway: "query", mode: "native" },
+      {
+        domain: "check",
+        operation: "schema",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "protocol",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "task",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "manifest",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "output",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "compliance.summary",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "check",
+        operation: "test",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "coherence",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "gate.status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "archive.stats",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "grade",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "grade.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "chain.validate",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "check", operation: "compliance.record", gateway: "mutate", mode: "native" },
-      { domain: "check", operation: "test.run", gateway: "mutate", mode: "native" },
-      { domain: "check", operation: "gate.set", gateway: "mutate", mode: "native" },
+      {
+        domain: "check",
+        operation: "compliance.record",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "check",
+        operation: "test.run",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "gate.set",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "check",
+        operation: "compliance.sync",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Orchestrate Domain ===
       // Query operations
-      { domain: "orchestrate", operation: "status", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "next", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "ready", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "analyze", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "context", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "waves", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "bootstrap", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "unblock.opportunities", gateway: "query", mode: "native" },
-      { domain: "orchestrate", operation: "tessera.list", gateway: "query", mode: "native" },
+      {
+        domain: "orchestrate",
+        operation: "status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "next",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "ready",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "analyze",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "context",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "waves",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "bootstrap",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "unblock.opportunities",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "tessera.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "orchestrate", operation: "start", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "spawn", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "handoff", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "spawn.execute", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "validate", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "parallel", gateway: "mutate", mode: "native" },
-      { domain: "orchestrate", operation: "tessera.instantiate", gateway: "mutate", mode: "native" },
+      {
+        domain: "orchestrate",
+        operation: "start",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "spawn",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "orchestrate",
+        operation: "handoff",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "spawn.execute",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "validate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "parallel",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "orchestrate",
+        operation: "tessera.instantiate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Memory Domain (brain.db cognitive memory -- T5241) ===
       // Query operations
-      { domain: "memory", operation: "find", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "timeline", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "fetch", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "decision.find", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "pattern.find", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "learning.find", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "graph.show", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "graph.neighbors", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "reason.why", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "reason.similar", gateway: "query", mode: "native" },
-      { domain: "memory", operation: "search.hybrid", gateway: "query", mode: "native" },
+      {
+        domain: "memory",
+        operation: "find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "timeline",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "fetch",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "decision.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "pattern.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "learning.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "graph.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "graph.neighbors",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "reason.why",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "reason.similar",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "search.hybrid",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "memory", operation: "observe", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "decision.store", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "pattern.store", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "learning.store", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "link", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "graph.add", gateway: "mutate", mode: "native" },
-      { domain: "memory", operation: "graph.remove", gateway: "mutate", mode: "native" },
+      {
+        domain: "memory",
+        operation: "observe",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "decision.store",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "pattern.store",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "learning.store",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "memory",
+        operation: "link",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "graph.add",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "memory",
+        operation: "graph.remove",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Pipeline Domain ===
       // Stage sub-domain (RCASD lifecycle)
-      { domain: "pipeline", operation: "stage.validate", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "stage.status", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "stage.history", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "stage.record", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "stage.skip", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "stage.reset", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "stage.gate.pass", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "stage.gate.fail", gateway: "mutate", mode: "native" },
+      {
+        domain: "pipeline",
+        operation: "stage.validate",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.history",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.record",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.skip",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.reset",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.gate.pass",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "stage.gate.fail",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Manifest sub-domain (T5241)
-      { domain: "pipeline", operation: "manifest.show", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "manifest.list", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "manifest.find", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "manifest.stats", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "manifest.append", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "manifest.archive", gateway: "mutate", mode: "native" },
+      {
+        domain: "pipeline",
+        operation: "manifest.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "manifest.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "manifest.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "manifest.stats",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "manifest.append",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "manifest.archive",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Phase sub-domain (T5326)
-      { domain: "pipeline", operation: "phase.show", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "phase.list", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "phase.set", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "phase.advance", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "phase.rename", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "phase.delete", gateway: "mutate", mode: "native" },
+      {
+        domain: "pipeline",
+        operation: "phase.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "phase.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "phase.set",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "phase.advance",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "phase.rename",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "phase.delete",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Chain sub-domain (T5405)
-      { domain: "pipeline", operation: "chain.show", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "chain.list", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "chain.add", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "chain.instantiate", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "chain.advance", gateway: "mutate", mode: "native" },
+      {
+        domain: "pipeline",
+        operation: "chain.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "chain.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "chain.add",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "chain.instantiate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "chain.advance",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Release sub-domain (T5615 consolidated)
-      { domain: "pipeline", operation: "release.list", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "release.show", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "release.channel.show", gateway: "query", mode: "native" },
-      { domain: "pipeline", operation: "release.ship", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "release.cancel", gateway: "mutate", mode: "native" },
-      { domain: "pipeline", operation: "release.rollback", gateway: "mutate", mode: "native" },
+      {
+        domain: "pipeline",
+        operation: "release.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "release.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "release.channel.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "release.ship",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "cli"
+      },
+      {
+        domain: "pipeline",
+        operation: "release.cancel",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "pipeline",
+        operation: "release.rollback",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Tools Domain ===
       // Issue operations
-      { domain: "tools", operation: "issue.diagnostics", gateway: "query", mode: "native" },
+      {
+        domain: "tools",
+        operation: "issue.diagnostics",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Skill operations
-      { domain: "tools", operation: "skill.list", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.show", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.find", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.dispatch", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.verify", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.dependencies", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.spawn.providers", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.catalog", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.precedence", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "skill.install", gateway: "mutate", mode: "native" },
-      { domain: "tools", operation: "skill.uninstall", gateway: "mutate", mode: "native" },
-      { domain: "tools", operation: "skill.refresh", gateway: "mutate", mode: "native" },
+      {
+        domain: "tools",
+        operation: "skill.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "skill.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "skill.find",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "skill.dispatch",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.verify",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.dependencies",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.spawn.providers",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.catalog",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.precedence",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.install",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.uninstall",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "skill.refresh",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Provider operations
-      { domain: "tools", operation: "provider.list", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "provider.detect", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "provider.inject.status", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "provider.supports", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "provider.hooks", gateway: "query", mode: "native" },
-      { domain: "tools", operation: "provider.inject", gateway: "mutate", mode: "native" },
+      {
+        domain: "tools",
+        operation: "provider.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "provider.detect",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "provider.inject.status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "provider.supports",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "provider.hooks",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "provider.inject",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      // Adapter sub-domain (T5240)
+      {
+        domain: "tools",
+        operation: "adapter.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "adapter.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "adapter.detect",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "adapter.health",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "tools",
+        operation: "adapter.activate",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "tools",
+        operation: "adapter.dispose",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Nexus Domain ===
       // Query operations
-      { domain: "nexus", operation: "status", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "list", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "show", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "search", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "graph", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "deps", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "resolve", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "discover", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "orphans.list", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "blockers.show", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "path.show", gateway: "query", mode: "native" },
-      { domain: "nexus", operation: "share.status", gateway: "query", mode: "native" },
+      {
+        domain: "nexus",
+        operation: "status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "search",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "graph",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "deps",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "resolve",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "discover",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "orphans.list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "blockers.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "path.show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "share.status",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "transfer.preview",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // Mutate operations
-      { domain: "nexus", operation: "init", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "register", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "unregister", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "sync", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "reconcile", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "permission.set", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "share.snapshot.export", gateway: "mutate", mode: "native" },
-      { domain: "nexus", operation: "share.snapshot.import", gateway: "mutate", mode: "native" },
+      {
+        domain: "nexus",
+        operation: "init",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "register",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "unregister",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "sync",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "reconcile",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "permission.set",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "share.snapshot.export",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "share.snapshot.import",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "nexus",
+        operation: "transfer",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
       // === Sticky Domain ===
       // Query operations
-      { domain: "sticky", operation: "list", gateway: "query", mode: "native" },
-      { domain: "sticky", operation: "show", gateway: "query", mode: "native" },
+      {
+        domain: "sticky",
+        operation: "list",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "sticky",
+        operation: "show",
+        gateway: "query",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
       // Mutate operations
-      { domain: "sticky", operation: "add", gateway: "mutate", mode: "native" },
-      { domain: "sticky", operation: "archive", gateway: "mutate", mode: "native" },
-      { domain: "sticky", operation: "convert", gateway: "mutate", mode: "native" },
-      { domain: "sticky", operation: "purge", gateway: "mutate", mode: "native" }
+      {
+        domain: "sticky",
+        operation: "add",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "mcp"
+      },
+      {
+        domain: "sticky",
+        operation: "archive",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "sticky",
+        operation: "convert",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      },
+      {
+        domain: "sticky",
+        operation: "purge",
+        gateway: "mutate",
+        mode: "native",
+        preferredChannel: "either"
+      }
     ];
   }
 });
@@ -51405,6 +52921,7 @@ var init_config2 = __esm({
 
 // packages/core/src/skills/agents/install.ts
 import { existsSync as existsSync67, mkdirSync as mkdirSync14, readdirSync as readdirSync25, readlinkSync, symlinkSync, unlinkSync as unlinkSync4 } from "node:fs";
+import { platform as platform2 } from "node:os";
 import { basename as basename12, join as join70 } from "node:path";
 function getAgentInstallDir() {
   return getClaudeAgentsDir();
@@ -51435,7 +52952,7 @@ function installAgent(agentDir) {
     }
   }
   try {
-    symlinkSync(agentDir, targetPath, "dir");
+    symlinkSync(agentDir, targetPath, DIR_SYMLINK_TYPE);
     return { installed: true, path: targetPath };
   } catch (err) {
     return { installed: false, path: targetPath, error: `Symlink failed: ${err}` };
@@ -51475,11 +52992,13 @@ function uninstallAgent(agentName) {
     return false;
   }
 }
+var DIR_SYMLINK_TYPE;
 var init_install = __esm({
   "packages/core/src/skills/agents/install.ts"() {
     "use strict";
     init_paths();
     init_config2();
+    DIR_SYMLINK_TYPE = platform2() === "win32" ? "junction" : "dir";
   }
 });
 
@@ -53412,8 +54931,9 @@ var init_validator = __esm({
 // packages/core/src/skills/skill-paths.ts
 import { existsSync as existsSync77, lstatSync, readlinkSync as readlinkSync2, realpathSync as realpathSync2 } from "node:fs";
 import { delimiter, join as join79, resolve as resolve9 } from "node:path";
+import { getCanonicalSkillsDir as getCanonicalSkillsDir2 } from "@cleocode/caamp";
 function getCaampCanonical() {
-  return join79(getAgentsHome(), "skills");
+  return getCanonicalSkillsDir2();
 }
 function getProjectEmbedded(projectRoot) {
   const root = projectRoot ?? process.cwd();
@@ -53533,7 +55053,6 @@ function getSkillSourceType(skillDir, projectRoot) {
 var init_skill_paths = __esm({
   "packages/core/src/skills/skill-paths.ts"() {
     "use strict";
-    init_paths();
   }
 });
 
@@ -55464,7 +56983,7 @@ import { createGzip } from "node:zlib";
 async function pruneAuditLog(cleoDir, config2) {
   try {
     if (!config2.auditRetentionDays || config2.auditRetentionDays <= 0) {
-      log6.debug("auditRetentionDays is 0 or unset; skipping audit prune");
+      log7.debug("auditRetentionDays is 0 or unset; skipping audit prune");
       return { rowsArchived: 0, rowsDeleted: 0 };
     }
     const cutoff = new Date(Date.now() - config2.auditRetentionDays * 864e5).toISOString();
@@ -55475,7 +56994,7 @@ async function pruneAuditLog(cleoDir, config2) {
     const db = await getDb4(projectRoot);
     const oldRows = await db.select().from(auditLog2).where(lt3(auditLog2.timestamp, cutoff));
     if (oldRows.length === 0) {
-      log6.debug("No audit_log rows older than cutoff; nothing to prune");
+      log7.debug("No audit_log rows older than cutoff; nothing to prune");
       return { rowsArchived: 0, rowsDeleted: 0 };
     }
     let archivePath;
@@ -55493,17 +57012,17 @@ async function pruneAuditLog(cleoDir, config2) {
         const inStream = Readable.from([jsonlContent]);
         await pipeline(inStream, gzip, outStream);
         rowsArchived = oldRows.length;
-        log6.info(
+        log7.info(
           { archivePath, rowsArchived },
           `Archived ${rowsArchived} audit rows to ${archivePath}`
         );
       } catch (archiveErr) {
-        log6.warn({ err: archiveErr }, "Failed to archive audit rows; continuing with deletion");
+        log7.warn({ err: archiveErr }, "Failed to archive audit rows; continuing with deletion");
         archivePath = void 0;
       }
     }
     await db.delete(auditLog2).where(lt3(auditLog2.timestamp, cutoff)).run();
-    log6.info(
+    log7.info(
       { rowsDeleted: oldRows.length, cutoff },
       `Pruned ${oldRows.length} audit_log rows older than ${cutoff}`
     );
@@ -55513,16 +57032,16 @@ async function pruneAuditLog(cleoDir, config2) {
       archivePath
     };
   } catch (err) {
-    log6.warn({ err }, "audit log pruning failed");
+    log7.warn({ err }, "audit log pruning failed");
     return { rowsArchived: 0, rowsDeleted: 0 };
   }
 }
-var log6;
+var log7;
 var init_audit_prune = __esm({
   "packages/core/src/audit-prune.ts"() {
     "use strict";
     init_logger();
-    log6 = getLogger("prune");
+    log7 = getLogger("prune");
   }
 });
 
@@ -55914,7 +57433,7 @@ function getNodeVersionInfo() {
   };
 }
 function getNodeUpgradeInstructions() {
-  const platform3 = detectPlatform();
+  const platform5 = detectPlatform();
   const arch2 = process.arch;
   const instructions = [];
   const hasFnm = commandExists2("fnm");
@@ -55929,7 +57448,7 @@ function getNodeUpgradeInstructions() {
   if (hasVolta) {
     instructions.push(`volta install node@${MINIMUM_NODE_MAJOR}`);
   }
-  switch (platform3) {
+  switch (platform5) {
     case "linux":
       if (commandExists2("dnf")) {
         instructions.push(
@@ -55961,7 +57480,7 @@ function getNodeUpgradeInstructions() {
   }
   instructions.push(`https://nodejs.org/en/download/`);
   const recommended = instructions[0] ?? `https://nodejs.org/en/download/`;
-  return { platform: platform3, arch: arch2, instructions, recommended };
+  return { platform: platform5, arch: arch2, instructions, recommended };
 }
 function getSystemInfo2() {
   return {
@@ -57496,12 +59015,22 @@ async function startupHealthCheck(projectRoot) {
         message: scaffoldResult.home.action === "skipped" ? "Global home already current" : `Global home ${scaffoldResult.home.action}: ${scaffoldResult.home.details ?? ""}`,
         repaired: scaffoldResult.home.action !== "skipped"
       });
-      checks.push({
-        check: "global_schemas",
-        status: "pass",
-        message: `Schemas: ${scaffoldResult.schemas.installed} installed, ${scaffoldResult.schemas.updated} updated of ${scaffoldResult.schemas.total}`,
-        repaired: scaffoldResult.schemas.installed > 0 || scaffoldResult.schemas.updated > 0
-      });
+      if (!globalSchemaCheck.ok) {
+        const { ensureGlobalSchemas: ensureGlobalSchemas2 } = await Promise.resolve().then(() => (init_schema_management(), schema_management_exports));
+        const schemaResult = ensureGlobalSchemas2();
+        checks.push({
+          check: "global_schemas",
+          status: "pass",
+          message: `Schemas: ${schemaResult.installed} installed, ${schemaResult.updated} updated of ${schemaResult.total}`,
+          repaired: schemaResult.installed > 0 || schemaResult.updated > 0
+        });
+      } else {
+        checks.push({
+          check: "global_schemas",
+          status: "pass",
+          message: `All ${globalSchemaCheck.installed} schemas current`
+        });
+      }
       checks.push({
         check: "global_templates",
         status: "pass",
@@ -59010,13 +60539,13 @@ var init_templates = __esm({
 
 // packages/core/src/ui/aliases.ts
 import { existsSync as existsSync93, readFileSync as readFileSync67, writeFileSync as writeFileSync15 } from "node:fs";
-import { homedir as homedir5, platform as platform2 } from "node:os";
+import { homedir as homedir5, platform as platform3 } from "node:os";
 import { join as join96 } from "node:path";
 function getCurrentShell() {
   const shell = process.env.SHELL ?? "";
   if (shell.includes("zsh")) return "zsh";
   if (shell.includes("bash")) return "bash";
-  if (platform2() === "win32") return "powershell";
+  if (platform3() === "win32") return "powershell";
   return "bash";
 }
 function getRcFilePath(shell) {
@@ -59040,7 +60569,7 @@ function detectAvailableShells() {
   const shells = [];
   if (existsSync93(getRcFilePath("bash")) || existsSync93("/bin/bash")) shells.push("bash");
   if (existsSync93(getRcFilePath("zsh")) || existsSync93("/bin/zsh")) shells.push("zsh");
-  if (platform2() === "win32") shells.push("powershell");
+  if (platform3() === "win32") shells.push("powershell");
   return shells;
 }
 function generateBashAliases(cleoPath) {
@@ -59504,27 +61033,10 @@ var init_flags = __esm({
   }
 });
 
-// packages/core/src/ui/injection-legacy.ts
-function getValidationKey(target) {
-  return INJECTION_VALIDATION_KEYS[target] ?? target.toLowerCase().replace(/[^a-z0-9]/g, "_");
-}
-var INJECTION_VALIDATION_KEYS;
-var init_injection_legacy = __esm({
-  "packages/core/src/ui/injection-legacy.ts"() {
-    "use strict";
-    INJECTION_VALIDATION_KEYS = {
-      "CLAUDE.md": "claude_md",
-      "AGENTS.md": "agents_md",
-      "GEMINI.md": "gemini_md"
-    };
-  }
-});
-
 // packages/core/src/ui/index.ts
 var ui_exports = {};
 __export(ui_exports, {
   ALIASES_VERSION: () => ALIASES_VERSION,
-  INJECTION_VALIDATION_KEYS: () => INJECTION_VALIDATION_KEYS,
   appendToChangelog: () => appendToChangelog,
   checkAliasesStatus: () => checkAliasesStatus,
   defaultFlags: () => defaultFlags,
@@ -59541,7 +61053,6 @@ __export(ui_exports, {
   getCurrentShell: () => getCurrentShell,
   getInstalledVersion: () => getInstalledVersion,
   getRcFilePath: () => getRcFilePath,
-  getValidationKey: () => getValidationKey,
   groupTasksIntoSections: () => groupTasksIntoSections,
   hasAliasBlock: () => hasAliasBlock,
   injectAliases: () => injectAliases,
@@ -59561,7 +61072,6 @@ var init_ui = __esm({
     init_changelog();
     init_command_registry();
     init_flags();
-    init_injection_legacy();
   }
 });
 
@@ -62736,11 +64246,29 @@ __export(init_exports, {
 });
 import { existsSync as existsSync100, readdirSync as readdirSync33, readFileSync as readFileSync73 } from "node:fs";
 import { copyFile as copyFile3, lstat, mkdir as mkdir16, readFile as readFile17, symlink, unlink as unlink4, writeFile as writeFile11 } from "node:fs/promises";
+import { platform as platform4 } from "node:os";
 import { basename as basename17, dirname as dirname19, join as join100 } from "node:path";
 async function initAgentDefinition(created, warnings) {
-  const packageRoot = getPackageRoot();
-  const agentSourceDir = join100(packageRoot, "agents", "cleo-subagent");
-  if (!existsSync100(agentSourceDir)) {
+  let agentSourceDir = null;
+  try {
+    const { createRequire: createRequire6 } = await import("node:module");
+    const req = createRequire6(import.meta.url);
+    const agentsPkgMain = req.resolve("@cleocode/agents/package.json");
+    const agentsPkgRoot = dirname19(agentsPkgMain);
+    const candidate = join100(agentsPkgRoot, "cleo-subagent");
+    if (existsSync100(candidate)) {
+      agentSourceDir = candidate;
+    }
+  } catch {
+  }
+  if (!agentSourceDir) {
+    const packageRoot = getPackageRoot();
+    const bundled = join100(packageRoot, "agents", "cleo-subagent");
+    if (existsSync100(bundled)) {
+      agentSourceDir = bundled;
+    }
+  }
+  if (!agentSourceDir) {
     warnings.push("agents/cleo-subagent/ not found in package, skipping agent definition install");
     return;
   }
@@ -62754,7 +64282,7 @@ async function initAgentDefinition(created, warnings) {
       }
     } catch {
     }
-    await symlink(agentSourceDir, globalAgentsDir, "dir");
+    await symlink(agentSourceDir, globalAgentsDir, DIR_SYMLINK_TYPE2);
     created.push("agent: cleo-subagent (symlinked)");
   } catch (_err) {
     try {
@@ -62813,17 +64341,29 @@ async function initCoreSkills(created, warnings) {
     const packageRoot = getPackageRoot();
     let ctSkillsRoot = null;
     try {
-      const bundledPath = join100(packageRoot, "packages", "skills");
-      if (existsSync100(join100(bundledPath, "skills.json"))) {
-        ctSkillsRoot = bundledPath;
-      } else {
-        const ctSkillsPath = join100(packageRoot, "node_modules", "@cleocode", "skills");
-        if (existsSync100(join100(ctSkillsPath, "skills.json"))) {
-          ctSkillsRoot = ctSkillsPath;
-        }
+      const { createRequire: createRequire6 } = await import("node:module");
+      const req = createRequire6(import.meta.url);
+      const skillsPkgMain = req.resolve("@cleocode/skills/package.json");
+      const skillsPkgRoot = dirname19(skillsPkgMain);
+      if (existsSync100(join100(skillsPkgRoot, "skills.json"))) {
+        ctSkillsRoot = skillsPkgRoot;
       }
     } catch {
     }
+    if (!ctSkillsRoot) {
+      try {
+        const bundledPath = join100(packageRoot, "packages", "skills");
+        if (existsSync100(join100(bundledPath, "skills.json"))) {
+          ctSkillsRoot = bundledPath;
+        } else {
+          const ctSkillsPath = join100(packageRoot, "node_modules", "@cleocode", "skills");
+          if (existsSync100(join100(ctSkillsPath, "skills.json"))) {
+            ctSkillsRoot = ctSkillsPath;
+          }
+        }
+      } catch {
+      }
+    }
     if (!ctSkillsRoot) {
       warnings.push("skills package not found, skipping core skill installation");
       return;
@@ -63115,7 +64655,6 @@ async function initProject(opts = {}) {
     warnings.push(`Contributor MCP setup: ${err instanceof Error ? err.message : String(err)}`);
   }
   await initAgentDefinition(created, warnings);
-  await initCoreSkills(created, warnings);
   await initNexusRegistration(projRoot, created, warnings);
   try {
     const { AdapterManager: AdapterManager2 } = await Promise.resolve().then(() => (init_adapters(), adapters_exports));
@@ -63202,6 +64741,7 @@ async function getVersion2(projectRoot) {
   }
   return { version: "0.0.0" };
 }
+var DIR_SYMLINK_TYPE2;
 var init_init = __esm({
   "packages/core/src/init.ts"() {
     "use strict";
@@ -63215,6 +64755,7 @@ var init_init = __esm({
     init_scaffold();
     init_schema_management();
     init_json2();
+    DIR_SYMLINK_TYPE2 = platform4() === "win32" ? "junction" : "dir";
   }
 });
 
@@ -63237,7 +64778,7 @@ var init_context_alert = __esm({
 });
 
 // packages/core/src/output.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 function pushWarning(warning) {
   pendingWarnings.push(warning);
 }
@@ -63254,7 +64795,7 @@ function createCliMeta(operation, mvi = "standard") {
     schemaVersion: "2026.2.1",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     operation,
-    requestId: randomUUID5(),
+    requestId: randomUUID6(),
     transport: "cli",
     strict: true,
     mvi,
@@ -63630,6 +65171,7 @@ var init_cleo = __esm({
 // packages/core/src/index.ts
 var init_src2 = __esm({
   "packages/core/src/index.ts"() {
+    "use strict";
     init_src();
     init_adapters();
     init_admin();
@@ -63786,7 +65328,8 @@ async function injectAgentsHub(ctx) {
           await writeFile12(globalAgentsMd, stripped, "utf8");
         }
       }
-      const action = await inject2(globalAgentsMd, "@~/.cleo/templates/CLEO-INJECTION.md");
+      const expectedContent = "@~/.cleo/templates/CLEO-INJECTION.md";
+      const action = await inject2(globalAgentsMd, expectedContent);
       ctx.created.push(`~/.agents/AGENTS.md (${action})`);
     } else {
       ctx.created.push("~/.agents/AGENTS.md (would create/update CAAMP block)");
@@ -65048,7 +66591,7 @@ var init_chain_validation = __esm({
 });
 
 // packages/core/src/lifecycle/chain-store.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 async function addChain(chain, projectRoot) {
   const validation = validateChain(chain);
   if (validation.errors.length > 0) {
@@ -65087,7 +66630,7 @@ async function createInstance(params, projectRoot) {
   if (!chain) {
     throw new Error(`Chain "${params.chainId}" not found`);
   }
-  const id = `wci-${randomUUID6().slice(0, 8)}`;
+  const id = `wci-${randomUUID7().slice(0, 8)}`;
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const variables = params.variables ?? {};
   const stageToTask = params.stageToTask ?? {};
@@ -67392,7 +68935,7 @@ var init_model_provider_registry = __esm({
 });
 
 // packages/core/src/metrics/token-service.ts
-import { createHash as createHash13, randomUUID as randomUUID7 } from "node:crypto";
+import { createHash as createHash13, randomUUID as randomUUID8 } from "node:crypto";
 import { existsSync as existsSync106, readdirSync as readdirSync34, readFileSync as readFileSync78 } from "node:fs";
 import { join as join105 } from "node:path";
 function normalizeProvider(provider, model, runtimeProvider) {
@@ -67645,7 +69188,7 @@ async function recordTokenExchange(input) {
   const measurement = await measureTokenExchange(input);
   const db = await getDb4(input.cwd);
   const row = {
-    id: randomUUID7(),
+    id: randomUUID8(),
     provider: measurement.provider,
     model: measurement.model,
     transport: input.transport ?? "unknown",
@@ -67872,13 +69415,13 @@ var init_parallel = __esm({
 // packages/core/src/orchestration/skill-ops.ts
 import { existsSync as existsSync107, readdirSync as readdirSync35, readFileSync as readFileSync79 } from "node:fs";
 import { join as join106 } from "node:path";
-import { getCanonicalSkillsDir as getCanonicalSkillsDir2 } from "@cleocode/caamp";
+import { getCanonicalSkillsDir as getCanonicalSkillsDir3 } from "@cleocode/caamp";
 function getSkillContent(skillName, projectRoot) {
   if (!skillName) {
     throw new CleoError(2 /* INVALID_INPUT */, "skill name is required");
   }
   const projectSkillDir = join106(projectRoot, ".cleo", "skills", skillName);
-  const canonicalSkillDir = join106(getCanonicalSkillsDir2(), skillName);
+  const canonicalSkillDir = join106(getCanonicalSkillsDir3(), skillName);
   const skillDir = existsSync107(projectSkillDir) ? projectSkillDir : canonicalSkillDir;
   if (!existsSync107(skillDir)) {
     throw new CleoError(
@@ -68338,7 +69881,7 @@ async function validateAndRepairSequence(cwd, config2 = {}) {
     }
     const repair = await repairSequence(cwd);
     if (repair.repaired) {
-      log7.warn(
+      log8.warn(
         { oldCounter: repair.oldCounter, newCounter: repair.newCounter },
         "Sequence repaired"
       );
@@ -68367,7 +69910,7 @@ async function triggerCheckpoint(context, cwd, config2 = {}) {
   try {
     await gitCheckpoint("auto", context, cwd);
   } catch (err) {
-    log7.warn({ err }, "Checkpoint failed (non-fatal)");
+    log8.warn({ err }, "Checkpoint failed (non-fatal)");
   }
   vacuumIntoBackup({ cwd }).catch(() => {
   });
@@ -68405,16 +69948,16 @@ async function safeDeleteTask(deleteFn, taskId, cwd, config2 = {}) {
   return result;
 }
 async function forceCheckpointBeforeOperation(operation, cwd) {
-  log7.info({ operation }, "Forcing checkpoint before operation");
+  log8.info({ operation }, "Forcing checkpoint before operation");
   try {
     await gitCheckpoint("manual", `pre-${operation}`, cwd);
   } catch (err) {
-    log7.error({ err }, "Failed to create pre-operation checkpoint");
+    log8.error({ err }, "Failed to create pre-operation checkpoint");
   }
   vacuumIntoBackup({ cwd, force: true }).catch(() => {
   });
 }
-var log7, DEFAULT_CONFIG2, SafetyError;
+var log8, DEFAULT_CONFIG2, SafetyError;
 var init_data_safety = __esm({
   "packages/core/src/store/data-safety.ts"() {
     "use strict";
@@ -68424,7 +69967,7 @@ var init_data_safety = __esm({
     init_sqlite2();
     init_sqlite_backup();
     init_tasks_schema();
-    log7 = getLogger("data-safety");
+    log8 = getLogger("data-safety");
     DEFAULT_CONFIG2 = {
       verifyWrites: true,
       detectCollisions: true,
@@ -71949,7 +73492,7 @@ async function validateLayer2Semantic(context) {
   }
   if (context.domain === "session" && context.operation === "start") {
     const scope = context.params?.scope;
-    if (scope && !scope.match(/^(epic|task|global):/)) {
+    if (scope && scope !== "global" && !scope.match(/^(epic|task):/)) {
       violations.push({
         layer: 2 /* SEMANTIC */,
         severity: "error" /* ERROR */,
@@ -71957,7 +73500,7 @@ async function validateLayer2Semantic(context) {
         message: `Invalid session scope format: ${scope}`,
         field: "scope",
         constraint: "Must be epic:<id>, task:<id>, or global",
-        fix: "Use format: epic:T1234, task:T5678, or global"
+        fix: 'Provide scope as "global" or "epic:TXXX"'
       });
     }
   }
@@ -74283,6 +75826,7 @@ __export(internal_exports, {
   ensureProjectContext: () => ensureProjectContext,
   ensureSqliteDb: () => ensureSqliteDb,
   estimateContext: () => estimateContext,
+  executeTransfer: () => executeTransfer,
   exportSnapshot: () => exportSnapshot,
   exportTasks: () => exportTasks,
   exportTasksPackage: () => exportTasksPackage,
@@ -74409,6 +75953,7 @@ __export(internal_exports, {
   gradeSession: () => gradeSession,
   heartbeat: () => heartbeat,
   hooks: () => hooks,
+  importFromPackage: () => importFromPackage,
   importSnapshot: () => importSnapshot,
   importTasks: () => importTasks,
   importTasksPackage: () => importTasksPackage,
@@ -74552,6 +76097,7 @@ __export(internal_exports, {
   predictValidationOutcome: () => predictValidationOutcome,
   prepareRelease: () => prepareRelease,
   prepareSpawn: () => prepareSpawn,
+  previewTransfer: () => previewTransfer,
   protocolEnforcer: () => protocolEnforcer,
   pruneAuditLog: () => pruneAuditLog,
   pull: () => pull,
@@ -74842,6 +76388,7 @@ var init_internal = __esm({
     init_session_memory();
     init_discover();
     init_registry3();
+    init_transfer();
     init_analyze();
     init_critical_path();
     init_orchestration();
@@ -78461,10 +80008,10 @@ var StdioServerTransport = class {
 
 // packages/cleo/src/dispatch/adapters/mcp.ts
 init_src2();
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 
 // packages/cleo/src/dispatch/lib/meta.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 function createDispatchMeta(gateway, domain2, operation, startTime, source = "mcp", requestId, sessionId) {
   return {
     gateway,
@@ -78473,7 +80020,7 @@ function createDispatchMeta(gateway, domain2, operation, startTime, source = "mc
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     duration_ms: Date.now() - startTime,
     source,
-    requestId: requestId ?? randomUUID8(),
+    requestId: requestId ?? randomUUID9(),
     ...sessionId != null && { sessionId }
   };
 }
@@ -81029,6 +82576,95 @@ var OPERATIONS = [
     requiredParams: []
   },
   // ---------------------------------------------------------------------------
+  // nexus.transfer — Cross-project task transfer (T046)
+  // ---------------------------------------------------------------------------
+  {
+    gateway: "query",
+    domain: "nexus",
+    operation: "transfer.preview",
+    description: "nexus.transfer.preview (query) \u2014 preview a cross-project task transfer",
+    tier: 2,
+    idempotent: true,
+    sessionRequired: false,
+    requiredParams: ["taskIds", "sourceProject", "targetProject"],
+    params: [
+      { name: "taskIds", type: "array", required: true, description: "Task IDs to transfer" },
+      {
+        name: "sourceProject",
+        type: "string",
+        required: true,
+        description: "Source project name or hash"
+      },
+      {
+        name: "targetProject",
+        type: "string",
+        required: true,
+        description: "Target project name or hash"
+      },
+      {
+        name: "mode",
+        type: "string",
+        required: false,
+        description: "Transfer mode: 'copy' (default) or 'move'"
+      },
+      {
+        name: "scope",
+        type: "string",
+        required: false,
+        description: "Transfer scope: 'subtree' (default) or 'single'"
+      }
+    ]
+  },
+  {
+    gateway: "mutate",
+    domain: "nexus",
+    operation: "transfer",
+    description: "nexus.transfer (mutate) \u2014 transfer tasks between NEXUS projects",
+    tier: 2,
+    idempotent: false,
+    sessionRequired: false,
+    requiredParams: ["taskIds", "sourceProject", "targetProject"],
+    params: [
+      { name: "taskIds", type: "array", required: true, description: "Task IDs to transfer" },
+      {
+        name: "sourceProject",
+        type: "string",
+        required: true,
+        description: "Source project name or hash"
+      },
+      {
+        name: "targetProject",
+        type: "string",
+        required: true,
+        description: "Target project name or hash"
+      },
+      {
+        name: "mode",
+        type: "string",
+        required: false,
+        description: "Transfer mode: 'copy' (default) or 'move'"
+      },
+      {
+        name: "scope",
+        type: "string",
+        required: false,
+        description: "Transfer scope: 'subtree' (default) or 'single'"
+      },
+      {
+        name: "onConflict",
+        type: "string",
+        required: false,
+        description: "Conflict strategy: 'rename' (default), 'skip', 'duplicate', 'fail'"
+      },
+      {
+        name: "transferBrain",
+        type: "boolean",
+        required: false,
+        description: "Whether to transfer brain observations (default: false)"
+      }
+    ]
+  },
+  // ---------------------------------------------------------------------------
   // sticky — Ephemeral notes for quick capture (T5282)
   // ---------------------------------------------------------------------------
   // Query operations
@@ -83755,8 +85391,15 @@ async function taskList(projectRoot, params) {
       data: { tasks: tasks2, total: result.total, filtered: result.filtered },
       page: result.page
     };
-  } catch {
-    return engineError("E_NOT_INITIALIZED", "Task database not initialized");
+  } catch (err) {
+    const code = err?.code;
+    if (code === 4) return engineError("E_NOT_FOUND", err.message || "Task not found");
+    if (code === 2)
+      return engineError("E_INVALID_INPUT", err.message || "Invalid input");
+    return engineError(
+      "E_NOT_INITIALIZED",
+      err.message || "Task database not initialized"
+    );
   }
 }
 async function taskFind(projectRoot, query, limit, options) {
@@ -83783,8 +85426,15 @@ async function taskFind(projectRoot, query, limit, options) {
       parentId: r.parentId
     }));
     return { success: true, data: { results, total: results.length } };
-  } catch {
-    return engineError("E_NOT_INITIALIZED", "Task database not initialized");
+  } catch (err) {
+    const code = err?.code;
+    if (code === 4) return engineError("E_NOT_FOUND", err.message || "Task not found");
+    if (code === 2)
+      return engineError("E_INVALID_INPUT", err.message || "Invalid input");
+    return engineError(
+      "E_NOT_INITIALIZED",
+      err.message || "Task database not initialized"
+    );
   }
 }
 async function taskCreate(projectRoot, params) {
@@ -84715,54 +86365,42 @@ function routeByParam(params, paramName, routes, defaultRoute) {
 
 // packages/cleo/src/dispatch/domains/admin.ts
 var AdminHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "version": {
-          const result = await getVersion3(this.projectRoot);
+          const result = await getVersion3(projectRoot);
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "health": {
           const mode = params?.mode;
           if (mode === "diagnose") {
-            const result2 = await systemDoctor(this.projectRoot);
+            const result2 = await systemDoctor(projectRoot);
             return wrapResult(result2, "query", "admin", operation, startTime);
           }
-          const result = systemHealth(
-            this.projectRoot,
-            params
-          );
+          const result = systemHealth(projectRoot, params);
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "config.show": {
-          const result = await configGet(this.projectRoot, params?.key);
+          const result = await configGet(projectRoot, params?.key);
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "stats": {
-          const result = await systemStats(
-            this.projectRoot,
-            params
-          );
+          const result = await systemStats(projectRoot, params);
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "context": {
-          const result = systemContext(
-            this.projectRoot,
-            params
-          );
+          const result = systemContext(projectRoot, params);
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "runtime": {
           const result = await systemRuntime(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "admin", operation, startTime);
@@ -84857,12 +86495,12 @@ var AdminHandler = class {
         }
         case "dash": {
           const blockedTasksLimit = typeof params?.blockedTasksLimit === "number" ? params.blockedTasksLimit : void 0;
-          const result = await systemDash(this.projectRoot, { blockedTasksLimit });
+          const result = await systemDash(projectRoot, { blockedTasksLimit });
           return wrapResult(result, "query", "admin", operation, startTime);
         }
         case "log": {
           const result = await systemLog(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "admin", operation, startTime);
@@ -84879,7 +86517,7 @@ var AdminHandler = class {
               startTime
             );
           }
-          const result = await systemSequence(this.projectRoot, {
+          const result = await systemSequence(projectRoot, {
             action
           });
           return wrapResult(result, "query", "admin", operation, startTime);
@@ -84897,7 +86535,7 @@ var AdminHandler = class {
         case "adr.find": {
           const query = params?.query;
           if (query) {
-            const result2 = await findAdrs(this.projectRoot, query, {
+            const result2 = await findAdrs(projectRoot, query, {
               topics: params?.topics,
               keywords: params?.keywords,
               status: params?.status
@@ -84909,7 +86547,7 @@ var AdminHandler = class {
             };
           }
           const { limit, offset } = getListParams(params);
-          const result = await listAdrs(this.projectRoot, {
+          const result = await listAdrs(projectRoot, {
             status: params?.status,
             since: params?.since,
             limit,
@@ -84934,7 +86572,7 @@ var AdminHandler = class {
               startTime
             );
           }
-          const adr = await showAdr(this.projectRoot, adrId);
+          const adr = await showAdr(projectRoot, adrId);
           if (!adr) {
             return errorResult(
               "query",
@@ -84973,7 +86611,7 @@ var AdminHandler = class {
                     since: params?.since,
                     until: params?.until
                   },
-                  this.projectRoot
+                  projectRoot
                 );
                 return {
                   _meta: dispatchMeta("query", "admin", operation, startTime),
@@ -85000,7 +86638,7 @@ var AdminHandler = class {
                     limit,
                     offset
                   },
-                  this.projectRoot
+                  projectRoot
                 );
                 return {
                   _meta: dispatchMeta("query", "admin", operation, startTime),
@@ -85025,7 +86663,7 @@ var AdminHandler = class {
                     startTime
                   );
                 }
-                const result = await showTokenUsage(tokenId, this.projectRoot);
+                const result = await showTokenUsage(tokenId, projectRoot);
                 if (!result) {
                   return errorResult(
                     "query",
@@ -85050,8 +86688,8 @@ var AdminHandler = class {
         case "export": {
           const scope = params?.scope;
           if (scope === "snapshot") {
-            const snapshot = await exportSnapshot(this.projectRoot);
-            const outputPath = params?.output ?? getDefaultSnapshotPath(this.projectRoot);
+            const snapshot = await exportSnapshot(projectRoot);
+            const outputPath = params?.output ?? getDefaultSnapshotPath(projectRoot);
             await writeSnapshot(snapshot, outputPath);
             return {
               _meta: dispatchMeta("query", "admin", operation, startTime),
@@ -85072,7 +86710,7 @@ var AdminHandler = class {
               filter: params?.filter,
               includeDeps: params?.includeDeps,
               dryRun: params?.dryRun,
-              cwd: this.projectRoot
+              cwd: projectRoot
             });
             return {
               _meta: dispatchMeta("query", "admin", operation, startTime),
@@ -85086,7 +86724,7 @@ var AdminHandler = class {
             status: params?.status,
             parent: params?.parent,
             phase: params?.phase,
-            cwd: this.projectRoot
+            cwd: projectRoot
           });
           return {
             _meta: dispatchMeta("query", "admin", operation, startTime),
@@ -85096,7 +86734,7 @@ var AdminHandler = class {
         }
         case "map": {
           const { mapCodebase: mapCodebase3 } = await Promise.resolve().then(() => (init_codebase_map_engine(), codebase_map_engine_exports));
-          const result = await mapCodebase3(this.projectRoot, {
+          const result = await mapCodebase3(projectRoot, {
             focus: params?.focus,
             storeToBrain: false
           });
@@ -85117,12 +86755,13 @@ var AdminHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "init": {
           const result = await initProject2(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "mutate", "admin", operation, startTime);
@@ -85131,10 +86770,10 @@ var AdminHandler = class {
         case "health": {
           const mode = params?.mode;
           if (mode === "diagnose") {
-            const result2 = await systemDoctor(this.projectRoot);
+            const result2 = await systemDoctor(projectRoot);
             return wrapResult(result2, "mutate", "admin", operation, startTime);
           }
-          const result = await systemFix(this.projectRoot);
+          const result = await systemFix(projectRoot);
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         case "config.set": {
@@ -85149,7 +86788,7 @@ var AdminHandler = class {
               startTime
             );
           }
-          const result = await configSet(this.projectRoot, key, params?.value);
+          const result = await configSet(projectRoot, key, params?.value);
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         // Merged: backup absorbs restore and backup.restore via action param (T5615)
@@ -85167,7 +86806,7 @@ var AdminHandler = class {
                 startTime
               );
             }
-            const result2 = systemRestore(this.projectRoot, {
+            const result2 = systemRestore(projectRoot, {
               backupId,
               force: params?.force
             });
@@ -85185,20 +86824,20 @@ var AdminHandler = class {
                 startTime
               );
             }
-            const result2 = await backupRestore(this.projectRoot, file2, {
+            const result2 = await backupRestore(projectRoot, file2, {
               dryRun: params?.dryRun
             });
             return wrapResult(result2, "mutate", "admin", operation, startTime);
           }
           const result = systemBackup(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         case "migrate": {
           const result = await systemMigrate(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "mutate", "admin", operation, startTime);
@@ -85215,7 +86854,7 @@ var AdminHandler = class {
               startTime
             );
           }
-          const result = await systemCleanup(this.projectRoot, {
+          const result = await systemCleanup(projectRoot, {
             target,
             olderThan: params?.olderThan,
             dryRun: params?.dryRun
@@ -85267,20 +86906,20 @@ var AdminHandler = class {
         }
         case "safestop": {
           const result = systemSafestop(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         case "inject.generate": {
-          const result = await systemInjectGenerate(this.projectRoot);
+          const result = await systemInjectGenerate(projectRoot);
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         // adr.sync absorbs adr.validate via validate flag (T5615)
         case "adr.sync": {
           const validate = params?.validate;
           if (validate) {
-            const result2 = await validateAllAdrs(this.projectRoot);
+            const result2 = await validateAllAdrs(projectRoot);
             return {
               _meta: dispatchMeta("mutate", "admin", operation, startTime),
               success: result2.valid,
@@ -85293,7 +86932,7 @@ var AdminHandler = class {
               }
             };
           }
-          const result = await syncAdrsToDb(this.projectRoot);
+          const result = await syncAdrsToDb(projectRoot);
           return {
             _meta: dispatchMeta("mutate", "admin", operation, startTime),
             success: true,
@@ -85328,7 +86967,7 @@ var AdminHandler = class {
                 }
               };
             }
-            const result2 = await importSnapshot(snapshot, this.projectRoot);
+            const result2 = await importSnapshot(snapshot, projectRoot);
             return {
               _meta: dispatchMeta("mutate", "admin", operation, startTime),
               success: true,
@@ -85364,7 +87003,7 @@ var AdminHandler = class {
               onConflict: params?.onConflict,
               onMissingDep: params?.onMissingDep,
               force: params?.force,
-              cwd: this.projectRoot
+              cwd: projectRoot
             });
             return {
               _meta: dispatchMeta("mutate", "admin", operation, startTime),
@@ -85390,7 +87029,7 @@ var AdminHandler = class {
             onDuplicate: params?.onDuplicate,
             addLabel: params?.addLabel,
             dryRun: params?.dryRun,
-            cwd: this.projectRoot
+            cwd: projectRoot
           });
           return {
             _meta: dispatchMeta("mutate", "admin", operation, startTime),
@@ -85400,8 +87039,8 @@ var AdminHandler = class {
         }
         case "detect": {
           const { ensureProjectContext: ensureProjectContext2, ensureContributorMcp: ensureContributorMcp2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-          const contextResult = await ensureProjectContext2(this.projectRoot, { force: true });
-          const mcpResult = await ensureContributorMcp2(this.projectRoot);
+          const contextResult = await ensureProjectContext2(projectRoot, { force: true });
+          const mcpResult = await ensureContributorMcp2(projectRoot);
           return wrapResult(
             {
               success: true,
@@ -85433,7 +87072,7 @@ var AdminHandler = class {
                   requestPayload: params?.requestPayload,
                   responsePayload: params?.responsePayload,
                   metadata: params?.metadata,
-                  cwd: this.projectRoot
+                  cwd: projectRoot
                 });
                 return {
                   _meta: dispatchMeta("mutate", "admin", operation, startTime),
@@ -85453,7 +87092,7 @@ var AdminHandler = class {
                     startTime
                   );
                 }
-                const result = await deleteTokenUsage(tokenId, this.projectRoot);
+                const result = await deleteTokenUsage(tokenId, projectRoot);
                 return {
                   _meta: dispatchMeta("mutate", "admin", operation, startTime),
                   success: true,
@@ -85476,7 +87115,7 @@ var AdminHandler = class {
                     since: params?.since,
                     until: params?.until
                   },
-                  this.projectRoot
+                  projectRoot
                 );
                 return {
                   _meta: dispatchMeta("mutate", "admin", operation, startTime),
@@ -85507,13 +87146,13 @@ var AdminHandler = class {
               taskId: params?.taskId,
               variant: params?.variant
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "admin", operation, startTime);
         }
         case "map": {
           const { mapCodebase: mapCodebase3 } = await Promise.resolve().then(() => (init_codebase_map_engine(), codebase_map_engine_exports));
-          const result = await mapCodebase3(this.projectRoot, {
+          const result = await mapCodebase3(projectRoot, {
             focus: params?.focus,
             storeToBrain: true
           });
@@ -85594,14 +87233,11 @@ var AdminHandler = class {
 // packages/cleo/src/dispatch/domains/check.ts
 init_internal();
 var CheckHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -85617,7 +87253,7 @@ var CheckHandler = class {
               startTime
             );
           }
-          const result = validateSchemaOp(type, params?.data, this.projectRoot);
+          const result = validateSchemaOp(type, params?.data, projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "task": {
@@ -85632,11 +87268,11 @@ var CheckHandler = class {
               startTime
             );
           }
-          const result = await validateTask2(taskId, this.projectRoot);
+          const result = await validateTask2(taskId, projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "manifest": {
-          const result = validateManifest(this.projectRoot);
+          const result = validateManifest(projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "output": {
@@ -85654,7 +87290,7 @@ var CheckHandler = class {
           const result = validateOutput(
             filePath,
             params?.taskId,
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "check", operation, startTime);
         }
@@ -85662,23 +87298,23 @@ var CheckHandler = class {
           const detail = params?.detail;
           const limit = params?.limit;
           if (detail) {
-            const result2 = validateComplianceViolations(limit, this.projectRoot);
+            const result2 = validateComplianceViolations(limit, projectRoot);
             return wrapResult(result2, "query", "check", operation, startTime);
           }
-          const result = validateComplianceSummary(this.projectRoot);
+          const result = validateComplianceSummary(projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "test": {
           const format = params?.format;
           if (format === "coverage") {
-            const result2 = validateTestCoverage(this.projectRoot);
+            const result2 = validateTestCoverage(projectRoot);
             return wrapResult(result2, "query", "check", operation, startTime);
           }
-          const result = validateTestStatus(this.projectRoot);
+          const result = validateTestStatus(projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "coherence": {
-          const result = await validateCoherenceCheck(this.projectRoot);
+          const result = await validateCoherenceCheck(projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "protocol": {
@@ -85697,12 +87333,12 @@ var CheckHandler = class {
                   ...protocolParams,
                   votingMatrixFile: params?.votingMatrixFile
                 },
-                this.projectRoot
+                projectRoot
               );
               return wrapResult(result, "query", "check", operation, startTime);
             }
             case "contribution": {
-              const result = await validateProtocolContribution(protocolParams, this.projectRoot);
+              const result = await validateProtocolContribution(protocolParams, projectRoot);
               return wrapResult(result, "query", "check", operation, startTime);
             }
             case "decomposition": {
@@ -85711,12 +87347,12 @@ var CheckHandler = class {
                   ...protocolParams,
                   epicId: params?.epicId
                 },
-                this.projectRoot
+                projectRoot
               );
               return wrapResult(result, "query", "check", operation, startTime);
             }
             case "implementation": {
-              const result = await validateProtocolImplementation(protocolParams, this.projectRoot);
+              const result = await validateProtocolImplementation(protocolParams, projectRoot);
               return wrapResult(result, "query", "check", operation, startTime);
             }
             case "specification": {
@@ -85725,7 +87361,7 @@ var CheckHandler = class {
                   ...protocolParams,
                   specFile: params?.specFile
                 },
-                this.projectRoot
+                projectRoot
               );
               return wrapResult(result, "query", "check", operation, startTime);
             }
@@ -85741,7 +87377,7 @@ var CheckHandler = class {
                   startTime
                 );
               }
-              const result = await validateProtocol(taskId, protocolType, this.projectRoot);
+              const result = await validateProtocol(taskId, protocolType, projectRoot);
               return wrapResult(result, "query", "check", operation, startTime);
             }
           }
@@ -85758,11 +87394,11 @@ var CheckHandler = class {
               startTime
             );
           }
-          const result = await validateGateVerify({ taskId }, this.projectRoot);
+          const result = await validateGateVerify({ taskId }, projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         case "archive.stats": {
-          const result = await systemArchiveStats(this.projectRoot);
+          const result = await systemArchiveStats(projectRoot);
           return wrapResult(result, "query", "check", operation, startTime);
         }
         // T5405: WarpChain validation
@@ -85801,7 +87437,7 @@ var CheckHandler = class {
               startTime
             );
           }
-          const gradeResult = await gradeSession2(sessionId, this.projectRoot);
+          const gradeResult = await gradeSession2(sessionId, projectRoot);
           return wrapResult(
             { success: true, data: gradeResult },
             "query",
@@ -85814,7 +87450,7 @@ var CheckHandler = class {
           const { readGrades: readGrades2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
           const limit = typeof params?.limit === "number" ? params.limit : void 0;
           const offset = typeof params?.offset === "number" ? params.offset : void 0;
-          const allGrades = await readGrades2(void 0, this.projectRoot);
+          const allGrades = await readGrades2(void 0, projectRoot);
           const sessionId = params?.sessionId;
           const filteredGrades = sessionId ? allGrades.filter((g) => g.sessionId === sessionId) : allGrades;
           const page = paginate(filteredGrades, limit, offset);
@@ -85845,6 +87481,7 @@ var CheckHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -85866,14 +87503,14 @@ var CheckHandler = class {
             result,
             params?.protocol,
             params?.violations,
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(engineResult, "mutate", "check", operation, startTime);
         }
         case "test.run": {
           const result = validateTestRun(
             params,
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "check", operation, startTime);
         }
@@ -85881,7 +87518,7 @@ var CheckHandler = class {
           const { syncComplianceMetrics: syncComplianceMetrics2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
           const result = await syncComplianceMetrics2({
             force: params?.force,
-            cwd: this.projectRoot
+            cwd: projectRoot
           });
           return {
             _meta: dispatchMeta("mutate", "check", operation, startTime),
@@ -85909,7 +87546,7 @@ var CheckHandler = class {
             all: params?.all,
             reset: params?.reset
           };
-          const result = await validateGateVerify(gateParams, this.projectRoot);
+          const result = await validateGateVerify(gateParams, projectRoot);
           return wrapResult(result, "mutate", "check", operation, startTime);
         }
         default:
@@ -85952,14 +87589,11 @@ var CheckHandler = class {
 // packages/cleo/src/dispatch/domains/memory.ts
 init_src2();
 var MemoryHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -85983,7 +87617,7 @@ var MemoryHandler = class {
               dateStart: params?.dateStart,
               dateEnd: params?.dateEnd
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -86005,7 +87639,7 @@ var MemoryHandler = class {
               depthBefore: params?.depthBefore,
               depthAfter: params?.depthAfter
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -86021,7 +87655,7 @@ var MemoryHandler = class {
               startTime
             );
           }
-          const result = await memoryFetch({ ids }, this.projectRoot);
+          const result = await memoryFetch({ ids }, projectRoot);
           return wrapResult(result, "query", "memory", operation, startTime);
         }
         case "decision.find": {
@@ -86031,7 +87665,7 @@ var MemoryHandler = class {
               taskId: params?.taskId,
               limit: params?.limit
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -86044,7 +87678,7 @@ var MemoryHandler = class {
               minFrequency: params?.minFrequency,
               limit: params?.limit
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -86057,7 +87691,7 @@ var MemoryHandler = class {
               applicableType: params?.applicableType,
               limit: params?.limit
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -86073,7 +87707,7 @@ var MemoryHandler = class {
               startTime
             );
           }
-          const result = await memoryGraphShow({ nodeId }, this.projectRoot);
+          const result = await memoryGraphShow({ nodeId }, projectRoot);
           return wrapResult(result, "query", "memory", operation, startTime);
         }
         case "graph.neighbors": {
@@ -86090,7 +87724,7 @@ var MemoryHandler = class {
           }
           const result = await memoryGraphNeighbors(
             { nodeId, edgeType: params?.edgeType },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -86106,7 +87740,7 @@ var MemoryHandler = class {
               startTime
             );
           }
-          const result = await memoryReasonWhy({ taskId }, this.projectRoot);
+          const result = await memoryReasonWhy({ taskId }, projectRoot);
           return wrapResult(result, "query", "memory", operation, startTime);
         }
         case "reason.similar": {
@@ -86123,7 +87757,7 @@ var MemoryHandler = class {
           }
           const result = await memoryReasonSimilar(
             { entryId, limit: params?.limit },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -86147,7 +87781,7 @@ var MemoryHandler = class {
               graphWeight: params?.graphWeight,
               limit: params?.limit
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "query", "memory", operation, startTime);
         }
@@ -86167,6 +87801,7 @@ var MemoryHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -86191,7 +87826,7 @@ var MemoryHandler = class {
               sourceSessionId: params?.sourceSessionId,
               sourceType: params?.sourceType
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -86216,7 +87851,7 @@ var MemoryHandler = class {
               taskId: params?.taskId,
               sessionId: params?.sessionId
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -86244,7 +87879,7 @@ var MemoryHandler = class {
               examples: params?.examples,
               successRate: params?.successRate
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -86270,7 +87905,7 @@ var MemoryHandler = class {
               application: params?.application,
               applicableTypes: params?.applicableTypes
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -86287,7 +87922,7 @@ var MemoryHandler = class {
               startTime
             );
           }
-          const result = await memoryLink({ taskId, entryId }, this.projectRoot);
+          const result = await memoryLink({ taskId, entryId }, projectRoot);
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
         case "graph.add": {
@@ -86302,7 +87937,7 @@ var MemoryHandler = class {
               edgeType: params?.edgeType,
               weight: params?.weight
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -86314,7 +87949,7 @@ var MemoryHandler = class {
               toId: params?.toId,
               edgeType: params?.edgeType
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "memory", operation, startTime);
         }
@@ -86584,17 +88219,30 @@ async function nexusShareSnapshotImport(projectRoot, inputPath) {
     return engineError("E_INTERNAL", error40 instanceof Error ? error40.message : String(error40));
   }
 }
+async function nexusTransferPreview(params) {
+  try {
+    const result = await previewTransfer(params);
+    return engineSuccess(result);
+  } catch (error40) {
+    return engineError("E_INTERNAL", error40 instanceof Error ? error40.message : String(error40));
+  }
+}
+async function nexusTransferExecute(params) {
+  try {
+    const result = await executeTransfer(params);
+    return engineSuccess(result);
+  } catch (error40) {
+    return engineError("E_INTERNAL", error40 instanceof Error ? error40.message : String(error40));
+  }
+}
 
 // packages/cleo/src/dispatch/domains/nexus.ts
 var NexusHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -86742,9 +88390,32 @@ var NexusHandler = class {
           return wrapResult(result, "query", "nexus", operation, startTime);
         }
         case "share.status": {
-          const result = await nexusShareStatus(this.projectRoot);
+          const result = await nexusShareStatus(projectRoot);
           return wrapResult(result, "query", "nexus", "share.status", startTime);
         }
+        case "transfer.preview": {
+          const taskIds = params?.taskIds;
+          const sourceProject = params?.sourceProject;
+          const targetProject = params?.targetProject;
+          if (!taskIds?.length || !sourceProject || !targetProject) {
+            return errorResult(
+              "query",
+              "nexus",
+              operation,
+              "E_INVALID_INPUT",
+              "taskIds, sourceProject, and targetProject are required",
+              startTime
+            );
+          }
+          const result = await nexusTransferPreview({
+            taskIds,
+            sourceProject,
+            targetProject,
+            mode: params?.mode ?? "copy",
+            scope: params?.scope ?? "subtree"
+          });
+          return wrapResult(result, "query", "nexus", operation, startTime);
+        }
         default:
           return unsupportedOp("query", "nexus", operation, startTime);
       }
@@ -86760,6 +88431,7 @@ var NexusHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -86843,13 +88515,13 @@ var NexusHandler = class {
           return wrapResult(result, "mutate", "nexus", operation, startTime);
         }
         case "reconcile": {
-          const projectRoot = params?.projectRoot || process.cwd();
-          const result = await nexusReconcileProject(projectRoot);
+          const projectRoot2 = params?.projectRoot || process.cwd();
+          const result = await nexusReconcileProject(projectRoot2);
           return wrapResult(result, "mutate", "nexus", operation, startTime);
         }
         case "share.snapshot.export": {
           const outputPath = params?.outputPath;
-          const result = await nexusShareSnapshotExport(this.projectRoot, outputPath);
+          const result = await nexusShareSnapshotExport(projectRoot, outputPath);
           return wrapResult(result, "mutate", "nexus", "share.snapshot.export", startTime);
         }
         case "share.snapshot.import": {
@@ -86864,9 +88536,34 @@ var NexusHandler = class {
               startTime
             );
           }
-          const result = await nexusShareSnapshotImport(this.projectRoot, inputPath);
+          const result = await nexusShareSnapshotImport(projectRoot, inputPath);
           return wrapResult(result, "mutate", "nexus", "share.snapshot.import", startTime);
         }
+        case "transfer": {
+          const taskIds = params?.taskIds;
+          const sourceProject = params?.sourceProject;
+          const targetProject = params?.targetProject;
+          if (!taskIds?.length || !sourceProject || !targetProject) {
+            return errorResult(
+              "mutate",
+              "nexus",
+              operation,
+              "E_INVALID_INPUT",
+              "taskIds, sourceProject, and targetProject are required",
+              startTime
+            );
+          }
+          const result = await nexusTransferExecute({
+            taskIds,
+            sourceProject,
+            targetProject,
+            mode: params?.mode ?? "copy",
+            scope: params?.scope ?? "subtree",
+            onConflict: params?.onConflict ?? "rename",
+            transferBrain: params?.transferBrain ?? false
+          });
+          return wrapResult(result, "mutate", "nexus", operation, startTime);
+        }
         default:
           return unsupportedOp("mutate", "nexus", operation, startTime);
       }
@@ -86895,7 +88592,8 @@ var NexusHandler = class {
         "blockers.show",
         "orphans.list",
         "discover",
-        "search"
+        "search",
+        "transfer.preview"
       ],
       mutate: [
         "share.snapshot.export",
@@ -86905,7 +88603,8 @@ var NexusHandler = class {
         "unregister",
         "sync",
         "permission.set",
-        "reconcile"
+        "reconcile",
+        "transfer"
       ]
     };
   }
@@ -86914,20 +88613,17 @@ var NexusHandler = class {
 // packages/cleo/src/dispatch/domains/orchestrate.ts
 init_internal();
 var OrchestrateHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // DomainHandler interface
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "status": {
           const epicId = params?.epicId;
-          const result = await orchestrateStatus(epicId, this.projectRoot);
+          const result = await orchestrateStatus(epicId, projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "next": {
@@ -86942,7 +88638,7 @@ var OrchestrateHandler = class {
               startTime
             );
           }
-          const result = await orchestrateNext(epicId, this.projectRoot);
+          const result = await orchestrateNext(epicId, projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "ready": {
@@ -86957,18 +88653,18 @@ var OrchestrateHandler = class {
               startTime
             );
           }
-          const result = await orchestrateReady(epicId, this.projectRoot);
+          const result = await orchestrateReady(epicId, projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "analyze": {
           const epicId = params?.epicId;
           const mode = params?.mode;
-          const result = await orchestrateAnalyze(epicId, this.projectRoot, mode);
+          const result = await orchestrateAnalyze(epicId, projectRoot, mode);
           return wrapResult(result, "query", "orchestrate", "analyze", startTime);
         }
         case "context": {
           const epicId = params?.epicId;
-          const result = await orchestrateContext(epicId, this.projectRoot);
+          const result = await orchestrateContext(epicId, projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "waves": {
@@ -86983,16 +88679,16 @@ var OrchestrateHandler = class {
               startTime
             );
           }
-          const result = await orchestrateWaves(epicId, this.projectRoot);
+          const result = await orchestrateWaves(epicId, projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "bootstrap": {
           const speed = params?.speed;
-          const result = await orchestrateBootstrap(this.projectRoot, { speed });
+          const result = await orchestrateBootstrap(projectRoot, { speed });
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "unblock.opportunities": {
-          const result = await orchestrateUnblockOpportunities(this.projectRoot);
+          const result = await orchestrateUnblockOpportunities(projectRoot);
           return wrapResult(result, "query", "orchestrate", operation, startTime);
         }
         case "tessera.list": {
@@ -87049,6 +88745,7 @@ var OrchestrateHandler = class {
     }
   }
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -87064,7 +88761,7 @@ var OrchestrateHandler = class {
               startTime
             );
           }
-          const result = await orchestrateStartup(epicId, this.projectRoot);
+          const result = await orchestrateStartup(epicId, projectRoot);
           return wrapResult(result, "mutate", "orchestrate", operation, startTime);
         }
         case "spawn": {
@@ -87081,7 +88778,7 @@ var OrchestrateHandler = class {
           }
           const protocolType = params?.protocolType;
           const tier = params?.tier;
-          const result = await orchestrateSpawn(taskId, protocolType, this.projectRoot, tier);
+          const result = await orchestrateSpawn(taskId, protocolType, projectRoot, tier);
           return wrapResult(result, "mutate", "orchestrate", operation, startTime);
         }
         case "handoff": {
@@ -87118,7 +88815,7 @@ var OrchestrateHandler = class {
               tier,
               idempotencyKey: params?.idempotencyKey
             },
-            this.projectRoot
+            projectRoot
           );
           return wrapResult(result, "mutate", "orchestrate", operation, startTime);
         }
@@ -87141,7 +88838,7 @@ var OrchestrateHandler = class {
             taskId,
             adapterId,
             protocolType,
-            this.projectRoot,
+            projectRoot,
             tier
           );
           return wrapResult(result, "mutate", "orchestrate", operation, startTime);
@@ -87158,7 +88855,7 @@ var OrchestrateHandler = class {
               startTime
             );
           }
-          const result = await orchestrateValidate(taskId, this.projectRoot);
+          const result = await orchestrateValidate(taskId, projectRoot);
           return wrapResult(result, "mutate", "orchestrate", operation, startTime);
         }
         case "parallel": {
@@ -87186,7 +88883,7 @@ var OrchestrateHandler = class {
                   startTime
                 );
               }
-              const result = await orchestrateParallelStart(epicId, wave, this.projectRoot);
+              const result = await orchestrateParallelStart(epicId, wave, projectRoot);
               return wrapResult(result, "mutate", "orchestrate", "parallel", startTime);
             },
             end: async () => {
@@ -87212,7 +88909,7 @@ var OrchestrateHandler = class {
                   startTime
                 );
               }
-              const result = await orchestrateParallelEnd(epicId, wave, this.projectRoot);
+              const result = await orchestrateParallelEnd(epicId, wave, projectRoot);
               return wrapResult(result, "mutate", "orchestrate", "parallel", startTime);
             }
           });
@@ -87255,7 +88952,7 @@ var OrchestrateHandler = class {
           const instance = await instantiateTessera(
             template,
             { templateId, epicId, variables: { epicId, ...variables } },
-            this.projectRoot
+            projectRoot
           );
           return {
             _meta: dispatchMeta("mutate", "orchestrate", operation, startTime),
@@ -87311,9 +89008,8 @@ var OrchestrateHandler = class {
 init_internal();
 import { execFileSync as execFileSync13 } from "node:child_process";
 var PipelineHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
+  get projectRoot() {
+    return getProjectRoot();
   }
   // -----------------------------------------------------------------------
   // DomainHandler interface
@@ -88186,24 +89882,21 @@ function unbindSession() {
 
 // packages/cleo/src/dispatch/domains/session.ts
 var SessionHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "status": {
-          const result = await sessionStatus2(this.projectRoot);
+          const result = await sessionStatus2(projectRoot);
           return wrapResult(result, "query", "session", operation, startTime);
         }
         case "list": {
           const result = await sessionList(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "session", operation, startTime);
@@ -88223,24 +89916,21 @@ var SessionHandler = class {
           }
           const include = params?.include;
           if (include === "debrief") {
-            const result2 = await sessionDebriefShow(this.projectRoot, sessionId);
+            const result2 = await sessionDebriefShow(projectRoot, sessionId);
             return wrapResult(result2, "query", "session", operation, startTime);
           }
-          const result = await sessionShow(this.projectRoot, sessionId);
+          const result = await sessionShow(projectRoot, sessionId);
           return wrapResult(result, "query", "session", operation, startTime);
         }
         case "decision.log": {
           const result = await sessionDecisionLog(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "session", operation, startTime);
         }
         case "context.drift": {
-          const result = await sessionContextDrift(
-            this.projectRoot,
-            params
-          );
+          const result = await sessionContextDrift(projectRoot, params);
           return wrapResult(result, "query", "session", operation, startTime);
         }
         case "handoff.show": {
@@ -88253,11 +89943,11 @@ var SessionHandler = class {
               scopeFilter = { type: "epic", epicId: scope.replace("epic:", "") };
             }
           }
-          const result = await sessionHandoff(this.projectRoot, scopeFilter);
+          const result = await sessionHandoff(projectRoot, scopeFilter);
           return wrapResult(result, "query", "session", operation, startTime);
         }
         case "briefing.show": {
-          const result = await sessionBriefing(this.projectRoot, {
+          const result = await sessionBriefing(projectRoot, {
             maxNextTasks: params?.maxNextTasks,
             maxBugs: params?.maxBugs,
             maxBlocked: params?.maxBlocked,
@@ -88268,7 +89958,7 @@ var SessionHandler = class {
         }
         case "find": {
           const result = await sessionFind(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "session", operation, startTime);
@@ -88288,6 +89978,7 @@ var SessionHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -88303,7 +89994,7 @@ var SessionHandler = class {
               startTime
             );
           }
-          const result = await sessionStart(this.projectRoot, {
+          const result = await sessionStart(projectRoot, {
             scope,
             name: params?.name,
             autoStart: params?.autoStart,
@@ -88334,19 +90025,19 @@ var SessionHandler = class {
           return wrapResult(result, "mutate", "session", operation, startTime);
         }
         case "end": {
-          const endResult = await sessionEnd(this.projectRoot, params?.note);
+          const endResult = await sessionEnd(projectRoot, params?.note);
           if (endResult.success && endResult.data) {
             const sessionId = endResult.data.sessionId;
             if (sessionId) {
               let debriefResult = null;
               try {
-                debriefResult = await sessionComputeDebrief(this.projectRoot, sessionId, {
+                debriefResult = await sessionComputeDebrief(projectRoot, sessionId, {
                   note: params?.note,
                   nextAction: params?.nextAction
                 });
               } catch {
                 try {
-                  await sessionComputeHandoff(this.projectRoot, sessionId, {
+                  await sessionComputeHandoff(projectRoot, sessionId, {
                     note: params?.note,
                     nextAction: params?.nextAction
                   });
@@ -88356,7 +90047,7 @@ var SessionHandler = class {
               if (debriefResult?.success && debriefResult.data) {
                 try {
                   const { persistSessionMemory: persistSessionMemory2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-                  await persistSessionMemory2(this.projectRoot, sessionId, debriefResult.data);
+                  await persistSessionMemory2(projectRoot, sessionId, debriefResult.data);
                 } catch {
                 }
               }
@@ -88377,7 +90068,7 @@ var SessionHandler = class {
               startTime
             );
           }
-          const result = await sessionResume(this.projectRoot, sessionId);
+          const result = await sessionResume(projectRoot, sessionId);
           return wrapResult(result, "mutate", "session", operation, startTime);
         }
         case "suspend": {
@@ -88393,21 +90084,18 @@ var SessionHandler = class {
             );
           }
           const result = await sessionSuspend(
-            this.projectRoot,
+            projectRoot,
             sessionId,
             params?.reason
           );
           return wrapResult(result, "mutate", "session", operation, startTime);
         }
         case "gc": {
-          const result = await sessionGc(
-            this.projectRoot,
-            params?.maxAgeDays
-          );
+          const result = await sessionGc(projectRoot, params?.maxAgeDays);
           return wrapResult(result, "mutate", "session", operation, startTime);
         }
         case "record.decision": {
-          const result = await sessionRecordDecision(this.projectRoot, {
+          const result = await sessionRecordDecision(projectRoot, {
             sessionId: params?.sessionId,
             taskId: params?.taskId,
             decision: params?.decision,
@@ -88417,7 +90105,7 @@ var SessionHandler = class {
           return wrapResult(result, "mutate", "session", operation, startTime);
         }
         case "record.assumption": {
-          const result = await sessionRecordAssumption(this.projectRoot, {
+          const result = await sessionRecordAssumption(projectRoot, {
             sessionId: params?.sessionId,
             taskId: params?.taskId,
             assumption: params?.assumption,
@@ -88558,14 +90246,11 @@ async function stickyPurge(projectRoot, id) {
 
 // packages/cleo/src/dispatch/domains/sticky.ts
 var StickyHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -88575,13 +90260,13 @@ var StickyHandler = class {
             color: params?.color,
             priority: params?.priority
           };
-          const result = await stickyList(this.projectRoot, filters);
+          const result = await stickyList(projectRoot, filters);
           if (!result.success) {
             return wrapResult(result, "query", "sticky", operation, startTime);
           }
           const filteredStickies = result.data?.stickies ?? [];
           const hasFilter = filters.status !== void 0 || filters.color !== void 0 || filters.priority !== void 0;
-          const totalResult = hasFilter ? await stickyList(this.projectRoot, {}) : result;
+          const totalResult = hasFilter ? await stickyList(projectRoot, {}) : result;
           if (!totalResult.success) {
             return wrapResult(totalResult, "query", "sticky", operation, startTime);
           }
@@ -88611,7 +90296,7 @@ var StickyHandler = class {
               startTime
             );
           }
-          const result = await stickyShow(this.projectRoot, stickyId);
+          const result = await stickyShow(projectRoot, stickyId);
           return wrapResult(result, "query", "sticky", operation, startTime);
         }
         default:
@@ -88630,6 +90315,7 @@ var StickyHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
@@ -88645,7 +90331,7 @@ var StickyHandler = class {
               startTime
             );
           }
-          const result = await stickyAdd(this.projectRoot, {
+          const result = await stickyAdd(projectRoot, {
             content,
             tags: params?.tags,
             color: params?.color,
@@ -88678,7 +90364,7 @@ var StickyHandler = class {
           }
           if (targetType === "task") {
             const result = await stickyConvertToTask(
-              this.projectRoot,
+              projectRoot,
               stickyId,
               params?.title
             );
@@ -88695,18 +90381,18 @@ var StickyHandler = class {
                 startTime
               );
             }
-            const result = await stickyConvertToTaskNote(this.projectRoot, stickyId, taskId);
+            const result = await stickyConvertToTaskNote(projectRoot, stickyId, taskId);
             return wrapResult(result, "mutate", "sticky", operation, startTime);
           } else if (targetType === "session_note") {
             const result = await stickyConvertToSessionNote(
-              this.projectRoot,
+              projectRoot,
               stickyId,
               params?.sessionId
             );
             return wrapResult(result, "mutate", "sticky", operation, startTime);
           } else {
             const result = await stickyConvertToMemory(
-              this.projectRoot,
+              projectRoot,
               stickyId,
               params?.memoryType
             );
@@ -88725,7 +90411,7 @@ var StickyHandler = class {
               startTime
             );
           }
-          const result = await stickyArchive(this.projectRoot, stickyId);
+          const result = await stickyArchive(projectRoot, stickyId);
           return wrapResult(result, "mutate", "sticky", operation, startTime);
         }
         case "purge": {
@@ -88740,7 +90426,7 @@ var StickyHandler = class {
               startTime
             );
           }
-          const result = await stickyPurge(this.projectRoot, stickyId);
+          const result = await stickyPurge(projectRoot, stickyId);
           return wrapResult(result, "mutate", "sticky", operation, startTime);
         }
         default:
@@ -88769,23 +90455,20 @@ var StickyHandler = class {
 // packages/cleo/src/dispatch/domains/tasks.ts
 init_src2();
 var TasksHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
-  }
   // -----------------------------------------------------------------------
   // Query
   // -----------------------------------------------------------------------
   async query(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "show": {
-          const result = await taskShow(this.projectRoot, params.taskId);
+          const result = await taskShow(projectRoot, params.taskId);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "list": {
-          const result = await taskList(this.projectRoot, {
+          const result = await taskList(projectRoot, {
             parent: params?.parent,
             status: params?.status,
             priority: params?.priority,
@@ -88801,7 +90484,7 @@ var TasksHandler = class {
         }
         case "find": {
           const result = await taskFind(
-            this.projectRoot,
+            projectRoot,
             params?.query,
             params?.limit,
             {
@@ -88816,12 +90499,12 @@ var TasksHandler = class {
         }
         case "tree": {
           const taskId = params?.taskId;
-          const result = await taskTree(this.projectRoot, taskId);
+          const result = await taskTree(projectRoot, taskId);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "blockers": {
           const result = await taskBlockers(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "tasks", operation, startTime);
@@ -88829,11 +90512,11 @@ var TasksHandler = class {
         case "depends": {
           const action = params?.action;
           if (action === "overview") {
-            const result2 = await taskDepsOverview(this.projectRoot);
+            const result2 = await taskDepsOverview(projectRoot);
             return wrapResult(result2, "query", "tasks", operation, startTime);
           }
           if (action === "cycles") {
-            const result2 = await taskDepsCycles(this.projectRoot);
+            const result2 = await taskDepsCycles(projectRoot);
             return wrapResult(result2, "query", "tasks", operation, startTime);
           }
           const taskId = params?.taskId;
@@ -88849,64 +90532,64 @@ var TasksHandler = class {
           }
           const direction = params?.direction;
           const tree = params?.tree;
-          const result = await taskDepends(this.projectRoot, taskId, direction, tree);
+          const result = await taskDepends(projectRoot, taskId, direction, tree);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "analyze": {
           const taskId = params?.taskId;
           const tierLimit = params?.tierLimit;
-          const result = await taskAnalyze(this.projectRoot, taskId, { tierLimit });
+          const result = await taskAnalyze(projectRoot, taskId, { tierLimit });
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "next": {
           const result = await taskNext(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "plan": {
-          const result = await taskPlan(this.projectRoot);
+          const result = await taskPlan(projectRoot);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "relates": {
           const taskId = params.taskId;
           if (params?.mode) {
-            const result2 = await taskRelatesFind(this.projectRoot, taskId, {
+            const result2 = await taskRelatesFind(projectRoot, taskId, {
               mode: params.mode,
               threshold: params?.threshold ? Number(params.threshold) : void 0
             });
             return wrapResult(result2, "query", "tasks", operation, startTime);
           }
-          const result = await taskRelates(this.projectRoot, taskId);
+          const result = await taskRelates(projectRoot, taskId);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "complexity.estimate": {
-          const result = await taskComplexityEstimate(this.projectRoot, {
+          const result = await taskComplexityEstimate(projectRoot, {
             taskId: params.taskId
           });
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "current": {
-          const result = await taskCurrentGet(this.projectRoot);
+          const result = await taskCurrentGet(projectRoot);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "history": {
           const taskId = params?.taskId;
           if (taskId) {
-            const result2 = await taskHistory(this.projectRoot, taskId, params?.limit);
+            const result2 = await taskHistory(projectRoot, taskId, params?.limit);
             return wrapResult(result2, "query", "tasks", operation, startTime);
           }
-          const result = await taskWorkHistory2(this.projectRoot);
+          const result = await taskWorkHistory2(projectRoot);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "label.list": {
-          const result = await taskLabelList(this.projectRoot);
+          const result = await taskLabelList(projectRoot);
           return wrapResult(result, "query", "tasks", operation, startTime);
         }
         case "sync.links": {
           const result = await taskSyncLinks(
-            this.projectRoot,
+            projectRoot,
             params
           );
           return wrapResult(result, "query", "tasks", operation, startTime);
@@ -88926,11 +90609,12 @@ var TasksHandler = class {
   // Mutate
   // -----------------------------------------------------------------------
   async mutate(operation, params) {
+    const projectRoot = getProjectRoot();
     const startTime = Date.now();
     try {
       switch (operation) {
         case "add": {
-          const result = await taskCreate(this.projectRoot, {
+          const result = await taskCreate(projectRoot, {
             title: params.title,
             description: params?.description ?? params.title,
             parent: params?.parent ?? params?.parentId,
@@ -88942,7 +90626,7 @@ var TasksHandler = class {
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         case "update": {
-          const result = await taskUpdate(this.projectRoot, params.taskId, {
+          const result = await taskUpdate(projectRoot, params.taskId, {
             title: params?.title,
             description: params?.description,
             status: params?.status,
@@ -88963,7 +90647,7 @@ var TasksHandler = class {
         }
         case "complete": {
           const result = await taskComplete(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             params?.notes
           );
@@ -88971,7 +90655,7 @@ var TasksHandler = class {
         }
         case "delete": {
           const result = await taskDelete(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             params?.force
           );
@@ -88979,7 +90663,7 @@ var TasksHandler = class {
         }
         case "archive": {
           const result = await taskArchive(
-            this.projectRoot,
+            projectRoot,
             params?.taskId,
             params?.before
           );
@@ -88989,20 +90673,20 @@ var TasksHandler = class {
           const taskId = params.taskId;
           const from = params?.from;
           if (from === "done") {
-            const result2 = await taskReopen(this.projectRoot, taskId, {
+            const result2 = await taskReopen(projectRoot, taskId, {
               status: params?.status,
               reason: params?.reason
             });
             return wrapResult(result2, "mutate", "tasks", operation, startTime);
           }
           if (from === "archived") {
-            const result2 = await taskUnarchive(this.projectRoot, taskId, {
+            const result2 = await taskUnarchive(projectRoot, taskId, {
               status: params?.status,
               preserveStatus: params?.preserveStatus
             });
             return wrapResult(result2, "mutate", "tasks", operation, startTime);
           }
-          const result = await taskRestore(this.projectRoot, taskId, {
+          const result = await taskRestore(projectRoot, taskId, {
             cascade: params?.cascade,
             notes: params?.notes
           });
@@ -89010,7 +90694,7 @@ var TasksHandler = class {
         }
         case "cancel": {
           const result = await taskCancel(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             params?.reason
           );
@@ -89018,7 +90702,7 @@ var TasksHandler = class {
         }
         case "reparent": {
           const result = await taskReparent(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             params?.newParentId ?? null
           );
@@ -89026,7 +90710,7 @@ var TasksHandler = class {
         }
         case "reorder": {
           const result = await taskReorder(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             params.position
           );
@@ -89045,7 +90729,7 @@ var TasksHandler = class {
             );
           }
           const result = await taskRelatesAdd(
-            this.projectRoot,
+            projectRoot,
             params.taskId,
             relatedId,
             params.type,
@@ -89054,15 +90738,15 @@ var TasksHandler = class {
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         case "start": {
-          const result = await taskStart(this.projectRoot, params.taskId);
+          const result = await taskStart(projectRoot, params.taskId);
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         case "stop": {
-          const result = await taskStop(this.projectRoot);
+          const result = await taskStop(projectRoot);
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         case "sync.reconcile": {
-          const result = await taskSyncReconcile(this.projectRoot, {
+          const result = await taskSyncReconcile(projectRoot, {
             providerId: params.providerId,
             externalTasks: params.externalTasks,
             dryRun: params?.dryRun,
@@ -89073,7 +90757,7 @@ var TasksHandler = class {
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         case "sync.links.remove": {
-          const result = await taskSyncLinksRemove(this.projectRoot, params.providerId);
+          const result = await taskSyncLinksRemove(projectRoot, params.providerId);
           return wrapResult(result, "mutate", "tasks", operation, startTime);
         }
         default:
@@ -89144,7 +90828,7 @@ import {
   discoverSkill as discoverSkill2,
   discoverSkills,
   getAllProviders as getAllProviders2,
-  getCanonicalSkillsDir as getCanonicalSkillsDir3,
+  getCanonicalSkillsDir as getCanonicalSkillsDir4,
   getInstalledProviders as getInstalledProviders3,
   getTrackedSkills,
   injectAll as injectAll2,
@@ -89161,7 +90845,7 @@ function toolsIssueDiagnostics() {
 }
 async function toolsSkillList(limit, offset) {
   try {
-    const skills = await discoverSkills(getCanonicalSkillsDir3());
+    const skills = await discoverSkills(getCanonicalSkillsDir4());
     const page = paginate(skills, limit, offset);
     return {
       success: true,
@@ -89180,7 +90864,7 @@ async function toolsSkillList(limit, offset) {
 }
 async function toolsSkillShow(name2) {
   try {
-    const skill = await discoverSkill2(`${getCanonicalSkillsDir3()}/${name2}`);
+    const skill = await discoverSkill2(`${getCanonicalSkillsDir4()}/${name2}`);
     if (!skill) {
       return engineError("E_NOT_FOUND", `Skill not found: ${name2}`);
     }
@@ -89192,7 +90876,7 @@ async function toolsSkillShow(name2) {
 async function toolsSkillFind(query) {
   try {
     const q = (query ?? "").toLowerCase();
-    const skills = await discoverSkills(getCanonicalSkillsDir3());
+    const skills = await discoverSkills(getCanonicalSkillsDir4());
     const filtered = q ? skills.filter(
       (s) => s.name.toLowerCase().includes(q) || s.metadata.description.toLowerCase().includes(q)
     ) : skills;
@@ -89216,13 +90900,13 @@ function toolsSkillDispatch(name2) {
 }
 async function toolsSkillVerify(name2) {
   try {
-    const installed = await discoverSkill2(`${getCanonicalSkillsDir3()}/${name2}`);
+    const installed = await discoverSkill2(`${getCanonicalSkillsDir4()}/${name2}`);
     const catalogEntry = catalog3.getSkill(name2);
     return engineSuccess({
       skill: name2,
       installed: !!installed,
       inCatalog: !!catalogEntry,
-      installPath: installed ? `${getCanonicalSkillsDir3()}/${name2}` : null
+      installPath: installed ? `${getCanonicalSkillsDir4()}/${name2}` : null
     });
   } catch (error40) {
     return engineError("E_INTERNAL", error40 instanceof Error ? error40.message : String(error40));
@@ -89627,9 +91311,8 @@ async function toolsAdapterDispose(projectRoot, id) {
 
 // packages/cleo/src/dispatch/domains/tools.ts
 var ToolsHandler = class {
-  projectRoot;
-  constructor() {
-    this.projectRoot = getProjectRoot();
+  get projectRoot() {
+    return getProjectRoot();
   }
   // -----------------------------------------------------------------------
   // DomainHandler interface
@@ -90362,7 +92045,7 @@ function getConfig() {
 
 // packages/cleo/src/dispatch/middleware/audit.ts
 init_internal();
-var log8 = getLogger("audit");
+var log9 = getLogger("audit");
 var cachedProjectHash;
 function resolveProjectHash() {
   if (cachedProjectHash !== void 0) return cachedProjectHash;
@@ -90393,9 +92076,9 @@ async function writeToSqlite(entry, requestId) {
     const { getDb: getDb4 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
     const { AuditLogInsertSchema: AuditLogInsertSchema2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-    const { randomUUID: randomUUID11 } = await import("node:crypto");
+    const { randomUUID: randomUUID12 } = await import("node:crypto");
     const payload = {
-      id: randomUUID11(),
+      id: randomUUID12(),
       timestamp: entry.timestamp,
       action: entry.operation,
       taskId: entry.metadata.taskId ?? "system",
@@ -90416,7 +92099,7 @@ async function writeToSqlite(entry, requestId) {
     };
     const parsed = AuditLogInsertSchema2.safeParse(payload);
     if (!parsed.success) {
-      log8.warn(
+      log9.warn(
         { issues: parsed.error.issues },
         "Audit payload failed Zod validation; skipping insert"
       );
@@ -90425,7 +92108,7 @@ async function writeToSqlite(entry, requestId) {
     const db = await getDb4(process.cwd());
     await db.insert(auditLog2).values(parsed.data).run();
   } catch (err) {
-    log8.warn({ err }, "Failed to write audit entry to SQLite");
+    log9.warn({ err }, "Failed to write audit entry to SQLite");
   }
 }
 function createAudit() {
@@ -90456,7 +92139,7 @@ function createAudit() {
       },
       error: response.error?.message
     };
-    log8.info(
+    log9.info(
       {
         domain: entry.domain,
         operation: entry.operation,
@@ -90473,7 +92156,7 @@ function createAudit() {
       await writeToSqlite(entry, req.requestId);
     } else {
       writeToSqlite(entry, req.requestId).catch((err) => {
-        log8.error({ err }, "Failed to persist audit entry to SQLite");
+        log9.error({ err }, "Failed to persist audit entry to SQLite");
       });
     }
     return response;
@@ -90954,7 +92637,7 @@ async function handleMcpToolCall(gateway, domain2, operation, params, requestId)
     operation,
     params,
     source: "mcp",
-    requestId: requestId || randomUUID9()
+    requestId: requestId || randomUUID10()
   };
   return dispatcher.dispatch(req);
 }
@@ -91045,7 +92728,7 @@ function registerQueryTool() {
 }
 
 // packages/cleo/src/mcp/lib/background-jobs.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 var BackgroundJobManager = class {
   jobs;
   abortControllers;
@@ -91078,7 +92761,7 @@ var BackgroundJobManager = class {
         `Maximum concurrent jobs reached (${this.maxJobs}). Cancel or wait for existing jobs to complete.`
       );
     }
-    const jobId = randomUUID10();
+    const jobId = randomUUID11();
     const abortController = new AbortController();
     const job = {
       id: jobId,
@@ -91770,30 +93453,30 @@ async function main() {
       projectInfo?.projectHash
     );
     startupLog = getLogger("mcp:startup");
-    const log9 = startupLog;
+    const log10 = startupLog;
     const cleoVersion = getCleoVersion();
-    log9.info(
+    log10.info(
       { version: cleoVersion, projectHash: projectInfo?.projectHash, logLevel: config2.logLevel },
       "CLEO MCP server starting"
     );
-    log9.info(
+    log10.info(
       { enableMetrics: config2.enableMetrics },
       `Metrics: ${config2.enableMetrics ? "enabled" : "disabled"}`
     );
     Promise.resolve().then(() => (init_internal(), internal_exports)).then(
       ({ loadConfig: loadCoreConfig }) => loadCoreConfig().then((coreConfig) => pruneAuditLog(cleoDir, coreConfig.logging))
-    ).catch((err) => log9.warn({ err }, "audit log pruning failed"));
-    log9.info("Initializing dispatch layer");
+    ).catch((err) => log10.warn({ err }, "audit log pruning failed"));
+    log10.info("Initializing dispatch layer");
     initMcpDispatcher({
       rateLimiting: config2.rateLimiting,
       strictMode: true
     });
-    log9.info("Dispatch layer initialized");
+    log10.info("Dispatch layer initialized");
     const jobManager = new BackgroundJobManager({ maxJobs: 10, retentionMs: 36e5 });
     setJobManager(jobManager);
-    log9.info({ maxJobs: 10, retentionMs: 36e5 }, "Background job manager initialized");
+    log10.info({ maxJobs: 10, retentionMs: 36e5 }, "Background job manager initialized");
     const cache = new QueryCache(config2.queryCacheTtl, config2.queryCache);
-    log9.info(
+    log10.info(
       { enabled: config2.queryCache, ttlMs: config2.queryCacheTtl },
       `Query cache: ${config2.queryCache ? "enabled" : "disabled"}`
     );
@@ -91810,7 +93493,7 @@ async function main() {
       }
     );
     registerMemoryResources(server);
-    log9.info("Memory resources registered");
+    log10.info("Memory resources registered");
     server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
         tools: [registerQueryTool(), registerMutateTool()]
@@ -92005,11 +93688,11 @@ async function main() {
       cache,
       jobManager
     };
-    log9.info("Connecting to stdio transport");
+    log10.info("Connecting to stdio transport");
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    log9.info({ transport: "stdio" }, "Server started successfully");
-    log9.info("Ready for requests");
+    log10.info({ transport: "stdio" }, "Server started successfully");
+    log10.info("Ready for requests");
   } catch (error40) {
     startupLog.fatal({ err: error40 }, "Failed to start server");
     process.exit(1);