@cleocode/cleo 2026.5.81 → 2026.5.82

package/dist/cli/index.js

@@ -16086,10 +16086,11 @@ var init_check = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/conduit.ts
+import { getProjectRoot as getProjectRoot4 } from "@cleocode/core";
 async function _resolveCredential(agentId) {
   const { AgentRegistryAccessor, getDb: getDb3 } = await import("@cleocode/core/internal");
   await getDb3();
-  const registry = new AgentRegistryAccessor(process.cwd());
+  const registry = new AgentRegistryAccessor(getProjectRoot4());
   const credential = agentId ? await registry.get(agentId) : await registry.getActive();
   if (!credential) {
     throw new Error(
@@ -16102,7 +16103,7 @@ async function getStatusImpl(agentId) {
   const credential = await _resolveCredential(agentId);
   const pollerRunning = activePoller !== null && activeAgentId === credential.agentId;
   const { LocalTransport } = await import("@cleocode/core/conduit");
-  if (LocalTransport.isAvailable(process.cwd())) {
+  if (LocalTransport.isAvailable(getProjectRoot4())) {
     const transport = new LocalTransport();
     await transport.connect({
       agentId: credential.agentId,
@@ -16160,7 +16161,7 @@ async function getStatusImpl(agentId) {
 async function peekImpl(agentId, limit) {
   const credential = await _resolveCredential(agentId);
   const { LocalTransport } = await import("@cleocode/core/conduit");
-  if (LocalTransport.isAvailable(process.cwd())) {
+  if (LocalTransport.isAvailable(getProjectRoot4())) {
     const transport = new LocalTransport();
     await transport.connect({
       agentId: credential.agentId,
@@ -16232,7 +16233,7 @@ async function startPollingImpl(agentId, pollIntervalMs, groupConversationIds) {
   const { LocalTransport } = await import("@cleocode/core/conduit");
   let transport;
   let transportName = "http";
-  if (LocalTransport.isAvailable(process.cwd())) {
+  if (LocalTransport.isAvailable(getProjectRoot4())) {
     const local = new LocalTransport();
     await local.connect({
       agentId: credential.agentId,
@@ -16291,7 +16292,7 @@ async function subscribeTopicImpl(topicName, agentId, _filter) {
   }
   const credential = await _resolveCredential(agentId);
   const { LocalTransport } = await import("@cleocode/core/conduit");
-  if (!LocalTransport.isAvailable(process.cwd())) {
+  if (!LocalTransport.isAvailable(getProjectRoot4())) {
     return {
       success: false,
       error: { code: "E_CONDUIT", message: "conduit.db not found \u2014 run: cleo init" }
@@ -16332,7 +16333,7 @@ async function publishToTopicImpl(topicName, content, kind, payload, agentId) {
   }
   const credential = await _resolveCredential(agentId);
   const { LocalTransport } = await import("@cleocode/core/conduit");
-  if (!LocalTransport.isAvailable(process.cwd())) {
+  if (!LocalTransport.isAvailable(getProjectRoot4())) {
     return {
       success: false,
       error: { code: "E_CONDUIT", message: "conduit.db not found \u2014 run: cleo init" }
@@ -16370,7 +16371,7 @@ async function listenTopicImpl(topicName, agentId, limit, since) {
   const startMs = Date.now();
   const credential = await _resolveCredential(agentId);
   const { LocalTransport } = await import("@cleocode/core/conduit");
-  if (!LocalTransport.isAvailable(process.cwd())) {
+  if (!LocalTransport.isAvailable(getProjectRoot4())) {
     return {
       success: false,
       error: { code: "E_CONDUIT", message: "conduit.db not found \u2014 run: cleo init" }
@@ -16415,7 +16416,7 @@ async function sendMessageImpl(content, to, conversationId, agentId) {
   }
   const credential = await _resolveCredential(agentId);
   const { LocalTransport } = await import("@cleocode/core/conduit");
-  if (LocalTransport.isAvailable(process.cwd())) {
+  if (LocalTransport.isAvailable(getProjectRoot4())) {
     const transport = new LocalTransport();
     await transport.connect({
       agentId: credential.agentId,
@@ -16669,7 +16670,7 @@ import {
   createAttachmentStoreV2,
   generateDocsLlmsTxt,
   getCleoDirAbsolute,
-  getProjectRoot as getProjectRoot4,
+  getProjectRoot as getProjectRoot5,
   resolveAttachmentBackend
 } from "@cleocode/core/internal";
 function inferOwnerType(ownerId) {
@@ -16782,7 +16783,7 @@ var init_docs2 = __esm({
         if (!forId) {
           return lafsError("E_INVALID_INPUT", "--for <taskId|epicId> is required", "generate");
         }
-        const cwd = getProjectRoot4();
+        const cwd = getProjectRoot5();
         const result = await generateDocsLlmsTxt({ ownerId: forId, cwd });
         let attachmentId;
         let attachmentSha256;
@@ -16848,7 +16849,7 @@ var init_docs2 = __esm({
         if (!fetchResult || !metadata) {
           return lafsError("E_NOT_FOUND", `Attachment not found: ${ref}`, "fetch");
         }
-        const cwd = getProjectRoot4();
+        const cwd = getProjectRoot5();
         const cleoDir = getCleoDirAbsolute(cwd);
         let storagePath;
         if (metadata.attachment.kind === "local-file") {
@@ -16938,7 +16939,7 @@ var init_docs2 = __esm({
           const meta = await store.put(bytes, attachment, ownerType, ownerId, attachedBy);
           let backend = "legacy";
           try {
-            const v2 = createAttachmentStoreV2(getProjectRoot4());
+            const v2 = createAttachmentStoreV2(getProjectRoot5());
             const v2Result = await v2.put(ownerId, {
               name: absPath.split(/[\\/]/).pop() ?? meta.sha256.slice(0, 12),
               data: new Uint8Array(bytes),
@@ -16950,7 +16951,7 @@ var init_docs2 = __esm({
           }
           import("@cleocode/core/internal").then(
             ({ ensureLlmtxtNode }) => ensureLlmtxtNode(
-              getProjectRoot4(),
+              getProjectRoot5(),
               meta.sha256,
               `${ownerType}:${ownerId}`,
               absPath.split("/").pop() ?? meta.sha256.slice(0, 12)
@@ -16981,7 +16982,7 @@ var init_docs2 = __esm({
           const urlBytes = Buffer.from(url, "utf-8");
           const meta = await store.put(urlBytes, attachment, ownerType, ownerId, attachedBy);
           import("@cleocode/core/internal").then(
-            ({ ensureLlmtxtNode }) => ensureLlmtxtNode(getProjectRoot4(), meta.sha256, `${ownerType}:${ownerId}`, url)
+            ({ ensureLlmtxtNode }) => ensureLlmtxtNode(getProjectRoot5(), meta.sha256, `${ownerType}:${ownerId}`, url)
           ).catch(() => {
           });
           const backend = "legacy";
@@ -17036,7 +17037,7 @@ var init_docs2 = __esm({
         const blobPurged = derefResult.status === "removed";
         const refCountAfter = derefResult.status === "derefd" ? derefResult.refCountAfter : 0;
         try {
-          const v2 = createAttachmentStoreV2(getProjectRoot4());
+          const v2 = createAttachmentStoreV2(getProjectRoot5());
           await v2.remove(attachmentId, fromOwner);
         } catch {
         }
@@ -17123,7 +17124,7 @@ var init_docs2 = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/intelligence.ts
-import { getLogger as getLogger5, getProjectRoot as getProjectRoot5, getTaskAccessor as getTaskAccessor2 } from "@cleocode/core";
+import { getLogger as getLogger5, getProjectRoot as getProjectRoot6, getTaskAccessor as getTaskAccessor2 } from "@cleocode/core";
 import {
   calculateTaskRisk,
   extractPatternsFromHistory,
@@ -17143,7 +17144,7 @@ var init_intelligence2 = __esm({
       // Query
       // -----------------------------------------------------------------------
       async query(operation, params) {
-        const projectRoot = getProjectRoot5();
+        const projectRoot = getProjectRoot6();
         const startTime = Date.now();
         try {
           switch (operation) {
@@ -17447,7 +17448,7 @@ var init_llm2 = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/memory.ts
-import { getLogger as getLogger6, getProjectRoot as getProjectRoot6 } from "@cleocode/core";
+import { getLogger as getLogger6, getProjectRoot as getProjectRoot7 } from "@cleocode/core";
 import {
   generateMemoryBridgeContent,
   getBrainDb,
@@ -17475,7 +17476,7 @@ var init_memory2 = __esm({
       // Query
       // -----------------------------------------------------------------------
       async query(operation, params) {
-        const projectRoot = getProjectRoot6();
+        const projectRoot = getProjectRoot7();
         const startTime = Date.now();
         try {
           switch (operation) {
@@ -18582,7 +18583,7 @@ var init_memory2 = __esm({
       // Mutate
       // -----------------------------------------------------------------------
       async mutate(operation, params) {
-        const projectRoot = getProjectRoot6();
+        const projectRoot = getProjectRoot7();
         const startTime = Date.now();
         try {
           switch (operation) {
@@ -19231,7 +19232,7 @@ import {
   getBrainNativeDb as getBrainNativeDb2,
   getLogger as getLogger7,
   getNexusNativeDb,
-  getProjectRoot as getProjectRoot7,
+  getProjectRoot as getProjectRoot8,
   nexusAugment,
   nexusBlockers,
   nexusBrainAnchors,
@@ -19503,7 +19504,7 @@ async function handleImpact(operation, params, startTime) {
     5
   );
   const projectIdParam = params?.projectId;
-  const projectId = projectIdParam ?? Buffer.from(process.cwd()).toString("base64url").slice(0, 32);
+  const projectId = projectIdParam ?? Buffer.from(getProjectRoot8()).toString("base64url").slice(0, 32);
   try {
     const { getNexusDb } = await import("@cleocode/core/store/nexus-sqlite");
     await getNexusDb();
@@ -19764,7 +19765,7 @@ var init_nexus3 = __esm({
         return wrapCoreResult(await nexusAugment(params.pattern, params.limit ?? 5), "augment");
       },
       "share.status": async (_params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         return wrapCoreResult(await nexusShareStatus(projectRoot), "share.status");
       },
       "transfer.preview": async (params) => {
@@ -19800,39 +19801,39 @@ var init_nexus3 = __esm({
       },
       "full-context": async (params) => {
         if (!params.symbol) return lafsError("E_INVALID_INPUT", "symbol is required", "full-context");
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         return wrapCoreResult(await nexusFullContext(params.symbol, projectRoot), "full-context");
       },
       "task-footprint": async (params) => {
         if (!params.taskId) return lafsError("E_INVALID_INPUT", "taskId is required", "task-footprint");
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         return wrapCoreResult(await nexusTaskFootprint(params.taskId, projectRoot), "task-footprint");
       },
       "brain-anchors": async (params) => {
         if (!params.entryId)
           return lafsError("E_INVALID_INPUT", "entryId is required", "brain-anchors");
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         return wrapCoreResult(await nexusBrainAnchors(params.entryId, projectRoot), "brain-anchors");
       },
       why: async (params) => {
         if (!params.symbol) return lafsError("E_INVALID_INPUT", "symbol is required", "why");
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         return wrapCoreResult(await nexusWhy(params.symbol, projectRoot), "why");
       },
       "impact-full": async (params) => {
         if (!params.symbol) return lafsError("E_INVALID_INPUT", "symbol is required", "impact-full");
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         return wrapCoreResult(await nexusImpactFull(params.symbol, projectRoot), "impact-full");
       },
       "route-map": async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const projectId = params.projectId ?? Buffer.from(projectRoot).toString("base64url").slice(0, 32);
         return wrapCoreResult(await nexusRouteMap(projectId, projectRoot), "route-map");
       },
       "shape-check": async (params) => {
         if (!params.routeSymbol)
           return lafsError("E_INVALID_INPUT", "routeSymbol is required", "shape-check");
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const projectId = params.projectId ?? Buffer.from(projectRoot).toString("base64url").slice(0, 32);
         return wrapCoreResult(
           await nexusShapeCheck(params.routeSymbol, projectId, projectRoot),
@@ -19844,7 +19845,7 @@ var init_nexus3 = __esm({
         return wrapCoreResult(await nexusSearchCode(params.pattern, params.limit ?? 10), "search-code");
       },
       wiki: async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const outputDir = params.outputDir ?? `${projectRoot}/.cleo/wiki`;
         return wrapCoreResult(
           await nexusWiki(outputDir, projectRoot, {
@@ -19857,7 +19858,7 @@ var init_nexus3 = __esm({
       "contracts-show": async (params) => {
         if (!params.projectA || !params.projectB)
           return lafsError("E_INVALID_INPUT", "projectA and projectB are required", "contracts-show");
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         return wrapCoreResult(
           await nexusContractsShow(params.projectA, params.projectB, projectRoot),
           "contracts-show"
@@ -19865,7 +19866,7 @@ var init_nexus3 = __esm({
       },
       "task-symbols": async (params) => {
         if (!params.taskId) return lafsError("E_INVALID_INPUT", "taskId is required", "task-symbols");
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         return wrapCoreResult(await nexusTaskSymbols(params.taskId, projectRoot), "task-symbols");
       },
       "profile.view": async (params) => wrapCoreResult(
@@ -19880,20 +19881,20 @@ var init_nexus3 = __esm({
       "sigil.list": async (params) => wrapCoreResult(await nexusSigilList(params.role), "sigil.list"),
       // T1510 — Phase 2 query ops
       clusters: async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const repoPath = params.repoPath ?? projectRoot;
         const projectId = params.projectId ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         return wrapCoreResult(await nexusClusters(projectId, repoPath), "clusters");
       },
       flows: async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const repoPath = params.repoPath ?? projectRoot;
         const projectId = params.projectId ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         return wrapCoreResult(await nexusFlows(projectId, repoPath), "flows");
       },
       context: async (params) => {
         if (!params.symbol) return lafsError("E_INVALID_INPUT", "symbol is required", "context");
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const projectId = params.projectId ?? Buffer.from(projectRoot).toString("base64url").slice(0, 32);
         const limit = typeof params.limit === "number" ? params.limit : 20;
         const showContent = params.content === true;
@@ -19942,13 +19943,13 @@ var init_nexus3 = __esm({
         "projects.clean"
       ),
       "refresh-bridge": async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const repoPath = params.repoPath ?? projectRoot;
         const projectId = params.projectId;
         return wrapCoreResult(await nexusRefreshBridge(repoPath, projectId), "refresh-bridge");
       },
       diff: async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const repoPath = params.repoPath ?? projectRoot;
         return wrapCoreResult(
           await nexusDiff(
@@ -19968,17 +19969,17 @@ var init_nexus3 = __esm({
         );
       },
       "hot-paths": async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const limit = typeof params.limit === "number" ? params.limit : 20;
         return wrapCoreResult(await nexusHotPaths(projectRoot, limit), "hot-paths");
       },
       "hot-nodes": async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const limit = typeof params.limit === "number" ? params.limit : 20;
         return wrapCoreResult(await nexusHotNodes(projectRoot, limit), "hot-nodes");
       },
       "cold-symbols": async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const days = typeof params.days === "number" ? params.days : 30;
         return wrapCoreResult(await nexusColdSymbols(projectRoot, days), "cold-symbols");
       },
@@ -20013,9 +20014,12 @@ var init_nexus3 = __esm({
           "permission.set"
         );
       },
-      reconcile: async (params) => wrapCoreResult(await nexusReconcileProject(params.projectRoot ?? process.cwd()), "reconcile"),
+      reconcile: async (params) => wrapCoreResult(
+        await nexusReconcileProject(params.projectRoot ?? getProjectRoot8()),
+        "reconcile"
+      ),
       "share.snapshot.export": async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         return wrapCoreResult(
           await nexusShareSnapshotExport(projectRoot, params.outputPath),
           "share.snapshot.export"
@@ -20024,7 +20028,7 @@ var init_nexus3 = __esm({
       "share.snapshot.import": async (params) => {
         if (!params.inputPath)
           return lafsError("E_INVALID_INPUT", "inputPath is required", "share.snapshot.import");
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         return wrapCoreResult(
           await nexusShareSnapshotImport(projectRoot, params.inputPath),
           "share.snapshot.import"
@@ -20052,13 +20056,13 @@ var init_nexus3 = __esm({
         );
       },
       "contracts-sync": async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const repoPath = params.repoPath ?? projectRoot;
         const projectId = params.projectId ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         return wrapCoreResult(await nexusContractsSync(projectId, repoPath), "contracts-sync");
       },
       "contracts-link-tasks": async (params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         const repoPath = params.repoPath ?? projectRoot;
         const projectId = params.projectId ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         return wrapCoreResult(
@@ -20067,7 +20071,7 @@ var init_nexus3 = __esm({
         );
       },
       "conduit-scan": async (_params) => {
-        const projectRoot = getProjectRoot7();
+        const projectRoot = getProjectRoot8();
         return wrapCoreResult(await nexusConduitScan(projectRoot), "conduit-scan");
       },
       "profile.import": async (params) => wrapCoreResult(await nexusProfileImport(params.path), "profile.import"),
@@ -20271,7 +20275,7 @@ import {
   extractTypedGates,
   getIvtrState,
   getLogger as getLogger8,
-  getProjectRoot as getProjectRoot8,
+  getProjectRoot as getProjectRoot9,
   getTask,
   loopBackIvtr,
   releaseIvtr,
@@ -20287,7 +20291,7 @@ function extractEvidenceFromRaw(raw) {
   return [];
 }
 async function ivtrStatusOp(params) {
-  const cwd = getProjectRoot8();
+  const cwd = getProjectRoot9();
   const state = await getIvtrState(params.taskId, { cwd });
   if (!state) {
     return engineSuccess2({
@@ -20317,7 +20321,7 @@ async function ivtrStatusOp(params) {
   });
 }
 async function ivtrStartOp(params) {
-  const cwd = getProjectRoot8();
+  const cwd = getProjectRoot9();
   const task = await getTask(params.taskId, cwd);
   if (!task) {
     return engineError2("E_NOT_FOUND", `Task ${params.taskId} not found`);
@@ -20338,7 +20342,7 @@ async function ivtrStartOp(params) {
   });
 }
 async function ivtrNextOp(params) {
-  const cwd = getProjectRoot8();
+  const cwd = getProjectRoot9();
   const task = await getTask(params.taskId, cwd);
   if (!task) {
     return engineError2("E_NOT_FOUND", `Task ${params.taskId} not found`);
@@ -20389,7 +20393,7 @@ async function ivtrNextOp(params) {
   });
 }
 async function ivtrReleaseOp(params) {
-  const cwd = getProjectRoot8();
+  const cwd = getProjectRoot9();
   const result = await releaseIvtr(params.taskId, { cwd });
   if (!result.released) {
     return {
@@ -20426,7 +20430,7 @@ async function ivtrReleaseOp(params) {
   };
 }
 async function ivtrLoopBackOp(params) {
-  const cwd = getProjectRoot8();
+  const cwd = getProjectRoot9();
   if (!isLoopBackTarget(params.phase)) {
     return {
       success: false,
@@ -24992,8 +24996,8 @@ async function loadPlaybookByName(name) {
     return null;
   }
   try {
-    const { getProjectRoot: getProjectRoot38 } = await import("@cleocode/core/internal");
-    const projectRoot = __playbookRuntimeOverrides.projectRoot ?? getProjectRoot38();
+    const { getProjectRoot: getProjectRoot41 } = await import("@cleocode/core/internal");
+    const projectRoot = __playbookRuntimeOverrides.projectRoot ?? getProjectRoot41();
     const resolved = resolvePlaybook(name, {
       projectRoot,
       globalPlaybooksDir: __playbookRuntimeOverrides.globalPlaybooksDir,
@@ -25037,8 +25041,8 @@ async function acquireDb() {
 async function buildDefaultDispatcher() {
   if (__playbookRuntimeOverrides.dispatcher) return __playbookRuntimeOverrides.dispatcher;
   const { orchestrateSpawnExecute: orchestrateSpawnExecute2 } = await Promise.resolve().then(() => (init_engine(), engine_exports));
-  const { getProjectRoot: getProjectRoot38 } = await import("@cleocode/core/internal");
-  const projectRoot = getProjectRoot38();
+  const { getProjectRoot: getProjectRoot41 } = await import("@cleocode/core/internal");
+  const projectRoot = getProjectRoot41();
   return {
     async dispatch(input2) {
       try {
@@ -25228,8 +25232,8 @@ var init_playbook2 = __esm({
             projectRoot = __playbookRuntimeOverrides.projectRoot;
           } else {
             try {
-              const { getProjectRoot: getProjectRoot38 } = await import("@cleocode/core/internal");
-              projectRoot = getProjectRoot38();
+              const { getProjectRoot: getProjectRoot41 } = await import("@cleocode/core/internal");
+              projectRoot = getProjectRoot41();
             } catch {
               projectRoot = void 0;
             }
@@ -25293,14 +25297,14 @@ var init_playbook2 = __esm({
         const dispatcher = await buildDefaultDispatcher();
         let result;
         try {
-          const { getProjectRoot: getProjectRoot38 } = await import("@cleocode/core/internal");
+          const { getProjectRoot: getProjectRoot41 } = await import("@cleocode/core/internal");
           const opts = {
             db,
             playbook: parsed.definition,
             playbookHash: parsed.sourceHash,
             initialContext,
             dispatcher,
-            projectRoot: getProjectRoot38()
+            projectRoot: getProjectRoot41()
           };
           if (__playbookRuntimeOverrides.approvalSecret !== void 0) {
             opts.approvalSecret = __playbookRuntimeOverrides.approvalSecret;
@@ -25482,7 +25486,7 @@ var init_playbook2 = __esm({
 // packages/cleo/src/dispatch/domains/orchestrate.ts
 import {
   getLogger as getLogger9,
-  getProjectRoot as getProjectRoot9,
+  getProjectRoot as getProjectRoot10,
   instantiateTessera,
   listTesseraTemplates,
   paginate as paginate2,
@@ -25496,24 +25500,24 @@ function evictFanoutManifest() {
   }
 }
 async function orchestrateStatusOp(params) {
-  return orchestrateStatus(params.epicId, getProjectRoot9());
+  return orchestrateStatus(params.epicId, getProjectRoot10());
 }
 async function orchestrateNextOp(params) {
-  return orchestrateNext(params.epicId, getProjectRoot9());
+  return orchestrateNext(params.epicId, getProjectRoot10());
 }
 async function orchestrateReadyOp(params) {
-  return orchestrateReady(params.epicId, getProjectRoot9(), {
+  return orchestrateReady(params.epicId, getProjectRoot10(), {
     ignoreDepsValidate: params.ignoreDepsValidate
   });
 }
 async function orchestrateAnalyzeOp(params) {
   if (params.mode === "parallel-safety") {
-    return orchestrateAnalyzeParallelSafety(params.taskIds ?? [], getProjectRoot9());
+    return orchestrateAnalyzeParallelSafety(params.taskIds ?? [], getProjectRoot10());
   }
-  return orchestrateAnalyze(params.epicId, getProjectRoot9(), params.mode);
+  return orchestrateAnalyze(params.epicId, getProjectRoot10(), params.mode);
 }
 async function orchestrateClassifyOp(params) {
-  return orchestrateClassify(params.request, params.context, getProjectRoot9());
+  return orchestrateClassify(params.request, params.context, getProjectRoot10());
 }
 function orchestrateFanoutStatusOp(params) {
   const entry = fanoutManifestStore.get(params.manifestEntryId);
@@ -25546,23 +25550,23 @@ function orchestrateFanoutStatusOp(params) {
   });
 }
 async function orchestrateContextOp(params) {
-  return orchestrateContext(params.epicId, getProjectRoot9());
+  return orchestrateContext(params.epicId, getProjectRoot10());
 }
 async function orchestrateWavesOp(params) {
-  return orchestrateWaves(params.epicId, getProjectRoot9());
+  return orchestrateWaves(params.epicId, getProjectRoot10());
 }
 async function orchestratePlanOp(params) {
   return orchestratePlan({
     epicId: params.epicId,
-    projectRoot: getProjectRoot9(),
+    projectRoot: getProjectRoot10(),
     preferTier: params.preferTier
   });
 }
 async function orchestrateBootstrapOp(params) {
-  return orchestrateBootstrap(getProjectRoot9(), { speed: params.speed });
+  return orchestrateBootstrap(getProjectRoot10(), { speed: params.speed });
 }
 async function orchestrateUnblockOp(_params) {
-  return orchestrateUnblockOpportunities(getProjectRoot9());
+  return orchestrateUnblockOpportunities(getProjectRoot10());
 }
 async function orchestrateTesseraListOp(params) {
   return Promise.resolve({ success: true, data: params });
@@ -25574,13 +25578,13 @@ async function orchestratePendingOp(_params) {
   return Promise.resolve({ success: true, data: {} });
 }
 async function orchestrateStartOp(params) {
-  return orchestrateStartup(params.epicId, getProjectRoot9());
+  return orchestrateStartup(params.epicId, getProjectRoot10());
 }
 async function orchestrateSpawnOp(params) {
   return orchestrateSpawn(
     params.taskId,
     params.protocolType,
-    getProjectRoot9(),
+    getProjectRoot10(),
     params.tier,
     params.noWorktree
   );
@@ -25598,7 +25602,7 @@ async function orchestrateHandoffOp(params) {
     },
     // Inject cleo session ops to avoid core→cleo import cycle (T1570 ADR-057)
     { sessionStatus, sessionEnd, sessionContextInject },
-    getProjectRoot9()
+    getProjectRoot10()
   );
 }
 async function orchestrateSpawnExecuteOp(params) {
@@ -25606,19 +25610,19 @@ async function orchestrateSpawnExecuteOp(params) {
     params.taskId,
     params.adapterId,
     params.protocolType,
-    getProjectRoot9(),
+    getProjectRoot10(),
     params.tier
   );
 }
 async function orchestrateValidateOp(params) {
-  return orchestrateValidate(params.taskId, getProjectRoot9());
+  return orchestrateValidate(params.taskId, getProjectRoot10());
 }
 async function orchestratePivotOp(params) {
   try {
     const result = await pivotTask(params.fromTaskId, params.toTaskId, {
       reason: params.reason,
       blocksFrom: params.blocksFrom,
-      projectRoot: getProjectRoot9()
+      projectRoot: getProjectRoot10()
     });
     return { success: true, data: result };
   } catch (err) {
@@ -25636,19 +25640,19 @@ async function orchestratePivotOp(params) {
   }
 }
 async function orchestrateWorktreeCompleteOp(params) {
-  return handleWorktreeComplete(params.taskId, getProjectRoot9(), params.resolve);
+  return handleWorktreeComplete(params.taskId, getProjectRoot10(), params.resolve);
 }
 async function orchestrateWorktreeCleanupOp(params) {
-  return handleWorktreeCleanup(getProjectRoot9(), params.taskIds);
+  return handleWorktreeCleanup(getProjectRoot10(), params.taskIds);
 }
 async function orchestrateWorktreePruneOp(params) {
-  return handleWorktreePrune(getProjectRoot9(), params.taskId);
+  return handleWorktreePrune(getProjectRoot10(), params.taskId);
 }
 async function orchestrateParallelOp(params) {
   return Promise.resolve({ success: true, data: params });
 }
 async function orchestrateFanoutOp(params) {
-  return orchestrateFanoutImpl(params.items, getProjectRoot9());
+  return orchestrateFanoutImpl(params.items, getProjectRoot10());
 }
 async function orchestrateTesseraInstantiateOp(params) {
   return Promise.resolve({ success: true, data: params });
@@ -26616,7 +26620,7 @@ var init_orchestrate2 = __esm({
                       startTime
                     );
                   return wrapResult(
-                    await orchestrateParallelStart(epicId, wave, getProjectRoot9()),
+                    await orchestrateParallelStart(epicId, wave, getProjectRoot10()),
                     "mutate",
                     "orchestrate",
                     "parallel",
@@ -26645,7 +26649,7 @@ var init_orchestrate2 = __esm({
                       startTime
                     );
                   return wrapResult(
-                    await orchestrateParallelEnd(epicId, wave, getProjectRoot9()),
+                    await orchestrateParallelEnd(epicId, wave, getProjectRoot10()),
                     "mutate",
                     "orchestrate",
                     "parallel",
@@ -26712,7 +26716,7 @@ var init_orchestrate2 = __esm({
                   epicId,
                   variables: { epicId, ...variables }
                 },
-                getProjectRoot9()
+                getProjectRoot10()
               );
               return {
                 meta: dispatchMeta("mutate", "orchestrate", operation, startTime),
@@ -26805,7 +26809,7 @@ import {
   describeChannel,
   formatStageGuidance,
   getLogger as getLogger10,
-  getProjectRoot as getProjectRoot10,
+  getProjectRoot as getProjectRoot11,
   isValidStage,
   listChains,
   paginate as paginate3,
@@ -26813,19 +26817,19 @@ import {
   showChain
 } from "@cleocode/core/internal";
 async function stageValidateOp(params) {
-  return lifecycleCheck(params.epicId, params.targetStage, getProjectRoot10());
+  return lifecycleCheck(params.epicId, params.targetStage, getProjectRoot11());
 }
 async function stageStatusOp(params) {
-  return lifecycleStatus(params.epicId, getProjectRoot10());
+  return lifecycleStatus(params.epicId, getProjectRoot11());
 }
 async function stageHistoryOp(params) {
-  return lifecycleHistory(params.taskId, getProjectRoot10());
+  return lifecycleHistory(params.taskId, getProjectRoot11());
 }
 async function stageGuidanceOp(params) {
   let stage = params.stage;
   const epicId = params.epicId;
   const format = params.format ?? "markdown";
-  const projectRoot = getProjectRoot10();
+  const projectRoot = getProjectRoot11();
   if (!stage && epicId) {
     const statusResult = await lifecycleStatus(epicId, projectRoot);
     if (statusResult.success) {
@@ -26841,14 +26845,14 @@ async function stageRecordOp(params) {
     params.stage,
     params.status,
     params.notes,
-    getProjectRoot10()
+    getProjectRoot11()
   );
 }
 async function stageSkipOp(params) {
-  return lifecycleSkip(params.taskId, params.stage, params.reason, getProjectRoot10());
+  return lifecycleSkip(params.taskId, params.stage, params.reason, getProjectRoot11());
 }
 async function stageResetOp(params) {
-  return lifecycleReset(params.taskId, params.stage, params.reason, getProjectRoot10());
+  return lifecycleReset(params.taskId, params.stage, params.reason, getProjectRoot11());
 }
 async function stageGatePassOp(params) {
   return lifecycleGatePass(
@@ -26856,24 +26860,24 @@ async function stageGatePassOp(params) {
     params.gateName,
     params.agent,
     params.notes,
-    getProjectRoot10()
+    getProjectRoot11()
   );
 }
 async function stageGateFailOp(params) {
-  return lifecycleGateFail(params.taskId, params.gateName, params.reason, getProjectRoot10());
+  return lifecycleGateFail(params.taskId, params.gateName, params.reason, getProjectRoot11());
 }
 async function releaseListOp(params) {
   return releaseList(
     { status: params.status, limit: params.limit, offset: params.offset },
-    getProjectRoot10()
+    getProjectRoot11()
   );
 }
 async function releaseShowOp(params) {
-  return releaseShow(params.version, getProjectRoot10());
+  return releaseShow(params.version, getProjectRoot11());
 }
 async function releaseChannelShowOp(_params) {
   let currentBranch = "unknown";
-  const projectRoot = getProjectRoot10();
+  const projectRoot = getProjectRoot11();
   try {
     currentBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       encoding: "utf-8",
@@ -26891,55 +26895,55 @@ async function releaseChannelShowOp(_params) {
   };
 }
 async function releaseChangelogSinceOp(params) {
-  return releaseChangelogSince(params.sinceTag, getProjectRoot10());
+  return releaseChangelogSince(params.sinceTag, getProjectRoot11());
 }
 async function releasePrStatusOp(params) {
-  return releasePrStatus(params.version, getProjectRoot10());
+  return releasePrStatus(params.version, getProjectRoot11());
 }
 async function releaseCancelOp(params) {
-  return releaseCancel(params.version, getProjectRoot10());
+  return releaseCancel(params.version, getProjectRoot11());
 }
 async function releaseRollbackOp(params) {
-  return releaseRollback(params.version, params.reason, getProjectRoot10());
+  return releaseRollback(params.version, params.reason, getProjectRoot11());
 }
 async function releaseRollbackFullOp(params) {
   return releaseRollbackFull(
     params.version,
     { reason: params.reason, force: params.force, unpublish: params.unpublish },
-    getProjectRoot10()
+    getProjectRoot11()
   );
 }
 async function manifestShowOp(params) {
-  return pipelineManifestShow(params.entryId, getProjectRoot10());
+  return pipelineManifestShow(params.entryId, getProjectRoot11());
 }
 async function manifestListOp(params) {
-  return pipelineManifestList(params, getProjectRoot10());
+  return pipelineManifestList(params, getProjectRoot11());
 }
 async function manifestFindOp(params) {
   return pipelineManifestFind(
     params.query,
     { confidence: params.confidence, limit: params.limit },
-    getProjectRoot10()
+    getProjectRoot11()
   );
 }
 async function manifestStatsOp(params) {
-  return pipelineManifestStats(params.epicId, getProjectRoot10());
+  return pipelineManifestStats(params.epicId, getProjectRoot11());
 }
 async function manifestAppendOp(params) {
-  return pipelineManifestAppend(params.entry, getProjectRoot10());
+  return pipelineManifestAppend(params.entry, getProjectRoot11());
 }
 async function manifestArchiveOp(params) {
-  return pipelineManifestArchive(params.beforeDate, getProjectRoot10());
+  return pipelineManifestArchive(params.beforeDate, getProjectRoot11());
 }
 async function phaseShowOp(params) {
-  return phaseShow(params.phaseId, getProjectRoot10());
+  return phaseShow(params.phaseId, getProjectRoot11());
 }
 async function phaseListOp(_params) {
-  return phaseList(getProjectRoot10());
+  return phaseList(getProjectRoot11());
 }
 async function phaseSetOp(params) {
   const { phaseId, action, rollback, force, dryRun } = params;
-  const projectRoot = getProjectRoot10();
+  const projectRoot = getProjectRoot11();
   if (action === "start") {
     return phaseStart(phaseId, projectRoot);
   }
@@ -26949,28 +26953,28 @@ async function phaseSetOp(params) {
   return phaseSet({ phaseId, rollback, force, dryRun }, projectRoot);
 }
 async function phaseAdvanceOp(params) {
-  return phaseAdvance(params.force, getProjectRoot10());
+  return phaseAdvance(params.force, getProjectRoot11());
 }
 async function phaseRenameOp(params) {
-  return phaseRename(params.oldName, params.newName, getProjectRoot10());
+  return phaseRename(params.oldName, params.newName, getProjectRoot11());
 }
 async function phaseDeleteOp(params) {
   return phaseDelete(
     params.phaseId,
     { reassignTo: params.reassignTo, force: params.force },
-    getProjectRoot10()
+    getProjectRoot11()
   );
 }
 async function chainShowOp(params) {
-  const chain = await showChain(params.chainId, getProjectRoot10());
+  const chain = await showChain(params.chainId, getProjectRoot11());
   return { _chain: chain, _chainId: params.chainId };
 }
 async function chainListOp(_params) {
-  const chains = await listChains(getProjectRoot10());
+  const chains = await listChains(getProjectRoot11());
   return { _chains: chains };
 }
 async function chainAddOp(params) {
-  await addChain(params.chain, getProjectRoot10());
+  await addChain(params.chain, getProjectRoot11());
   return { id: params.chain.id };
 }
 async function chainInstantiateOp(params) {
@@ -26981,7 +26985,7 @@ async function chainInstantiateOp(params) {
       variables: params.variables,
       stageToTask: params.stageToTask
     },
-    getProjectRoot10()
+    getProjectRoot11()
   );
 }
 async function chainAdvanceOp(params) {
@@ -26989,7 +26993,7 @@ async function chainAdvanceOp(params) {
     params.instanceId,
     params.nextStage,
     params.gateResults ?? [],
-    getProjectRoot10()
+    getProjectRoot11()
   );
 }
 function pipelinePhaseListResponse(envelope, params, operation, startTime) {
@@ -27518,7 +27522,7 @@ var init_pipeline3 = __esm({
 // packages/cleo/src/dispatch/domains/provenance.ts
 import {
   getLogger as getLogger11,
-  getProjectRoot as getProjectRoot11,
+  getProjectRoot as getProjectRoot12,
   provenanceBackfill,
   verifyProvenance
 } from "@cleocode/core/internal";
@@ -27563,7 +27567,7 @@ var init_provenance = __esm({
                 ...version ? { version } : {},
                 all,
                 ...limit !== void 0 ? { limit } : {},
-                projectRoot: getProjectRoot11()
+                projectRoot: getProjectRoot12()
               });
               return wrapResult(result, "query", "provenance", operation, startTime);
             }
@@ -27609,7 +27613,7 @@ var init_provenance = __esm({
               const resetCheckpoint = typeof params?.["resetCheckpoint"] === "boolean" ? params["resetCheckpoint"] : false;
               const result = await provenanceBackfill({
                 since,
-                projectRoot: getProjectRoot11(),
+                projectRoot: getProjectRoot12(),
                 forceOverwrite,
                 dryRun,
                 resetCheckpoint
@@ -27639,12 +27643,12 @@ var init_provenance = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/release.ts
-import { getLogger as getLogger12, getProjectRoot as getProjectRoot12 } from "@cleocode/core/internal";
+import { getLogger as getLogger12, getProjectRoot as getProjectRoot13 } from "@cleocode/core/internal";
 async function releaseGateOp(params) {
-  return releaseGateCheck(params.epicId, params.force ?? false, getProjectRoot12());
+  return releaseGateCheck(params.epicId, params.force ?? false, getProjectRoot13());
 }
 async function releaseIvtrSuggestOp(params) {
-  return releaseIvtrAutoSuggest(params.taskId, getProjectRoot12());
+  return releaseIvtrAutoSuggest(params.taskId, getProjectRoot13());
 }
 var log3, coreOps4, ReleaseHandler;
 var init_release2 = __esm({
@@ -27815,7 +27819,7 @@ var init_release2 = __esm({
                 channel: typeof params?.channel === "string" ? params.channel : void 0,
                 hotfix: typeof params?.hotfix === "boolean" ? params.hotfix : false,
                 dryRun: typeof params?.dryRun === "boolean" ? params.dryRun : false,
-                projectRoot: getProjectRoot12()
+                projectRoot: getProjectRoot13()
               };
               return wrapResult(await releasePlan(typed), "mutate", "release", operation, startTime);
             }
@@ -27837,7 +27841,7 @@ var init_release2 = __esm({
                 workflow: typeof params?.workflow === "string" ? params.workflow : void 0,
                 watch: typeof params?.watch === "boolean" ? params.watch : false,
                 commitPlan: typeof params?.commitPlan === "boolean" ? params.commitPlan : false,
-                projectRoot: getProjectRoot12()
+                projectRoot: getProjectRoot13()
               };
               return wrapResult(await releaseOpen(typed), "mutate", "release", operation, startTime);
             }
@@ -27854,7 +27858,7 @@ var init_release2 = __esm({
                   startTime
                 );
               const result = await releaseReconcileV2(version, {
-                projectRoot: getProjectRoot12(),
+                projectRoot: getProjectRoot13(),
                 fromWorkflow: typeof params?.fromWorkflow === "boolean" ? params.fromWorkflow : false,
                 rollback: typeof params?.rollback === "boolean" ? params.rollback : false
               });
@@ -27883,7 +27887,7 @@ var init_release2 = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/sentient.ts
-import { getProjectRoot as getProjectRoot13 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot14 } from "@cleocode/core";
 import {
   sentientAllowlistAdd,
   sentientAllowlistList,
@@ -27903,16 +27907,16 @@ var init_sentient2 = __esm({
     init_typed();
     init_base();
     coreOps5 = {
-      "propose.list": (params) => sentientProposeList(getProjectRoot13(), params),
-      "propose.diff": (params) => sentientProposeDiff(getProjectRoot13(), params),
-      "allowlist.list": (params) => sentientAllowlistList(getProjectRoot13(), params),
-      "propose.accept": (params) => sentientProposeAccept(getProjectRoot13(), params),
-      "propose.reject": (params) => sentientProposeReject(getProjectRoot13(), params),
-      "propose.run": (params) => sentientProposeRun(getProjectRoot13(), params),
-      "propose.enable": (params) => sentientProposeEnable(getProjectRoot13(), params),
-      "propose.disable": (params) => sentientProposeDisable(getProjectRoot13(), params),
-      "allowlist.add": (params) => sentientAllowlistAdd(getProjectRoot13(), params),
-      "allowlist.remove": (params) => sentientAllowlistRemove(getProjectRoot13(), params)
+      "propose.list": (params) => sentientProposeList(getProjectRoot14(), params),
+      "propose.diff": (params) => sentientProposeDiff(getProjectRoot14(), params),
+      "allowlist.list": (params) => sentientAllowlistList(getProjectRoot14(), params),
+      "propose.accept": (params) => sentientProposeAccept(getProjectRoot14(), params),
+      "propose.reject": (params) => sentientProposeReject(getProjectRoot14(), params),
+      "propose.run": (params) => sentientProposeRun(getProjectRoot14(), params),
+      "propose.enable": (params) => sentientProposeEnable(getProjectRoot14(), params),
+      "propose.disable": (params) => sentientProposeDisable(getProjectRoot14(), params),
+      "allowlist.add": (params) => sentientAllowlistAdd(getProjectRoot14(), params),
+      "allowlist.remove": (params) => sentientAllowlistRemove(getProjectRoot14(), params)
     };
     _sentientTypedHandler = defineTypedHandler("sentient", {
       // -------------------------------------------------------------------------
@@ -28142,28 +28146,28 @@ var init_session_context = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/session.ts
-import { getDb, getLogger as getLogger13, getProjectRoot as getProjectRoot14, sessions } from "@cleocode/core/internal";
+import { getDb, getLogger as getLogger13, getProjectRoot as getProjectRoot15, sessions } from "@cleocode/core/internal";
 import { eq } from "drizzle-orm";
 async function sessionStatusOp() {
-  return sessionStatus(getProjectRoot14());
+  return sessionStatus(getProjectRoot15());
 }
 async function sessionListOp(params) {
-  return sessionList(getProjectRoot14(), params);
+  return sessionList(getProjectRoot15(), params);
 }
 async function sessionShowOp(params) {
   if (params.include === "debrief") {
-    return sessionDebriefShow(getProjectRoot14(), params.sessionId);
+    return sessionDebriefShow(getProjectRoot15(), params.sessionId);
   }
-  return sessionShow(getProjectRoot14(), params.sessionId);
+  return sessionShow(getProjectRoot15(), params.sessionId);
 }
 async function sessionFindOp(params) {
-  return sessionFind(getProjectRoot14(), params);
+  return sessionFind(getProjectRoot15(), params);
 }
 async function sessionDecisionLogOp(params) {
-  return sessionDecisionLog(getProjectRoot14(), params);
+  return sessionDecisionLog(getProjectRoot15(), params);
 }
 async function sessionContextDriftOp(params) {
-  return sessionContextDrift(getProjectRoot14(), params);
+  return sessionContextDrift(getProjectRoot15(), params);
 }
 async function sessionHandoffShowOp(params) {
   let scopeFilter;
@@ -28174,33 +28178,33 @@ async function sessionHandoffShowOp(params) {
       scopeFilter = { type: "epic", epicId: params.scope.replace("epic:", "") };
     }
   }
-  return sessionHandoff(getProjectRoot14(), scopeFilter);
+  return sessionHandoff(getProjectRoot15(), scopeFilter);
 }
 async function sessionBriefingShowOp(params) {
-  return sessionBriefing(getProjectRoot14(), params);
+  return sessionBriefing(getProjectRoot15(), params);
 }
 async function sessionStartOp(params) {
-  return sessionStart(getProjectRoot14(), params);
+  return sessionStart(getProjectRoot15(), params);
 }
 async function sessionEndOp(params) {
-  return sessionEnd(getProjectRoot14(), params.note, {
+  return sessionEnd(getProjectRoot15(), params.note, {
     sessionSummary: params.sessionSummary
   });
 }
 async function sessionResumeOp(params) {
-  return sessionResume(getProjectRoot14(), params.sessionId);
+  return sessionResume(getProjectRoot15(), params.sessionId);
 }
 async function sessionSuspendOp(params) {
-  return sessionSuspend(getProjectRoot14(), params.sessionId, params.reason);
+  return sessionSuspend(getProjectRoot15(), params.sessionId, params.reason);
 }
 async function sessionGcOp(params) {
-  return sessionGc(getProjectRoot14(), params.maxAgeDays);
+  return sessionGc(getProjectRoot15(), params.maxAgeDays);
 }
 async function sessionRecordDecisionOp(params) {
-  return sessionRecordDecision(getProjectRoot14(), params);
+  return sessionRecordDecision(getProjectRoot15(), params);
 }
 async function sessionRecordAssumptionOp(params) {
-  return sessionRecordAssumption(getProjectRoot14(), params);
+  return sessionRecordAssumption(getProjectRoot15(), params);
 }
 async function storeSessionOwnerAuthToken(projectRoot, sessionId, token) {
   const db = await getDb(projectRoot);
@@ -28289,7 +28293,7 @@ var init_session3 = __esm({
       // SSoT-EXEMPT: storeOwnerAuthToken (DB side-effect requiring post-create sessionId),
       // bindSession (process-scoped context, requires scope-string parsing) — ADR-058
       start: async (params) => {
-        const projectRoot = getProjectRoot14();
+        const projectRoot = getProjectRoot15();
         if (!params.scope) {
           return lafsError("E_INVALID_INPUT", "scope is required", "start");
         }
@@ -28338,7 +28342,7 @@ var init_session3 = __esm({
       // SSoT-EXEMPT: orchestrated post-op pipeline — sessionComputeDebrief, persistSessionMemory,
       // unbindSession (process-context teardown), refreshMemoryBridge — ADR-058
       end: async (params) => {
-        const projectRoot = getProjectRoot14();
+        const projectRoot = getProjectRoot15();
         const endResult = await coreOps6.end(params);
         if (!endResult.success) {
           return lafsError(
@@ -28530,7 +28534,7 @@ var init_session3 = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/sticky.ts
-import { getLogger as getLogger14, getProjectRoot as getProjectRoot15 } from "@cleocode/core";
+import { getLogger as getLogger14, getProjectRoot as getProjectRoot16 } from "@cleocode/core";
 import {
   stickyAdd,
   stickyArchive,
@@ -28544,7 +28548,7 @@ import {
 } from "@cleocode/core/internal";
 async function stickyListOp(params) {
   return stickyListFiltered(
-    getProjectRoot15(),
+    getProjectRoot16(),
     {
       status: params.status,
       color: params.color,
@@ -28556,10 +28560,10 @@ async function stickyListOp(params) {
   );
 }
 async function stickyShowOp(params) {
-  return stickyShow(getProjectRoot15(), params.stickyId);
+  return stickyShow(getProjectRoot16(), params.stickyId);
 }
 async function stickyAddOp(params) {
-  return stickyAdd(getProjectRoot15(), {
+  return stickyAdd(getProjectRoot16(), {
     content: params.content,
     tags: params.tags,
     color: params.color,
@@ -28567,24 +28571,24 @@ async function stickyAddOp(params) {
   });
 }
 async function stickyArchiveOp(params) {
-  return stickyArchive(getProjectRoot15(), params.stickyId);
+  return stickyArchive(getProjectRoot16(), params.stickyId);
 }
 async function stickyPurgeOp(params) {
-  return stickyPurge(getProjectRoot15(), params.stickyId);
+  return stickyPurge(getProjectRoot16(), params.stickyId);
 }
 async function stickyConvertTaskOp(params) {
-  const result = await stickyConvertToTask(getProjectRoot15(), params.stickyId, params.title);
+  const result = await stickyConvertToTask(getProjectRoot16(), params.stickyId, params.title);
   if (!result.success) return { taskId: void 0 };
   return { taskId: result.data.taskId };
 }
 async function stickyConvertMemoryOp(params) {
-  const result = await stickyConvertToMemory(getProjectRoot15(), params.stickyId, params.memoryType);
+  const result = await stickyConvertToMemory(getProjectRoot16(), params.stickyId, params.memoryType);
   if (!result.success) return { memoryId: void 0 };
   return { memoryId: result.data.memoryId };
 }
 async function stickyConvertSessionNoteOp(params) {
   const result = await stickyConvertToSessionNote(
-    getProjectRoot15(),
+    getProjectRoot16(),
     params.stickyId,
     params.sessionId
   );
@@ -28592,7 +28596,7 @@ async function stickyConvertSessionNoteOp(params) {
   return { sessionId: result.data.sessionId };
 }
 async function stickyConvertTaskNoteOp(params) {
-  const result = await stickyConvertToTaskNote(getProjectRoot15(), params.stickyId, params.taskId);
+  const result = await stickyConvertToTaskNote(getProjectRoot16(), params.stickyId, params.taskId);
   if (!result.success) return { taskId: void 0 };
   return { taskId: result.data.taskId };
 }
@@ -28763,9 +28767,9 @@ var init_sticky2 = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/tasks.ts
-import { getLogger as getLogger15, getProjectRoot as getProjectRoot16 } from "@cleocode/core";
+import { getLogger as getLogger15, getProjectRoot as getProjectRoot17 } from "@cleocode/core";
 async function sagaCreate(params) {
-  const projectRoot = getProjectRoot16();
+  const projectRoot = getProjectRoot17();
   const title = typeof params.title === "string" ? params.title : "";
   const description = typeof params.description === "string" ? params.description : void 0;
   const acceptance = Array.isArray(params.acceptance) ? params.acceptance : void 0;
@@ -28781,7 +28785,7 @@ async function sagaCreate(params) {
   );
 }
 async function sagaAdd(params) {
-  const projectRoot = getProjectRoot16();
+  const projectRoot = getProjectRoot17();
   const sagaId = typeof params.sagaId === "string" ? params.sagaId : "";
   const epicId = typeof params.epicId === "string" ? params.epicId : "";
   if (!sagaId || !epicId) {
@@ -28819,7 +28823,7 @@ async function sagaAdd(params) {
   return lafsSuccess({ sagaId, epicId, added: relResult.data?.added ?? true }, "saga.add");
 }
 async function sagaList() {
-  const projectRoot = getProjectRoot16();
+  const projectRoot = getProjectRoot17();
   const result = await taskList(projectRoot, { type: "epic", label: "saga" });
   if (!result.success) {
     return lafsError("E_GENERAL", result.error?.message ?? "Failed to list Sagas", "saga.list");
@@ -28832,7 +28836,7 @@ async function sagaList() {
   return lafsSuccess({ sagas: topLevel, total: topLevel.length }, "saga.list");
 }
 async function sagaMembers(params) {
-  const projectRoot = getProjectRoot16();
+  const projectRoot = getProjectRoot17();
   const sagaId = typeof params.sagaId === "string" ? params.sagaId : "";
   if (!sagaId) {
     return lafsError("E_INVALID_INPUT", "sagaId is required", "saga.members");
@@ -28857,7 +28861,7 @@ async function sagaMembers(params) {
   );
 }
 async function sagaRollup(params) {
-  const projectRoot = getProjectRoot16();
+  const projectRoot = getProjectRoot17();
   const sagaId = typeof params.sagaId === "string" ? params.sagaId : "";
   if (!sagaId) {
     return lafsError("E_INVALID_INPUT", "sagaId is required", "saga.rollup");
@@ -28909,7 +28913,7 @@ var init_tasks3 = __esm({
       // Query ops
       // -------------------------------------------------------------------------
       show: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         if (params.ivtrHistory) {
           return wrapCoreResult(await taskShowIvtrHistory(projectRoot, params.taskId), "show");
         }
@@ -28919,7 +28923,7 @@ var init_tasks3 = __esm({
         return wrapCoreResult(await taskShow(projectRoot, params.taskId), "show");
       },
       list: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         const result = await taskList(projectRoot, {
           parent: params.parent,
           status: params.status,
@@ -28945,7 +28949,7 @@ var init_tasks3 = __esm({
         return lafsSuccess(result.data, "list");
       },
       find: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await taskFind(projectRoot, params.query, params.limit, {
             id: params.id,
@@ -28962,15 +28966,15 @@ var init_tasks3 = __esm({
         );
       },
       tree: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskTree(projectRoot, params.taskId, params.withBlockers), "tree");
       },
       blockers: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskBlockers(projectRoot, params), "blockers");
       },
       depends: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         if (params.action === "overview") {
           return wrapCoreResult(await taskDepsOverview(projectRoot), "depends");
         }
@@ -28990,14 +28994,14 @@ var init_tasks3 = __esm({
         );
       },
       "deps.validate": async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await taskDepsValidate(projectRoot, params.epicId, params.scope),
           "deps.validate"
         );
       },
       "deps.tree": async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         if (!params.epicId) {
           return lafsError("E_INVALID_INPUT", "epicId is required for deps.tree", "deps.tree");
         }
@@ -29007,29 +29011,29 @@ var init_tasks3 = __esm({
         );
       },
       analyze: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await taskAnalyze(projectRoot, params.taskId, { tierLimit: params.tierLimit }),
           "analyze"
         );
       },
       impact: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await taskImpact(projectRoot, params.change, params.matchLimit),
           "impact"
         );
       },
       next: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskNext(projectRoot, params), "next");
       },
       plan: async (_params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskPlan(projectRoot), "plan");
       },
       relates: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         if (params.mode) {
           return wrapCoreResult(
             await taskRelatesFind(projectRoot, params.taskId, {
@@ -29042,36 +29046,36 @@ var init_tasks3 = __esm({
         return wrapCoreResult(await taskRelates(projectRoot, params.taskId), "relates");
       },
       "complexity.estimate": async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await taskComplexityEstimate(projectRoot, { taskId: params.taskId }),
           "complexity.estimate"
         );
       },
       history: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         if (params.taskId) {
           return wrapCoreResult(await taskHistory(projectRoot, params.taskId, params.limit), "history");
         }
         return wrapCoreResult(await taskWorkHistory(projectRoot), "history");
       },
       current: async (_params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskCurrentGet(projectRoot), "current");
       },
       "label.list": async (_params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskLabelList(projectRoot), "label.list");
       },
       "sync.links": async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskSyncLinks(projectRoot, params), "sync.links");
       },
       // -------------------------------------------------------------------------
       // Mutate ops
       // -------------------------------------------------------------------------
       add: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await addTaskWithSessionScope(projectRoot, {
             title: params.title,
@@ -29099,7 +29103,7 @@ var init_tasks3 = __esm({
         );
       },
       update: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await taskUpdate(projectRoot, params.taskId, {
             title: params.title,
@@ -29142,7 +29146,7 @@ var init_tasks3 = __esm({
         );
       },
       complete: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         if (params.force !== void 0) {
           return lafsError(
             "E_FLAG_REMOVED",
@@ -29165,15 +29169,15 @@ var init_tasks3 = __esm({
         return wrapCoreResult(result, "complete");
       },
       cancel: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskCancel(projectRoot, params.taskId, params.reason), "cancel");
       },
       delete: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskDelete(projectRoot, params.taskId, params.force), "delete");
       },
       archive: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await taskArchive(projectRoot, params.taskId, params.before, {
             taskIds: params.taskIds,
@@ -29184,7 +29188,7 @@ var init_tasks3 = __esm({
         );
       },
       restore: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         if (params.from === "done") {
           return wrapCoreResult(
             await taskReopen(projectRoot, params.taskId, {
@@ -29212,21 +29216,21 @@ var init_tasks3 = __esm({
         );
       },
       reparent: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await taskReparent(projectRoot, params.taskId, params.newParentId ?? null),
           "reparent"
         );
       },
       reorder: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await taskReorder(projectRoot, params.taskId, params.position),
           "reorder"
         );
       },
       "relates.add": async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         const relatedId = params.relatedId ?? params.targetId;
         if (!relatedId) {
           return lafsError("E_INVALID_INPUT", "relatedId (or targetId) is required", "relates.add");
@@ -29237,7 +29241,7 @@ var init_tasks3 = __esm({
         );
       },
       "relates.remove": async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         if (!params.relatedId) {
           return lafsError("E_INVALID_INPUT", "relatedId is required", "relates.remove");
         }
@@ -29247,15 +29251,15 @@ var init_tasks3 = __esm({
         );
       },
       start: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskStart(projectRoot, params.taskId), "start");
       },
       stop: async (_params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskStop(projectRoot), "stop");
       },
       "sync.reconcile": async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await taskSyncReconcile(projectRoot, {
             providerId: params.providerId,
@@ -29269,18 +29273,18 @@ var init_tasks3 = __esm({
         );
       },
       "sync.links.remove": async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(
           await taskSyncLinksRemove(projectRoot, params.providerId),
           "sync.links.remove"
         );
       },
       claim: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskClaim(projectRoot, params.taskId, params.agentId), "claim");
       },
       unclaim: async (params) => {
-        const projectRoot = getProjectRoot16();
+        const projectRoot = getProjectRoot17();
         return wrapCoreResult(await taskUnclaim(projectRoot, params.taskId), "unclaim");
       }
     });
@@ -29506,7 +29510,7 @@ var init_tasks3 = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/tools.ts
-import { getLogger as getLogger16, getProjectRoot as getProjectRoot17 } from "@cleocode/core";
+import { getLogger as getLogger16, getProjectRoot as getProjectRoot18 } from "@cleocode/core";
 import {
   codeOutline,
   codeParse,
@@ -29551,7 +29555,7 @@ var init_tools = __esm({
     init_routing();
     ToolsHandler = class {
       get projectRoot() {
-        return getProjectRoot17();
+        return getProjectRoot18();
       }
       // -----------------------------------------------------------------------
       // DomainHandler interface
@@ -30074,7 +30078,7 @@ var init_tools = __esm({
 // packages/cleo/src/dispatch/domains/upgrade.ts
 import { dirname as dirname3, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { getLogger as getLogger17, getProjectRoot as getProjectRoot18 } from "@cleocode/core";
+import { getLogger as getLogger17, getProjectRoot as getProjectRoot19 } from "@cleocode/core";
 import { upgradeWorkflows } from "@cleocode/core/internal";
 function resolveTemplatesDir() {
   const here = dirname3(fileURLToPath2(import.meta.url));
@@ -30114,7 +30118,7 @@ var init_upgrade = __esm({
             case "workflows": {
               const includeRendered = params?.["includeRendered"] === true;
               const result = await upgradeWorkflows({
-                projectRoot: getProjectRoot18(),
+                projectRoot: getProjectRoot19(),
                 templatesDir: resolveTemplatesDir(),
                 dryRun: true
               });
@@ -30157,7 +30161,7 @@ var init_upgrade = __esm({
               const dryRun = params?.["dryRun"] === true;
               const includeRendered = params?.["includeRendered"] === true;
               const result = await upgradeWorkflows({
-                projectRoot: getProjectRoot18(),
+                projectRoot: getProjectRoot19(),
                 templatesDir: resolveTemplatesDir(),
                 force,
                 dryRun
@@ -30198,7 +30202,7 @@ var init_upgrade = __esm({
 import {
   forceUnlockWorktree,
   getLogger as getLogger18,
-  getProjectRoot as getProjectRoot19,
+  getProjectRoot as getProjectRoot20,
   listWorktrees,
   pruneOrphanedWorktreesByStatus
 } from "@cleocode/core/internal";
@@ -30249,7 +30253,7 @@ var init_worktree2 = __esm({
           switch (operation) {
             case "list": {
               const opts = {
-                projectRoot: getProjectRoot19(),
+                projectRoot: getProjectRoot20(),
                 statusFilter: coerceStatusFilter(params?.["statusFilter"]),
                 staleDays: typeof params?.["staleDays"] === "number" ? params["staleDays"] : void 0
               };
@@ -30288,7 +30292,7 @@ var init_worktree2 = __esm({
           switch (operation) {
             case "prune": {
               const opts = {
-                projectRoot: getProjectRoot19(),
+                projectRoot: getProjectRoot20(),
                 dryRun: params?.["dryRun"] === true,
                 ...typeof params?.["staleDays"] === "number" ? { staleDays: params["staleDays"] } : {},
                 ...coerceStringList(params?.["paths"]) !== void 0 ? { paths: coerceStringList(params?.["paths"]) } : {},
@@ -30316,7 +30320,7 @@ var init_worktree2 = __esm({
                 );
               }
               const opts = {
-                projectRoot: getProjectRoot19(),
+                projectRoot: getProjectRoot20(),
                 taskId,
                 ...typeof params?.["actor"] === "string" && params["actor"].length > 0 ? { actor: params["actor"] } : {}
               };
@@ -30839,11 +30843,11 @@ var init_security = __esm({
 });
 
 // packages/cleo/src/dispatch/middleware/sanitizer.ts
-function createSanitizer(getProjectRoot38) {
+function createSanitizer(getProjectRoot41) {
   return async (req, next) => {
     if (req.params) {
       try {
-        const root = getProjectRoot38 ? getProjectRoot38() : void 0;
+        const root = getProjectRoot41 ? getProjectRoot41() : void 0;
         req.params = sanitizeParams(req.params, root, {
           domain: req.domain,
           operation: req.operation
@@ -30968,7 +30972,7 @@ import { createRequire } from "node:module";
 import { dirname as dirname4, join as join6 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { catalog, registerSkillLibraryFromPath } from "@cleocode/caamp";
-import { autoRecordDispatchTokenUsage, getProjectRoot as getProjectRoot20, hooks } from "@cleocode/core/internal";
+import { autoRecordDispatchTokenUsage, getProjectRoot as getProjectRoot21, hooks } from "@cleocode/core/internal";
 function ensureCaampLibrary() {
   if (catalog.isCatalogAvailable()) return;
   try {
@@ -31019,7 +31023,7 @@ function createCliDispatcher() {
     middlewares: [
       createSessionResolver(lookupCliSession),
       // T4959: session identity first
-      createSanitizer(() => getProjectRoot20()),
+      createSanitizer(() => getProjectRoot21()),
       createFieldFilter(),
       createAudit(),
       // T4959: CLI now gets audit trail
@@ -31033,7 +31037,7 @@ function resetCliDispatcher() {
 }
 async function dispatchFromCli(gateway, domain, operation, params, outputOpts) {
   const dispatcher = getCliDispatcher();
-  const projectRoot = getProjectRoot20();
+  const projectRoot = getProjectRoot21();
   const dispatchStart = Date.now();
   hooks.dispatch("PromptSubmit", projectRoot, {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -31078,7 +31082,7 @@ async function dispatchFromCli(gateway, domain, operation, params, outputOpts) {
       operation,
       sessionId: response.meta.sessionId,
       requestId: response.meta.requestId,
-      cwd: getProjectRoot20()
+      cwd: getProjectRoot21()
     });
     const opts = {
       command: outputOpts?.command ?? operation,
@@ -31140,7 +31144,7 @@ function handleRawError(response, _opts) {
 }
 async function dispatchRaw(gateway, domain, operation, params) {
   const dispatcher = getCliDispatcher();
-  const projectRoot = getProjectRoot20();
+  const projectRoot = getProjectRoot21();
   const dispatchStart = Date.now();
   hooks.dispatch("PromptSubmit", projectRoot, {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -31535,7 +31539,7 @@ __export(add_exports, {
 });
 import {
   appendSignedSeverityAttestation,
-  getProjectRoot as getProjectRoot21,
+  getProjectRoot as getProjectRoot22,
   inferTaskAddParams
 } from "@cleocode/core";
 var addCommand;
@@ -31763,7 +31767,7 @@ var init_add = __esm({
           return;
         }
         if (args["depends-waiver"] !== void 0) params["dependsWaiver"] = args["depends-waiver"];
-        const inferred = await inferTaskAddParams(getProjectRoot21(), {
+        const inferred = await inferTaskAddParams(getProjectRoot22(), {
           title: args.title,
           description: args.description ?? args.desc,
           filesInfer: args["files-infer"],
@@ -32387,6 +32391,7 @@ var agent_exports = {};
 __export(agent_exports, {
   agentCommand: () => agentCommand
 });
+import { getProjectRoot as getProjectRoot23 } from "@cleocode/core";
 import {
   checkAgentHealth,
   detectCrashedAgents,
@@ -32779,7 +32784,7 @@ var init_agent = __esm({
           const { AgentRegistryAccessor } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const agentId = args.id;
           const displayName = args.name;
           const classification = args.classification;
@@ -32897,7 +32902,7 @@ agent ${agentId}:
           const { AgentRegistryAccessor } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const credential = await registry.get(args.agentId);
           if (!credential) {
             cliOutput(
@@ -32985,7 +32990,7 @@ agent ${agentId}:
           const { existsSync: existsSync17, readFileSync: readFileSync18 } = await import("node:fs");
           const { join: join29 } = await import("node:path");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const credential = await registry.get(args.agentId);
           if (!credential) {
             cliOutput(
@@ -33104,7 +33109,7 @@ agent ${agentId}:
           const { AgentRegistryAccessor } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const credential = await registry.get(args.agentId);
           if (!credential) {
             cliOutput(
@@ -33161,7 +33166,7 @@ agent ${agentId}:
           const { AgentRegistryAccessor } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           if (args.agentId) {
             const credential = await registry.get(args.agentId);
             if (!credential) {
@@ -33237,7 +33242,7 @@ agent ${agentId}:
           const { AgentRegistryAccessor, createConduit } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const active = await registry.getActive();
           if (!active) {
             cliOutput(
@@ -33294,7 +33299,7 @@ Assigned task ${args.taskId}. Run: cleo show ${args.taskId} && cleo start ${args
           const { AgentRegistryAccessor, createConduit } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const active = await registry.getActive();
           if (!active) {
             cliOutput(
@@ -33360,7 +33365,7 @@ You are idle. Check your queue: cleo current || cleo next. Report status immedia
           const { AgentRegistryAccessor } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const role = args.role;
           const taskId = args.task;
           const model = args.model ?? "sonnet";
@@ -33425,7 +33430,7 @@ You are idle. Check your queue: cleo current || cleo next. Report status immedia
           const { AgentRegistryAccessor, createConduit } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const active = await registry.getActive();
           if (!active) {
             cliOutput(
@@ -33469,7 +33474,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { AgentRegistryAccessor } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const agents = await registry.list({ active: true });
           let stopped = 0;
           for (const a of agents) {
@@ -33542,7 +33547,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { promisify: promisify2 } = await import("node:util");
           const execFileAsync = promisify2(execFile2);
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const credential = await registry.get(args.agentId);
           if (!credential) {
             cliOutput(
@@ -33699,7 +33704,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           await getDb3();
           const includeGlobal = args.global === true;
           const includeDisabled = args["include-disabled"] === true;
-          const agents = listAgentsForProject(process.cwd(), {
+          const agents = listAgentsForProject(getProjectRoot23(), {
             includeGlobal,
             includeDisabled
           });
@@ -33750,7 +33755,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
           const includeGlobal = args.global === true;
-          const agent = lookupAgent(process.cwd(), args.agentId, { includeGlobal });
+          const agent = lookupAgent(getProjectRoot23(), args.agentId, { includeGlobal });
           if (!agent) {
             cliOutput(
               {
@@ -33816,7 +33821,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { AgentRegistryAccessor, attachAgentToProject, lookupAgent } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const projectRoot = process.cwd();
+          const projectRoot = getProjectRoot23();
           const _registry = new AgentRegistryAccessor(projectRoot);
           void _registry;
           const globalAgent = lookupAgent(projectRoot, args.agentId, { includeGlobal: true });
@@ -33872,7 +33877,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { AgentRegistryAccessor, detachAgentFromProject, getProjectAgentRef } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const projectRoot = process.cwd();
+          const projectRoot = getProjectRoot23();
           const _registry = new AgentRegistryAccessor(projectRoot);
           void _registry;
           const ref = getProjectAgentRef(projectRoot, args.agentId);
@@ -33929,7 +33934,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { AgentRegistryAccessor, detachAgentFromProject, getProjectAgentRef } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const projectRoot = process.cwd();
+          const projectRoot = getProjectRoot23();
           if (!args.global) {
             const _registry = new AgentRegistryAccessor(projectRoot);
             void _registry;
@@ -34011,7 +34016,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { AgentRegistryAccessor } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const result = await registry.rotateKey(args.agentId);
           cliOutput(
             {
@@ -34050,7 +34055,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { AgentRegistryAccessor } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const credential = await registry.get(args.agentId);
           if (!credential) {
             cliOutput(
@@ -34125,7 +34130,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           const { createRuntime } = await import("@cleocode/runtime");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const groupIds = args.group ? args.group.split(",").map((s) => s.trim()) : void 0;
           const handle = await createRuntime(registry, {
             agentId: args.agent,
@@ -34208,7 +34213,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { AgentRegistryAccessor, createConduit } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const agentId = args.agent;
           const conduit = await createConduit(registry, agentId);
           const limit = Number(args.limit) || 20;
@@ -34260,7 +34265,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { AgentRegistryAccessor, createConduit } = await import("@cleocode/core/agents");
           const { getDb: getDb3 } = await import("@cleocode/core/internal");
           await getDb3();
-          const registry = new AgentRegistryAccessor(process.cwd());
+          const registry = new AgentRegistryAccessor(getProjectRoot23());
           const agentId = args.agent;
           const to = args.to;
           const conv = args.conv;
@@ -34538,7 +34543,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const db = _sdDb;
           const isGlobal = args.global === true;
           const targetTier = isGlobal ? "global" : "project";
-          const projectRoot = process.cwd();
+          const projectRoot = getProjectRoot23();
           try {
             if (args.resync) {
               const parsedName = basename(cantPath, ".cant");
@@ -34835,7 +34840,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
             const xdgData = process.env["XDG_DATA_HOME"] ?? join29(home, ".local", "share");
             targetRoot = join29(xdgData, "cleo", "cant", "agents");
           } else {
-            targetRoot = join29(process.cwd(), CLEO_DIR_NAME, CANT_AGENTS_SUBDIR);
+            targetRoot = join29(getProjectRoot23(), CLEO_DIR_NAME, CANT_AGENTS_SUBDIR);
           }
           const agentDir = join29(targetRoot, name);
           if (existsSync17(agentDir)) {
@@ -34908,7 +34913,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
             const { AgentRegistryAccessor } = await import("@cleocode/core/agents");
             const { getDb: getDb3 } = await import("@cleocode/core/internal");
             await getDb3();
-            const registry = new AgentRegistryAccessor(process.cwd());
+            const registry = new AgentRegistryAccessor(getProjectRoot23());
             const existing = await registry.get(name);
             if (!existing) {
               const descMatch = personaContent.match(/description:\s*"([^"]+)"/);
@@ -34992,7 +34997,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
             return;
           }
           const specContent = readFileSync18(specPath, "utf-8");
-          const projectRoot = process.cwd();
+          const projectRoot = getProjectRoot23();
           const outputDir = args["output-dir"] ? resolve8(args["output-dir"]) : join29(projectRoot, ".cleo", "cant", "agents");
           mkdirSync7(outputDir, { recursive: true });
           if (args["dry-run"]) {
@@ -35123,7 +35128,7 @@ Task ${args.taskId} reassigned to you by ${active.agentId}. Run: cleo show ${arg
           const { db: _sdDb3 } = await openCleoDb2("signaldock");
           const db = _sdDb3;
           try {
-            const report = await buildDoctorReport(db, { projectRoot: process.cwd() });
+            const report = await buildDoctorReport(db, { projectRoot: getProjectRoot23() });
             const repairFlag = args.repair === true;
             let reconciled;
             if (repairFlag) {
@@ -35391,7 +35396,7 @@ var audit_exports = {};
 __export(audit_exports, {
   auditCommand: () => auditCommand
 });
-import { getProjectRoot as getProjectRoot22, reconstructLineage } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot24, reconstructLineage } from "@cleocode/core/internal";
 var reconstructCommand, auditCommand;
 var init_audit2 = __esm({
   "packages/cleo/src/cli/commands/audit.ts"() {
@@ -35435,7 +35440,7 @@ var init_audit2 = __esm({
           repoRoot = args["repo-root"];
         } else {
           try {
-            repoRoot = getProjectRoot22(process.cwd()) ?? process.cwd();
+            repoRoot = getProjectRoot24(process.cwd()) ?? process.cwd();
           } catch {
             repoRoot = process.cwd();
           }
@@ -36059,7 +36064,7 @@ var backfill_exports = {};
 __export(backfill_exports, {
   backfillCommand: () => backfillCommand
 });
-import { backfillTasks, getProjectRoot as getProjectRoot23, populateEmbeddings } from "@cleocode/core/internal";
+import { backfillTasks, getProjectRoot as getProjectRoot25, populateEmbeddings } from "@cleocode/core/internal";
 var backfillCommand;
 var init_backfill = __esm({
   "packages/cleo/src/cli/commands/backfill.ts"() {
@@ -36093,7 +36098,7 @@ var init_backfill = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot23();
+        const root = getProjectRoot25();
         if (args.embeddings) {
           try {
             let lastLine = "";
@@ -36611,9 +36616,9 @@ var init_backup = __esm({
       async run({ args }) {
         const scope = args.scope;
         const { packBundle } = await import("@cleocode/core/store/backup-pack.js");
-        const { getProjectRoot: getProjectRoot38 } = await import("@cleocode/core");
+        const { getProjectRoot: getProjectRoot41 } = await import("@cleocode/core");
         const includesProject = scope === "project" || scope === "all";
-        const projectRoot = includesProject ? getProjectRoot38() : void 0;
+        const projectRoot = includesProject ? getProjectRoot41() : void 0;
         let passphrase;
         if (args.encrypt === true) {
           passphrase = process.env["CLEO_BACKUP_PASSPHRASE"];
@@ -36689,12 +36694,12 @@ var init_backup = __esm({
       },
       async run({ args }) {
         const bundlePath = args.bundle;
-        const { getProjectRoot: getProjectRoot38, getCleoHome: getCleoHome3, getCleoVersion } = await import("@cleocode/core");
+        const { getProjectRoot: getProjectRoot41, getCleoHome: getCleoHome3, getCleoVersion } = await import("@cleocode/core");
         const { BundleError, cleanupStaging, unpackBundle } = await import("@cleocode/core/store/backup-unpack.js");
         const { regenerateConfigJson, regenerateProjectContextJson, regenerateProjectInfoJson } = await import("@cleocode/core/store/regenerators.js");
         const { regenerateAndCompare } = await import("@cleocode/core/store/restore-json-merge.js");
         const { buildConflictReport, writeConflictReport } = await import("@cleocode/core/store/restore-conflict-report.js");
-        const projectRoot = getProjectRoot38();
+        const projectRoot = getProjectRoot41();
         if (args.force !== true) {
           const existing = checkForExistingData(projectRoot, getCleoHome3());
           if (existing.length > 0) {
@@ -36912,7 +36917,7 @@ var brain_exports = {};
 __export(brain_exports, {
   brainCommand: () => brainCommand
 });
-import { getProjectRoot as getProjectRoot24 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot26 } from "@cleocode/core";
 import {
   backfillBrainGraph,
   exportBrainAsGexf,
@@ -36957,7 +36962,7 @@ var init_brain2 = __esm({
         json: { type: "boolean", description: "Output results as JSON" }
       },
       async run({ args }) {
-        const root = getProjectRoot24();
+        const root = getProjectRoot26();
         try {
           const result = await runBrainMaintenance(root, {
             skipDecay: !!args["skip-decay"],
@@ -37028,7 +37033,7 @@ var init_brain2 = __esm({
         json: { type: "boolean", description: "Output results as JSON" }
       },
       async run({ args: _args }) {
-        const root = getProjectRoot24();
+        const root = getProjectRoot26();
         try {
           const result = await backfillBrainGraph(root);
           cliOutput(
@@ -37069,7 +37074,7 @@ var init_brain2 = __esm({
         json: { type: "boolean", description: "Output results as JSON" }
       },
       async run({ args: _args }) {
-        const root = getProjectRoot24();
+        const root = getProjectRoot26();
         try {
           const result = await purgeBrainNoise(root);
           cliOutput(
@@ -37115,7 +37120,7 @@ var init_brain2 = __esm({
         json: { type: "boolean", description: "Output results as JSON" }
       },
       async run({ args }) {
-        const root = getProjectRoot24();
+        const root = getProjectRoot26();
         const limit = Number.parseInt(args.limit, 10) || 20;
         try {
           const stats = await getPlasticityStats(root, limit);
@@ -37165,7 +37170,7 @@ var init_brain2 = __esm({
         json: { type: "boolean", description: "Output results as JSON" }
       },
       async run({ args: _args }) {
-        const root = getProjectRoot24();
+        const root = getProjectRoot26();
         try {
           const report = await getMemoryQualityReport(root);
           cliOutput(
@@ -37214,7 +37219,7 @@ var init_brain2 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot24();
+        const root = getProjectRoot26();
         const format = args.format ?? "gexf";
         if (format !== "gexf" && format !== "json") {
           cliError(`Invalid format: ${format}. Use 'gexf' or 'json'.`, "E_VALIDATION", {
@@ -41091,7 +41096,7 @@ import {
   exportDocument,
   formatError as formatError5,
   getAgentOutputsAbsolute,
-  getProjectRoot as getProjectRoot25,
+  getProjectRoot as getProjectRoot27,
   listDocVersions,
   mergeDocs,
   publishDocs,
@@ -41387,7 +41392,7 @@ var init_docs3 = __esm({
         const taskId = String(args.task);
         const includeAttachments = args["include-attachments"] !== false;
         const includeMemoryRefs = args["include-memory-refs"] === true;
-        const projectRoot = getProjectRoot25();
+        const projectRoot = getProjectRoot27();
         try {
           const result = await exportDocument({
             taskId,
@@ -41450,7 +41455,7 @@ var init_docs3 = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot25();
+        const projectRoot = getProjectRoot27();
         try {
           const result = await searchDocs2(String(args.query), {
             ownerId: args.owner ?? void 0,
@@ -41502,7 +41507,7 @@ var init_docs3 = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot25();
+        const projectRoot = getProjectRoot27();
         const rawStrategy = args.strategy ?? "three-way";
         const strategy = rawStrategy === "cherry-pick" || rawStrategy === "multi-diff" ? rawStrategy : "three-way";
         try {
@@ -41552,7 +41557,7 @@ var init_docs3 = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot25();
+        const projectRoot = getProjectRoot27();
         const fmt = args.format ?? "mermaid";
         try {
           const result = await buildDocsGraph({ ownerId: String(args.for), projectRoot });
@@ -41622,7 +41627,7 @@ var init_docs3 = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot25();
+        const projectRoot = getProjectRoot27();
         try {
           const result = await rankDocs({
             ownerId: String(args.for),
@@ -41661,7 +41666,7 @@ var init_docs3 = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot25();
+        const projectRoot = getProjectRoot27();
         try {
           const result = await listDocVersions({
             ownerId: String(args.for),
@@ -41705,7 +41710,7 @@ var init_docs3 = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot25();
+        const projectRoot = getProjectRoot27();
         try {
           const result = await publishDocs({
             ownerId: String(args.for),
@@ -42110,7 +42115,7 @@ __export(migrate_agents_v2_exports, {
 import { createHash as createHash2 } from "node:crypto";
 import { appendFileSync as appendFileSync2, existsSync as existsSync12, mkdirSync as mkdirSync3, readdirSync as readdirSync2, readFileSync as readFileSync12 } from "node:fs";
 import { join as join15 } from "node:path";
-import { getProjectRoot as getProjectRoot26, installAgentFromCant } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot28, installAgentFromCant } from "@cleocode/core/internal";
 import { openCleoDb } from "@cleocode/core/store/open-cleo-db";
 function sha256Hex(bytes) {
   return createHash2("sha256").update(bytes).digest("hex");
@@ -42297,7 +42302,7 @@ var init_migrate_agents_v2 = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot26();
+        const projectRoot = getProjectRoot28();
         const verbose = args.quiet !== true;
         if (verbose) {
           humanInfo("Scanning .cleo/cant/agents/ and .cleo/agents/ for unregistered agents...");
@@ -42341,7 +42346,7 @@ __export(doctor_exports, {
 });
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync4 } from "node:fs";
 import { join as join16 } from "node:path";
-import { getProjectRoot as getProjectRoot27 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot29 } from "@cleocode/core";
 import {
   quarantineRogueCleoDir,
   scanRogueCleoDirs
@@ -42567,7 +42572,7 @@ var init_doctor = __esm({
         try {
           if (args.brain) {
             const { computeBrainHealthDashboard } = await import("@cleocode/core/memory/brain-health-dashboard.js");
-            const projectRoot = getProjectRoot27();
+            const projectRoot = getProjectRoot29();
             const dashboard = await computeBrainHealthDashboard(projectRoot);
             cliOutput(dashboard, { command: "doctor", operation: "doctor.brain" });
             if (dashboard.hasP0Failure) {
@@ -42576,7 +42581,7 @@ var init_doctor = __esm({
             return;
           }
           if (args["scan-test-fixtures-in-prod"]) {
-            const projectRoot = getProjectRoot27();
+            const projectRoot = getProjectRoot29();
             const matches = await scanTestFixturesInProd(projectRoot);
             const dryRun = args["dry-run"] !== false && args.quarantine !== true;
             const quarantined = !dryRun && matches.length > 0 ? await quarantineTestFixtures(projectRoot, matches) : void 0;
@@ -42664,7 +42669,7 @@ var init_doctor = __esm({
             progress.complete("Comprehensive diagnostics complete");
           } else if (args["scan-rogue-cleo-dirs"]) {
             progress.step(0, "Scanning for rogue .cleo/ directories");
-            const projectRoot = getProjectRoot27();
+            const projectRoot = getProjectRoot29();
             const reports = scanRogueCleoDirs(projectRoot);
             progress.complete(
               `Found ${reports.length} rogue .cleo/ director${reports.length === 1 ? "y" : "ies"}`
@@ -42673,7 +42678,7 @@ var init_doctor = __esm({
           } else if (args["quarantine-rogue-cleo-dirs"]) {
             const isDryRun = args["dry-run"] === true;
             progress.step(0, `${isDryRun ? "[DRY RUN] " : ""}Scanning for rogue .cleo/ directories`);
-            const projectRoot = getProjectRoot27();
+            const projectRoot = getProjectRoot29();
             const reports = scanRogueCleoDirs(projectRoot);
             if (reports.length === 0) {
               progress.complete("No rogue .cleo/ directories found \u2014 nothing to quarantine");
@@ -42727,7 +42732,7 @@ var init_doctor = __esm({
             const { detectAndRemoveLegacyGlobalFiles, detectAndRemoveStrayProjectNexus } = await import("@cleocode/core/store/cleanup-legacy.js");
             const { getCleoHome: getCleoHome3 } = await import("@cleocode/core");
             const cleoHome = getCleoHome3();
-            const projectRoot = getProjectRoot27();
+            const projectRoot = getProjectRoot29();
             const legacyResult = detectAndRemoveLegacyGlobalFiles(cleoHome);
             const strayResult = detectAndRemoveStrayProjectNexus(projectRoot);
             const isDryRun = args["dry-run"] === true;
@@ -42776,7 +42781,7 @@ var init_doctor = __esm({
               { command: "doctor", operation: "admin.health" }
             );
             try {
-              const projectRoot = getProjectRoot27();
+              const projectRoot = getProjectRoot29();
               const conflicts = readMigrationConflicts(projectRoot);
               if (conflicts.length > 0) {
                 progress.complete(
@@ -43721,7 +43726,7 @@ __export(generate_changelog_exports, {
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync13, writeFileSync as writeFileSync5 } from "node:fs";
 import { dirname as dirname8, join as join19 } from "node:path";
-import { CleoError as CleoError4, formatError as formatError6, getConfigPath, getProjectRoot as getProjectRoot28 } from "@cleocode/core";
+import { CleoError as CleoError4, formatError as formatError6, getConfigPath, getProjectRoot as getProjectRoot30 } from "@cleocode/core";
 function getChangelogSource(cwd) {
   const configPath = getConfigPath(cwd);
   try {
@@ -43752,7 +43757,7 @@ function getDefaultOutputPath(platform) {
   }
 }
 function getGitHubRepoSlug(cwd) {
-  const projectRoot = getProjectRoot28(cwd);
+  const projectRoot = getProjectRoot30(cwd);
   try {
     const remoteUrl = execFileSync2("git", ["remote", "get-url", "origin"], {
       cwd: projectRoot,
@@ -43885,7 +43890,7 @@ var init_generate_changelog = __esm({
           const targetPlatform = args.platform;
           const dryRun = args["dry-run"] === true;
           const sourceFile = getChangelogSource();
-          const sourcePath = join19(getProjectRoot28(), sourceFile);
+          const sourcePath = join19(getProjectRoot30(), sourceFile);
           if (!existsSync13(sourcePath)) {
             throw new CleoError4(4 /* NOT_FOUND */, `Changelog source not found: ${sourcePath}`);
           }
@@ -43898,7 +43903,7 @@ var init_generate_changelog = __esm({
             const outputPath = platformConfig?.path ?? getDefaultOutputPath(targetPlatform);
             const content = generateForPlatform(targetPlatform, sourceContent, repoSlug, limit);
             if (!dryRun) {
-              const fullPath = join19(getProjectRoot28(), outputPath);
+              const fullPath = join19(getProjectRoot30(), outputPath);
               mkdirSync5(dirname8(fullPath), { recursive: true });
               writeFileSync5(fullPath, content, "utf-8");
             }
@@ -43919,7 +43924,7 @@ var init_generate_changelog = __esm({
                 limit
               );
               if (!dryRun) {
-                const fullPath = join19(getProjectRoot28(), platformConfig.path);
+                const fullPath = join19(getProjectRoot30(), platformConfig.path);
                 mkdirSync5(dirname8(fullPath), { recursive: true });
                 writeFileSync5(fullPath, content, "utf-8");
               }
@@ -46000,7 +46005,7 @@ var llm_cost_exports = {};
 __export(llm_cost_exports, {
   costCommand: () => costCommand
 });
-import { getProjectRoot as getProjectRoot29 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot31 } from "@cleocode/core/internal";
 import { computeCost } from "@cleocode/core/llm/usage-pricing";
 function resolveSessionId(raw) {
   if (raw === "current") {
@@ -46073,7 +46078,7 @@ var init_llm_cost = __esm({
           process.exit(6);
         }
         const sessionId = resolveSessionId(rawSessionId);
-        const projectRoot = getProjectRoot29(process.cwd());
+        const projectRoot = getProjectRoot31(process.cwd());
         let breakdown;
         try {
           breakdown = await loadSessionCostBreakdown(projectRoot, sessionId);
@@ -47580,7 +47585,7 @@ import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync15, mkdirSync as mkdirSync6, readdirSync as readdirSync3, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir7 } from "node:os";
 import { join as join21 } from "node:path";
-import { getProjectRoot as getProjectRoot30 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot32 } from "@cleocode/core";
 import {
   getBrainDb as getBrainDb2,
   getDreamStatus,
@@ -48547,7 +48552,7 @@ var init_memory3 = __esm({
       },
       args: {},
       async run() {
-        const root = getProjectRoot30();
+        const root = getProjectRoot32();
         try {
           const result = await runConsolidation(root);
           cliOutput(result, { command: "memory-consolidate", operation: "memory.consolidate" });
@@ -48571,7 +48576,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot30();
+        const root = getProjectRoot32();
         if (args.status) {
           try {
             const status = await getDreamStatus(root);
@@ -48608,7 +48613,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot30();
+        const root = getProjectRoot32();
         try {
           const { runObserver, runReflector } = await import("@cleocode/core/memory");
           const observerResult = await runObserver(root, args.session, {
@@ -48648,7 +48653,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot30();
+        const root = getProjectRoot32();
         try {
           await getBrainDb2(root);
           const { totalDuplicateRows, groups } = await scanDuplicateEntries();
@@ -48694,7 +48699,7 @@ var init_memory3 = __esm({
       async run({ args }) {
         const sourceDir = args.from ?? join21(homedir7(), ".claude", "projects", "-mnt-projects-cleocode", "memory");
         const isDryRun = !!args["dry-run"];
-        const projectRoot = getProjectRoot30();
+        const projectRoot = getProjectRoot32();
         const stateFile = join21(projectRoot, CLEO_DIR_NAME, MIGRATE_MEMORY_HASHES_JSON);
         if (!existsSync15(sourceDir)) {
           cliError(`Source directory not found: ${sourceDir}`, "E_NOT_FOUND", { name: "E_NOT_FOUND" });
@@ -48907,7 +48912,7 @@ var init_memory3 = __esm({
       },
       args: {},
       async run() {
-        const root = getProjectRoot30();
+        const root = getProjectRoot32();
         try {
           await getBrainDb2(root);
           const result = await getTierStats(root);
@@ -48950,7 +48955,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot30();
+        const root = getProjectRoot32();
         const targetTier = args.to;
         const reason = args.reason;
         const validTiers = ["medium", "long"];
@@ -49016,7 +49021,7 @@ var init_memory3 = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot30();
+        const root = getProjectRoot32();
         const targetTier = args.to;
         const reason = args.reason;
         const validTiers = ["short", "medium"];
@@ -49484,7 +49489,7 @@ var migrate_claude_mem_exports = {};
 __export(migrate_claude_mem_exports, {
   migrateClaudeMemCommand: () => migrateClaudeMemCommand
 });
-import { getProjectRoot as getProjectRoot31, migrateClaudeMem } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot33, migrateClaudeMem } from "@cleocode/core/internal";
 import { ingestLooseAgentOutputs, ingestRcasdDirectories } from "@cleocode/core/memory";
 import { getDb as getDb2 } from "@cleocode/core/store/sqlite";
 var storageCommand, claudeMemCommand, manifestIngestCommand, migrateClaudeMemCommand;
@@ -49547,7 +49552,7 @@ var init_migrate_claude_mem = __esm({
         }
       },
       async run({ args }) {
-        const root = getProjectRoot31();
+        const root = getProjectRoot33();
         try {
           const result = await migrateClaudeMem(root, {
             sourcePath: args.source,
@@ -49596,7 +49601,7 @@ var init_migrate_claude_mem = __esm({
         }
       },
       async run({ args }) {
-        const projectRoot = getProjectRoot31();
+        const projectRoot = getProjectRoot33();
         try {
           const db = await getDb2(projectRoot);
           const rcasdFlag = Boolean(args.rcasd);
@@ -49700,6 +49705,7 @@ __export(nexus_exports, {
 import { appendFile, mkdir as mkdir2 } from "node:fs/promises";
 import { homedir as homedir8 } from "node:os";
 import path4 from "node:path";
+import { getProjectRoot as getProjectRoot34 } from "@cleocode/core";
 import { generateGexf, getSymbolImpact } from "@cleocode/core/nexus";
 async function appendDeprecationTelemetry(op, replacement) {
   try {
@@ -49811,7 +49817,7 @@ var init_nexus4 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : process.cwd();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot34();
         const startTime = Date.now();
         try {
           const [{ getNexusDb, nexusSchema }, { getIndexStats }] = await Promise.all([
@@ -50326,7 +50332,7 @@ var init_nexus4 = __esm({
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : process.cwd();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot34();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "clusters", { projectId, repoPath });
         const durationMs = Date.now() - startTime;
@@ -50370,7 +50376,7 @@ var init_nexus4 = __esm({
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : process.cwd();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot34();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "flows", { projectId, repoPath });
         const durationMs = Date.now() - startTime;
@@ -50413,7 +50419,7 @@ var init_nexus4 = __esm({
         void appendDeprecationTelemetry("nexus.context", "cleo graph context");
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = process.cwd();
+        const repoPath = getProjectRoot34();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const limit = parseInt(args.limit, 10);
         const symbolName = args.symbol;
@@ -50476,7 +50482,7 @@ var init_nexus4 = __esm({
         const startTime = Date.now();
         const whyFlag = !!args.why;
         const projectIdOverride = args["project-id"];
-        const repoPath = process.cwd();
+        const repoPath = getProjectRoot34();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const maxDepth = Math.min(parseInt(args.depth, 10), 5);
         const symbolName = args.symbol;
@@ -50548,13 +50554,12 @@ var init_nexus4 = __esm({
         const projectIdOverride = args["project-id"];
         const isIncremental = !!args.incremental;
         const ctx = getFormatContext();
-        const repoPath = args.path ? path4.resolve(args.path) : process.cwd();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot34();
         humanInfo(`[nexus] Analyzing: ${repoPath}${isIncremental ? " (incremental)" : ""}`);
         try {
-          const [{ getNexusDb, nexusSchema }, { runPipeline }, { getProjectRoot: getProjectRoot38 }, { eq: eq2 }] = await Promise.all([
+          const [{ getNexusDb, nexusSchema }, { runPipeline }, { eq: eq2 }] = await Promise.all([
             import("@cleocode/core/store/nexus-sqlite"),
             import("@cleocode/nexus/pipeline"),
-            import("@cleocode/core/internal"),
             import("drizzle-orm")
           ]);
           const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
@@ -50631,7 +50636,6 @@ var init_nexus4 = __esm({
               extensions: { duration_ms: durationMs }
             }
           );
-          void getProjectRoot38;
         } catch (err) {
           const msg = err instanceof Error ? err.message : String(err);
           cliError(
@@ -50702,7 +50706,7 @@ var init_nexus4 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : process.cwd();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot34();
         const name = args.name;
         const response = await dispatchRaw("mutate", "nexus", "projects.register", {
           path: repoPath,
@@ -51060,7 +51064,7 @@ var init_nexus4 = __esm({
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : process.cwd();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot34();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("mutate", "nexus", "refresh-bridge", {
           repoPath,
@@ -51209,7 +51213,7 @@ var init_nexus4 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : process.cwd();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot34();
         const projectIdOverride = args["project-id"];
         const beforeRef = args.before ?? "HEAD~1";
         const afterRef = args.after ?? "HEAD";
@@ -51327,7 +51331,7 @@ var init_nexus4 = __esm({
         applyJsonFlag2(args.json);
         const startTime = Date.now();
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : process.cwd();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot34();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "route-map", { projectId });
         const durationMs = Date.now() - startTime;
@@ -51383,7 +51387,7 @@ var init_nexus4 = __esm({
         const startTime = Date.now();
         const routeSymbol = args.routeSymbol;
         const projectIdOverride = args["project-id"];
-        const repoPath = args.path ? path4.resolve(args.path) : process.cwd();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot34();
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("query", "nexus", "shape-check", { routeSymbol, projectId });
         const durationMs = Date.now() - startTime;
@@ -51773,7 +51777,7 @@ var init_nexus4 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : process.cwd();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot34();
         const projectIdOverride = args["project-id"];
         const projectId = projectIdOverride ?? Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("mutate", "nexus", "contracts-sync", {
@@ -51877,7 +51881,7 @@ var init_nexus4 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const repoPath = args.path ? path4.resolve(args.path) : process.cwd();
+        const repoPath = args.path ? path4.resolve(args.path) : getProjectRoot34();
         const projectId = Buffer.from(repoPath).toString("base64url").slice(0, 32);
         const response = await dispatchRaw("mutate", "nexus", "contracts-link-tasks", {
           projectId,
@@ -51953,7 +51957,7 @@ var init_nexus4 = __esm({
       async run({ args }) {
         applyJsonFlag2(args.json);
         const startTime = Date.now();
-        const outputDir = args.output ?? path4.join(process.cwd(), ".cleo", "wiki");
+        const outputDir = args.output ?? path4.join(getProjectRoot34(), ".cleo", "wiki");
         const communityFilter = args.community ?? void 0;
         const isIncremental = !!args.incremental;
         let loomProvider = null;
@@ -51977,11 +51981,11 @@ var init_nexus4 = __esm({
         }
         try {
           const { generateNexusWikiIndex } = await import("@cleocode/core/nexus/wiki-index.js");
-          const result = await generateNexusWikiIndex(outputDir, process.cwd(), {
+          const result = await generateNexusWikiIndex(outputDir, getProjectRoot34(), {
             communityFilter,
             incremental: isIncremental,
             loomProvider,
-            projectRoot: process.cwd()
+            projectRoot: getProjectRoot34()
           });
           const durationMs = Date.now() - startTime;
           if (!result.success) {
@@ -54379,7 +54383,7 @@ var refresh_memory_exports = {};
 __export(refresh_memory_exports, {
   refreshMemoryCommand: () => refreshMemoryCommand
 });
-import { getProjectRoot as getProjectRoot32 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot35 } from "@cleocode/core";
 var refreshMemoryCommand;
 var init_refresh_memory = __esm({
   "packages/cleo/src/cli/commands/refresh-memory.ts"() {
@@ -54392,7 +54396,7 @@ var init_refresh_memory = __esm({
         description: "Regenerate .cleo/memory-bridge.md from brain.db"
       },
       async run() {
-        const projectDir = getProjectRoot32();
+        const projectDir = getProjectRoot35();
         const { writeMemoryBridge } = await import("@cleocode/core/internal");
         const result = await writeMemoryBridge(projectDir);
         if (result.written) {
@@ -55772,7 +55776,7 @@ __export(restore_exports, {
 });
 import fs3 from "node:fs";
 import path5 from "node:path";
-import { CleoError as CleoError8, getProjectRoot as getProjectRoot33, getTaskAccessor as getTaskAccessor3 } from "@cleocode/core";
+import { CleoError as CleoError8, getProjectRoot as getProjectRoot36, getTaskAccessor as getTaskAccessor3 } from "@cleocode/core";
 function parseMarkdownValue(raw) {
   const trimmed = raw.trim();
   if (trimmed === "_(not present)_" || trimmed === "") return void 0;
@@ -55892,7 +55896,7 @@ var init_restore = __esm({
         description: "Apply manually-resolved conflicts from .cleo/restore-conflicts.md"
       },
       async run() {
-        const projectRoot = getProjectRoot33();
+        const projectRoot = getProjectRoot36();
         const reportPath = path5.join(projectRoot, CLEO_DIR_NAME, RESTORE_CONFLICTS_MD);
         if (!fs3.existsSync(reportPath)) {
           humanLine("No pending restore conflicts. Nothing to finalize.");
@@ -58014,7 +58018,7 @@ var sequence_exports = {};
 __export(sequence_exports, {
   sequenceCommand: () => sequenceCommand
 });
-import { getProjectRoot as getProjectRoot34 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot37 } from "@cleocode/core/internal";
 var showCommand12, checkCommand6, repairCommand, sequenceCommand;
 var init_sequence = __esm({
   "packages/cleo/src/cli/commands/sequence.ts"() {
@@ -58050,7 +58054,7 @@ var init_sequence = __esm({
       meta: { name: "repair", description: "Reset counter to max + 1 if behind" },
       async run() {
         const { repairSequence } = await import("@cleocode/core/internal");
-        const projectRoot = getProjectRoot34();
+        const projectRoot = getProjectRoot37();
         const repair = await repairSequence(projectRoot);
         const result = {
           repaired: repair.repaired,
@@ -58493,8 +58497,8 @@ var init_session4 = __esm({
         "audit-scope": { type: "string", description: "Audit log scope (global|local)" }
       },
       async run({ args }) {
-        const { detectSessionDrift, getProjectRoot: getProjectRoot38 } = await import("@cleocode/core");
-        const projectRoot = await getProjectRoot38();
+        const { detectSessionDrift, getProjectRoot: getProjectRoot41 } = await import("@cleocode/core");
+        const projectRoot = await getProjectRoot41();
         const scope = args["audit-scope"] === "local" ? "local" : "global";
         const report = await detectSessionDrift({ projectRoot, auditScope: scope });
         cliOutput(report, { command: "session drift", operation: "session.drift" });
@@ -60695,7 +60699,7 @@ __export(token_exports, {
   tokenCommand: () => tokenCommand
 });
 import { readFileSync as readFileSync16 } from "node:fs";
-import { getProjectRoot as getProjectRoot35, measureTokenExchange, recordTokenExchange as recordTokenExchange2 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot38, measureTokenExchange, recordTokenExchange as recordTokenExchange2 } from "@cleocode/core/internal";
 function readPayload(args, textKey, fileKey) {
   const text = args[textKey];
   const file = args[fileKey];
@@ -60859,7 +60863,7 @@ var init_token = __esm({
           domain: args.domain,
           operation: args.operation
         };
-        const result = args.record ? await recordTokenExchange2(getProjectRoot35(), input2) : await measureTokenExchange(input2);
+        const result = args.record ? await recordTokenExchange2(getProjectRoot38(), input2) : await measureTokenExchange(input2);
         cliOutput(result, {
           command: "token",
           operation: args.record ? "admin.token.record" : "token.estimate"
@@ -60895,7 +60899,7 @@ __export(transcript_exports, {
 });
 import { homedir as homedir9 } from "node:os";
 import { join as join25 } from "node:path";
-import { getProjectRoot as getProjectRoot36 } from "@cleocode/core";
+import { getProjectRoot as getProjectRoot39 } from "@cleocode/core";
 import {
   parseDurationMs,
   pruneTranscripts,
@@ -60925,7 +60929,7 @@ var init_transcript = __esm({
       async run({ args }) {
         if (args.pending) {
           try {
-            const projectRoot = getProjectRoot36();
+            const projectRoot = getProjectRoot39();
             const { scanPendingTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
             const pending = await scanPendingTranscripts(projectRoot);
             cliOutput(
@@ -61022,7 +61026,7 @@ var init_transcript = __esm({
       async run({ args }) {
         const tier = args.tier ?? "warm";
         const dryRun = args["dry-run"] ?? false;
-        const projectRoot = getProjectRoot36();
+        const projectRoot = getProjectRoot39();
         try {
           const { extractTranscript } = await import("@cleocode/core/memory/transcript-extractor.js");
           const { findSessionTranscriptPath, listAllTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
@@ -61134,7 +61138,7 @@ var init_transcript = __esm({
         const dryRun = args["dry-run"] ?? false;
         const olderThanHours = args["older-than-hours"] ? Number.parseInt(args["older-than-hours"], 10) : 24;
         const limit = args.limit ? Number.parseInt(args.limit, 10) : void 0;
-        const projectRoot = getProjectRoot36();
+        const projectRoot = getProjectRoot39();
         try {
           const { extractTranscript } = await import("@cleocode/core/memory/transcript-extractor.js");
           const { listAllTranscripts } = await import("@cleocode/core/memory/transcript-scanner.js");
@@ -62249,7 +62253,7 @@ __export(worktree_exports, {
   worktreeCommand: () => worktreeCommand
 });
 import readline4 from "node:readline";
-import { getProjectRoot as getProjectRoot37, listWorktrees as listWorktrees2 } from "@cleocode/core/internal";
+import { getProjectRoot as getProjectRoot40, listWorktrees as listWorktrees2 } from "@cleocode/core/internal";
 async function promptYesNo2(question) {
   return new Promise((resolve8) => {
     const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
@@ -62348,7 +62352,7 @@ var init_worktree3 = __esm({
         const yes = args["yes"] === true;
         const staleDaysRaw = typeof args["days"] === "string" ? args["days"] : void 0;
         const staleDays = staleDaysRaw !== void 0 ? Number.parseInt(staleDaysRaw, 10) : void 0;
-        const projectRoot = getProjectRoot37();
+        const projectRoot = getProjectRoot40();
         const listResult = await listWorktrees2({
           projectRoot,
           ...staleDays !== void 0 && !Number.isNaN(staleDays) ? { staleDays } : {}
@@ -63777,7 +63781,7 @@ async function runStartupMaintenance() {
     detectAndRemoveStrayProjectNexus,
     getGlobalSalt,
     getLogger: getLogger20,
-    getProjectRoot: getProjectRoot38,
+    getProjectRoot: getProjectRoot41,
     isCleanupMarkerSet,
     migrateSignaldockToConduit,
     needsSignaldockToConduitMigration,
@@ -63786,7 +63790,7 @@ async function runStartupMaintenance() {
   } = await import("@cleocode/core/internal");
   let projectRootForCleanup = "";
   try {
-    projectRootForCleanup = getProjectRoot38();
+    projectRootForCleanup = getProjectRoot41();
   } catch {
   }
   if (!isCleanupMarkerSet(CLI_VERSION, projectRootForCleanup)) {
@@ -63806,7 +63810,7 @@ async function runStartupMaintenance() {
   const isInitInvocation = process.argv.slice(2).some((a) => a === "init");
   if (!isInitInvocation) {
     try {
-      const _projectRootForMigration = getProjectRoot38();
+      const _projectRootForMigration = getProjectRoot41();
       if (needsSignaldockToConduitMigration(_projectRootForMigration)) {
         const migrationResult = migrateSignaldockToConduit(_projectRootForMigration);
         if (migrationResult.status === "failed") {