@cleocode/cleo 2026.10.4 → 2026.10.5

package/dist/cli/nexus-FPQV2EAF.js

@@ -0,0 +1,1059 @@
+(() => {
+  const _installed = Symbol.for('cleocode.cli.sqliteWarningFilter');
+  if (globalThis[_installed]) return;
+  globalThis[_installed] = true;
+  const _origEmitWarning = process.emitWarning;
+  process.emitWarning = function(warning, type, code, ctor) {
+    if (typeof warning === 'object' && warning.name === 'ExperimentalWarning' && typeof warning.message === 'string' && /SQLite is an experimental feature/i.test(warning.message)) {
+      return;
+    }
+    if (typeof warning === 'string' && /SQLite is an experimental feature/i.test(warning)) {
+      return;
+    }
+    return _origEmitWarning.call(process, warning, type, code, ctor);
+  };
+})();
+import {
+  defineTypedHandler,
+  lafsError,
+  lafsSuccess,
+  typedDispatch,
+  wrapCoreResult
+} from "./chunk-QWNKLLLG.js";
+import {
+  lazyOperation
+} from "./chunk-TYC7G5LF.js";
+import {
+  envelopeToEngineResult,
+  errorResult,
+  handleErrorResult,
+  unsupportedOp,
+  wrapResult
+} from "./chunk-XHRZ7OYZ.js";
+
+// packages/cleo/src/dispatch/domains/nexus.ts
+import {
+  getNexusDescriptor,
+  NEXUS_SCOPE_MAP
+} from "@cleocode/contracts/operations/nexus-scope-map.js";
+import { getLogger } from "@cleocode/core/logger";
+import {
+  discloseNexusFreshness,
+  judgeSymbolFiles,
+  querySymbolFiles,
+  withNexusFreshnessMeta
+} from "@cleocode/core/nexus/freshness";
+import { resolveNexusQueryProjectId } from "@cleocode/core/nexus/registry.js";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+import { getBrainNativeDb } from "@cleocode/core/store/memory-sqlite";
+import { getNexusNativeDb } from "@cleocode/core/store/nexus-sqlite";
+import { stampNexusMeta } from "@cleocode/runtime/gateway/dispatch";
+var assessNexusFreshnessForQuery = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/freshness")).assessNexusFreshnessForQuery
+);
+var nexusAugment = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/augment")).nexusAugment
+);
+var nexusBlockers = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/deps")).nexusBlockers
+);
+var nexusBrainAnchors = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/living-brain")).nexusBrainAnchors
+);
+var nexusClusters = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/clusters")).nexusClusters
+);
+var nexusColdSymbols = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/plasticity-queries")).nexusColdSymbols
+);
+var nexusConduitScan = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/api-contracts")).nexusConduitScan
+);
+var nexusContext = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/context")).nexusContext
+);
+var nexusContractsLinkTasks = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/api-contracts")).nexusContractsLinkTasks
+);
+var nexusContractsShow = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/api-contracts")).nexusContractsShow
+);
+var nexusContractsSync = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/api-contracts")).nexusContractsSync
+);
+var nexusCriticalPath = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/deps")).nexusCriticalPath
+);
+var nexusDepsQuery = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/deps")).nexusDepsQuery
+);
+var nexusDiff = lazyOperation(async () => (await import("@cleocode/core/nexus/diff")).nexusDiff);
+var nexusDiscover = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/discover")).nexusDiscover
+);
+var nexusFlows = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/flows")).nexusFlows
+);
+var nexusFullContext = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/living-brain")).nexusFullContext
+);
+var nexusGraph = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/deps")).nexusGraph
+);
+var nexusHotNodes = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/plasticity-queries")).nexusHotNodes
+);
+var nexusHotPaths = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/plasticity-queries")).nexusHotPaths
+);
+var nexusImpact = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/impact")).nexusImpact
+);
+var nexusImpactFull = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/living-brain")).nexusImpactFull
+);
+var nexusInitialize = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusInitialize
+);
+var nexusListProjects = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusListProjects
+);
+var nexusOrphans = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/deps")).nexusOrphans
+);
+var nexusProfileExport = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/user-profile")).nexusProfileExport
+);
+var nexusProfileGet = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/user-profile")).nexusProfileGet
+);
+var nexusProfileImport = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/user-profile")).nexusProfileImport
+);
+var nexusProfileReinforce = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/user-profile")).nexusProfileReinforce
+);
+var nexusProfileSupersede = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/user-profile")).nexusProfileSupersede
+);
+var nexusProfileUpsert = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/user-profile")).nexusProfileUpsert
+);
+var nexusProfileView = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/user-profile")).nexusProfileView
+);
+var nexusProjectsClean = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/projects-clean")).nexusProjectsClean
+);
+var nexusProjectsFleet = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusProjectsFleet
+);
+var nexusProjectsList = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusProjectsList
+);
+var nexusProjectsRegister = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusProjectsRegister
+);
+var nexusProjectsRemove = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusProjectsRemove
+);
+var nexusProjectsScan = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/projects-scan")).nexusProjectsScan
+);
+var nexusProjectsStatus = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusProjectsStatus
+);
+var nexusQueryCte = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/query-dsl")).nexusQueryCte
+);
+var nexusReconcileProject = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusReconcileProject
+);
+var nexusRefreshBridge = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/nexus-bridge")).nexusRefreshBridge
+);
+var nexusRegisterProject = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusRegisterProject
+);
+var nexusResolve = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/query")).nexusResolve
+);
+var nexusRouteMap = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/route-analysis")).nexusRouteMap
+);
+var nexusSearch = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/discover")).nexusSearch
+);
+var nexusSearchCode = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/augment")).nexusSearchCode
+);
+var nexusSetPermission = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/permissions")).nexusSetPermission
+);
+var nexusShapeCheck = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/route-analysis")).nexusShapeCheck
+);
+var nexusShareSnapshotExport = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/transfer")).nexusShareSnapshotExport
+);
+var nexusShareSnapshotImport = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/transfer")).nexusShareSnapshotImport
+);
+var nexusShareStatus = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/sharing/index")).nexusShareStatus
+);
+var nexusShowProject = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusShowProject
+);
+var nexusSigilList = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/sigil")).nexusSigilList
+);
+var nexusSigilSync = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/sigil-sync")).nexusSigilSync
+);
+var nexusStatus = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusStatus
+);
+var nexusSyncProject = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusSyncProject
+);
+var nexusTaskFootprint = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/living-brain")).nexusTaskFootprint
+);
+var nexusTaskSymbols = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/api-contracts")).nexusTaskSymbols
+);
+var nexusTopEntries = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/query")).nexusTopEntries
+);
+var nexusTransferExecute = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/transfer")).nexusTransferExecute
+);
+var nexusTransferPreview = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/transfer")).nexusTransferPreview
+);
+var nexusUnregisterProject = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/registry")).nexusUnregisterProject
+);
+var nexusWhy = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/living-brain")).nexusWhy
+);
+var nexusWiki = lazyOperation(
+  async () => (await import("@cleocode/core/nexus/wiki-index")).nexusWiki
+);
+var _nexusTypedHandler = defineTypedHandler("nexus", {
+  // -------------------------------------------------------------------------
+  // Query ops (30)
+  // -------------------------------------------------------------------------
+  status: async (_params) => wrapCoreResult(await nexusStatus(), "status"),
+  list: async (params) => {
+    const result = await nexusListProjects(params.limit, params.offset);
+    if (!result.success) {
+      return lafsError(
+        String(result.error?.code ?? "E_INTERNAL"),
+        result.error?.message ?? "Unknown error",
+        "list"
+      );
+    }
+    const data = result.data;
+    return lafsSuccess(
+      { projects: data.projects, count: data.count, total: data.total, filtered: data.filtered },
+      "list",
+      { page: data.page ?? result.page }
+    );
+  },
+  show: async (params) => {
+    if (!params.name) return lafsError("E_INVALID_INPUT", "name is required", "show");
+    return wrapCoreResult(await nexusShowProject(params.name), "show");
+  },
+  resolve: async (params) => {
+    if (!params.query) return lafsError("E_INVALID_INPUT", "query is required", "resolve");
+    return wrapCoreResult(await nexusResolve(params.query, params.currentProject), "resolve");
+  },
+  deps: async (params) => {
+    if (!params.query) return lafsError("E_INVALID_INPUT", "query is required", "deps");
+    return wrapCoreResult(
+      await nexusDepsQuery(params.query, params.direction ?? "forward"),
+      "deps"
+    );
+  },
+  graph: async (_params) => wrapCoreResult(await nexusGraph(), "graph"),
+  "path.show": async (_params) => wrapCoreResult(await nexusCriticalPath(), "path.show"),
+  "blockers.show": async (params) => {
+    if (!params.query) return lafsError("E_INVALID_INPUT", "query is required", "blockers.show");
+    return wrapCoreResult(await nexusBlockers(params.query), "blockers.show");
+  },
+  "orphans.list": async (params) => {
+    const result = await nexusOrphans(params.limit, params.offset);
+    if (!result.success) {
+      return lafsError(
+        String(result.error?.code ?? "E_INTERNAL"),
+        result.error?.message ?? "Unknown error",
+        "orphans.list"
+      );
+    }
+    const data = result.data;
+    return lafsSuccess(
+      { orphans: data.orphans, count: data.count, total: data.total, filtered: data.filtered },
+      "orphans.list",
+      { page: data.page ?? result.page }
+    );
+  },
+  discover: async (params) => {
+    if (!params.query) return lafsError("E_INVALID_INPUT", "query is required", "discover");
+    return wrapCoreResult(
+      await nexusDiscover(params.query, params.method ?? "auto", params.limit ?? 10),
+      "discover"
+    );
+  },
+  search: async (params) => {
+    if (!params.pattern) return lafsError("E_INVALID_INPUT", "pattern is required", "search");
+    return wrapCoreResult(
+      await nexusSearch(params.pattern, params.project, params.limit ?? 20),
+      "search"
+    );
+  },
+  augment: async (params) => {
+    if (!params.pattern) return lafsError("E_INVALID_INPUT", "pattern is required", "augment");
+    return wrapCoreResult(await nexusAugment(params.pattern, params.limit ?? 5), "augment");
+  },
+  "share.status": async (_params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await nexusShareStatus(projectRoot), "share.status");
+  },
+  "transfer.preview": async (params) => {
+    if (!params.taskIds?.length || !params.sourceProject || !params.targetProject) {
+      return lafsError(
+        "E_INVALID_INPUT",
+        "taskIds, sourceProject, and targetProject are required",
+        "transfer.preview"
+      );
+    }
+    return wrapCoreResult(
+      await nexusTransferPreview({
+        taskIds: params.taskIds,
+        sourceProject: params.sourceProject,
+        targetProject: params.targetProject,
+        mode: params.mode ?? "copy",
+        scope: params.scope ?? "subtree"
+      }),
+      "transfer.preview"
+    );
+  },
+  "top-entries": async (params) => wrapCoreResult(
+    await nexusTopEntries({
+      limit: params?.limit,
+      kind: params?.kind,
+      nodeType: params?.nodeType
+    }),
+    "top-entries"
+  ),
+  impact: async (params) => {
+    if (!params.symbol) return lafsError("E_INVALID_INPUT", "symbol is required", "impact");
+    return wrapCoreResult(await nexusImpact(getProjectRoot(), params), "impact");
+  },
+  "full-context": async (params) => {
+    if (!params.symbol) return lafsError("E_INVALID_INPUT", "symbol is required", "full-context");
+    const projectRoot = getProjectRoot();
+    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 = getProjectRoot();
+    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 = getProjectRoot();
+    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 = getProjectRoot();
+    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 = getProjectRoot();
+    return wrapCoreResult(await nexusImpactFull(params.symbol, projectRoot), "impact-full");
+  },
+  "route-map": async (params) => {
+    const projectRoot = getProjectRoot();
+    const projectId = await resolveNexusQueryProjectId(projectRoot, params.projectId);
+    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 = getProjectRoot();
+    const projectId = await resolveNexusQueryProjectId(projectRoot, params.projectId);
+    return wrapCoreResult(
+      await nexusShapeCheck(params.routeSymbol, projectId, projectRoot),
+      "shape-check"
+    );
+  },
+  "search-code": async (params) => {
+    if (!params.pattern) return lafsError("E_INVALID_INPUT", "pattern is required", "search-code");
+    return wrapCoreResult(await nexusSearchCode(params.pattern, params.limit ?? 10), "search-code");
+  },
+  wiki: async (params) => {
+    const projectRoot = getProjectRoot();
+    const outputDir = params.outputDir ?? `${projectRoot}/.cleo/wiki`;
+    return wrapCoreResult(
+      await nexusWiki(outputDir, projectRoot, {
+        communityFilter: params.communityFilter,
+        incremental: params.incremental
+      }),
+      "wiki"
+    );
+  },
+  "contracts-show": async (params) => {
+    if (!params.projectA || !params.projectB)
+      return lafsError("E_INVALID_INPUT", "projectA and projectB are required", "contracts-show");
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await nexusContractsShow(params.projectA, params.projectB, projectRoot),
+      "contracts-show"
+    );
+  },
+  "task-symbols": async (params) => {
+    if (!params.taskId) return lafsError("E_INVALID_INPUT", "taskId is required", "task-symbols");
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await nexusTaskSymbols(params.taskId, projectRoot), "task-symbols");
+  },
+  "profile.view": async (params) => wrapCoreResult(
+    await nexusProfileView(params.minConfidence, params.includeSuperseded),
+    "profile.view"
+  ),
+  "profile.get": async (params) => {
+    if (!params.traitKey)
+      return lafsError("E_INVALID_INPUT", "traitKey is required", "profile.get");
+    return wrapCoreResult(await nexusProfileGet(params.traitKey), "profile.get");
+  },
+  "sigil.list": async (params) => wrapCoreResult(await nexusSigilList(params.role), "sigil.list"),
+  // T1510 — Phase 2 query ops
+  clusters: async (params) => {
+    const projectRoot = getProjectRoot();
+    const repoPath = params.repoPath ?? projectRoot;
+    const projectId = await resolveNexusQueryProjectId(repoPath, params.projectId);
+    return wrapCoreResult(await nexusClusters(projectId, repoPath), "clusters");
+  },
+  flows: async (params) => {
+    const projectRoot = getProjectRoot();
+    const repoPath = params.repoPath ?? projectRoot;
+    const projectId = await resolveNexusQueryProjectId(repoPath, params.projectId);
+    return wrapCoreResult(await nexusFlows(projectId, repoPath), "flows");
+  },
+  context: async (params) => {
+    if (!params.symbol) return lafsError("E_INVALID_INPUT", "symbol is required", "context");
+    const projectRoot = getProjectRoot();
+    const projectId = await resolveNexusQueryProjectId(projectRoot, params.projectId);
+    const limit = typeof params.limit === "number" ? params.limit : 20;
+    const showContent = params.content === true;
+    return wrapCoreResult(
+      await nexusContext(params.symbol, projectId, projectRoot, limit, showContent),
+      "context"
+    );
+  },
+  "projects.list": async (_params) => wrapCoreResult(await nexusProjectsList(), "projects.list"),
+  "projects.register": async (params) => {
+    if (!params.path) return lafsError("E_INVALID_INPUT", "path is required", "projects.register");
+    return wrapCoreResult(
+      await nexusProjectsRegister(params.path, params.name),
+      "projects.register"
+    );
+  },
+  "projects.remove": async (params) => {
+    if (!params.nameOrHash)
+      return lafsError("E_INVALID_INPUT", "nameOrHash is required", "projects.remove");
+    return wrapCoreResult(
+      await nexusProjectsRemove(params.nameOrHash),
+      "projects.remove"
+    );
+  },
+  "projects.scan": async (params) => wrapCoreResult(
+    await nexusProjectsScan({
+      roots: params.roots,
+      maxDepth: typeof params.maxDepth === "number" ? params.maxDepth : void 0,
+      autoRegister: params.autoRegister === true,
+      includeExisting: params.includeExisting === true
+    }),
+    "projects.scan"
+  ),
+  "projects.clean": async (params) => wrapCoreResult(
+    await nexusProjectsClean({
+      dryRun: params.dryRun === true,
+      pattern: params.pattern,
+      includeTemp: params.includeTemp === true,
+      includeTests: params.includeTests === true,
+      matchUnhealthy: params.matchUnhealthy === true,
+      matchNeverIndexed: params.matchNeverIndexed === true,
+      matchOrphaned: params.matchOrphaned === true,
+      removeFs: params.removeFs === true,
+      vacuum: params.vacuum === true
+    }),
+    "projects.clean"
+  ),
+  "projects.status": async (params) => wrapCoreResult(
+    await nexusProjectsStatus(getProjectRoot(), {
+      fetch: params.fetch === true,
+      concurrency: typeof params.concurrency === "number" ? params.concurrency : void 0,
+      timeoutMs: typeof params.timeoutMs === "number" ? params.timeoutMs : void 0,
+      staleAfterMs: typeof params.staleAfterMs === "number" ? params.staleAfterMs : void 0
+    }),
+    "projects.status"
+  ),
+  "projects.fleet": async (params) => wrapCoreResult(
+    await nexusProjectsFleet(getProjectRoot(), {
+      device: typeof params.device === "string" ? params.device : void 0,
+      missing: params.missing === true,
+      dirty: params.dirty === true,
+      behind: params.behind === true,
+      ahead: params.ahead === true,
+      stale: params.stale === true,
+      errored: params.errored === true,
+      staleAfterMs: typeof params.staleAfterMs === "number" ? params.staleAfterMs : void 0,
+      limit: typeof params.limit === "number" ? params.limit : void 0,
+      offset: typeof params.offset === "number" ? params.offset : void 0
+    }),
+    "projects.fleet"
+  ),
+  "refresh-bridge": async (params) => {
+    const projectRoot = getProjectRoot();
+    const repoPath = params.repoPath ?? projectRoot;
+    const projectId = params.projectId;
+    return wrapCoreResult(await nexusRefreshBridge(repoPath, projectId), "refresh-bridge");
+  },
+  diff: async (params) => {
+    const projectRoot = getProjectRoot();
+    const repoPath = params.repoPath ?? projectRoot;
+    return wrapCoreResult(
+      await nexusDiff(
+        repoPath,
+        params.beforeRef,
+        params.afterRef,
+        params.projectId
+      ),
+      "diff"
+    );
+  },
+  "query-cte": async (params) => {
+    if (!params.cte) return lafsError("E_INVALID_INPUT", "cte is required", "query-cte");
+    return wrapCoreResult(
+      await nexusQueryCte(params.cte, params.params),
+      "query-cte"
+    );
+  },
+  "hot-paths": async (params) => {
+    const projectRoot = getProjectRoot();
+    const limit = typeof params.limit === "number" ? params.limit : 20;
+    return wrapCoreResult(await nexusHotPaths(projectRoot, limit), "hot-paths");
+  },
+  "hot-nodes": async (params) => {
+    const projectRoot = getProjectRoot();
+    const limit = typeof params.limit === "number" ? params.limit : 20;
+    return wrapCoreResult(await nexusHotNodes(projectRoot, limit), "hot-nodes");
+  },
+  "cold-symbols": async (params) => {
+    const projectRoot = getProjectRoot();
+    const days = typeof params.days === "number" ? params.days : 30;
+    return wrapCoreResult(await nexusColdSymbols(projectRoot, days), "cold-symbols");
+  },
+  // -------------------------------------------------------------------------
+  // Mutate ops (18)
+  // -------------------------------------------------------------------------
+  init: async (_params) => wrapCoreResult(await nexusInitialize(), "init"),
+  register: async (params) => {
+    if (!params.path) return lafsError("E_INVALID_INPUT", "path is required", "register");
+    return wrapCoreResult(
+      await nexusRegisterProject(params.path, params.name, params.permission ?? "read"),
+      "register"
+    );
+  },
+  unregister: async (params) => {
+    if (!params.name) return lafsError("E_INVALID_INPUT", "name is required", "unregister");
+    return wrapCoreResult(await nexusUnregisterProject(params.name), "unregister");
+  },
+  sync: async (params) => wrapCoreResult(await nexusSyncProject(params.name), "sync"),
+  "permission.set": async (params) => {
+    if (!params.name) return lafsError("E_INVALID_INPUT", "name is required", "permission.set");
+    if (!params.level) return lafsError("E_INVALID_INPUT", "level is required", "permission.set");
+    if (!["read", "write", "execute"].includes(params.level)) {
+      return lafsError(
+        "E_INVALID_INPUT",
+        `Invalid permission level: ${params.level}. Must be: read, write, or execute`,
+        "permission.set"
+      );
+    }
+    return wrapCoreResult(
+      await nexusSetPermission(params.name, params.level),
+      "permission.set"
+    );
+  },
+  reconcile: async (params) => wrapCoreResult(
+    await nexusReconcileProject(params.projectRoot ?? getProjectRoot(), {
+      forceRebind: params.forceRebind === true
+    }),
+    "reconcile"
+  ),
+  "share.snapshot.export": async (params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await nexusShareSnapshotExport(projectRoot, params.outputPath),
+      "share.snapshot.export"
+    );
+  },
+  "share.snapshot.import": async (params) => {
+    if (!params.inputPath)
+      return lafsError("E_INVALID_INPUT", "inputPath is required", "share.snapshot.import");
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(
+      await nexusShareSnapshotImport(projectRoot, params.inputPath),
+      "share.snapshot.import"
+    );
+  },
+  transfer: async (params) => {
+    if (!params.taskIds?.length || !params.sourceProject || !params.targetProject) {
+      return lafsError(
+        "E_INVALID_INPUT",
+        "taskIds, sourceProject, and targetProject are required",
+        "transfer"
+      );
+    }
+    return wrapCoreResult(
+      await nexusTransferExecute({
+        taskIds: params.taskIds,
+        sourceProject: params.sourceProject,
+        targetProject: params.targetProject,
+        mode: params.mode ?? "copy",
+        scope: params.scope ?? "subtree",
+        onConflict: params.onConflict ?? "rename",
+        transferBrain: params.transferBrain ?? false
+      }),
+      "transfer"
+    );
+  },
+  "contracts-sync": async (params) => {
+    const projectRoot = getProjectRoot();
+    const repoPath = params.repoPath ?? projectRoot;
+    const projectId = await resolveNexusQueryProjectId(repoPath, params.projectId);
+    return wrapCoreResult(await nexusContractsSync(projectId, repoPath), "contracts-sync");
+  },
+  "contracts-link-tasks": async (params) => {
+    const projectRoot = getProjectRoot();
+    const repoPath = params.repoPath ?? projectRoot;
+    const projectId = await resolveNexusQueryProjectId(repoPath, params.projectId);
+    return wrapCoreResult(
+      await nexusContractsLinkTasks(projectId, repoPath),
+      "contracts-link-tasks"
+    );
+  },
+  "conduit-scan": async (_params) => {
+    const projectRoot = getProjectRoot();
+    return wrapCoreResult(await nexusConduitScan(projectRoot), "conduit-scan");
+  },
+  "profile.import": async (params) => wrapCoreResult(await nexusProfileImport(params.path), "profile.import"),
+  "profile.export": async (params) => wrapCoreResult(await nexusProfileExport(params.path), "profile.export"),
+  "profile.reinforce": async (params) => {
+    if (!params.traitKey)
+      return lafsError("E_INVALID_INPUT", "traitKey is required", "profile.reinforce");
+    return wrapCoreResult(
+      await nexusProfileReinforce(params.traitKey, params.source),
+      "profile.reinforce"
+    );
+  },
+  "profile.upsert": async (params) => {
+    if (!params.trait?.traitKey || !params.trait?.traitValue) {
+      return lafsError(
+        "E_INVALID_INPUT",
+        "trait.traitKey and trait.traitValue are required",
+        "profile.upsert"
+      );
+    }
+    return wrapCoreResult(await nexusProfileUpsert(params.trait), "profile.upsert");
+  },
+  "profile.supersede": async (params) => {
+    if (!params.oldKey || !params.newKey)
+      return lafsError("E_INVALID_INPUT", "oldKey and newKey are required", "profile.supersede");
+    return wrapCoreResult(
+      await nexusProfileSupersede(params.oldKey, params.newKey),
+      "profile.supersede"
+    );
+  },
+  "sigil.sync": async (_params) => wrapCoreResult(await nexusSigilSync(), "sigil.sync")
+});
+var QUERY_OPS = /* @__PURE__ */ new Set([
+  "share.status",
+  "status",
+  "list",
+  "show",
+  "resolve",
+  "deps",
+  "graph",
+  "path.show",
+  "blockers.show",
+  "orphans.list",
+  "discover",
+  "search",
+  "augment",
+  "transfer.preview",
+  "top-entries",
+  "impact",
+  "full-context",
+  "task-footprint",
+  "brain-anchors",
+  "why",
+  "impact-full",
+  "route-map",
+  "shape-check",
+  "search-code",
+  "wiki",
+  "contracts-show",
+  "task-symbols",
+  "profile.view",
+  "profile.get",
+  "sigil.list",
+  // T1510 — Phase 2 query ops
+  "clusters",
+  "flows",
+  "context",
+  "projects.list",
+  "projects.fleet",
+  "diff",
+  "query-cte",
+  "hot-paths",
+  "hot-nodes",
+  "cold-symbols"
+]);
+var MUTATE_OPS = /* @__PURE__ */ new Set([
+  "share.snapshot.export",
+  "share.snapshot.import",
+  "init",
+  "register",
+  "unregister",
+  "sync",
+  "permission.set",
+  "reconcile",
+  "transfer",
+  "contracts-sync",
+  "contracts-link-tasks",
+  "conduit-scan",
+  "profile.import",
+  "profile.export",
+  "profile.reinforce",
+  "profile.upsert",
+  "profile.supersede",
+  "sigil.sync",
+  // T1510 — Phase 2 mutate ops
+  "projects.register",
+  "projects.remove",
+  "projects.scan",
+  "projects.clean",
+  "projects.status",
+  "refresh-bridge"
+]);
+function nexusQueryEnvelopeToResponse(envelope, operation, startTime) {
+  const env = envelope;
+  let pageMetadata = env.page;
+  let resultData = env.data;
+  if (!pageMetadata && env.success && resultData && typeof resultData === "object") {
+    const dataObj = resultData;
+    if ("page" in dataObj && dataObj.page) {
+      pageMetadata = dataObj.page;
+      const { page: _removed, ...cleanData } = dataObj;
+      resultData = cleanData;
+    }
+  }
+  return wrapResult(
+    envelopeToEngineResult({
+      success: env.success,
+      data: resultData,
+      page: pageMetadata,
+      error: env.error
+    }),
+    "query",
+    "nexus",
+    operation,
+    startTime
+  );
+}
+function nexusMutateEnvelopeToResponse(envelope, operation, startTime) {
+  const env = envelope;
+  return wrapResult(
+    envelopeToEngineResult({
+      success: env.success,
+      data: env.data,
+      error: env.error
+    }),
+    "mutate",
+    "nexus",
+    operation,
+    startTime
+  );
+}
+var FRESHNESS_EXEMPT_OPS = /* @__PURE__ */ new Set(["diff"]);
+function isScopeMapOp(operation) {
+  return operation in NEXUS_SCOPE_MAP;
+}
+function answersFromGraph(operation) {
+  if (FRESHNESS_EXEMPT_OPS.has(operation) || !isScopeMapOp(operation)) return false;
+  return getNexusDescriptor(operation).indexSensitive === true;
+}
+function withFreshness(response, operation, assessment) {
+  const freshness = judgeSymbolFiles(assessment, querySymbolFiles(response.data));
+  discloseNexusFreshness(`nexus ${operation}`, freshness);
+  return {
+    ...response,
+    meta: { ...response.meta, ...withNexusFreshnessMeta(response.meta, freshness) }
+  };
+}
+var NexusHandler = class {
+  /**
+   * Execute a read-only nexus query operation.
+   *
+   * @param operation - The nexus query op name (e.g. 'status', 'list').
+   * @param params - Raw params from the dispatcher (narrowed internally).
+   */
+  async query(operation, params) {
+    const startTime = Date.now();
+    if (!QUERY_OPS.has(operation)) {
+      return unsupportedOp("query", "nexus", operation, startTime);
+    }
+    if (answersFromGraph(operation)) {
+      const assessment = await assessNexusFreshnessForQuery(getProjectRoot());
+      return withFreshness(await this.answer(operation, params, startTime), operation, assessment);
+    }
+    return this.answer(operation, params, startTime);
+  }
+  /** Run one validated query op and stamp its `_nexus` scope metadata. */
+  async answer(operation, params, startTime) {
+    if (operation === "top-entries") {
+      const r = await handleTopEntries(operation, params, startTime);
+      return stampNexusMeta(r, operation, params ?? {});
+    }
+    if (operation === "impact") {
+      const r = await handleImpact(operation, params, startTime);
+      return stampNexusMeta(r, operation, params ?? {});
+    }
+    try {
+      const envelope = await typedDispatch(
+        _nexusTypedHandler,
+        operation,
+        params ?? {}
+      );
+      const response = nexusQueryEnvelopeToResponse(envelope, operation, startTime);
+      return stampNexusMeta(response, operation, params ?? {});
+    } catch (error) {
+      getLogger("domain:nexus").error(
+        { gateway: "query", domain: "nexus", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("query", "nexus", operation, error, startTime);
+    }
+  }
+  /**
+   * Execute a state-modifying nexus mutation operation.
+   *
+   * @param operation - The nexus mutate op name (e.g. 'init', 'register').
+   * @param params - Raw params from the dispatcher (narrowed internally).
+   */
+  async mutate(operation, params) {
+    const startTime = Date.now();
+    if (!MUTATE_OPS.has(operation)) {
+      return unsupportedOp("mutate", "nexus", operation, startTime);
+    }
+    try {
+      const envelope = await typedDispatch(
+        _nexusTypedHandler,
+        operation,
+        params ?? {}
+      );
+      const response = nexusMutateEnvelopeToResponse(envelope, operation, startTime);
+      return stampNexusMeta(response, operation, params ?? {});
+    } catch (error) {
+      getLogger("domain:nexus").error(
+        { gateway: "mutate", domain: "nexus", operation, err: error },
+        error instanceof Error ? error.message : String(error)
+      );
+      return handleErrorResult("mutate", "nexus", operation, error, startTime);
+    }
+  }
+  /** Declared operations for introspection and validation. */
+  getSupportedOperations() {
+    return {
+      query: Array.from(QUERY_OPS),
+      mutate: Array.from(MUTATE_OPS)
+    };
+  }
+};
+async function handleTopEntries(operation, params, startTime) {
+  const rawLimit = params?.limit;
+  const limit = typeof rawLimit === "number" && Number.isFinite(rawLimit) && rawLimit > 0 ? Math.floor(rawLimit) : 20;
+  const brainDb = getBrainNativeDb();
+  if (brainDb !== null && brainDb !== void 0) {
+    return handleTopEntriesFromBrain(
+      operation,
+      params,
+      startTime,
+      brainDb,
+      limit
+    );
+  }
+  try {
+    const nexusDb = getNexusNativeDb();
+    if (!nexusDb) {
+      const emptyData = {
+        entries: [],
+        count: 0,
+        limit,
+        kind: params?.kind ?? null,
+        note: 'Neither brain.db nor nexus.db is available. Run "cleo nexus init" to initialize.'
+      };
+      return wrapResult({ success: true, data: emptyData }, "query", "nexus", operation, startTime);
+    }
+    return handleTopEntriesFromNexus(
+      operation,
+      params,
+      startTime,
+      nexusDb,
+      limit
+    );
+  } catch (dbErr) {
+    return handleErrorResult("query", "nexus", operation, dbErr, startTime);
+  }
+}
+function handleTopEntriesFromBrain(operation, params, startTime, db, limit) {
+  const rawNodeType = params?.nodeType;
+  const nodeType = typeof rawNodeType === "string" && rawNodeType.length > 0 ? rawNodeType : null;
+  let rows = [];
+  try {
+    const sql = nodeType === null ? `SELECT id, node_type, label, quality_score, last_activity_at, metadata_json
+             FROM brain_page_nodes
+            ORDER BY quality_score DESC
+            LIMIT ?` : `SELECT id, node_type, label, quality_score, last_activity_at, metadata_json
+             FROM brain_page_nodes
+            WHERE node_type = ?
+            ORDER BY quality_score DESC
+            LIMIT ?`;
+    const bindArgs = nodeType === null ? [limit] : [nodeType, limit];
+    const rawRows = db.prepare(sql).all(...bindArgs);
+    rows = rawRows.map((raw) => {
+      const r = raw;
+      return {
+        id: String(r["id"] ?? ""),
+        node_type: r["node_type"] != null ? String(r["node_type"]) : null,
+        label: r["label"] != null ? String(r["label"]) : null,
+        quality_score: r["quality_score"] != null ? Number(r["quality_score"]) : null,
+        last_activity_at: r["last_activity_at"] != null ? String(r["last_activity_at"]) : null,
+        metadata_json: r["metadata_json"] != null ? String(r["metadata_json"]) : null
+      };
+    });
+  } catch {
+    rows = [];
+  }
+  const entries = rows.map((r) => ({
+    id: r.id,
+    node_type: r.node_type ?? "unknown",
+    label: r.label ?? r.id,
+    quality_score: r.quality_score ?? 0,
+    last_activity_at: r.last_activity_at ?? "",
+    metadata_json: r.metadata_json ?? null
+  }));
+  const data = {
+    entries,
+    count: entries.length,
+    limit,
+    nodeType
+  };
+  return wrapResult({ success: true, data }, "query", "nexus", operation, startTime);
+}
+function handleTopEntriesFromNexus(operation, params, startTime, db, limit) {
+  const rawKind = params?.kind;
+  const kind = typeof rawKind === "string" && rawKind.length > 0 ? rawKind : null;
+  let rows = [];
+  try {
+    const sql = kind === null ? `SELECT r.source_id,
+                  SUM(COALESCE(w.weight, 0)) AS totalWeight,
+                  COUNT(*)                   AS edgeCount,
+                  n.label,
+                  n.kind,
+                  n.file_path
+             FROM nexus_relations r
+             LEFT JOIN nexus_relation_weights w ON w.relation_id = r.id
+             LEFT JOIN nexus_nodes n ON n.id = r.source_id
+            GROUP BY r.source_id
+            ORDER BY totalWeight DESC, edgeCount DESC
+            LIMIT ?` : `SELECT r.source_id,
+                  SUM(COALESCE(w.weight, 0)) AS totalWeight,
+                  COUNT(*)                   AS edgeCount,
+                  n.label,
+                  n.kind,
+                  n.file_path
+             FROM nexus_relations r
+             LEFT JOIN nexus_relation_weights w ON w.relation_id = r.id
+             LEFT JOIN nexus_nodes n ON n.id = r.source_id
+            WHERE n.kind = ?
+            GROUP BY r.source_id
+            ORDER BY totalWeight DESC, edgeCount DESC
+            LIMIT ?`;
+    const bindArgs = kind === null ? [limit] : [kind, limit];
+    const rawRows = db.prepare(sql).all(...bindArgs);
+    rows = rawRows.map((raw) => {
+      const r = raw;
+      return {
+        source_id: String(r["source_id"] ?? ""),
+        totalWeight: Number(r["totalWeight"] ?? 0),
+        edgeCount: Number(r["edgeCount"] ?? 0),
+        label: r["label"] != null ? String(r["label"]) : null,
+        kind: r["kind"] != null ? String(r["kind"]) : null,
+        file_path: r["file_path"] != null ? String(r["file_path"]) : null
+      };
+    });
+  } catch {
+    rows = [];
+  }
+  const entries = rows.map((r) => ({
+    nodeId: r.source_id,
+    label: r.label ?? r.source_id,
+    kind: r.kind ?? "unknown",
+    filePath: r.file_path ?? null,
+    totalWeight: r.totalWeight,
+    edgeCount: r.edgeCount
+  }));
+  const allZero = entries.length === 0 || entries.every((e) => e.totalWeight === 0);
+  const note = allZero ? "No Hebbian weights accumulated yet. Run a dream cycle or wait for plasticity updates." : void 0;
+  const data = {
+    entries,
+    count: entries.length,
+    limit,
+    kind,
+    ...note !== void 0 ? { note } : {}
+  };
+  return wrapResult({ success: true, data }, "query", "nexus", operation, startTime);
+}
+async function handleImpact(operation, params, startTime) {
+  if (typeof params?.symbol !== "string" || !params.symbol) {
+    return errorResult(
+      "query",
+      "nexus",
+      operation,
+      "E_INVALID_INPUT",
+      "symbol is required",
+      startTime
+    );
+  }
+  const projectId = typeof params.projectId === "string" ? params.projectId : void 0;
+  const depth = typeof params.depth === "number" ? params.depth : void 0;
+  const result = await nexusImpact(getProjectRoot(), {
+    symbol: params.symbol,
+    projectId,
+    why: params.why === true,
+    depth
+  });
+  return wrapResult(result, "query", "nexus", operation, startTime);
+}
+export {
+  NexusHandler
+};
+//# sourceMappingURL=nexus-FPQV2EAF.js.map