@cleocode/cleo 2026.10.3 → 2026.10.5-rc.ci.672

package/dist/cli/nexus-XSFXN5E6.js

@@ -0,0 +1,2924 @@
+(() => {
+  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 {
+  dispatchFromCli,
+  dispatchRaw
+} from "./chunk-L7ONYSV6.js";
+import "./chunk-6N6WGLXE.js";
+import "./chunk-4VASFLUW.js";
+import {
+  asCleoErrorLike,
+  cleoErrorCodeName
+} from "./chunk-VLEYOOPH.js";
+import {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import "./chunk-QKMBWYAS.js";
+import {
+  cliError,
+  cliOutput,
+  humanInfo,
+  humanWarn
+} from "./chunk-4RGSNUUP.js";
+import {
+  getFormatContext,
+  setFormatContext
+} from "./chunk-6JSJNYH2.js";
+import "./chunk-D7BAQNV2.js";
+import "./chunk-TYC7G5LF.js";
+
+// packages/cleo/src/cli/commands/nexus.ts
+import { statSync } from "node:fs";
+import { appendFile, mkdir } from "node:fs/promises";
+import path from "node:path";
+import {
+  ExitCode
+} from "@cleocode/contracts";
+import { getSymbolImpact } from "@cleocode/core/nexus";
+import { runNexusAnalysis } from "@cleocode/core/nexus/analyze-orchestrator.js";
+import {
+  parseAssessmentFilesRequest,
+  projectAssessmentFiles
+} from "@cleocode/core/nexus/assessment-projection.js";
+import { exportNexusGraph } from "@cleocode/core/nexus/export.js";
+import {
+  assessNexusFreshnessForQuery,
+  assessNexusIndexFreshness,
+  discloseNexusFreshness,
+  judgeSymbolFiles,
+  querySymbolFiles,
+  withNexusFreshnessMeta
+} from "@cleocode/core/nexus/freshness.js";
+import { KnowledgeSymbolAmbiguityError } from "@cleocode/core/nexus/knowledge.js";
+import { resolveNexusQueryProjectId } from "@cleocode/core/nexus/registry.js";
+import { runNexusWiki } from "@cleocode/core/nexus/wiki-orchestrator.js";
+import { getProjectRoot } from "@cleocode/core/project-scope";
+import { getCleoStateDir } from "@cleocode/paths";
+
+// packages/cleo/src/dispatch/nexus-decorator.ts
+import {
+  buildNexusMetaExtensions,
+  formatSuggestedNext,
+  pickDecoratorMetaExtensions,
+  stampNexusMeta,
+  validateSuggestedNext
+} from "@cleocode/runtime/gateway/dispatch";
+
+// packages/cleo/src/cli/commands/nexus.ts
+async function appendDeprecationTelemetry(op, replacement) {
+  try {
+    const dateStr = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    const dir = path.join(getCleoStateDir(), "nexus-deprecation");
+    await mkdir(dir, { recursive: true });
+    const record = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), op, replacement }) + "\n";
+    await appendFile(path.join(dir, `${dateStr}.jsonl`), record, "utf8");
+  } catch {
+  }
+}
+function applyJsonFlag(jsonFlag) {
+  if (jsonFlag) {
+    setFormatContext({ format: "json", source: "flag", quiet: false });
+  }
+}
+var initCommand = defineCommand({
+  meta: { name: "init", description: "Initialize NEXUS directory structure and registry" },
+  async run() {
+    await dispatchFromCli("mutate", "nexus", "init", {}, { command: "nexus" });
+  }
+});
+var registerCommand = defineCommand({
+  meta: { name: "register", description: "Register a project in the global registry" },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to the project directory",
+      required: true
+    },
+    name: {
+      type: "string",
+      description: "Custom project name (default: directory name)"
+    },
+    permissions: {
+      type: "string",
+      description: "Permissions: read|write|execute",
+      default: "read"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "register",
+      {
+        path: args.path,
+        name: args.name,
+        permission: args.permissions
+      },
+      { command: "nexus" }
+    );
+  }
+});
+var unregisterCommand = defineCommand({
+  meta: { name: "unregister", description: "Remove a project from the registry" },
+  args: {
+    nameOrHash: {
+      type: "positional",
+      description: "Project name or hash to unregister",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "unregister",
+      { name: args.nameOrHash },
+      { command: "nexus" }
+    );
+  }
+});
+var listCommand = defineCommand({
+  meta: { name: "list", description: "List all registered projects" },
+  async run() {
+    await dispatchFromCli("query", "nexus", "list", {}, { command: "nexus" });
+  }
+});
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show code intelligence index freshness: file count, node/relation counts, last indexed time, stale files. Per-file rows are counted (assessment.filesByStatus) and paged (assessment.filesPage; --limit/--offset/--file-status, --files for all). Falls back to NEXUS registry status if code-intelligence index is unavailable."
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to the project directory (default: cwd)",
+      required: false
+    },
+    "project-id": {
+      type: "string",
+      description: "Override the project ID (default: auto-detected from path)"
+    },
+    references: {
+      type: "boolean",
+      description: "Include every retained unresolved/unmodeled reference (large; the default reports referenceCount)"
+    },
+    // T12560: the per-file list is ~635 B per file (391 MB for one reporter),
+    // so the default reports counts plus a 20-row page and marks `files` withheld.
+    files: {
+      type: "boolean",
+      description: "Include every assessed file row under assessment.files (large; the default reports fileCount, filesByStatus and a 20-row filesPage)"
+    },
+    limit: {
+      type: "string",
+      description: "Rows in assessment.filesPage (default 20; 0 = every row)"
+    },
+    offset: {
+      type: "string",
+      description: "Rows to skip before assessment.filesPage (use filesPage.nextOffset)"
+    },
+    "file-status": {
+      type: "string",
+      description: "Page only files with this status: analyzed|excluded|unsupported|oversized|failed"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON (LAFS envelope format)"
+    },
+    // gh#1329, second half — DECLARE the global output flag so citty consumes
+    // it. Undeclared, `--output json` was consumed as the positional `path`,
+    // and `json` base64url'd into a well-formed project id: the flag silently
+    // changed WHICH PROJECT was queried, which is how the reporter reached the
+    // reporting bug. Same precedent as `docs.ts`, which declares it "for
+    // docs-command consistency".
+    //
+    // The repo-wide fix is the strict-flags chokepoint (gh#1276); declaring it
+    // here removes the hazard from the one command whose swallowed value selects
+    // a project rather than merely being ignored.
+    output: {
+      type: "string",
+      description: "Output mode: envelope|id|table|count|silent (global output flag; declared here so it is not consumed as the positional path)."
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const projectIdOverride = args["project-id"];
+    const repoPath = args.path ? path.resolve(args.path) : getProjectRoot();
+    const startTime = Date.now();
+    if (args.path) {
+      let isDir = false;
+      try {
+        isDir = statSync(repoPath).isDirectory();
+      } catch {
+        isDir = false;
+      }
+      if (!isDir) {
+        cliError(
+          `nexus status was given '${args.path}', which is not a directory.
+A project id can be derived from any string, so an unreadable path would otherwise produce a well-formed id and be reported alongside THIS project's counts. If you meant to pass a flag value, note that an undeclared flag on this subcommand is consumed as the positional path.`,
+          ExitCode.INVALID_INPUT,
+          {
+            name: "E_NEXUS_PATH_NOT_A_DIRECTORY",
+            fix: `cleo nexus status <existing project directory>   (omit the path to use the current project)`
+          },
+          { operation: "nexus.status" }
+        );
+        process.exitCode = ExitCode.INVALID_INPUT;
+        return;
+      }
+    }
+    let projectId;
+    try {
+      projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+    } catch (error) {
+      const typed = asCleoErrorLike(error);
+      const code = typed?.code ?? ExitCode.INVALID_INPUT;
+      const name = code === ExitCode.INVALID_INPUT && !typed?.codeName ? "E_NEXUS_CROSS_PROJECT_STATUS" : typed ? cleoErrorCodeName(typed) : "E_NEXUS_IDENTITY";
+      cliError(
+        error instanceof Error ? error.message : String(error),
+        code,
+        {
+          name,
+          fix: typed ? typed.fix : "Run nexus status from the intended project using its portable project id."
+        },
+        { operation: "nexus.status" }
+      );
+      process.exitCode = code;
+      return;
+    }
+    let filesRequest;
+    try {
+      filesRequest = parseAssessmentFilesRequest({
+        files: args.files,
+        limit: args.limit,
+        offset: args.offset,
+        fileStatus: args["file-status"]
+      });
+    } catch (err) {
+      cliError(
+        err instanceof Error ? err.message : String(err),
+        ExitCode.INVALID_INPUT,
+        {
+          name: "E_VALIDATION",
+          fix: "cleo nexus status --limit 20 --offset 0 --file-status failed"
+        },
+        { operation: "nexus.status" }
+      );
+      process.exitCode = ExitCode.INVALID_INPUT;
+      return;
+    }
+    const currentRoot = getProjectRoot();
+    if (args.path && path.resolve(repoPath) !== path.resolve(currentRoot)) {
+      cliError(
+        `nexus status cannot report on '${repoPath}' from this project.
+The code-intelligence graph is project-scoped (ADR-090 \xB7 T11648): one store per project, and the counts always describe the store that is open. Reporting them under '${repoPath}' would attribute this project's index to another.`,
+        ExitCode.INVALID_INPUT,
+        {
+          name: "E_NEXUS_CROSS_PROJECT_STATUS",
+          fix: `cd ${repoPath} && cleo nexus status`
+        },
+        { operation: "nexus.status" }
+      );
+      process.exitCode = ExitCode.INVALID_INPUT;
+      return;
+    }
+    try {
+      const [
+        { getNexusDb, nexusSchema },
+        { getIndexStats },
+        { readKnowledgeIndexAssessment, readKnowledgeIndexReferences }
+      ] = await Promise.all([
+        import("@cleocode/core/store/nexus-sqlite"),
+        import("@cleocode/nexus/pipeline"),
+        import("@cleocode/core/nexus/knowledge")
+      ]);
+      const db = await getNexusDb();
+      const tables = {
+        nexusNodes: nexusSchema.nexusNodes,
+        nexusRelations: nexusSchema.nexusRelations
+      };
+      const freshness = await assessNexusIndexFreshness(currentRoot);
+      const stats = await getIndexStats(projectId, repoPath, db, tables, {
+        staleScan: freshness.status === "unknown"
+      });
+      const summary = await readKnowledgeIndexAssessment(currentRoot);
+      const detailed = summary && args.references ? { ...summary, references: await readKnowledgeIndexReferences(currentRoot) } : summary;
+      const assessment = detailed && projectAssessmentFiles(detailed, filesRequest);
+      const durationMs = Date.now() - startTime;
+      cliOutput(
+        {
+          projectId,
+          repoPath,
+          ...stats,
+          ...freshness.status === "unknown" ? {} : { staleFileCount: freshness.staleFileCount },
+          freshness,
+          assessment
+        },
+        {
+          command: "nexus-status",
+          operation: "nexus.status",
+          extensions: {
+            duration_ms: durationMs,
+            ...buildNexusMetaExtensions("status", { projectId, path: repoPath })
+          }
+        }
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const ctx = getFormatContext();
+      if (ctx.format === "json") {
+        cliError(msg, 1, { name: "E_STATUS_FAILED" }, { operation: "nexus.status" });
+      } else {
+        humanWarn(`[nexus] Error: ${msg}`);
+        await dispatchFromCli("query", "nexus", "status", {}, { command: "nexus" });
+      }
+      process.exitCode = 1;
+    }
+  }
+});
+var showCommand = defineCommand({
+  meta: { name: "show", description: "Show details for a registered project by name" },
+  args: {
+    name: {
+      type: "positional",
+      description: "Project name",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli("query", "nexus", "show", { name: args.name }, { command: "nexus" });
+  }
+});
+var resolveCommand = defineCommand({
+  meta: {
+    name: "resolve",
+    description: "Resolve a task reference across projects (project:T### or T###)"
+  },
+  args: {
+    taskRef: {
+      type: "positional",
+      description: "Task reference to resolve",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "resolve",
+      { query: args.taskRef },
+      { command: "nexus" }
+    );
+  }
+});
+var discoverCommand = defineCommand({
+  meta: { name: "discover", description: "Find related tasks across projects" },
+  args: {
+    taskQuery: {
+      type: "positional",
+      description: "Task query string",
+      required: true
+    },
+    method: {
+      type: "string",
+      description: "Discovery method: labels|description|files|auto",
+      default: "auto"
+    },
+    limit: {
+      type: "string",
+      description: "Max results",
+      default: "10"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "discover",
+      {
+        query: args.taskQuery,
+        method: args.method,
+        limit: parseInt(args.limit, 10)
+      },
+      { command: "nexus" }
+    );
+  }
+});
+var augmentCommand = defineCommand({
+  meta: {
+    name: "augment",
+    description: "Augment symbol pattern with code context (for PreToolUse hooks)"
+  },
+  args: {
+    pattern: {
+      type: "positional",
+      description: "Symbol name or file pattern to search",
+      required: true
+    },
+    limit: {
+      type: "string",
+      description: "Max results to return (default: 5)",
+      default: "5"
+    }
+  },
+  async run({ args }) {
+    const pattern = args.pattern;
+    const limit = parseInt(args.limit, 10) || 5;
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "augment",
+      {
+        pattern,
+        limit
+      },
+      { command: "nexus" }
+    );
+  }
+});
+var setupCommand = defineCommand({
+  meta: {
+    name: "setup",
+    description: "Install Nexus PreToolUse hook augmenter"
+  },
+  args: {},
+  async run() {
+    try {
+      const { homedir } = await import("node:os");
+      const { installNexusAugmentHook } = await import("@cleocode/core/nexus/hooks-augment");
+      const homeDir = homedir();
+      installNexusAugmentHook(homeDir);
+      cliOutput({ homeDir }, { command: "nexus-setup", operation: "nexus.setup" });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      cliError(msg, 1, { name: "E_SETUP_FAILED" }, { operation: "nexus.setup" });
+      process.exitCode = 1;
+    }
+  }
+});
+var searchCommand = defineCommand({
+  meta: { name: "search", description: "Search tasks across projects by pattern" },
+  args: {
+    pattern: {
+      type: "positional",
+      description: "Search pattern",
+      required: true
+    },
+    project: {
+      type: "string",
+      description: "Limit search to specific project"
+    },
+    limit: {
+      type: "string",
+      description: "Max results",
+      default: "20"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "search",
+      {
+        pattern: args.pattern,
+        project: args.project,
+        limit: parseInt(args.limit, 10)
+      },
+      { command: "nexus" }
+    );
+  }
+});
+var depsCommand = defineCommand({
+  meta: { name: "deps", description: "Show cross-project dependencies" },
+  args: {
+    taskQuery: {
+      type: "positional",
+      description: "Task query string",
+      required: true
+    },
+    reverse: {
+      type: "boolean",
+      description: "Show reverse dependencies (what depends on this)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "deps",
+      {
+        query: args.taskQuery,
+        direction: args.reverse ? "reverse" : "forward"
+      },
+      { command: "nexus" }
+    );
+  }
+});
+var criticalPathCommand = defineCommand({
+  meta: {
+    name: "critical-path",
+    description: "Show global critical path across all registered projects"
+  },
+  async run() {
+    await dispatchFromCli("query", "nexus", "path.show", {}, { command: "nexus" });
+  }
+});
+var blockingCommand = defineCommand({
+  meta: { name: "blocking", description: "Show blocking impact analysis for a task" },
+  args: {
+    taskQuery: {
+      type: "positional",
+      description: "Task query string",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "blockers.show",
+      { query: args.taskQuery },
+      { command: "nexus" }
+    );
+  }
+});
+var orphansCommand = defineCommand({
+  meta: { name: "orphans", description: "Detect broken cross-project dependency references" },
+  async run() {
+    await dispatchFromCli("query", "nexus", "orphans.list", {}, { command: "nexus" });
+  }
+});
+var syncCommand = defineCommand({
+  meta: { name: "sync", description: "Sync project metadata (task count, labels)" },
+  args: {
+    project: {
+      type: "positional",
+      description: "Project name to sync (default: all)",
+      required: false
+    }
+  },
+  async run({ args }) {
+    if (args.project) {
+      await dispatchFromCli(
+        "mutate",
+        "nexus",
+        "sync",
+        { name: args.project },
+        { command: "nexus" }
+      );
+    } else {
+      await dispatchFromCli("mutate", "nexus", "sync", {}, { command: "nexus" });
+    }
+  }
+});
+var reconcileCommand = defineCommand({
+  meta: {
+    name: "reconcile",
+    description: "Reconcile current project with NEXUS registry (auto-register if new, update path if moved)"
+  },
+  args: {
+    path: {
+      type: "string",
+      description: "Project path (default: current directory)"
+    },
+    "force-rebind": {
+      type: "boolean",
+      description: "Point the registry row at this checkout even though its previous location still exists (T12470). Without it, that checkout is recorded as a candidate.",
+      default: false
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "reconcile",
+      {
+        projectRoot: args.path,
+        ...args["force-rebind"] ? { forceRebind: true } : {}
+      },
+      { command: "nexus" }
+    );
+  }
+});
+var graphCommand = defineCommand({
+  meta: { name: "graph", description: "Show full dependency graph across all registered projects" },
+  async run() {
+    await dispatchFromCli("query", "nexus", "graph", {}, { command: "nexus" });
+  }
+});
+var shareStatusCommand = defineCommand({
+  meta: {
+    name: "share-status",
+    description: "Show multi-contributor sharing status for the current project"
+  },
+  async run() {
+    await dispatchFromCli("query", "nexus", "share.status", {}, { command: "nexus" });
+  }
+});
+var transferPreviewCommand = defineCommand({
+  meta: {
+    name: "transfer-preview",
+    description: "Preview a task transfer between projects (dry-run, no changes made)"
+  },
+  args: {
+    taskIds: {
+      type: "positional",
+      description: "Task IDs to preview transfer for",
+      required: true
+    },
+    from: {
+      type: "string",
+      description: "Source project name",
+      required: true
+    },
+    to: {
+      type: "string",
+      description: "Target project name",
+      required: true
+    },
+    mode: {
+      type: "string",
+      description: "Transfer mode: copy|move",
+      default: "copy"
+    },
+    scope: {
+      type: "string",
+      description: "Transfer scope: single|subtree",
+      default: "subtree"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "transfer.preview",
+      {
+        taskIds: args.taskIds.split(",").map((s) => s.trim()),
+        sourceProject: args.from,
+        targetProject: args.to,
+        mode: args.mode,
+        scope: args.scope
+      },
+      { command: "nexus" }
+    );
+  }
+});
+var transferCommand = defineCommand({
+  meta: { name: "transfer", description: "Transfer tasks from one project to another" },
+  args: {
+    taskIds: {
+      type: "positional",
+      description: "Task IDs to transfer",
+      required: true
+    },
+    from: {
+      type: "string",
+      description: "Source project name",
+      required: true
+    },
+    to: {
+      type: "string",
+      description: "Target project name",
+      required: true
+    },
+    mode: {
+      type: "string",
+      description: "Transfer mode: copy|move",
+      default: "copy"
+    },
+    scope: {
+      type: "string",
+      description: "Transfer scope: single|subtree",
+      default: "subtree"
+    },
+    "on-conflict": {
+      type: "string",
+      description: "Conflict strategy: rename|skip|duplicate|fail",
+      default: "rename"
+    },
+    "transfer-brain": {
+      type: "boolean",
+      description: "Also transfer associated brain memory entries"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "transfer",
+      {
+        taskIds: args.taskIds.split(",").map((s) => s.trim()),
+        sourceProject: args.from,
+        targetProject: args.to,
+        mode: args.mode,
+        scope: args.scope,
+        onConflict: args["on-conflict"],
+        transferBrain: args["transfer-brain"]
+      },
+      { command: "nexus" }
+    );
+  }
+});
+var permissionSetCommand = defineCommand({
+  meta: {
+    name: "set",
+    description: "Set permission level for a registered project (read|write|execute)"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Project name",
+      required: true
+    },
+    level: {
+      type: "positional",
+      description: "Permission level: read|write|execute",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "permission.set",
+      { name: args.name, level: args.level },
+      { command: "nexus" }
+    );
+  }
+});
+var permissionCommand = defineCommand({
+  meta: { name: "permission", description: "Manage permissions for registered projects" },
+  subCommands: {
+    set: permissionSetCommand
+  }
+});
+var shareExportCommand = defineCommand({
+  meta: { name: "export", description: "Export a snapshot of current project state for sharing" },
+  args: {
+    output: {
+      type: "string",
+      description: "Output file path (default: auto-generated in current directory)"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "share.snapshot.export",
+      { outputPath: args.output },
+      { command: "nexus" }
+    );
+  }
+});
+var shareImportCommand = defineCommand({
+  meta: { name: "import", description: "Import a shared project snapshot" },
+  args: {
+    file: {
+      type: "positional",
+      description: "Path to snapshot file",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "share.snapshot.import",
+      { inputPath: args.file },
+      { command: "nexus" }
+    );
+  }
+});
+var shareCommand = defineCommand({
+  meta: { name: "share", description: "Multi-contributor sharing operations" },
+  subCommands: {
+    export: shareExportCommand,
+    import: shareImportCommand
+  }
+});
+var clustersCommand = defineCommand({
+  meta: {
+    name: "clusters",
+    description: "List all detected communities (Louvain clusters) from the last analysis"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to project directory (default: cwd)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    },
+    "project-id": {
+      type: "string",
+      description: "Override the project ID (default: auto-detected from path)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const projectIdOverride = args["project-id"];
+    const repoPath = args.path ? path.resolve(args.path) : getProjectRoot();
+    const projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+    const response = await dispatchRaw("query", "nexus", "clusters", { projectId, repoPath });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        { name: response.error?.code ?? "E_CLUSTERS_FAILED", details: response.error?.details },
+        { operation: "nexus.clusters", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, {
+      command: "nexus-clusters",
+      operation: "nexus.clusters",
+      extensions: { duration_ms: durationMs },
+      responseMeta: response.meta
+    });
+  }
+});
+var flowsCommand = defineCommand({
+  meta: {
+    name: "flows",
+    description: "List all detected execution flows (processes) from the last analysis"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to project directory (default: cwd)",
+      required: false
+    },
+    json: { type: "boolean", description: "Output result as JSON (LAFS envelope format)" },
+    "project-id": {
+      type: "string",
+      description: "Override the project ID (default: auto-detected from path)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const projectIdOverride = args["project-id"];
+    const repoPath = args.path ? path.resolve(args.path) : getProjectRoot();
+    const projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+    const response = await dispatchRaw("query", "nexus", "flows", { projectId, repoPath });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        { name: response.error?.code ?? "E_FLOWS_FAILED", details: response.error?.details },
+        { operation: "nexus.flows", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, {
+      command: "nexus-flows",
+      operation: "nexus.flows",
+      extensions: { duration_ms: durationMs },
+      responseMeta: response.meta
+    });
+  }
+});
+var contextCommand = defineCommand({
+  meta: {
+    name: "context",
+    description: "Show callers, callees, community membership, and process participation for a code symbol"
+  },
+  args: {
+    symbol: { type: "positional", description: "Symbol name to look up", required: true },
+    json: { type: "boolean", description: "Output result as JSON (LAFS envelope format)" },
+    "project-id": {
+      type: "string",
+      description: "Override the project ID (default: auto-detected from cwd)"
+    },
+    limit: { type: "string", description: "Max callers/callees to show per side", default: "20" },
+    content: { type: "boolean", description: "Append source code content for the symbol" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    void appendDeprecationTelemetry("nexus.context", "cleo graph context");
+    const startTime = Date.now();
+    const projectIdOverride = args["project-id"];
+    const repoPath = getProjectRoot();
+    const projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+    const limit = parseInt(args.limit, 10);
+    const symbolName = args.symbol;
+    const showContent = !!args.content;
+    const response = await dispatchRaw("query", "nexus", "context", {
+      symbol: symbolName,
+      projectId,
+      limit,
+      content: showContent,
+      _legacyAliasFor: "cleo graph context"
+    });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        { name: response.error?.code ?? "E_CONTEXT_FAILED", details: response.error?.details },
+        { operation: "nexus.context", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const result = response.data;
+    if (result.matchCount === 0) {
+      cliError(
+        `No symbol found matching '${symbolName}' in project ${projectId}`,
+        4,
+        { name: "E_NOT_FOUND" },
+        { operation: "nexus.context", duration_ms: durationMs }
+      );
+      process.exitCode = 4;
+      return;
+    }
+    cliOutput({ ...result, _symbolName: symbolName }, {
+      command: "nexus-context",
+      operation: "nexus.context",
+      extensions: { duration_ms: durationMs },
+      responseMeta: response.meta
+    });
+  }
+});
+var impactCommand = defineCommand({
+  meta: {
+    name: "impact",
+    description: "Show blast radius for a code symbol \u2014 direct callers (d=1), indirect callers (d=2), transitive (d=3)"
+  },
+  args: {
+    symbol: { type: "positional", description: "Symbol name to analyze", required: true },
+    json: { type: "boolean", description: "Output result as JSON (LAFS envelope format)" },
+    "project-id": {
+      type: "string",
+      description: "Override the project ID (default: auto-detected from cwd)"
+    },
+    depth: { type: "string", description: "Maximum traversal depth (default: 3)", default: "3" },
+    why: { type: "boolean", description: "Append reasons[] path-strings for each affected symbol" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const whyFlag = !!args.why;
+    const projectIdOverride = args["project-id"];
+    const repoPath = getProjectRoot();
+    const projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+    const maxDepth = Math.min(parseInt(args.depth, 10), 5);
+    const symbolName = args.symbol;
+    try {
+      const assessment = await assessNexusFreshnessForQuery(repoPath);
+      const result = await getSymbolImpact(symbolName, projectId, repoPath, {
+        maxDepth,
+        why: whyFlag
+      });
+      const freshness = judgeSymbolFiles(assessment, querySymbolFiles(result));
+      discloseNexusFreshness("nexus impact", freshness);
+      const durationMs = Date.now() - startTime;
+      cliOutput({ ...result, _symbolName: symbolName, _why: whyFlag }, {
+        command: "nexus-impact",
+        operation: "nexus.impact",
+        extensions: withNexusFreshnessMeta(
+          {
+            duration_ms: durationMs,
+            ...buildNexusMetaExtensions("impact", { symbol: symbolName, projectId })
+          },
+          freshness
+        )
+      });
+    } catch (err) {
+      const code = err instanceof Error && "code" in err ? err.code : void 0;
+      const msg = err instanceof Error ? err.message : String(err);
+      const durationMs = Date.now() - startTime;
+      if (err instanceof KnowledgeSymbolAmbiguityError) {
+        cliError(
+          err.message,
+          6,
+          {
+            name: err.code,
+            details: { candidates: err.candidates },
+            fix: "Use one of the exact candidate identifiers."
+          },
+          { operation: "nexus.impact", duration_ms: durationMs }
+        );
+        process.exitCode = 6;
+        return;
+      }
+      if (code === "E_NOT_FOUND") {
+        cliError(
+          msg,
+          4,
+          { name: "E_NOT_FOUND" },
+          { operation: "nexus.impact", duration_ms: durationMs }
+        );
+        process.exitCode = 4;
+        return;
+      }
+      cliError(
+        msg,
+        1,
+        { name: "E_IMPACT_FAILED" },
+        { operation: "nexus.impact", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+    }
+  }
+});
+var analyzeCommand = defineCommand({
+  meta: {
+    name: "analyze",
+    description: "Run code intelligence pipeline on a repository directory"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to repository directory (default: cwd)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    },
+    "project-id": {
+      type: "string",
+      description: "Override the project ID (default: auto-detected)"
+    },
+    "include-repositories": {
+      type: "string",
+      description: "Comma-separated relative nested repository/worktree paths explicitly included in this project index"
+    },
+    full: {
+      type: "boolean",
+      description: "Parse every file instead of reusing unchanged files (default: incremental, falling back to full with a stated reason). Also re-binds a moved project's graph (same project id, old recorded root) to the live root"
+    },
+    incremental: {
+      type: "boolean",
+      description: "Deprecated no-op: incremental analysis is now the default (use --full to rebuild)"
+    },
+    "drop-missing-repositories": {
+      type: "boolean",
+      description: "Drop included repositories that are missing on disk instead of refusing (the default keeps the previous graph). Dropped paths are reported with a one-command restore"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const projectIdOverride = args["project-id"];
+    const full = !!args.full;
+    const ctx = getFormatContext();
+    const repoPath = args.path ? path.resolve(args.path) : getProjectRoot();
+    if (args.incremental)
+      humanWarn(
+        "[nexus] --incremental is deprecated and has no effect: incremental is the default."
+      );
+    humanInfo(`[nexus] Analyzing: ${repoPath}${full ? " (full rebuild)" : ""}`);
+    humanInfo("[nexus] Staging replacement graph; current index remains available...");
+    try {
+      const result = await runNexusAnalysis({
+        repoPath,
+        projectIdOverride,
+        full,
+        dropMissingRepositories: args["drop-missing-repositories"] === true,
+        includedRepositories: args["include-repositories"]?.split(",").map((entry) => entry.trim()).filter(Boolean),
+        onProgress: ctx.format === "json" ? void 0 : (current, total, filePath) => {
+          if (current % 50 === 0 || current === total) {
+            const pct = total > 0 ? Math.round(current / total * 100) : 100;
+            humanInfo(`[nexus] Progress: ${current}/${total} files (${pct}%) \u2014 ${filePath}`);
+          }
+        }
+      });
+      humanInfo(`[nexus] nexus-bridge.md refreshed at ${repoPath}/.cleo/nexus-bridge.md`);
+      humanInfo("[nexus] Project registered/updated in multi-project registry.");
+      if (result.droppedRepositories)
+        humanWarn(
+          `[nexus] DROPPED missing included repositories: ${result.droppedRepositories.paths.join(", ")}. Restore them once they exist again: ${result.droppedRepositories.restoreCommand}`
+        );
+      if (result.rebind)
+        humanInfo(
+          `[nexus] Re-bound graph for ${result.rebind.projectId}: ${result.rebind.oldRoot} -> ${result.rebind.newRoot}`
+        );
+      humanInfo(
+        `[nexus] Mode: ${result.summary.mode} \u2014 ${result.summary.reason} (parsed ${result.summary.parsedFiles}, reused ${result.summary.reusedFiles})`
+      );
+      cliOutput(
+        {
+          projectId: result.projectId,
+          repoPath,
+          incremental: result.incremental,
+          mode: result.summary.mode,
+          reason: result.summary.reason,
+          summary: result.summary,
+          nodeCount: result.nodeCount,
+          relationCount: result.relationCount,
+          fileCount: result.fileCount,
+          durationMs: result.durationMs,
+          assessment: result.assessment,
+          // T12659: receipt of a moved project's graph re-bound to the live root.
+          ...result.rebind ? { rebind: result.rebind } : {},
+          ...result.droppedRepositories ? { droppedRepositories: result.droppedRepositories } : {}
+        },
+        {
+          command: "nexus-analyze",
+          operation: "nexus.analyze",
+          extensions: { duration_ms: result.durationMs }
+        }
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      cliError(
+        msg,
+        1,
+        { name: "E_PIPELINE_FAILED" },
+        { operation: "nexus.analyze", duration_ms: Date.now() - startTime }
+      );
+      process.exitCode = 1;
+    }
+  }
+});
+var projectsListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List all projects registered in the global nexus registry"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const response = await dispatchRaw("query", "nexus", "projects.list", {});
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        {
+          name: response.error?.code ?? "E_PROJECTS_LIST_FAILED",
+          details: response.error?.details
+        },
+        { operation: "nexus.projects.list", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, {
+      command: "nexus-projects-list",
+      operation: "nexus.projects.list",
+      extensions: { duration_ms: durationMs },
+      responseMeta: response.meta
+    });
+  }
+});
+var projectsRegisterCommand = defineCommand({
+  meta: {
+    name: "register",
+    description: "Register a project in the global nexus registry (default: current directory)"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to the project directory (default: cwd)",
+      required: false
+    },
+    name: {
+      type: "string",
+      description: "Custom project name (default: directory name)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const repoPath = args.path ? path.resolve(args.path) : getProjectRoot();
+    const name = args.name;
+    const response = await dispatchRaw("mutate", "nexus", "projects.register", {
+      path: repoPath,
+      name
+    });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        { name: response.error?.code ?? "E_REGISTER_FAILED", details: response.error?.details },
+        { operation: "nexus.projects.register", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, {
+      command: "nexus-projects-register",
+      operation: "nexus.projects.register",
+      extensions: { duration_ms: durationMs },
+      responseMeta: response.meta
+    });
+  }
+});
+var projectsRemoveCommand = defineCommand({
+  meta: {
+    name: "remove",
+    description: "Remove a project from the global nexus registry"
+  },
+  args: {
+    nameOrHash: {
+      type: "positional",
+      description: "Project name or hash to remove",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const response = await dispatchRaw("mutate", "nexus", "projects.remove", {
+      nameOrHash: args.nameOrHash
+    });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        { name: response.error?.code ?? "E_REMOVE_FAILED", details: response.error?.details },
+        { operation: "nexus.projects.remove", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(
+      { ...response.data ?? {}, nameOrHash: args.nameOrHash },
+      {
+        command: "nexus-projects-remove",
+        operation: "nexus.projects.remove",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var projectsScanCommand = defineCommand({
+  meta: {
+    name: "scan",
+    description: "Walk filesystem roots to discover .cleo/ directories not registered in the global nexus registry"
+  },
+  args: {
+    roots: {
+      type: "string",
+      description: "Comma-separated search roots (default: parent directories of registered projects; ~/code,~/projects when none)"
+    },
+    "max-depth": {
+      type: "string",
+      description: "Maximum directory traversal depth (default: 4)",
+      default: "4"
+    },
+    "auto-register": {
+      type: "boolean",
+      description: "Register all discovered unregistered projects automatically"
+    },
+    "include-existing": {
+      type: "boolean",
+      description: "Also report projects that are already registered"
+    },
+    json: { type: "boolean", description: "Output as JSON (LAFS envelope format)" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const autoRegister = !!args["auto-register"];
+    const includeExisting = !!args["include-existing"];
+    const maxDepth = Math.max(1, Math.min(parseInt(args["max-depth"], 10), 20));
+    humanInfo(`[nexus] Scanning up to depth ${maxDepth} for .cleo/ project roots...`);
+    const response = await dispatchRaw("mutate", "nexus", "projects.scan", {
+      roots: args.roots,
+      maxDepth,
+      autoRegister,
+      includeExisting
+    });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        {
+          name: response.error?.code ?? "E_PROJECTS_SCAN_FAILED",
+          details: response.error?.details
+        },
+        { operation: "nexus.projects.scan", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(
+      {
+        ...response.data ?? {},
+        _maxDepth: maxDepth,
+        _autoRegister: autoRegister,
+        _includeExisting: includeExisting
+      },
+      {
+        command: "nexus-projects-scan",
+        operation: "nexus.projects.scan",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var projectsCleanCommand = defineCommand({
+  meta: {
+    name: "clean",
+    description: "Bulk purge project_registry rows matching path criteria (requires at least one filter flag)"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "List matching projects without deleting anything"
+    },
+    pattern: {
+      type: "string",
+      description: "JS regex matched against project_path"
+    },
+    "include-temp": {
+      type: "boolean",
+      description: "Preset: match paths containing a .temp/ segment or under the OS temp directory"
+    },
+    "include-tests": {
+      type: "boolean",
+      description: "Preset: match paths containing tmp/test(s)/__tests__/fixture(s)/scratch/sandbox segments"
+    },
+    unhealthy: {
+      type: "boolean",
+      description: 'Also match rows where health_status is "unhealthy"'
+    },
+    "never-indexed": {
+      type: "boolean",
+      description: "Also match rows where last_indexed IS NULL"
+    },
+    orphans: {
+      type: "boolean",
+      description: "Also match rows whose project_path no longer exists on disk (T9117)"
+    },
+    "rm-fs": {
+      type: "boolean",
+      description: "After DB delete, rm -rf each matched on-disk directory (T9117). Implies --yes when combined with --orphans for fully unattended runs is still gated by confirmation."
+    },
+    vacuum: {
+      type: "boolean",
+      description: "After delete, VACUUM the global registry store (<cleoHome>/cleo.db) to reclaim space"
+    },
+    yes: {
+      type: "boolean",
+      description: "Skip confirmation prompt (still shows preview)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const dryRun = !!args["dry-run"];
+    const skipPrompt = !!args.yes;
+    const ctx = getFormatContext();
+    const cleanOpts = {
+      pattern: args.pattern,
+      includeTemp: !!args["include-temp"],
+      includeTests: !!args["include-tests"],
+      matchUnhealthy: !!args.unhealthy,
+      matchNeverIndexed: !!args["never-indexed"],
+      matchOrphaned: !!args.orphans,
+      removeFs: !!args["rm-fs"],
+      vacuum: !!args.vacuum
+    };
+    try {
+      const previewResp = await dispatchRaw("mutate", "nexus", "projects.clean", {
+        ...cleanOpts,
+        dryRun: true
+      });
+      if (!previewResp.success) {
+        const code = previewResp.error?.code ?? "E_CLEAN_FAILED";
+        const msg = previewResp.error?.message ?? "Unknown error";
+        const exitCode = code === "E_NO_CRITERIA" || code === "E_INVALID_PATTERN" ? 6 : 1;
+        cliError(
+          msg,
+          exitCode,
+          { name: code },
+          { operation: "nexus.projects.clean", duration_ms: Date.now() - startTime }
+        );
+        process.exitCode = exitCode;
+        return;
+      }
+      const preview = previewResp.data;
+      const {
+        matched: matchCount,
+        totalCount,
+        sample: samplePaths,
+        classification,
+        matchedByReason
+      } = preview;
+      if (ctx.format !== "json") {
+        cliOutput(
+          {
+            matched: matchCount,
+            totalCount,
+            sample: samplePaths,
+            classification,
+            ...preview.relocated ? { relocated: preview.relocated } : {},
+            ...preview.unreadable ? { unreadable: preview.unreadable } : {},
+            ...preview.idMismatch ? { idMismatch: preview.idMismatch } : {}
+          },
+          {
+            command: "nexus-projects-clean-preview",
+            operation: "nexus.projects.clean",
+            responseMeta: previewResp.meta
+          }
+        );
+      }
+      if (matchCount === 0 || dryRun) {
+        const durationMs2 = Date.now() - startTime;
+        cliOutput(
+          {
+            dryRun: true,
+            matched: matchCount,
+            purged: 0,
+            remaining: totalCount,
+            sample: samplePaths,
+            classification,
+            matchedByReason,
+            ...preview.relocated ? { relocated: preview.relocated } : {},
+            ...preview.unreadable ? { unreadable: preview.unreadable } : {},
+            ...preview.idMismatch ? { idMismatch: preview.idMismatch } : {}
+          },
+          {
+            command: "nexus-projects-clean",
+            operation: "nexus.projects.clean",
+            extensions: { duration_ms: durationMs2 },
+            responseMeta: previewResp.meta
+          }
+        );
+        return;
+      }
+      if (!skipPrompt) {
+        const { createInterface } = await import("node:readline");
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        const confirmed = await new Promise((resolve) => {
+          rl.question(
+            `
+[nexus] Delete ${matchCount} project(s) from the registry? [y/N] `,
+            (answer) => {
+              rl.close();
+              resolve(answer.trim().toLowerCase() === "y");
+            }
+          );
+        });
+        if (!confirmed) {
+          cliOutput(
+            { aborted: true, message: "No projects deleted." },
+            { command: "nexus-projects-clean", operation: "nexus.projects.clean" }
+          );
+          return;
+        }
+      }
+      const deleteResp = await dispatchRaw("mutate", "nexus", "projects.clean", {
+        ...cleanOpts,
+        dryRun: false
+      });
+      const durationMs = Date.now() - startTime;
+      if (!deleteResp.success) {
+        const code = deleteResp.error?.code ?? "E_CLEAN_FAILED";
+        const msg = deleteResp.error?.message ?? "Unknown error";
+        const exitCode = code === "E_NO_CRITERIA" || code === "E_INVALID_PATTERN" ? 6 : 1;
+        cliError(
+          msg,
+          exitCode,
+          { name: code },
+          { operation: "nexus.projects.clean", duration_ms: durationMs }
+        );
+        process.exitCode = exitCode;
+        return;
+      }
+      const result = deleteResp.data;
+      cliOutput(
+        {
+          dryRun: false,
+          matched: result.matched,
+          purged: result.purged,
+          remaining: result.remaining,
+          sample: result.sample,
+          fsRemoved: result.fsRemoved,
+          fsFailed: result.fsFailed,
+          vacuumBytesFreed: result.vacuumBytesFreed,
+          classification: result.classification,
+          matchedByReason: result.matchedByReason,
+          receipt: result.receipt,
+          ...result.relocated ? { relocated: result.relocated } : {},
+          ...result.unreadable ? { unreadable: result.unreadable } : {},
+          ...result.idMismatch ? { idMismatch: result.idMismatch } : {}
+        },
+        {
+          command: "nexus-projects-clean",
+          operation: "nexus.projects.clean",
+          extensions: { duration_ms: durationMs },
+          responseMeta: deleteResp.meta
+        }
+      );
+    } catch (err) {
+      const durationMs = Date.now() - startTime;
+      const msg = err instanceof Error ? err.message : String(err);
+      cliError(
+        msg,
+        1,
+        { name: "E_CLEAN_FAILED" },
+        { operation: "nexus.projects.clean", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+    }
+  }
+});
+function intFlag(value, min) {
+  if (value === void 0 || value === "") return void 0;
+  const n = Number(value);
+  return Number.isInteger(n) && n >= min ? n : null;
+}
+var projectsStatusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Fleet view: every project, its location on each device, and its last recorded git state (branch, head, dirty, ahead/behind as of the last fetch) with staleness; paged, counts first. Reads recorded probes; --refresh re-probes this device (bounded), --fetch also fetches"
+  },
+  args: {
+    refresh: {
+      type: "boolean",
+      description: "Re-probe this device first (bounded concurrency, per-repo timeout; no network)"
+    },
+    fetch: {
+      type: "boolean",
+      description: "Re-probe this device with git fetch per location first (network; implies --refresh)"
+    },
+    device: {
+      type: "string",
+      description: "Only locations on this device (device id, hostname, or current)"
+    },
+    missing: { type: "boolean", description: "Only projects with a missing location" },
+    dirty: { type: "boolean", description: "Only projects with uncommitted or untracked changes" },
+    behind: {
+      type: "boolean",
+      description: "Only projects behind their upstream (as of last fetch)"
+    },
+    ahead: {
+      type: "boolean",
+      description: "Only projects ahead of their upstream (as of last fetch)"
+    },
+    stale: {
+      type: "boolean",
+      description: "Only projects never probed, or probed/fetched longer ago than --stale-after-ms"
+    },
+    errored: { type: "boolean", description: "Only projects whose last probe recorded an error" },
+    limit: { type: "string", description: "Projects per page (default 50, max 500; 0 = all)" },
+    offset: { type: "string", description: "Projects skipped before the page (default 0)" },
+    concurrency: {
+      type: "string",
+      description: "With --refresh: locations probed at once (default 8, max 64)"
+    },
+    "timeout-ms": {
+      type: "string",
+      description: "With --refresh: per-location git budget in ms (default 10000; 30000 with --fetch)"
+    },
+    "stale-after-ms": {
+      type: "string",
+      description: "Staleness window for probes, fetches and heartbeats (default 86400000)"
+    },
+    json: { type: "boolean", description: "Output as JSON (LAFS envelope format)" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const concurrency = intFlag(args.concurrency, 1);
+    const timeoutMs = intFlag(args["timeout-ms"], 1);
+    const staleAfterMs = intFlag(args["stale-after-ms"], 1);
+    const limit = intFlag(args.limit, 0);
+    const offset = intFlag(args.offset, 0);
+    if ([concurrency, timeoutMs, staleAfterMs, limit, offset].includes(null)) {
+      cliError(
+        "--concurrency, --timeout-ms and --stale-after-ms take positive integers; --limit and --offset take integers >= 0",
+        6,
+        { name: "E_VALIDATION" },
+        { operation: "nexus.projects.fleet", duration_ms: 0 }
+      );
+      process.exitCode = 6;
+      return;
+    }
+    const fetch = args.fetch === true;
+    let refresh;
+    if (fetch || args.refresh === true) {
+      const probe = await dispatchRaw("mutate", "nexus", "projects.status", {
+        fetch,
+        concurrency: concurrency ?? void 0,
+        timeoutMs: timeoutMs ?? void 0,
+        staleAfterMs: staleAfterMs ?? void 0
+      });
+      if (!probe.success) {
+        const probeExit = probe.error?.exitCode ?? 1;
+        cliError(
+          probe.error?.message ?? "Unknown error",
+          probeExit,
+          { name: probe.error?.code ?? "E_PROJECTS_STATUS_FAILED", details: probe.error?.details },
+          { operation: "nexus.projects.status", duration_ms: Date.now() - startTime }
+        );
+        process.exitCode = probeExit;
+        return;
+      }
+      const probed = probe.data;
+      refresh = {
+        deviceId: probed.deviceId,
+        count: probed.count,
+        fetched: probed.fetched,
+        durationMs: probed.durationMs,
+        summary: probed.summary
+      };
+    }
+    const response = await dispatchRaw("query", "nexus", "projects.fleet", {
+      device: typeof args.device === "string" ? args.device : void 0,
+      missing: args.missing === true,
+      dirty: args.dirty === true,
+      behind: args.behind === true,
+      ahead: args.ahead === true,
+      stale: args.stale === true,
+      errored: args.errored === true,
+      staleAfterMs: staleAfterMs ?? void 0,
+      limit: limit ?? void 0,
+      offset: offset ?? void 0
+    });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const code = response.error?.code ?? "E_PROJECTS_FLEET_FAILED";
+      const exitCode = response.error?.exitCode ?? 1;
+      cliError(
+        response.error?.message ?? "Unknown error",
+        exitCode,
+        { name: code, details: response.error?.details },
+        { operation: "nexus.projects.fleet", duration_ms: durationMs }
+      );
+      process.exitCode = exitCode;
+      return;
+    }
+    cliOutput(
+      { ...response.data, ...refresh ? { refresh } : {} },
+      {
+        command: "nexus-projects-fleet",
+        operation: "nexus.projects.fleet",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var projectsCommand = defineCommand({
+  meta: { name: "projects", description: "Multi-project registry management" },
+  subCommands: {
+    list: projectsListCommand,
+    register: projectsRegisterCommand,
+    remove: projectsRemoveCommand,
+    scan: projectsScanCommand,
+    clean: projectsCleanCommand,
+    status: projectsStatusCommand
+  }
+});
+var refreshBridgeCommand = defineCommand({
+  meta: {
+    name: "refresh-bridge",
+    description: "Regenerate .cleo/nexus-bridge.md from the existing nexus.db index (does not re-index)"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to project directory (default: cwd)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    },
+    "project-id": {
+      type: "string",
+      description: "Override the project ID (default: auto-detected from path)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const projectIdOverride = args["project-id"];
+    const repoPath = args.path ? path.resolve(args.path) : getProjectRoot();
+    const projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+    const response = await dispatchRaw("mutate", "nexus", "refresh-bridge", {
+      repoPath,
+      projectId
+    });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        { name: response.error?.code ?? "E_BRIDGE_FAILED", details: response.error?.details },
+        { operation: "nexus.refresh-bridge", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, {
+      command: "nexus-refresh-bridge",
+      operation: "nexus.refresh-bridge",
+      extensions: { duration_ms: durationMs },
+      responseMeta: response.meta
+    });
+  }
+});
+var exportCommand = defineCommand({
+  meta: { name: "export", description: "Export nexus graph to GEXF (Gephi) or JSON format" },
+  args: {
+    format: {
+      type: "string",
+      description: "Output format: gexf, json",
+      default: "gexf"
+    },
+    output: {
+      type: "string",
+      description: "Output file path (stdout if omitted)"
+    },
+    project: {
+      type: "string",
+      description: "Filter by project ID (exports all projects if omitted)"
+    }
+  },
+  async run({ args }) {
+    const startTime = Date.now();
+    const format = args.format ?? "gexf";
+    const outputFile = args.output;
+    const projectFilter = args.project;
+    try {
+      const result = await exportNexusGraph({
+        format,
+        projectFilter
+      });
+      if (outputFile) {
+        const { writeFileSync } = await import("node:fs");
+        writeFileSync(outputFile, result.content, "utf-8");
+        const durationMs = Date.now() - startTime;
+        cliOutput(
+          { outputFile, nodeCount: result.nodeCount, edgeCount: result.edgeCount },
+          {
+            command: "nexus-export",
+            operation: "nexus.export",
+            extensions: { duration_ms: durationMs }
+          }
+        );
+        humanInfo(`[nexus] Export completed in ${durationMs}ms`);
+      } else {
+        process.stdout.write(result.content);
+        if (!result.content.endsWith("\n")) process.stdout.write("\n");
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("Unknown format")) {
+        cliError(msg, 1, { name: "E_INVALID_INPUT" }, { operation: "nexus.export" });
+      } else {
+        cliError(msg, 1, { name: "E_EXPORT_FAILED" }, { operation: "nexus.export" });
+      }
+      process.exitCode = 1;
+    }
+  }
+});
+var diffCommand = defineCommand({
+  meta: {
+    name: "diff",
+    description: "Compare NEXUS index state between two git commits \u2014 shows new/removed relations and broken call chains"
+  },
+  args: {
+    before: {
+      type: "string",
+      description: 'Git SHA or ref for the "before" snapshot (default: HEAD~1)'
+    },
+    after: {
+      type: "string",
+      description: 'Git SHA or ref for the "after" snapshot (default: HEAD)',
+      default: "HEAD"
+    },
+    path: { type: "string", description: "Repository directory to analyze (default: cwd)" },
+    json: { type: "boolean", description: "Output result as JSON (LAFS envelope format)" },
+    "project-id": {
+      type: "string",
+      description: "Override the project ID (default: auto-detected from path)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const repoPath = args.path ? path.resolve(args.path) : getProjectRoot();
+    const projectIdOverride = args["project-id"];
+    const beforeRef = args.before ?? "HEAD~1";
+    const afterRef = args.after ?? "HEAD";
+    humanInfo(`[nexus] Diffing relations: ${beforeRef}..${afterRef} in ${repoPath}`);
+    const response = await dispatchRaw("query", "nexus", "diff", {
+      repoPath,
+      beforeRef,
+      afterRef,
+      projectId: projectIdOverride
+    });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        { name: response.error?.code ?? "E_DIFF_FAILED", details: response.error?.details },
+        { operation: "nexus.diff", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, {
+      command: "nexus-diff",
+      operation: "nexus.diff",
+      extensions: { duration_ms: durationMs },
+      responseMeta: response.meta
+    });
+  }
+});
+var queryCommand = defineCommand({
+  meta: {
+    name: "query",
+    description: "Execute recursive CTE queries against nexus.db"
+  },
+  args: {
+    cte: {
+      type: "positional",
+      description: "CTE SQL or template alias (callers-of, callees-of, co-changed, co-cited, path-between, community-members)",
+      required: true
+    },
+    params: {
+      type: "string",
+      description: 'Comma-separated parameters (e.g., "sym-id-1,sym-id-2")'
+    }
+  },
+  async run({ args }) {
+    const cteOrAlias = args.cte;
+    const paramsStr = args.params || "";
+    const params = paramsStr.split(",").map((p) => p.trim()).filter(Boolean);
+    const startTime = Date.now();
+    const response = await dispatchRaw("query", "nexus", "query-cte", {
+      cte: cteOrAlias,
+      params
+    });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const code = response.error?.code;
+      const msg = response.error?.message ?? "Unknown error";
+      const exitCode = code === "E_INVALID_INPUT" ? 6 : 77;
+      cliError(
+        msg,
+        exitCode,
+        { name: code ?? "E_QUERY_FAILED" },
+        { operation: "nexus.query-cte", duration_ms: durationMs }
+      );
+      process.exitCode = exitCode;
+      return;
+    }
+    const result = response.data;
+    if (!result.success) {
+      cliError(
+        result.error ?? "Unknown",
+        77,
+        { name: "E_QUERY_FAILED" },
+        { operation: "nexus.query-cte", duration_ms: durationMs }
+      );
+      process.exitCode = 77;
+      return;
+    }
+    const { formatCteResultAsMarkdown } = await import("@cleocode/core/nexus/query-dsl.js");
+    const markdown = formatCteResultAsMarkdown(result);
+    cliOutput(
+      { ...result, _markdown: markdown },
+      {
+        command: "nexus-query",
+        operation: "nexus.query-cte",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var routeMapCommand = defineCommand({
+  meta: {
+    name: "route-map",
+    description: "Display all routes with their handlers and dependencies"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to project directory (default: cwd)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    },
+    "project-id": {
+      type: "string",
+      description: "Override the project ID (default: auto-detected from path)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const projectIdOverride = args["project-id"];
+    const repoPath = args.path ? path.resolve(args.path) : getProjectRoot();
+    const projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+    const response = await dispatchRaw("query", "nexus", "route-map", { projectId });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        { name: response.error?.code ?? "E_ROUTE_MAP_FAILED", details: response.error?.details },
+        { operation: "nexus.route-map", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(
+      { ...response.data ?? {}, _projectId: projectId },
+      {
+        command: "nexus-route-map",
+        operation: "nexus.route-map",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var shapeCheckCommand = defineCommand({
+  meta: {
+    name: "shape-check",
+    description: "Check response shape compatibility for a route handler"
+  },
+  args: {
+    routeSymbol: {
+      type: "positional",
+      description: "Route symbol ID (format: <filePath>::<routeName>)",
+      required: true
+    },
+    path: {
+      type: "positional",
+      description: "Path to project directory (default: cwd)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    },
+    "project-id": {
+      type: "string",
+      description: "Override the project ID (default: auto-detected from path)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const routeSymbol = args.routeSymbol;
+    const projectIdOverride = args["project-id"];
+    const repoPath = args.path ? path.resolve(args.path) : getProjectRoot();
+    const projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+    const response = await dispatchRaw("query", "nexus", "shape-check", { routeSymbol, projectId });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        { name: response.error?.code ?? "E_SHAPE_CHECK_FAILED", details: response.error?.details },
+        { operation: "nexus.shape-check", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(
+      { ...response.data ?? {}, _routeSymbol: routeSymbol },
+      {
+        command: "nexus-shape-check",
+        operation: "nexus.shape-check",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var fullContextCommand = defineCommand({
+  meta: {
+    name: "full-context",
+    description: "Show full Living Brain context for a symbol: NEXUS callers/callees, BRAIN memories, TASKS, sentient proposals, conduit threads"
+  },
+  args: {
+    symbol: {
+      type: "positional",
+      description: "Symbol name or nexus node ID",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const symbolId = args.symbol;
+    const response = await dispatchRaw("query", "nexus", "full-context", { symbol: symbolId });
+    if (!response.success) {
+      cliError(
+        response.error?.message ?? "Unknown error",
+        1,
+        { name: response.error?.code ?? "E_FULL_CONTEXT_FAILED", details: response.error?.details },
+        { operation: "nexus.full-context" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const durationMs = Date.now() - startTime;
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "nexus-full-context",
+        operation: "nexus.full-context",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var taskFootprintCommand = defineCommand({
+  meta: {
+    name: "task-footprint",
+    description: "Show full code impact of a task: files, symbols, blast radius, brain observations, decisions, risk tier"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID (e.g., T001)",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const taskId = args.taskId;
+    const response = await dispatchRaw("query", "nexus", "task-footprint", { taskId });
+    if (!response.success) {
+      cliError(
+        response.error?.message ?? "Unknown error",
+        1,
+        {
+          name: response.error?.code ?? "E_TASK_FOOTPRINT_FAILED",
+          details: response.error?.details
+        },
+        { operation: "nexus.task-footprint" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const durationMs = Date.now() - startTime;
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "nexus-task-footprint",
+        operation: "nexus.task-footprint",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var brainAnchorsCommand = defineCommand({
+  meta: {
+    name: "brain-anchors",
+    description: "Show code anchors for a brain memory entry: linked nexus nodes, tasks that touched them, plasticity signal"
+  },
+  args: {
+    entryId: {
+      type: "positional",
+      description: "Brain entry node ID (e.g., observation:abc123)",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const entryId = args.entryId;
+    const response = await dispatchRaw("query", "nexus", "brain-anchors", { entryId });
+    if (!response.success) {
+      cliError(
+        response.error?.message ?? "Unknown error",
+        1,
+        {
+          name: response.error?.code ?? "E_BRAIN_ANCHORS_FAILED",
+          details: response.error?.details
+        },
+        { operation: "nexus.brain-anchors" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const durationMs = Date.now() - startTime;
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "nexus-brain-anchors",
+        operation: "nexus.brain-anchors",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var whyCommand = defineCommand({
+  meta: {
+    name: "why",
+    description: "Trace why a code symbol is structured this way: walks BRAIN decisions, observations, and tasks via code_reference+documents+applies_to edges"
+  },
+  args: {
+    symbol: {
+      type: "positional",
+      description: "Symbol name or nexus node ID to trace",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const symbolId = args.symbol;
+    const response = await dispatchRaw("query", "nexus", "why", { symbol: symbolId });
+    if (!response.success) {
+      cliError(
+        response.error?.message ?? "Unknown error",
+        1,
+        { name: response.error?.code ?? "E_WHY_FAILED", details: response.error?.details },
+        { operation: "nexus.why" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const durationMs = Date.now() - startTime;
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "nexus-why",
+        operation: "nexus.why",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var impactFullCommand = defineCommand({
+  meta: {
+    name: "impact-full",
+    description: "Full merged impact report for a code symbol: structural blast radius + open tasks + brain risk notes"
+  },
+  args: {
+    symbol: {
+      type: "positional",
+      description: "Symbol name or nexus node ID to analyze",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const symbolId = args.symbol;
+    const response = await dispatchRaw("query", "nexus", "impact-full", { symbol: symbolId });
+    if (!response.success) {
+      cliError(
+        response.error?.message ?? "Unknown error",
+        1,
+        { name: response.error?.code ?? "E_IMPACT_FULL_FAILED", details: response.error?.details },
+        { operation: "nexus.impact-full" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const durationMs = Date.now() - startTime;
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "nexus-impact-full",
+        operation: "nexus.impact-full",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var conduitScanCommand = defineCommand({
+  meta: {
+    name: "conduit-scan",
+    description: "Scan conduit messages for symbol mentions and link them to nexus nodes (conduit_mentions_symbol edges)"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const response = await dispatchRaw("mutate", "nexus", "conduit-scan", {});
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        { name: response.error?.code ?? "E_CONDUIT_SCAN_FAILED", details: response.error?.details },
+        { operation: "nexus.conduit-scan", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "nexus-conduit-scan",
+        operation: "nexus.conduit-scan",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var taskSymbolsCommand = defineCommand({
+  meta: {
+    name: "task-symbols",
+    description: "Show code symbols touched by a task (task_touches_symbol forward-lookup)"
+  },
+  args: {
+    taskId: {
+      type: "positional",
+      description: "Task ID (e.g., T001)",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const taskId = args.taskId;
+    const response = await dispatchRaw("query", "nexus", "task-symbols", { taskId });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        { name: response.error?.code ?? "E_TASK_SYMBOLS_FAILED", details: response.error?.details },
+        { operation: "nexus.task-symbols", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const data = response.data;
+    cliOutput(
+      { ...data, taskId, count: data.symbols.length, _durationMs: durationMs },
+      {
+        command: "nexus-task-symbols",
+        operation: "nexus.task-symbols",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var searchCodeCommand = defineCommand({
+  meta: {
+    name: "search-code",
+    description: "BM25 search of code symbols in nexus.db (augment BM25 index)"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search query (symbol name, file pattern, or keyword)",
+      required: true
+    },
+    limit: {
+      type: "string",
+      description: "Max results (default: 10)",
+      default: "10"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const query = args.query;
+    const limit = parseInt(args.limit, 10) || 10;
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "augment",
+      { pattern: query, limit },
+      { command: "nexus" }
+    );
+    const durationMs = Date.now() - startTime;
+    const ctx = getFormatContext();
+    if (ctx.format !== "json") {
+      cliOutput(
+        { _durationMs: durationMs },
+        { command: "nexus-search-code", operation: "nexus.search-code" }
+      );
+    }
+  }
+});
+var contractsSyncCommand = defineCommand({
+  meta: {
+    name: "sync",
+    description: "Extract contracts (HTTP/gRPC/topic) from the current project and store them"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to project directory (default: cwd)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    },
+    "project-id": {
+      type: "string",
+      description: "Override the project ID (default: auto-detected)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const repoPath = args.path ? path.resolve(args.path) : getProjectRoot();
+    const projectIdOverride = args["project-id"];
+    const projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+    const response = await dispatchRaw("mutate", "nexus", "contracts-sync", {
+      projectId,
+      repoPath
+    });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        {
+          name: response.error?.code ?? "E_CONTRACTS_SYNC_FAILED",
+          details: response.error?.details
+        },
+        { operation: "nexus.contracts.sync", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "nexus-contracts-sync",
+        operation: "nexus.contracts.sync",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var contractsShowCommand = defineCommand({
+  meta: {
+    name: "show",
+    description: "Show contract compatibility matrix between two registered projects"
+  },
+  args: {
+    "project-a": {
+      type: "string",
+      description: "First project name or ID",
+      required: true
+    },
+    "project-b": {
+      type: "string",
+      description: "Second project name or ID",
+      required: true
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const projectA = args["project-a"];
+    const projectB = args["project-b"];
+    const response = await dispatchRaw("query", "nexus", "contracts-show", { projectA, projectB });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        {
+          name: response.error?.code ?? "E_CONTRACTS_SHOW_FAILED",
+          details: response.error?.details
+        },
+        { operation: "nexus.contracts.show", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(
+      {
+        ...response.data ?? {},
+        _projectA: projectA,
+        _projectB: projectB,
+        _durationMs: durationMs
+      },
+      {
+        command: "nexus-contracts-show",
+        operation: "nexus.contracts.show",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var contractsLinkTasksCommand = defineCommand({
+  meta: {
+    name: "link-tasks",
+    description: "Link extracted contracts to tasks that touch their source symbols"
+  },
+  args: {
+    path: {
+      type: "positional",
+      description: "Path to project directory (default: cwd)",
+      required: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const repoPath = args.path ? path.resolve(args.path) : getProjectRoot();
+    const projectId = await resolveNexusQueryProjectId(repoPath);
+    const response = await dispatchRaw("mutate", "nexus", "contracts-link-tasks", {
+      projectId,
+      repoPath
+    });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      const msg = response.error?.message ?? "Unknown error";
+      cliError(
+        msg,
+        1,
+        {
+          name: response.error?.code ?? "E_CONTRACTS_LINK_FAILED",
+          details: response.error?.details
+        },
+        { operation: "nexus.contracts.link-tasks", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "nexus-contracts-link-tasks",
+        operation: "nexus.contracts.link-tasks",
+        extensions: { duration_ms: durationMs },
+        responseMeta: response.meta
+      }
+    );
+  }
+});
+var contractsCommand = defineCommand({
+  meta: { name: "contracts", description: "Contract extraction and compatibility operations" },
+  subCommands: {
+    sync: contractsSyncCommand,
+    show: contractsShowCommand,
+    "link-tasks": contractsLinkTasksCommand
+  }
+});
+var groupCommand = defineCommand({
+  meta: {
+    name: "group",
+    description: "Contract extraction and compatibility operations (alias for contracts)"
+  },
+  subCommands: {
+    sync: contractsSyncCommand,
+    show: contractsShowCommand,
+    "link-tasks": contractsLinkTasksCommand
+  }
+});
+var wikiCommand = defineCommand({
+  meta: {
+    name: "wiki",
+    description: "Generate community-grouped wiki index from nexus code graph"
+  },
+  args: {
+    output: {
+      type: "string",
+      description: "Output directory for wiki files (default: .cleo/wiki)",
+      alias: "o"
+    },
+    community: {
+      type: "string",
+      description: 'Filter generation to a single community ID (e.g. "community:3")',
+      alias: "c"
+    },
+    incremental: {
+      type: "boolean",
+      description: "Only regenerate communities whose symbols changed since last wiki run (uses .cleo/wiki-state.json)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const outputDir = args.output ?? void 0;
+    const communityFilter = args.community ?? void 0;
+    const isIncremental = !!args.incremental;
+    try {
+      const result = await runNexusWiki({
+        projectRoot: getProjectRoot(),
+        outputDir,
+        communityFilter,
+        incremental: isIncremental
+      });
+      if (!result.success) {
+        cliError(
+          `wiki generation failed: ${result.error ?? "unknown"}`,
+          1,
+          { name: "E_WIKI_GENERATION_FAILED" },
+          { operation: "nexus.wiki" }
+        );
+        process.exitCode = 1;
+        return;
+      }
+      cliOutput(
+        { ...result, _outputDir: result.outputDir, _durationMs: result.durationMs },
+        {
+          command: "nexus-wiki",
+          operation: "nexus.wiki",
+          extensions: { duration_ms: result.durationMs }
+        }
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      cliError(
+        msg,
+        1,
+        { name: "E_WIKI_GENERATION_FAILED" },
+        { operation: "nexus.wiki", duration_ms: Date.now() - startTime }
+      );
+      process.exitCode = 1;
+    }
+  }
+});
+var hotPathsCommand = defineCommand({
+  meta: {
+    name: "hot-paths",
+    description: "List highest-weight relation edges by Hebbian plasticity weight"
+  },
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum number of edges to return (default: 20)",
+      default: "20"
+    },
+    json: {
+      type: "boolean",
+      description: "Output raw JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const limit = Number.parseInt(args.limit, 10) || 20;
+    const startTime = Date.now();
+    const response = await dispatchRaw("query", "nexus", "hot-paths", { limit });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      cliError(
+        response.error?.message ?? "Unknown error",
+        1,
+        { name: response.error?.code ?? "E_HOT_PATHS_FAILED", details: response.error?.details },
+        { operation: "nexus.hot-paths", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, {
+      command: "nexus-hot-paths",
+      operation: "nexus.hot-paths",
+      extensions: { duration_ms: durationMs },
+      responseMeta: response.meta
+    });
+  }
+});
+var hotNodesCommand = defineCommand({
+  meta: {
+    name: "hot-nodes",
+    description: "List symbols with highest aggregate Hebbian weight"
+  },
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum number of nodes to return (default: 20)",
+      default: "20"
+    },
+    json: {
+      type: "boolean",
+      description: "Output raw JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const limit = Number.parseInt(args.limit, 10) || 20;
+    const startTime = Date.now();
+    const response = await dispatchRaw("query", "nexus", "hot-nodes", { limit });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      cliError(
+        response.error?.message ?? "Unknown error",
+        1,
+        { name: response.error?.code ?? "E_HOT_NODES_FAILED", details: response.error?.details },
+        { operation: "nexus.hot-nodes", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, {
+      command: "nexus-hot-nodes",
+      operation: "nexus.hot-nodes",
+      extensions: { duration_ms: durationMs },
+      responseMeta: response.meta
+    });
+  }
+});
+var coldSymbolsCommand = defineCommand({
+  meta: {
+    name: "cold-symbols",
+    description: "List cold symbols (stale access + low weight) for pruning candidates"
+  },
+  args: {
+    days: {
+      type: "string",
+      description: "Age threshold in days (default: 30)",
+      default: "30"
+    },
+    json: {
+      type: "boolean",
+      description: "Output raw JSON",
+      default: false
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const thresholdDays = Number.parseInt(args.days, 10) || 30;
+    const startTime = Date.now();
+    const response = await dispatchRaw("query", "nexus", "cold-symbols", { days: thresholdDays });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      cliError(
+        response.error?.message ?? "Unknown error",
+        1,
+        { name: response.error?.code ?? "E_COLD_SYMBOLS_FAILED", details: response.error?.details },
+        { operation: "nexus.cold-symbols", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, {
+      command: "nexus-cold-symbols",
+      operation: "nexus.cold-symbols",
+      extensions: { duration_ms: durationMs },
+      responseMeta: response.meta
+    });
+  }
+});
+var sigilSyncCommand = defineCommand({
+  meta: {
+    name: "sync",
+    description: "Populate the nexus.db sigils table with one row per canonical CANT agent (cleo-subagent + 5 seed roles + 2 meta agents). Idempotent."
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON (LAFS envelope format)"
+    }
+  },
+  async run() {
+    await dispatchFromCli("mutate", "nexus", "sigil.sync", {}, { command: "nexus" });
+  }
+});
+var sigilListCommand = defineCommand({
+  meta: {
+    name: "list",
+    description: "List every sigil currently stored in nexus.db, optionally filtered by role."
+  },
+  args: {
+    role: {
+      type: "string",
+      description: 'Filter by role (e.g. "orchestrator", "lead", "worker", "specialist", "subagent")'
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "sigil.list",
+      { role: args.role },
+      { command: "nexus" }
+    );
+  }
+});
+var sigilCommand = defineCommand({
+  meta: {
+    name: "sigil",
+    description: "Sigil (peer-card) operations \u2014 sync from canonical CANT agents, list current rows"
+  },
+  subCommands: {
+    sync: sigilSyncCommand,
+    list: sigilListCommand
+  }
+});
+var topEntriesCommand = defineCommand({
+  meta: {
+    name: "top-entries",
+    description: "List top-weighted symbols from nexus_relations by weight DESC"
+  },
+  args: {
+    limit: {
+      type: "string",
+      description: "Maximum number of entries to return (default: 20)",
+      default: "20"
+    },
+    kind: {
+      type: "string",
+      description: "Filter by nexus_nodes.kind (e.g. function, method, class, interface, type_alias)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output result as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    const limit = Number.parseInt(args.limit, 10) || 20;
+    const kind = args.kind ?? void 0;
+    const jsonOutput = !!args.json;
+    const params = { limit };
+    if (kind !== void 0 && kind.length > 0) params.kind = kind;
+    await dispatchFromCli("query", "nexus", "top-entries", params, {
+      command: "nexus",
+      operation: "nexus.top-entries",
+      ...jsonOutput ? { json: true } : {}
+    });
+  }
+});
+var nexusCommand = defineCommand({
+  meta: { name: "nexus", description: "Cross-project NEXUS operations" },
+  subCommands: {
+    init: initCommand,
+    register: registerCommand,
+    unregister: unregisterCommand,
+    list: listCommand,
+    status: statusCommand,
+    show: showCommand,
+    resolve: resolveCommand,
+    discover: discoverCommand,
+    search: searchCommand,
+    augment: augmentCommand,
+    setup: setupCommand,
+    deps: depsCommand,
+    "critical-path": criticalPathCommand,
+    blocking: blockingCommand,
+    orphans: orphansCommand,
+    sync: syncCommand,
+    reconcile: reconcileCommand,
+    graph: graphCommand,
+    "share-status": shareStatusCommand,
+    "transfer-preview": transferPreviewCommand,
+    transfer: transferCommand,
+    permission: permissionCommand,
+    share: shareCommand,
+    clusters: clustersCommand,
+    flows: flowsCommand,
+    context: contextCommand,
+    impact: impactCommand,
+    analyze: analyzeCommand,
+    query: queryCommand,
+    projects: projectsCommand,
+    "refresh-bridge": refreshBridgeCommand,
+    export: exportCommand,
+    diff: diffCommand,
+    "route-map": routeMapCommand,
+    "shape-check": shapeCheckCommand,
+    "full-context": fullContextCommand,
+    "task-footprint": taskFootprintCommand,
+    "brain-anchors": brainAnchorsCommand,
+    why: whyCommand,
+    "impact-full": impactFullCommand,
+    // T1071 — conduit scan
+    "conduit-scan": conduitScanCommand,
+    // T1067 — task symbols
+    "task-symbols": taskSymbolsCommand,
+    // T1058 — code symbol search
+    "search-code": searchCodeCommand,
+    // T1065 — contract registry
+    contracts: contractsCommand,
+    // T1114 — group alias for contracts
+    group: groupCommand,
+    // T1060 — wiki index
+    wiki: wikiCommand,
+    // T1108 — plasticity queries
+    "hot-paths": hotPathsCommand,
+    "hot-nodes": hotNodesCommand,
+    "cold-symbols": coldSymbolsCommand,
+    // T1013 / T1006 — top-weighted symbols by nexus_relations.weight
+    "top-entries": topEntriesCommand,
+    // T1386 — sigil sync + list (canonical CANT agent peer cards)
+    sigil: sigilCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  nexusCommand
+};
+//# sourceMappingURL=nexus-XSFXN5E6.js.map