@cleocode/core 2026.3.44 → 2026.3.46

package/dist/index.js

@@ -9122,7 +9122,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",
@@ -10579,7 +10579,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);
@@ -10823,7 +10825,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);
@@ -11014,7 +11018,7 @@ function getDbPath(cwd) {
   return join9(getCleoDirAbsolute(cwd), DB_FILENAME3);
 }
 async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
-  const log7 = getLogger("sqlite");
+  const log8 = getLogger("sqlite");
   try {
     const countResult = nativeDb.prepare("SELECT COUNT(*) as cnt FROM tasks").get();
     const taskCount = countResult?.cnt ?? 0;
@@ -11035,7 +11039,7 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
     if (backupTaskCount < MIN_BACKUP_TASK_COUNT) {
       return;
     }
-    log7.warn(
+    log8.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).`
     );
@@ -11053,7 +11057,7 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
     const tempPath = dbPath + ".recovery-tmp";
     copyFileSync3(newestBackup.path, tempPath);
     renameSync(tempPath, dbPath);
-    log7.info(
+    log8.info(
       { dbPath, backupPath: newestBackup.path, restoredTasks: backupTaskCount },
       "Database auto-recovered from backup successfully."
     );
@@ -11063,7 +11067,7 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
     runMigrations(restoredNativeDb, restoredDb);
     _db2 = restoredDb;
   } catch (err) {
-    log7.error({ err, dbPath }, "Auto-recovery from backup failed. Continuing with empty database.");
+    log8.error({ err, dbPath }, "Auto-recovery from backup failed. Continuing with empty database.");
   }
 }
 async function getDb(cwd) {
@@ -11094,7 +11098,7 @@ async function getDb(cwd) {
         const { execFileSync: execFileSync11 } = await import("node:child_process");
         const gitCwd = resolve3(dbPath, "..", "..");
         const filesToCheck = [dbPath, dbPath + "-wal", dbPath + "-shm"];
-        const log7 = getLogger("sqlite");
+        const log8 = getLogger("sqlite");
         for (const fileToCheck of filesToCheck) {
           try {
             execFileSync11("git", ["ls-files", "--error-unmatch", fileToCheck], {
@@ -11102,7 +11106,7 @@ async function getDb(cwd) {
               stdio: "pipe"
             });
             const basename18 = fileToCheck.split(/[\\/]/).pop();
-            log7.warn(
+            log8.warn(
               { path: fileToCheck },
               `${basename18} 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)`
             );
@@ -11124,7 +11128,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);
@@ -18466,16 +18472,6 @@ var init_json_schema_validator = __esm({
 });
 
 // packages/core/src/schema-management.ts
-var schema_management_exports = {};
-__export(schema_management_exports, {
-  checkGlobalSchemas: () => checkGlobalSchemas,
-  checkSchemaStaleness: () => checkSchemaStaleness,
-  cleanProjectSchemas: () => cleanProjectSchemas,
-  ensureGlobalSchemas: () => ensureGlobalSchemas,
-  getSchemaVersion: () => getSchemaVersion2,
-  listInstalledSchemas: () => listInstalledSchemas,
-  resolveSchemaPath: () => resolveSchemaPath
-});
 import {
   copyFileSync as copyFileSync4,
   existsSync as existsSync30,
@@ -18601,70 +18597,6 @@ function checkGlobalSchemas() {
     stale
   };
 }
-function checkSchemaStaleness() {
-  const globalDir = getCleoSchemasDir();
-  const bundledFiles = listBundledSchemas();
-  const stale = [];
-  const current = [];
-  const missing = [];
-  const packageRoot = getPackageRoot();
-  const bundledDir = join34(packageRoot, "schemas");
-  for (const file2 of bundledFiles) {
-    const globalPath = join34(globalDir, file2);
-    if (!existsSync30(globalPath)) {
-      missing.push(file2);
-      continue;
-    }
-    const bundledVersion = readVersionFromPath(join34(bundledDir, file2));
-    const globalVersion = readVersionFromPath(globalPath);
-    if (bundledVersion !== null && bundledVersion !== globalVersion) {
-      stale.push(file2);
-    } else {
-      current.push(file2);
-    }
-  }
-  return { stale, current, missing };
-}
-function listInstalledSchemas() {
-  const globalDir = getCleoSchemasDir();
-  if (!existsSync30(globalDir)) return [];
-  let files;
-  try {
-    files = readdirSync16(globalDir).filter((f) => f.endsWith(".schema.json"));
-  } catch {
-    return [];
-  }
-  return files.map((name2) => {
-    const fullPath = join34(globalDir, name2);
-    return {
-      name: name2,
-      path: fullPath,
-      version: readVersionFromPath(fullPath)
-    };
-  });
-}
-async function cleanProjectSchemas(projectRoot) {
-  const projectSchemasDir = join34(projectRoot, ".cleo", "schemas");
-  if (!existsSync30(projectSchemasDir)) {
-    return { cleaned: false };
-  }
-  try {
-    const stat2 = statSync7(projectSchemasDir);
-    if (!stat2.isDirectory()) {
-      return { cleaned: false };
-    }
-  } catch {
-    return { cleaned: false };
-  }
-  const timestamp2 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const backupDir = join34(projectRoot, ".cleo", "backups", "schemas");
-  const backupTarget = join34(backupDir, `schemas-${timestamp2}`);
-  if (!existsSync30(backupDir)) {
-    mkdirSync8(backupDir, { recursive: true });
-  }
-  renameSync3(projectSchemasDir, backupTarget);
-  return { cleaned: true };
-}
 var init_schema_management = __esm({
   "packages/core/src/schema-management.ts"() {
     "use strict";
@@ -18870,7 +18802,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 (existsSync32(projectContextPath)) {
     agentsMdLines.push("@.cleo/project-context.json");
@@ -18883,7 +18815,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) {
@@ -18898,8 +18831,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 {
@@ -19407,7 +19341,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 (existsSync33(schemaPath)) {
       const AjvModule = await import("ajv");
@@ -19848,11 +19782,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 templates = await ensureGlobalTemplates();
-  return { home, schemas, templates };
+  return { home, templates };
 }
 function checkGlobalHome() {
   const cleoHome = getCleoHome();
@@ -19986,7 +19918,7 @@ metrics/
 .backups/
 backups/
 `;
-    REQUIRED_GLOBAL_SUBDIRS = ["schemas", "templates"];
+    REQUIRED_GLOBAL_SUBDIRS = ["logs", "templates"];
   }
 });
 
@@ -24246,6 +24178,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
+  });
+}
 
 // packages/core/src/admin/export-tasks.ts
 function parseFilter(filter) {
@@ -24678,20 +24641,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}')`
@@ -24700,16 +24650,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) {
@@ -24778,7 +24728,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,
@@ -24798,6 +24748,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
+  });
+}
 
 // packages/core/src/adrs/index.ts
 var adrs_exports = {};
@@ -43851,6 +43828,7 @@ __export(nexus_exports, {
   checkPermissionDetail: () => checkPermissionDetail,
   criticalPath: () => criticalPath,
   discoverRelated: () => discoverRelated,
+  executeTransfer: () => executeTransfer,
   extractKeywords: () => extractKeywords2,
   generateProjectHash: () => generateProjectHash,
   getCurrentProject: () => getCurrentProject,
@@ -43874,6 +43852,7 @@ __export(nexus_exports, {
   orphanDetection: () => orphanDetection,
   parseQuery: () => parseQuery,
   permissionLevel: () => permissionLevel,
+  previewTransfer: () => previewTransfer,
   readRegistry: () => readRegistry,
   readRegistryRequired: () => readRegistryRequired,
   requirePermission: () => requirePermission,
@@ -44751,6 +44730,325 @@ async function syncGitignore(cwd) {
   return { updated: true, entriesCount: entries.length };
 }
 
+// packages/core/src/nexus/transfer.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+init_logger();
+
+// packages/core/src/reconciliation/link-store.ts
+init_sqlite2();
+init_tasks_schema();
+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 now = (/* @__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: now,
+    lastSyncAt: now
+  });
+  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: now,
+    lastSyncAt: now
+  };
+}
+async function touchLink(linkId, updates, cwd) {
+  const db = await getDb(cwd);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const values = { lastSyncAt: now };
+  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
+  };
+}
+
+// packages/core/src/nexus/transfer.ts
+init_brain_accessor();
+init_brain_sqlite();
+init_data_accessor();
+init_registry3();
+var log6 = getLogger("nexus:transfer");
+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;
+}
+
 // packages/core/src/observability/index.ts
 var observability_exports = {};
 __export(observability_exports, {
@@ -46149,95 +46447,6 @@ __export(reconciliation_exports, {
   touchLink: () => touchLink
 });
 
-// packages/core/src/reconciliation/link-store.ts
-init_sqlite2();
-init_tasks_schema();
-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 now = (/* @__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: now,
-    lastSyncAt: now
-  });
-  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: now,
-    lastSyncAt: now
-  };
-}
-async function touchLink(linkId, updates, cwd) {
-  const db = await getDb(cwd);
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const values = { lastSyncAt: now };
-  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
-  };
-}
-
 // packages/core/src/reconciliation/reconciliation-engine.ts
 init_data_accessor();
 init_add();
@@ -47268,8 +47477,8 @@ var PLATFORM_PATHS = {
   "gitlab-ci": ".gitlab-ci.yml",
   circleci: ".circleci/config.yml"
 };
-function getPlatformPath(platform3) {
-  return PLATFORM_PATHS[platform3];
+function getPlatformPath(platform5) {
+  return PLATFORM_PATHS[platform5];
 }
 function detectCIPlatform(projectDir) {
   const dir = projectDir ?? process.cwd();
@@ -47363,10 +47572,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":
@@ -47375,10 +47584,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 };
   }
@@ -47386,9 +47595,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 (!existsSync59(configPath)) {
     return { valid: false, exists: false, errors: ["Config file not found"] };
   }
@@ -48930,239 +49139,1463 @@ __export(routing_exports, {
 var 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"
+  }
 ];
 function getOperationMode(domain2, operation, gateway) {
   const entry = CAPABILITY_MATRIX.find(
@@ -50182,7 +51615,9 @@ function extractBody(content) {
 // packages/core/src/skills/agents/install.ts
 init_paths();
 import { existsSync as existsSync66, 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";
+var DIR_SYMLINK_TYPE = platform2() === "win32" ? "junction" : "dir";
 function getAgentInstallDir() {
   return getClaudeAgentsDir();
 }
@@ -50212,7 +51647,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}` };
@@ -52108,11 +53543,11 @@ async function validateOrchestratorCompliance(epicId, cwd) {
 }
 
 // packages/core/src/skills/skill-paths.ts
-init_paths();
 import { existsSync as existsSync76, 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();
@@ -53945,11 +55380,11 @@ import { join as join84 } from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGzip } from "node:zlib";
-var log6 = getLogger("prune");
+var log7 = getLogger("prune");
 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();
@@ -53960,7 +55395,7 @@ async function pruneAuditLog(cleoDir, config2) {
     const db = await getDb3(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;
@@ -53978,17 +55413,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}`
     );
@@ -53998,7 +55433,7 @@ 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 };
   }
 }
@@ -54258,7 +55693,7 @@ function getNodeVersionInfo() {
   };
 }
 function getNodeUpgradeInstructions() {
-  const platform3 = detectPlatform();
+  const platform5 = detectPlatform();
   const arch2 = process.arch;
   const instructions = [];
   const hasFnm = commandExists2("fnm");
@@ -54273,7 +55708,7 @@ function getNodeUpgradeInstructions() {
   if (hasVolta) {
     instructions.push(`volta install node@${MINIMUM_NODE_MAJOR}`);
   }
-  switch (platform3) {
+  switch (platform5) {
     case "linux":
       if (commandExists2("dnf")) {
         instructions.push(
@@ -54305,7 +55740,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 {
@@ -56877,7 +58312,6 @@ function validateLabels2(labels, repoLabels) {
 var ui_exports = {};
 __export(ui_exports, {
   ALIASES_VERSION: () => ALIASES_VERSION,
-  INJECTION_VALIDATION_KEYS: () => INJECTION_VALIDATION_KEYS,
   appendToChangelog: () => appendToChangelog,
   checkAliasesStatus: () => checkAliasesStatus,
   defaultFlags: () => defaultFlags,
@@ -56894,7 +58328,6 @@ __export(ui_exports, {
   getCurrentShell: () => getCurrentShell,
   getInstalledVersion: () => getInstalledVersion,
   getRcFilePath: () => getRcFilePath,
-  getValidationKey: () => getValidationKey,
   groupTasksIntoSections: () => groupTasksIntoSections,
   hasAliasBlock: () => hasAliasBlock,
   injectAliases: () => injectAliases,
@@ -56910,7 +58343,7 @@ __export(ui_exports, {
 
 // packages/core/src/ui/aliases.ts
 import { existsSync as existsSync92, 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";
 var MARKER_START = "# CLEO-CLAUDE-ALIASES:START";
 var MARKER_END = "# CLEO-CLAUDE-ALIASES:END";
@@ -56925,7 +58358,7 @@ 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) {
@@ -56949,7 +58382,7 @@ function detectAvailableShells() {
   const shells = [];
   if (existsSync92(getRcFilePath("bash")) || existsSync92("/bin/bash")) shells.push("bash");
   if (existsSync92(getRcFilePath("zsh")) || existsSync92("/bin/zsh")) shells.push("zsh");
-  if (platform2() === "win32") shells.push("powershell");
+  if (platform3() === "win32") shells.push("powershell");
   return shells;
 }
 function generateBashAliases(cleoPath) {
@@ -57381,16 +58814,6 @@ function isJsonOutput(flags) {
   return resolveFormat(flags.format) === "json";
 }
 
-// packages/core/src/ui/injection-legacy.ts
-var INJECTION_VALIDATION_KEYS = {
-  "CLAUDE.md": "claude_md",
-  "AGENTS.md": "agents_md",
-  "GEMINI.md": "gemini_md"
-};
-function getValidationKey(target) {
-  return INJECTION_VALIDATION_KEYS[target] ?? target.toLowerCase().replace(/[^a-z0-9]/g, "_");
-}
-
 // packages/core/src/validation/index.ts
 var validation_exports = {};
 __export(validation_exports, {
@@ -60371,15 +61794,34 @@ init_injection();
 init_memory_bridge();
 import { existsSync as existsSync99, 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";
 init_paths();
 init_scaffold();
 init_schema_management();
 init_json2();
+var DIR_SYMLINK_TYPE2 = platform4() === "win32" ? "junction" : "dir";
 async function initAgentDefinition(created, warnings) {
-  const packageRoot = getPackageRoot();
-  const agentSourceDir = join100(packageRoot, "agents", "cleo-subagent");
-  if (!existsSync99(agentSourceDir)) {
+  let agentSourceDir = null;
+  try {
+    const { createRequire: createRequire5 } = await import("node:module");
+    const req = createRequire5(import.meta.url);
+    const agentsPkgMain = req.resolve("@cleocode/agents/package.json");
+    const agentsPkgRoot = dirname19(agentsPkgMain);
+    const candidate = join100(agentsPkgRoot, "cleo-subagent");
+    if (existsSync99(candidate)) {
+      agentSourceDir = candidate;
+    }
+  } catch {
+  }
+  if (!agentSourceDir) {
+    const packageRoot = getPackageRoot();
+    const bundled = join100(packageRoot, "agents", "cleo-subagent");
+    if (existsSync99(bundled)) {
+      agentSourceDir = bundled;
+    }
+  }
+  if (!agentSourceDir) {
     warnings.push("agents/cleo-subagent/ not found in package, skipping agent definition install");
     return;
   }
@@ -60393,7 +61835,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 {
@@ -60410,61 +61852,6 @@ async function initAgentDefinition(created, warnings) {
     }
   }
 }
-async function initCoreSkills(created, warnings) {
-  try {
-    const { getInstalledProviders: getInstalledProviders3, installSkill: installSkill2, registerSkillLibraryFromPath } = await import("@cleocode/caamp");
-    const providers = getInstalledProviders3();
-    if (providers.length === 0) {
-      return;
-    }
-    const packageRoot = getPackageRoot();
-    let ctSkillsRoot = null;
-    try {
-      const bundledPath = join100(packageRoot, "packages", "skills");
-      if (existsSync99(join100(bundledPath, "skills.json"))) {
-        ctSkillsRoot = bundledPath;
-      } else {
-        const ctSkillsPath = join100(packageRoot, "node_modules", "@cleocode", "skills");
-        if (existsSync99(join100(ctSkillsPath, "skills.json"))) {
-          ctSkillsRoot = ctSkillsPath;
-        }
-      }
-    } catch {
-    }
-    if (!ctSkillsRoot) {
-      warnings.push("skills package not found, skipping core skill installation");
-      return;
-    }
-    try {
-      registerSkillLibraryFromPath(ctSkillsRoot);
-    } catch {
-      warnings.push("Failed to register skill library with CAAMP");
-    }
-    const catalogPath = join100(ctSkillsRoot, "skills.json");
-    const catalog3 = JSON.parse(readFileSync73(catalogPath, "utf-8"));
-    const skills = catalog3.skills ?? [];
-    const coreSkills = skills.filter((s) => s.tier <= 2);
-    const installed = [];
-    for (const skill of coreSkills) {
-      const skillSourceDir = dirname19(join100(ctSkillsRoot, skill.path));
-      if (!existsSync99(skillSourceDir)) {
-        continue;
-      }
-      try {
-        const result = await installSkill2(skillSourceDir, skill.name, providers, true);
-        if (result.success) {
-          installed.push(skill.name);
-        }
-      } catch {
-      }
-    }
-    if (installed.length > 0) {
-      created.push(`skills: ${installed.length} core skills installed`);
-    }
-  } catch (err) {
-    warnings.push(`Core skill install: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
 async function initNexusRegistration(projectRoot, created, warnings) {
   try {
     const { nexusReconcile: nexusReconcile2 } = await Promise.resolve().then(() => (init_registry3(), registry_exports3));
@@ -60722,7 +62109,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));
@@ -60816,7 +62202,7 @@ init_logger();
 
 // packages/core/src/output.ts
 init_errors3();
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 
 // packages/core/src/sessions/context-alert.ts
 init_paths();
@@ -60849,7 +62235,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,