@cleocode/cleo 2026.3.44 → 2026.3.45

package/dist/mcp/index.js

@@ -9123,7 +9123,7 @@ var init_tasks_schema = __esm({
       "supersedes"
     ];
     LIFECYCLE_TRANSITION_TYPES = ["automatic", "manual", "forced"];
-    EXTERNAL_LINK_TYPES = ["created", "matched", "manual"];
+    EXTERNAL_LINK_TYPES = ["created", "matched", "manual", "transferred"];
     SYNC_DIRECTIONS = ["inbound", "outbound", "bidirectional"];
     tasks = sqliteTable(
       "tasks",
@@ -10583,7 +10583,9 @@ function getBrainDbPath(cwd) {
 function resolveBrainMigrationsFolder() {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname3(__filename);
-  return join7(__dirname, "..", "..", "migrations", "drizzle-brain");
+  const isBundled = __dirname.endsWith("/dist") || __dirname.endsWith("\\dist");
+  const pkgRoot = isBundled ? join7(__dirname, "..") : join7(__dirname, "..", "..");
+  return join7(pkgRoot, "migrations", "drizzle-brain");
 }
 function tableExists(nativeDb, tableName) {
   const result = nativeDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
@@ -10827,7 +10829,9 @@ function getNexusDbPath() {
 function resolveNexusMigrationsFolder() {
   const __filename = fileURLToPath2(import.meta.url);
   const __dirname = dirname4(__filename);
-  return join8(__dirname, "..", "..", "migrations", "drizzle-nexus");
+  const isBundled = __dirname.endsWith("/dist") || __dirname.endsWith("\\dist");
+  const pkgRoot = isBundled ? join8(__dirname, "..") : join8(__dirname, "..", "..");
+  return join8(pkgRoot, "migrations", "drizzle-nexus");
 }
 function tableExists2(nativeDb, tableName) {
   const result = nativeDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
@@ -11018,7 +11022,7 @@ function getDbPath(cwd) {
   return join9(getCleoDirAbsolute(cwd), DB_FILENAME3);
 }
 async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
-  const log9 = getLogger("sqlite");
+  const log10 = getLogger("sqlite");
   try {
     const countResult = nativeDb.prepare("SELECT COUNT(*) as cnt FROM tasks").get();
     const taskCount = countResult?.cnt ?? 0;
@@ -11039,7 +11043,7 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
     if (backupTaskCount < MIN_BACKUP_TASK_COUNT) {
       return;
     }
-    log9.warn(
+    log10.warn(
       { dbPath, backupPath: newestBackup.path, backupTasks: backupTaskCount },
       `Empty database detected with ${backupTaskCount}-task backup available. Auto-recovering from backup. This likely happened because git-tracked WAL/SHM files were overwritten during a branch switch (T5188).`
     );
@@ -11057,7 +11061,7 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
     const tempPath = dbPath + ".recovery-tmp";
     copyFileSync3(newestBackup.path, tempPath);
     renameSync(tempPath, dbPath);
-    log9.info(
+    log10.info(
       { dbPath, backupPath: newestBackup.path, restoredTasks: backupTaskCount },
       "Database auto-recovered from backup successfully."
     );
@@ -11067,7 +11071,7 @@ async function autoRecoverFromBackup(nativeDb, dbPath, cwd) {
     runMigrations(restoredNativeDb, restoredDb);
     _db2 = restoredDb;
   } catch (err) {
-    log9.error({ err, dbPath }, "Auto-recovery from backup failed. Continuing with empty database.");
+    log10.error({ err, dbPath }, "Auto-recovery from backup failed. Continuing with empty database.");
   }
 }
 async function getDb(cwd) {
@@ -11098,7 +11102,7 @@ async function getDb(cwd) {
         const { execFileSync: execFileSync14 } = await import("node:child_process");
         const gitCwd = resolve3(dbPath, "..", "..");
         const filesToCheck = [dbPath, dbPath + "-wal", dbPath + "-shm"];
-        const log9 = getLogger("sqlite");
+        const log10 = getLogger("sqlite");
         for (const fileToCheck of filesToCheck) {
           try {
             execFileSync14("git", ["ls-files", "--error-unmatch", fileToCheck], {
@@ -11106,7 +11110,7 @@ async function getDb(cwd) {
               stdio: "pipe"
             });
             const basename19 = fileToCheck.split(/[\\/]/).pop();
-            log9.warn(
+            log10.warn(
               { path: fileToCheck },
               `${basename19} is tracked by project git \u2014 this risks data loss on branch switch. Run: git rm --cached ${fileToCheck.replace(gitCwd + sep, "")} (see ADR-013, T5188)`
             );
@@ -11128,7 +11132,9 @@ async function getDb(cwd) {
 function resolveMigrationsFolder() {
   const __filename = fileURLToPath3(import.meta.url);
   const __dirname = dirname5(__filename);
-  return join9(__dirname, "..", "..", "migrations", "drizzle-tasks");
+  const isBundled = __dirname.endsWith("/dist") || __dirname.endsWith("\\dist");
+  const pkgRoot = isBundled ? join9(__dirname, "..") : join9(__dirname, "..", "..");
+  return join9(pkgRoot, "migrations", "drizzle-tasks");
 }
 function tableExists3(nativeDb, tableName) {
   const result = nativeDb.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(tableName);
@@ -14396,6 +14402,37 @@ function buildExportPackage(tasks2, options) {
     relationshipGraph
   };
 }
+function exportSingle(taskId, allTasks, projectName) {
+  const task = allTasks.find((t) => t.id === taskId);
+  if (!task) return null;
+  return buildExportPackage([task], {
+    mode: "single",
+    rootTaskIds: [taskId],
+    includeChildren: false,
+    projectName
+  });
+}
+function exportSubtree(rootId, allTasks, projectName) {
+  const root = allTasks.find((t) => t.id === rootId);
+  if (!root) return null;
+  const collected = /* @__PURE__ */ new Map();
+  const queue = [rootId];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    const task = allTasks.find((t) => t.id === id);
+    if (!task || collected.has(id)) continue;
+    collected.set(id, task);
+    const children = allTasks.filter((t) => t.parentId === id);
+    queue.push(...children.map((c) => c.id));
+  }
+  const tasks2 = [...collected.values()];
+  return buildExportPackage(tasks2, {
+    mode: "subtree",
+    rootTaskIds: [rootId],
+    includeChildren: true,
+    projectName
+  });
+}
 var EXPORT_FORMAT_VERSION;
 var init_export2 = __esm({
   "packages/core/src/store/export.ts"() {
@@ -14856,20 +14893,7 @@ function topologicalSort(tasks2) {
   }
   return sorted;
 }
-async function importTasksPackage(params) {
-  const { file: file2 } = params;
-  try {
-    await access2(file2, fsConstants2.R_OK);
-  } catch {
-    throw new Error(`Export file not found: ${file2}`);
-  }
-  const content = await readFile4(file2, "utf-8");
-  let exportPkg;
-  try {
-    exportPkg = JSON.parse(content);
-  } catch {
-    throw new Error(`Invalid JSON in: ${file2}`);
-  }
+async function importFromPackage(exportPkg, options = {}) {
   if (exportPkg._meta?.format !== "cleo-export") {
     throw new Error(
       `Invalid export format (expected 'cleo-export', got '${exportPkg._meta?.format}')`
@@ -14878,16 +14902,16 @@ async function importTasksPackage(params) {
   if (!exportPkg.tasks?.length) {
     throw new Error("Export package contains no tasks");
   }
-  const accessor = await getAccessor(params.cwd);
+  const accessor = await getAccessor(options.cwd);
   const { tasks: existingTasks } = await accessor.queryTasks({});
-  const onConflict = params.onConflict ?? "fail";
-  const onMissingDep = params.onMissingDep ?? "strip";
-  const force = params.force ?? false;
-  const parentId = params.parent;
-  const phaseOverride = params.phase;
-  const addLabel = params.addLabel;
-  const resetStatus = params.resetStatus;
-  const addProvenance = params.provenance !== false;
+  const onConflict = options.onConflict ?? "fail";
+  const onMissingDep = options.onMissingDep === "fail" ? "fail" : "strip";
+  const force = options.force ?? false;
+  const parentId = options.parent;
+  const phaseOverride = options.phase;
+  const addLabel = options.addLabel;
+  const resetStatus = options.resetStatus;
+  const addProvenance = options.provenance !== false;
   if (parentId) {
     const parentExists = existingTasks.some((t) => t.id === parentId);
     if (!parentExists) {
@@ -14956,7 +14980,7 @@ async function importTasksPackage(params) {
     existingTitles.add(remapped.title.toLowerCase());
     existingIds.add(remapped.id);
   }
-  if (params.dryRun) {
+  if (options.dryRun) {
     return {
       imported: transformed.length,
       skipped: skipped.length,
@@ -14976,6 +15000,33 @@ async function importTasksPackage(params) {
     idRemap: idRemapJson
   };
 }
+async function importTasksPackage(params) {
+  const { file: file2 } = params;
+  try {
+    await access2(file2, fsConstants2.R_OK);
+  } catch {
+    throw new Error(`Export file not found: ${file2}`);
+  }
+  const content = await readFile4(file2, "utf-8");
+  let exportPkg;
+  try {
+    exportPkg = JSON.parse(content);
+  } catch {
+    throw new Error(`Invalid JSON in: ${file2}`);
+  }
+  return importFromPackage(exportPkg, {
+    cwd: params.cwd,
+    dryRun: params.dryRun,
+    parent: params.parent,
+    phase: params.phase,
+    addLabel: params.addLabel,
+    provenance: params.provenance,
+    resetStatus: params.resetStatus,
+    onConflict: params.onConflict,
+    onMissingDep: params.onMissingDep === "placeholder" ? "strip" : params.onMissingDep,
+    force: params.force
+  });
+}
 var init_import_tasks = __esm({
   "packages/core/src/admin/import-tasks.ts"() {
     "use strict";
@@ -43370,6 +43421,338 @@ var init_sharing = __esm({
   }
 });
 
+// packages/core/src/reconciliation/link-store.ts
+import { randomUUID as randomUUID4 } from "node:crypto";
+import { and as and5, eq as eq8 } from "drizzle-orm";
+async function getLinksByProvider(providerId, cwd) {
+  const db = await getDb(cwd);
+  const rows = await db.select().from(externalTaskLinks).where(eq8(externalTaskLinks.providerId, providerId));
+  return rows.map(rowToLink);
+}
+async function getLinkByExternalId(providerId, externalId, cwd) {
+  const db = await getDb(cwd);
+  const rows = await db.select().from(externalTaskLinks).where(
+    and5(
+      eq8(externalTaskLinks.providerId, providerId),
+      eq8(externalTaskLinks.externalId, externalId)
+    )
+  );
+  return rows.length > 0 ? rowToLink(rows[0]) : null;
+}
+async function getLinksByTaskId(taskId, cwd) {
+  const db = await getDb(cwd);
+  const rows = await db.select().from(externalTaskLinks).where(eq8(externalTaskLinks.taskId, taskId));
+  return rows.map(rowToLink);
+}
+async function createLink(params, cwd) {
+  const db = await getDb(cwd);
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const id = randomUUID4();
+  await db.insert(externalTaskLinks).values({
+    id,
+    taskId: params.taskId,
+    providerId: params.providerId,
+    externalId: params.externalId,
+    externalUrl: params.externalUrl ?? null,
+    externalTitle: params.externalTitle ?? null,
+    linkType: params.linkType,
+    syncDirection: params.syncDirection ?? "inbound",
+    metadataJson: params.metadata ? JSON.stringify(params.metadata) : "{}",
+    linkedAt: now2,
+    lastSyncAt: now2
+  });
+  return {
+    id,
+    taskId: params.taskId,
+    providerId: params.providerId,
+    externalId: params.externalId,
+    externalUrl: params.externalUrl ?? null,
+    externalTitle: params.externalTitle ?? null,
+    linkType: params.linkType,
+    syncDirection: params.syncDirection ?? "inbound",
+    metadata: params.metadata,
+    linkedAt: now2,
+    lastSyncAt: now2
+  };
+}
+async function touchLink(linkId, updates, cwd) {
+  const db = await getDb(cwd);
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const values = { lastSyncAt: now2 };
+  if (updates?.externalTitle !== void 0) {
+    values.externalTitle = updates.externalTitle;
+  }
+  if (updates?.metadata !== void 0) {
+    values.metadataJson = JSON.stringify(updates.metadata);
+  }
+  await db.update(externalTaskLinks).set(values).where(eq8(externalTaskLinks.id, linkId));
+}
+async function removeLinksByProvider(providerId, cwd) {
+  const db = await getDb(cwd);
+  const result = await db.delete(externalTaskLinks).where(eq8(externalTaskLinks.providerId, providerId));
+  return Number(result.changes);
+}
+function rowToLink(row) {
+  return {
+    id: row.id,
+    taskId: row.taskId,
+    providerId: row.providerId,
+    externalId: row.externalId,
+    externalUrl: row.externalUrl,
+    externalTitle: row.externalTitle,
+    linkType: row.linkType,
+    syncDirection: row.syncDirection,
+    metadata: row.metadataJson ? JSON.parse(row.metadataJson) : void 0,
+    linkedAt: row.linkedAt,
+    lastSyncAt: row.lastSyncAt
+  };
+}
+var init_link_store = __esm({
+  "packages/core/src/reconciliation/link-store.ts"() {
+    "use strict";
+    init_sqlite2();
+    init_tasks_schema();
+  }
+});
+
+// packages/core/src/nexus/transfer.ts
+import { randomUUID as randomUUID5 } from "node:crypto";
+async function previewTransfer(params) {
+  return executeTransferInternal({ ...params, dryRun: true });
+}
+async function executeTransfer(params) {
+  return executeTransferInternal(params);
+}
+async function executeTransferInternal(params) {
+  const {
+    taskIds,
+    sourceProject: sourceProjectRef,
+    targetProject: targetProjectRef,
+    mode = "copy",
+    scope = "subtree",
+    onConflict = "rename",
+    onMissingDep = "strip",
+    provenance = true,
+    targetParent,
+    transferBrain = false,
+    dryRun = false
+  } = params;
+  if (!taskIds.length) {
+    throw new Error("No task IDs specified for transfer");
+  }
+  const sourceProject = await nexusGetProject(sourceProjectRef);
+  if (!sourceProject) {
+    throw new Error(`Source project not found: ${sourceProjectRef}`);
+  }
+  const targetProject = await nexusGetProject(targetProjectRef);
+  if (!targetProject) {
+    throw new Error(`Target project not found: ${targetProjectRef}`);
+  }
+  if (sourceProject.hash === targetProject.hash) {
+    throw new Error("Source and target projects must be different");
+  }
+  await requirePermission(sourceProject.hash, "read", "nexus.transfer");
+  await requirePermission(targetProject.hash, "write", "nexus.transfer");
+  const sourceAccessor = await getAccessor(sourceProject.path);
+  const { tasks: allSourceTasks } = await sourceAccessor.queryTasks({});
+  const exportPackages = [];
+  for (const taskId of taskIds) {
+    const pkg = scope === "subtree" ? exportSubtree(taskId, allSourceTasks, sourceProject.name) : exportSingle(taskId, allSourceTasks, sourceProject.name);
+    if (!pkg) {
+      throw new Error(`Task not found in source project: ${taskId}`);
+    }
+    exportPackages.push(pkg);
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  const mergedTasks = [];
+  for (const pkg of exportPackages) {
+    for (const task of pkg.tasks) {
+      if (!seenIds.has(task.id)) {
+        seenIds.add(task.id);
+        mergedTasks.push(task);
+      }
+    }
+  }
+  const mergedPkg = { ...exportPackages[0] };
+  mergedPkg.tasks = mergedTasks;
+  mergedPkg._meta = { ...mergedPkg._meta, taskCount: mergedTasks.length };
+  const importResult = await importFromPackage(mergedPkg, {
+    cwd: targetProject.path,
+    dryRun,
+    parent: targetParent,
+    provenance,
+    onConflict,
+    onMissingDep
+  });
+  const entries = mergedTasks.map((t) => ({
+    sourceId: t.id,
+    targetId: importResult.idRemap[t.id] ?? t.id,
+    title: t.title,
+    type: t.type ?? "task"
+  }));
+  const manifest = {
+    sourceProject: sourceProject.name,
+    targetProject: targetProject.name,
+    mode,
+    scope,
+    entries,
+    idRemap: importResult.idRemap,
+    brainObservationsTransferred: 0
+  };
+  const result = {
+    dryRun,
+    transferred: importResult.imported,
+    skipped: importResult.skipped,
+    archived: 0,
+    linksCreated: 0,
+    brainObservationsTransferred: 0,
+    manifest
+  };
+  if (dryRun) {
+    return result;
+  }
+  let linksCreated = 0;
+  const targetAccessor = await getAccessor(targetProject.path);
+  const { tasks: targetTasks } = await targetAccessor.queryTasks({});
+  const targetTaskIds = new Set(targetTasks.map((t) => t.id));
+  for (const entry of entries) {
+    if (importResult.idRemap[entry.sourceId] && targetTaskIds.has(entry.targetId)) {
+      await createLink(
+        {
+          taskId: entry.targetId,
+          providerId: `nexus:${sourceProject.name}`,
+          externalId: entry.sourceId,
+          externalTitle: entry.title,
+          linkType: "transferred",
+          syncDirection: "inbound",
+          metadata: {
+            transferMode: mode,
+            transferScope: scope,
+            sourceProject: sourceProject.name,
+            transferredAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        },
+        targetProject.path
+      );
+      linksCreated++;
+      await createLink(
+        {
+          taskId: entry.sourceId,
+          providerId: `nexus:${targetProject.name}`,
+          externalId: entry.targetId,
+          externalTitle: entry.title,
+          linkType: "transferred",
+          syncDirection: "outbound",
+          metadata: {
+            transferMode: mode,
+            transferScope: scope,
+            targetProject: targetProject.name,
+            transferredAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        },
+        sourceProject.path
+      );
+      linksCreated++;
+    }
+  }
+  result.linksCreated = linksCreated;
+  try {
+    const { getNexusDb: getNexusDb2 } = await Promise.resolve().then(() => (init_nexus_sqlite(), nexus_sqlite_exports));
+    const { nexusAuditLog: nexusAuditLog2 } = await Promise.resolve().then(() => (init_nexus_schema(), nexus_schema_exports));
+    const db = await getNexusDb2();
+    await db.insert(nexusAuditLog2).values({
+      id: randomUUID5(),
+      action: "transfer",
+      projectHash: sourceProject.hash,
+      projectId: sourceProject.projectId,
+      domain: "nexus",
+      operation: "transfer",
+      success: 1,
+      detailsJson: JSON.stringify({
+        sourceProject: sourceProject.name,
+        targetProject: targetProject.name,
+        mode,
+        scope,
+        taskCount: result.transferred,
+        idRemap: importResult.idRemap
+      })
+    });
+  } catch (err) {
+    log6.warn({ err }, "nexus transfer audit write failed");
+  }
+  if (mode === "move") {
+    let archived = 0;
+    for (const entry of entries) {
+      if (importResult.idRemap[entry.sourceId]) {
+        try {
+          await sourceAccessor.archiveSingleTask(entry.sourceId, {
+            archivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            archiveReason: `Transferred to ${targetProject.name} as ${entry.targetId}`
+          });
+          archived++;
+        } catch (err) {
+          log6.warn({ err, taskId: entry.sourceId }, "failed to archive source task after transfer");
+        }
+      }
+    }
+    result.archived = archived;
+  }
+  if (transferBrain) {
+    let brainTransferred = 0;
+    try {
+      const sourceBrainDb = await getBrainDb(sourceProject.path);
+      const targetBrainDb = await getBrainDb(targetProject.path);
+      const sourceBrain = new BrainDataAccessor(sourceBrainDb);
+      const targetBrain = new BrainDataAccessor(targetBrainDb);
+      for (const entry of entries) {
+        if (!importResult.idRemap[entry.sourceId]) continue;
+        const links = await sourceBrain.getLinksForTask(entry.sourceId);
+        for (const link of links) {
+          if (link.memoryType !== "observation") continue;
+          const observation = await sourceBrain.getObservation(link.memoryId);
+          if (!observation) continue;
+          const newObsId = `O-${randomUUID5().slice(0, 8)}`;
+          await targetBrain.addObservation({
+            ...observation,
+            id: newObsId,
+            createdAt: observation.createdAt,
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19)
+          });
+          await targetBrain.addLink({
+            memoryType: "observation",
+            memoryId: newObsId,
+            taskId: entry.targetId,
+            linkType: "applies_to",
+            createdAt: (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19)
+          });
+          brainTransferred++;
+        }
+      }
+    } catch (err) {
+      log6.warn({ err }, "brain observation transfer failed");
+    }
+    result.brainObservationsTransferred = brainTransferred;
+    result.manifest.brainObservationsTransferred = brainTransferred;
+  }
+  return result;
+}
+var log6;
+var init_transfer = __esm({
+  "packages/core/src/nexus/transfer.ts"() {
+    "use strict";
+    init_import_tasks();
+    init_logger();
+    init_link_store();
+    init_brain_accessor();
+    init_brain_sqlite();
+    init_data_accessor();
+    init_export2();
+    init_permissions();
+    init_registry3();
+    log6 = getLogger("nexus:transfer");
+  }
+});
+
 // packages/core/src/nexus/index.ts
 var nexus_exports = {};
 __export(nexus_exports, {
@@ -43382,6 +43765,7 @@ __export(nexus_exports, {
   checkPermissionDetail: () => checkPermissionDetail,
   criticalPath: () => criticalPath,
   discoverRelated: () => discoverRelated,
+  executeTransfer: () => executeTransfer,
   extractKeywords: () => extractKeywords2,
   generateProjectHash: () => generateProjectHash,
   getCurrentProject: () => getCurrentProject,
@@ -43405,6 +43789,7 @@ __export(nexus_exports, {
   orphanDetection: () => orphanDetection,
   parseQuery: () => parseQuery,
   permissionLevel: () => permissionLevel,
+  previewTransfer: () => previewTransfer,
   readRegistry: () => readRegistry,
   readRegistryRequired: () => readRegistryRequired,
   requirePermission: () => requirePermission,
@@ -43427,6 +43812,7 @@ var init_nexus = __esm({
     init_query3();
     init_registry3();
     init_sharing();
+    init_transfer();
   }
 });
 
@@ -44927,100 +45313,6 @@ var init_pipeline = __esm({
   }
 });
 
-// packages/core/src/reconciliation/link-store.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
-import { and as and5, eq as eq8 } from "drizzle-orm";
-async function getLinksByProvider(providerId, cwd) {
-  const db = await getDb(cwd);
-  const rows = await db.select().from(externalTaskLinks).where(eq8(externalTaskLinks.providerId, providerId));
-  return rows.map(rowToLink);
-}
-async function getLinkByExternalId(providerId, externalId, cwd) {
-  const db = await getDb(cwd);
-  const rows = await db.select().from(externalTaskLinks).where(
-    and5(
-      eq8(externalTaskLinks.providerId, providerId),
-      eq8(externalTaskLinks.externalId, externalId)
-    )
-  );
-  return rows.length > 0 ? rowToLink(rows[0]) : null;
-}
-async function getLinksByTaskId(taskId, cwd) {
-  const db = await getDb(cwd);
-  const rows = await db.select().from(externalTaskLinks).where(eq8(externalTaskLinks.taskId, taskId));
-  return rows.map(rowToLink);
-}
-async function createLink(params, cwd) {
-  const db = await getDb(cwd);
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const id = randomUUID4();
-  await db.insert(externalTaskLinks).values({
-    id,
-    taskId: params.taskId,
-    providerId: params.providerId,
-    externalId: params.externalId,
-    externalUrl: params.externalUrl ?? null,
-    externalTitle: params.externalTitle ?? null,
-    linkType: params.linkType,
-    syncDirection: params.syncDirection ?? "inbound",
-    metadataJson: params.metadata ? JSON.stringify(params.metadata) : "{}",
-    linkedAt: now2,
-    lastSyncAt: now2
-  });
-  return {
-    id,
-    taskId: params.taskId,
-    providerId: params.providerId,
-    externalId: params.externalId,
-    externalUrl: params.externalUrl ?? null,
-    externalTitle: params.externalTitle ?? null,
-    linkType: params.linkType,
-    syncDirection: params.syncDirection ?? "inbound",
-    metadata: params.metadata,
-    linkedAt: now2,
-    lastSyncAt: now2
-  };
-}
-async function touchLink(linkId, updates, cwd) {
-  const db = await getDb(cwd);
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const values = { lastSyncAt: now2 };
-  if (updates?.externalTitle !== void 0) {
-    values.externalTitle = updates.externalTitle;
-  }
-  if (updates?.metadata !== void 0) {
-    values.metadataJson = JSON.stringify(updates.metadata);
-  }
-  await db.update(externalTaskLinks).set(values).where(eq8(externalTaskLinks.id, linkId));
-}
-async function removeLinksByProvider(providerId, cwd) {
-  const db = await getDb(cwd);
-  const result = await db.delete(externalTaskLinks).where(eq8(externalTaskLinks.providerId, providerId));
-  return Number(result.changes);
-}
-function rowToLink(row) {
-  return {
-    id: row.id,
-    taskId: row.taskId,
-    providerId: row.providerId,
-    externalId: row.externalId,
-    externalUrl: row.externalUrl,
-    externalTitle: row.externalTitle,
-    linkType: row.linkType,
-    syncDirection: row.syncDirection,
-    metadata: row.metadataJson ? JSON.parse(row.metadataJson) : void 0,
-    linkedAt: row.linkedAt,
-    lastSyncAt: row.lastSyncAt
-  };
-}
-var init_link_store = __esm({
-  "packages/core/src/reconciliation/link-store.ts"() {
-    "use strict";
-    init_sqlite2();
-    init_tasks_schema();
-  }
-});
-
 // packages/core/src/memory/auto-extract.ts
 var auto_extract_exports = {};
 __export(auto_extract_exports, {
@@ -55464,7 +55756,7 @@ import { createGzip } from "node:zlib";
 async function pruneAuditLog(cleoDir, config2) {
   try {
     if (!config2.auditRetentionDays || config2.auditRetentionDays <= 0) {
-      log6.debug("auditRetentionDays is 0 or unset; skipping audit prune");
+      log7.debug("auditRetentionDays is 0 or unset; skipping audit prune");
       return { rowsArchived: 0, rowsDeleted: 0 };
     }
     const cutoff = new Date(Date.now() - config2.auditRetentionDays * 864e5).toISOString();
@@ -55475,7 +55767,7 @@ async function pruneAuditLog(cleoDir, config2) {
     const db = await getDb4(projectRoot);
     const oldRows = await db.select().from(auditLog2).where(lt3(auditLog2.timestamp, cutoff));
     if (oldRows.length === 0) {
-      log6.debug("No audit_log rows older than cutoff; nothing to prune");
+      log7.debug("No audit_log rows older than cutoff; nothing to prune");
       return { rowsArchived: 0, rowsDeleted: 0 };
     }
     let archivePath;
@@ -55493,17 +55785,17 @@ async function pruneAuditLog(cleoDir, config2) {
         const inStream = Readable.from([jsonlContent]);
         await pipeline(inStream, gzip, outStream);
         rowsArchived = oldRows.length;
-        log6.info(
+        log7.info(
           { archivePath, rowsArchived },
           `Archived ${rowsArchived} audit rows to ${archivePath}`
         );
       } catch (archiveErr) {
-        log6.warn({ err: archiveErr }, "Failed to archive audit rows; continuing with deletion");
+        log7.warn({ err: archiveErr }, "Failed to archive audit rows; continuing with deletion");
         archivePath = void 0;
       }
     }
     await db.delete(auditLog2).where(lt3(auditLog2.timestamp, cutoff)).run();
-    log6.info(
+    log7.info(
       { rowsDeleted: oldRows.length, cutoff },
       `Pruned ${oldRows.length} audit_log rows older than ${cutoff}`
     );
@@ -55513,16 +55805,16 @@ async function pruneAuditLog(cleoDir, config2) {
       archivePath
     };
   } catch (err) {
-    log6.warn({ err }, "audit log pruning failed");
+    log7.warn({ err }, "audit log pruning failed");
     return { rowsArchived: 0, rowsDeleted: 0 };
   }
 }
-var log6;
+var log7;
 var init_audit_prune = __esm({
   "packages/core/src/audit-prune.ts"() {
     "use strict";
     init_logger();
-    log6 = getLogger("prune");
+    log7 = getLogger("prune");
   }
 });
 
@@ -63237,7 +63529,7 @@ var init_context_alert = __esm({
 });
 
 // packages/core/src/output.ts
-import { randomUUID as randomUUID5 } from "node:crypto";
+import { randomUUID as randomUUID6 } from "node:crypto";
 function pushWarning(warning) {
   pendingWarnings.push(warning);
 }
@@ -63254,7 +63546,7 @@ function createCliMeta(operation, mvi = "standard") {
     schemaVersion: "2026.2.1",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     operation,
-    requestId: randomUUID5(),
+    requestId: randomUUID6(),
     transport: "cli",
     strict: true,
     mvi,
@@ -63630,6 +63922,7 @@ var init_cleo = __esm({
 // packages/core/src/index.ts
 var init_src2 = __esm({
   "packages/core/src/index.ts"() {
+    "use strict";
     init_src();
     init_adapters();
     init_admin();
@@ -65048,7 +65341,7 @@ var init_chain_validation = __esm({
 });
 
 // packages/core/src/lifecycle/chain-store.ts
-import { randomUUID as randomUUID6 } from "node:crypto";
+import { randomUUID as randomUUID7 } from "node:crypto";
 async function addChain(chain, projectRoot) {
   const validation = validateChain(chain);
   if (validation.errors.length > 0) {
@@ -65087,7 +65380,7 @@ async function createInstance(params, projectRoot) {
   if (!chain) {
     throw new Error(`Chain "${params.chainId}" not found`);
   }
-  const id = `wci-${randomUUID6().slice(0, 8)}`;
+  const id = `wci-${randomUUID7().slice(0, 8)}`;
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   const variables = params.variables ?? {};
   const stageToTask = params.stageToTask ?? {};
@@ -67392,7 +67685,7 @@ var init_model_provider_registry = __esm({
 });
 
 // packages/core/src/metrics/token-service.ts
-import { createHash as createHash13, randomUUID as randomUUID7 } from "node:crypto";
+import { createHash as createHash13, randomUUID as randomUUID8 } from "node:crypto";
 import { existsSync as existsSync106, readdirSync as readdirSync34, readFileSync as readFileSync78 } from "node:fs";
 import { join as join105 } from "node:path";
 function normalizeProvider(provider, model, runtimeProvider) {
@@ -67645,7 +67938,7 @@ async function recordTokenExchange(input) {
   const measurement = await measureTokenExchange(input);
   const db = await getDb4(input.cwd);
   const row = {
-    id: randomUUID7(),
+    id: randomUUID8(),
     provider: measurement.provider,
     model: measurement.model,
     transport: input.transport ?? "unknown",
@@ -68338,7 +68631,7 @@ async function validateAndRepairSequence(cwd, config2 = {}) {
     }
     const repair = await repairSequence(cwd);
     if (repair.repaired) {
-      log7.warn(
+      log8.warn(
         { oldCounter: repair.oldCounter, newCounter: repair.newCounter },
         "Sequence repaired"
       );
@@ -68367,7 +68660,7 @@ async function triggerCheckpoint(context, cwd, config2 = {}) {
   try {
     await gitCheckpoint("auto", context, cwd);
   } catch (err) {
-    log7.warn({ err }, "Checkpoint failed (non-fatal)");
+    log8.warn({ err }, "Checkpoint failed (non-fatal)");
   }
   vacuumIntoBackup({ cwd }).catch(() => {
   });
@@ -68405,16 +68698,16 @@ async function safeDeleteTask(deleteFn, taskId, cwd, config2 = {}) {
   return result;
 }
 async function forceCheckpointBeforeOperation(operation, cwd) {
-  log7.info({ operation }, "Forcing checkpoint before operation");
+  log8.info({ operation }, "Forcing checkpoint before operation");
   try {
     await gitCheckpoint("manual", `pre-${operation}`, cwd);
   } catch (err) {
-    log7.error({ err }, "Failed to create pre-operation checkpoint");
+    log8.error({ err }, "Failed to create pre-operation checkpoint");
   }
   vacuumIntoBackup({ cwd, force: true }).catch(() => {
   });
 }
-var log7, DEFAULT_CONFIG2, SafetyError;
+var log8, DEFAULT_CONFIG2, SafetyError;
 var init_data_safety = __esm({
   "packages/core/src/store/data-safety.ts"() {
     "use strict";
@@ -68424,7 +68717,7 @@ var init_data_safety = __esm({
     init_sqlite2();
     init_sqlite_backup();
     init_tasks_schema();
-    log7 = getLogger("data-safety");
+    log8 = getLogger("data-safety");
     DEFAULT_CONFIG2 = {
       verifyWrites: true,
       detectCollisions: true,
@@ -74283,6 +74576,7 @@ __export(internal_exports, {
   ensureProjectContext: () => ensureProjectContext,
   ensureSqliteDb: () => ensureSqliteDb,
   estimateContext: () => estimateContext,
+  executeTransfer: () => executeTransfer,
   exportSnapshot: () => exportSnapshot,
   exportTasks: () => exportTasks,
   exportTasksPackage: () => exportTasksPackage,
@@ -74409,6 +74703,7 @@ __export(internal_exports, {
   gradeSession: () => gradeSession,
   heartbeat: () => heartbeat,
   hooks: () => hooks,
+  importFromPackage: () => importFromPackage,
   importSnapshot: () => importSnapshot,
   importTasks: () => importTasks,
   importTasksPackage: () => importTasksPackage,
@@ -74552,6 +74847,7 @@ __export(internal_exports, {
   predictValidationOutcome: () => predictValidationOutcome,
   prepareRelease: () => prepareRelease,
   prepareSpawn: () => prepareSpawn,
+  previewTransfer: () => previewTransfer,
   protocolEnforcer: () => protocolEnforcer,
   pruneAuditLog: () => pruneAuditLog,
   pull: () => pull,
@@ -74842,6 +75138,7 @@ var init_internal = __esm({
     init_session_memory();
     init_discover();
     init_registry3();
+    init_transfer();
     init_analyze();
     init_critical_path();
     init_orchestration();
@@ -78461,10 +78758,10 @@ var StdioServerTransport = class {
 
 // packages/cleo/src/dispatch/adapters/mcp.ts
 init_src2();
-import { randomUUID as randomUUID9 } from "node:crypto";
+import { randomUUID as randomUUID10 } from "node:crypto";
 
 // packages/cleo/src/dispatch/lib/meta.ts
-import { randomUUID as randomUUID8 } from "node:crypto";
+import { randomUUID as randomUUID9 } from "node:crypto";
 function createDispatchMeta(gateway, domain2, operation, startTime, source = "mcp", requestId, sessionId) {
   return {
     gateway,
@@ -78473,7 +78770,7 @@ function createDispatchMeta(gateway, domain2, operation, startTime, source = "mc
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     duration_ms: Date.now() - startTime,
     source,
-    requestId: requestId ?? randomUUID8(),
+    requestId: requestId ?? randomUUID9(),
     ...sessionId != null && { sessionId }
   };
 }
@@ -81029,6 +81326,95 @@ var OPERATIONS = [
     requiredParams: []
   },
   // ---------------------------------------------------------------------------
+  // nexus.transfer — Cross-project task transfer (T046)
+  // ---------------------------------------------------------------------------
+  {
+    gateway: "query",
+    domain: "nexus",
+    operation: "transfer.preview",
+    description: "nexus.transfer.preview (query) \u2014 preview a cross-project task transfer",
+    tier: 2,
+    idempotent: true,
+    sessionRequired: false,
+    requiredParams: ["taskIds", "sourceProject", "targetProject"],
+    params: [
+      { name: "taskIds", type: "array", required: true, description: "Task IDs to transfer" },
+      {
+        name: "sourceProject",
+        type: "string",
+        required: true,
+        description: "Source project name or hash"
+      },
+      {
+        name: "targetProject",
+        type: "string",
+        required: true,
+        description: "Target project name or hash"
+      },
+      {
+        name: "mode",
+        type: "string",
+        required: false,
+        description: "Transfer mode: 'copy' (default) or 'move'"
+      },
+      {
+        name: "scope",
+        type: "string",
+        required: false,
+        description: "Transfer scope: 'subtree' (default) or 'single'"
+      }
+    ]
+  },
+  {
+    gateway: "mutate",
+    domain: "nexus",
+    operation: "transfer",
+    description: "nexus.transfer (mutate) \u2014 transfer tasks between NEXUS projects",
+    tier: 2,
+    idempotent: false,
+    sessionRequired: false,
+    requiredParams: ["taskIds", "sourceProject", "targetProject"],
+    params: [
+      { name: "taskIds", type: "array", required: true, description: "Task IDs to transfer" },
+      {
+        name: "sourceProject",
+        type: "string",
+        required: true,
+        description: "Source project name or hash"
+      },
+      {
+        name: "targetProject",
+        type: "string",
+        required: true,
+        description: "Target project name or hash"
+      },
+      {
+        name: "mode",
+        type: "string",
+        required: false,
+        description: "Transfer mode: 'copy' (default) or 'move'"
+      },
+      {
+        name: "scope",
+        type: "string",
+        required: false,
+        description: "Transfer scope: 'subtree' (default) or 'single'"
+      },
+      {
+        name: "onConflict",
+        type: "string",
+        required: false,
+        description: "Conflict strategy: 'rename' (default), 'skip', 'duplicate', 'fail'"
+      },
+      {
+        name: "transferBrain",
+        type: "boolean",
+        required: false,
+        description: "Whether to transfer brain observations (default: false)"
+      }
+    ]
+  },
+  // ---------------------------------------------------------------------------
   // sticky — Ephemeral notes for quick capture (T5282)
   // ---------------------------------------------------------------------------
   // Query operations
@@ -86584,6 +86970,22 @@ async function nexusShareSnapshotImport(projectRoot, inputPath) {
     return engineError("E_INTERNAL", error40 instanceof Error ? error40.message : String(error40));
   }
 }
+async function nexusTransferPreview(params) {
+  try {
+    const result = await previewTransfer(params);
+    return engineSuccess(result);
+  } catch (error40) {
+    return engineError("E_INTERNAL", error40 instanceof Error ? error40.message : String(error40));
+  }
+}
+async function nexusTransferExecute(params) {
+  try {
+    const result = await executeTransfer(params);
+    return engineSuccess(result);
+  } catch (error40) {
+    return engineError("E_INTERNAL", error40 instanceof Error ? error40.message : String(error40));
+  }
+}
 
 // packages/cleo/src/dispatch/domains/nexus.ts
 var NexusHandler = class {
@@ -86745,6 +87147,29 @@ var NexusHandler = class {
           const result = await nexusShareStatus(this.projectRoot);
           return wrapResult(result, "query", "nexus", "share.status", startTime);
         }
+        case "transfer.preview": {
+          const taskIds = params?.taskIds;
+          const sourceProject = params?.sourceProject;
+          const targetProject = params?.targetProject;
+          if (!taskIds?.length || !sourceProject || !targetProject) {
+            return errorResult(
+              "query",
+              "nexus",
+              operation,
+              "E_INVALID_INPUT",
+              "taskIds, sourceProject, and targetProject are required",
+              startTime
+            );
+          }
+          const result = await nexusTransferPreview({
+            taskIds,
+            sourceProject,
+            targetProject,
+            mode: params?.mode ?? "copy",
+            scope: params?.scope ?? "subtree"
+          });
+          return wrapResult(result, "query", "nexus", operation, startTime);
+        }
         default:
           return unsupportedOp("query", "nexus", operation, startTime);
       }
@@ -86867,6 +87292,31 @@ var NexusHandler = class {
           const result = await nexusShareSnapshotImport(this.projectRoot, inputPath);
           return wrapResult(result, "mutate", "nexus", "share.snapshot.import", startTime);
         }
+        case "transfer": {
+          const taskIds = params?.taskIds;
+          const sourceProject = params?.sourceProject;
+          const targetProject = params?.targetProject;
+          if (!taskIds?.length || !sourceProject || !targetProject) {
+            return errorResult(
+              "mutate",
+              "nexus",
+              operation,
+              "E_INVALID_INPUT",
+              "taskIds, sourceProject, and targetProject are required",
+              startTime
+            );
+          }
+          const result = await nexusTransferExecute({
+            taskIds,
+            sourceProject,
+            targetProject,
+            mode: params?.mode ?? "copy",
+            scope: params?.scope ?? "subtree",
+            onConflict: params?.onConflict ?? "rename",
+            transferBrain: params?.transferBrain ?? false
+          });
+          return wrapResult(result, "mutate", "nexus", operation, startTime);
+        }
         default:
           return unsupportedOp("mutate", "nexus", operation, startTime);
       }
@@ -86895,7 +87345,8 @@ var NexusHandler = class {
         "blockers.show",
         "orphans.list",
         "discover",
-        "search"
+        "search",
+        "transfer.preview"
       ],
       mutate: [
         "share.snapshot.export",
@@ -86905,7 +87356,8 @@ var NexusHandler = class {
         "unregister",
         "sync",
         "permission.set",
-        "reconcile"
+        "reconcile",
+        "transfer"
       ]
     };
   }
@@ -90362,7 +90814,7 @@ function getConfig() {
 
 // packages/cleo/src/dispatch/middleware/audit.ts
 init_internal();
-var log8 = getLogger("audit");
+var log9 = getLogger("audit");
 var cachedProjectHash;
 function resolveProjectHash() {
   if (cachedProjectHash !== void 0) return cachedProjectHash;
@@ -90393,9 +90845,9 @@ async function writeToSqlite(entry, requestId) {
     const { getDb: getDb4 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
     const { auditLog: auditLog2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
     const { AuditLogInsertSchema: AuditLogInsertSchema2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
-    const { randomUUID: randomUUID11 } = await import("node:crypto");
+    const { randomUUID: randomUUID12 } = await import("node:crypto");
     const payload = {
-      id: randomUUID11(),
+      id: randomUUID12(),
       timestamp: entry.timestamp,
       action: entry.operation,
       taskId: entry.metadata.taskId ?? "system",
@@ -90416,7 +90868,7 @@ async function writeToSqlite(entry, requestId) {
     };
     const parsed = AuditLogInsertSchema2.safeParse(payload);
     if (!parsed.success) {
-      log8.warn(
+      log9.warn(
         { issues: parsed.error.issues },
         "Audit payload failed Zod validation; skipping insert"
       );
@@ -90425,7 +90877,7 @@ async function writeToSqlite(entry, requestId) {
     const db = await getDb4(process.cwd());
     await db.insert(auditLog2).values(parsed.data).run();
   } catch (err) {
-    log8.warn({ err }, "Failed to write audit entry to SQLite");
+    log9.warn({ err }, "Failed to write audit entry to SQLite");
   }
 }
 function createAudit() {
@@ -90456,7 +90908,7 @@ function createAudit() {
       },
       error: response.error?.message
     };
-    log8.info(
+    log9.info(
       {
         domain: entry.domain,
         operation: entry.operation,
@@ -90473,7 +90925,7 @@ function createAudit() {
       await writeToSqlite(entry, req.requestId);
     } else {
       writeToSqlite(entry, req.requestId).catch((err) => {
-        log8.error({ err }, "Failed to persist audit entry to SQLite");
+        log9.error({ err }, "Failed to persist audit entry to SQLite");
       });
     }
     return response;
@@ -90954,7 +91406,7 @@ async function handleMcpToolCall(gateway, domain2, operation, params, requestId)
     operation,
     params,
     source: "mcp",
-    requestId: requestId || randomUUID9()
+    requestId: requestId || randomUUID10()
   };
   return dispatcher.dispatch(req);
 }
@@ -91045,7 +91497,7 @@ function registerQueryTool() {
 }
 
 // packages/cleo/src/mcp/lib/background-jobs.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 var BackgroundJobManager = class {
   jobs;
   abortControllers;
@@ -91078,7 +91530,7 @@ var BackgroundJobManager = class {
         `Maximum concurrent jobs reached (${this.maxJobs}). Cancel or wait for existing jobs to complete.`
       );
     }
-    const jobId = randomUUID10();
+    const jobId = randomUUID11();
     const abortController = new AbortController();
     const job = {
       id: jobId,
@@ -91770,30 +92222,30 @@ async function main() {
       projectInfo?.projectHash
     );
     startupLog = getLogger("mcp:startup");
-    const log9 = startupLog;
+    const log10 = startupLog;
     const cleoVersion = getCleoVersion();
-    log9.info(
+    log10.info(
       { version: cleoVersion, projectHash: projectInfo?.projectHash, logLevel: config2.logLevel },
       "CLEO MCP server starting"
     );
-    log9.info(
+    log10.info(
       { enableMetrics: config2.enableMetrics },
       `Metrics: ${config2.enableMetrics ? "enabled" : "disabled"}`
     );
     Promise.resolve().then(() => (init_internal(), internal_exports)).then(
       ({ loadConfig: loadCoreConfig }) => loadCoreConfig().then((coreConfig) => pruneAuditLog(cleoDir, coreConfig.logging))
-    ).catch((err) => log9.warn({ err }, "audit log pruning failed"));
-    log9.info("Initializing dispatch layer");
+    ).catch((err) => log10.warn({ err }, "audit log pruning failed"));
+    log10.info("Initializing dispatch layer");
     initMcpDispatcher({
       rateLimiting: config2.rateLimiting,
       strictMode: true
     });
-    log9.info("Dispatch layer initialized");
+    log10.info("Dispatch layer initialized");
     const jobManager = new BackgroundJobManager({ maxJobs: 10, retentionMs: 36e5 });
     setJobManager(jobManager);
-    log9.info({ maxJobs: 10, retentionMs: 36e5 }, "Background job manager initialized");
+    log10.info({ maxJobs: 10, retentionMs: 36e5 }, "Background job manager initialized");
     const cache = new QueryCache(config2.queryCacheTtl, config2.queryCache);
-    log9.info(
+    log10.info(
       { enabled: config2.queryCache, ttlMs: config2.queryCacheTtl },
       `Query cache: ${config2.queryCache ? "enabled" : "disabled"}`
     );
@@ -91810,7 +92262,7 @@ async function main() {
       }
     );
     registerMemoryResources(server);
-    log9.info("Memory resources registered");
+    log10.info("Memory resources registered");
     server.setRequestHandler(ListToolsRequestSchema, async () => {
       return {
         tools: [registerQueryTool(), registerMutateTool()]
@@ -92005,11 +92457,11 @@ async function main() {
       cache,
       jobManager
     };
-    log9.info("Connecting to stdio transport");
+    log10.info("Connecting to stdio transport");
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    log9.info({ transport: "stdio" }, "Server started successfully");
-    log9.info("Ready for requests");
+    log10.info({ transport: "stdio" }, "Server started successfully");
+    log10.info("Ready for requests");
   } catch (error40) {
     startupLog.fatal({ err: error40 }, "Failed to start server");
     process.exit(1);