@cleocode/cleo 2026.10.3 → 2026.10.4

package/dist/cli/graph-XIXMCFKG.js

@@ -0,0 +1,878 @@
+(() => {
+  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 {
+  defineCommand,
+  showUsage
+} from "./chunk-PKKZPOOP.js";
+import {
+  dispatchFromCli,
+  dispatchRaw
+} from "./chunk-3IOQVUO7.js";
+import "./chunk-AWCQH2W5.js";
+import "./chunk-OGV57L4J.js";
+import "./chunk-ZBISIPCK.js";
+import {
+  cliError,
+  cliOutput,
+  humanWarn
+} from "./chunk-3ZO3M37V.js";
+import {
+  getFormatContext,
+  setFormatContext
+} from "./chunk-6JSJNYH2.js";
+import "./chunk-QFFQSKRC.js";
+
+// packages/cleo/src/cli/commands/graph.ts
+import path from "node:path";
+import { pushWarning } from "@cleocode/core";
+import { resolveNexusQueryProjectId } from "@cleocode/core/nexus/registry.js";
+function applyJsonFlag(jsonFlag) {
+  if (jsonFlag) {
+    setFormatContext({ format: "json", source: "flag", quiet: false });
+  }
+}
+var statusCommand = defineCommand({
+  meta: {
+    name: "status",
+    description: "Show code intelligence index freshness: file count, node/relation counts, last indexed time."
+  },
+  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)"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON (LAFS envelope format)"
+    }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const projectIdOverride = args["project-id"];
+    const repoPath = args.path ? path.resolve(args.path) : process.cwd();
+    const startTime = Date.now();
+    try {
+      const [{ getNexusDb, nexusSchema }, { getIndexStats }] = await Promise.all([
+        import("@cleocode/core/store/nexus-sqlite"),
+        import("@cleocode/nexus/pipeline")
+      ]);
+      const projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+      const db = await getNexusDb();
+      const tables = {
+        nexusNodes: nexusSchema.nexusNodes,
+        nexusRelations: nexusSchema.nexusRelations
+      };
+      const stats = await getIndexStats(
+        projectId,
+        repoPath,
+        db,
+        tables
+      );
+      const durationMs = Date.now() - startTime;
+      cliOutput(
+        { projectId, repoPath, ...stats },
+        {
+          command: "graph-status",
+          operation: "nexus.status",
+          extensions: { duration_ms: durationMs }
+        }
+      );
+    } 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(`[graph] Error: ${msg}`);
+        await dispatchFromCli("query", "nexus", "status", {}, { command: "graph" });
+      }
+      process.exitCode = 1;
+    }
+  }
+});
+var resolveCommand = defineCommand({
+  meta: { name: "resolve", description: "Resolve a symbol name to graph node(s)" },
+  args: {
+    taskRef: {
+      type: "positional",
+      description: "Symbol or task reference to resolve",
+      required: true
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "resolve",
+      { query: args.taskRef },
+      { command: "graph" }
+    );
+  }
+});
+var depsCommand = defineCommand({
+  meta: { name: "deps", description: "List dependencies of a symbol (callers or callees)" },
+  args: {
+    symbol: {
+      type: "positional",
+      description: "Symbol name",
+      required: true
+    },
+    direction: {
+      type: "string",
+      description: "upstream|downstream (default: downstream)",
+      default: "downstream"
+    }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "deps",
+      { symbol: args.symbol, direction: args.direction },
+      { command: "graph" }
+    );
+  }
+});
+var rawCommand = defineCommand({
+  meta: { name: "raw", description: "Return the raw graph (nodes + relations) for a project" },
+  args: {
+    "project-id": {
+      type: "string",
+      description: "Project ID (default: auto-detected from cwd)"
+    },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const projectId = args["project-id"];
+    await dispatchFromCli("query", "nexus", "graph", { projectId }, { command: "graph" });
+  }
+});
+var discoverCommand = defineCommand({
+  meta: {
+    name: "discover",
+    description: "Find code relevant to a task query (searches labels, descriptions, and file paths)"
+  },
+  args: {
+    taskQuery: {
+      type: "positional",
+      description: "Task query to find relevant code for (required)",
+      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: "graph" }
+    );
+  }
+});
+var searchCommand = defineCommand({
+  meta: {
+    name: "search",
+    description: "Full-text / semantic search over symbol names and docstrings"
+  },
+  args: {
+    query: {
+      type: "positional",
+      description: "Search query",
+      required: true
+    },
+    limit: { type: "string", description: "Max results", default: "20" },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "search",
+      { query: args.query, limit: parseInt(args.limit, 10) },
+      { command: "graph" }
+    );
+  }
+});
+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",
+      required: true
+    },
+    limit: { type: "string", description: "Max results (default: 5)", default: "5" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "augment",
+      { pattern: args.pattern, limit: parseInt(args.limit, 10) || 5 },
+      { command: "graph" }
+    );
+  }
+});
+var contextCommand = defineCommand({
+  meta: {
+    name: "context",
+    description: "Return project context summary (node/relation counts, freshness)"
+  },
+  args: {
+    path: { type: "positional", description: "Project path (default: cwd)", required: false },
+    "project-id": { type: "string", description: "Override project ID" },
+    json: { type: "boolean", description: "Output as JSON" },
+    limit: { type: "string", description: "Max symbols", default: "20" },
+    kind: { type: "string", description: "Filter by node kind" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const repoPath = args.path ? path.resolve(args.path) : process.cwd();
+    const projectIdOverride = args["project-id"];
+    const projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+    const limit = Number.parseInt(args.limit, 10) || 20;
+    const kind = args.kind ?? void 0;
+    const params = { projectId, limit };
+    if (kind) params["kind"] = kind;
+    await dispatchFromCli("query", "nexus", "context", params, { command: "graph" });
+  }
+});
+var impactCommand = defineCommand({
+  meta: {
+    name: "impact",
+    description: "Compute the blast radius (upstream/downstream) of a change"
+  },
+  args: {
+    symbol: {
+      type: "positional",
+      description: "Symbol name or ID to analyze",
+      required: true
+    },
+    direction: {
+      type: "string",
+      description: "upstream|downstream (default: upstream)",
+      default: "upstream"
+    },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "impact",
+      { symbol: args.symbol, direction: args.direction },
+      { command: "graph" }
+    );
+  }
+});
+var impactFullCommand = defineCommand({
+  meta: {
+    name: "impact-full",
+    description: "Full merged impact report: structural blast radius + open tasks + brain risk notes"
+  },
+  args: {
+    symbol: {
+      type: "positional",
+      description: "Symbol name or nexus node ID",
+      required: true
+    },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const startTime = Date.now();
+    const response = await dispatchRaw("query", "nexus", "impact-full", { symbol: args.symbol });
+    const durationMs = Date.now() - startTime;
+    if (!response.success) {
+      cliError(
+        response.error?.message ?? "Unknown error",
+        1,
+        { name: response.error?.code ?? "E_IMPACT_FULL_FAILED" },
+        { operation: "nexus.impact-full", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "graph-impact-full",
+        operation: "nexus.impact-full",
+        extensions: { duration_ms: durationMs }
+      }
+    );
+  }
+});
+var clustersCommand = defineCommand({
+  meta: { name: "clusters", description: "Return detected community clusters in the graph" },
+  args: {
+    json: { type: "boolean", description: "Output as JSON" },
+    limit: { type: "string", description: "Max clusters", default: "10" },
+    "project-id": { type: "string", description: "Override project ID" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const projectId = args["project-id"];
+    const limit = Number.parseInt(args.limit, 10) || 10;
+    await dispatchFromCli("query", "nexus", "clusters", { projectId, limit }, { command: "graph" });
+  }
+});
+var flowsCommand = defineCommand({
+  meta: { name: "flows", description: "Return detected execution flows (process traces)" },
+  args: {
+    json: { type: "boolean", description: "Output as JSON" },
+    "project-id": { type: "string", description: "Override project ID" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const projectId = args["project-id"];
+    await dispatchFromCli("query", "nexus", "flows", { projectId }, { command: "graph" });
+  }
+});
+var diffCommand = defineCommand({
+  meta: { name: "diff", description: "Diff the graph between two commits or snapshots" },
+  args: {
+    from: { type: "string", description: "Base commit/ref" },
+    to: { type: "string", description: "Target commit/ref (default: HEAD)" },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "diff",
+      { from: args.from, to: args.to },
+      { command: "graph" }
+    );
+  }
+});
+var routeMapCommand = defineCommand({
+  meta: {
+    name: "route-map",
+    description: "Display all routes with their handlers and dependencies"
+  },
+  args: {
+    path: { type: "positional", description: "Project path (default: cwd)", required: false },
+    json: { type: "boolean", description: "Output as JSON" },
+    "project-id": { type: "string", description: "Override project ID" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const repoPath = args.path ? path.resolve(args.path) : process.cwd();
+    const projectIdOverride = args["project-id"];
+    const projectId = await resolveNexusQueryProjectId(repoPath, projectIdOverride);
+    await dispatchFromCli("query", "nexus", "route-map", { projectId }, { command: "graph" });
+  }
+});
+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
+    },
+    json: { type: "boolean", description: "Output as JSON" },
+    "project-id": { type: "string", description: "Override project ID" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const projectId = args["project-id"];
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "shape-check",
+      { routeSymbol: args.routeSymbol, projectId },
+      { command: "graph" }
+    );
+  }
+});
+var searchCodeCommand = defineCommand({
+  meta: { name: "search-code", description: "Search code by pattern across the project graph" },
+  args: {
+    pattern: {
+      type: "positional",
+      description: "Search pattern",
+      required: true
+    },
+    limit: { type: "string", description: "Max results", default: "20" },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    await dispatchFromCli(
+      "query",
+      "nexus",
+      "search-code",
+      { pattern: args.pattern, limit: parseInt(args.limit, 10) },
+      { command: "graph" }
+    );
+  }
+});
+var wikiCommand = defineCommand({
+  meta: { name: "wiki", description: "Generate a wiki-style description for a symbol or module" },
+  args: {
+    symbol: {
+      type: "positional",
+      description: "Symbol name or ID",
+      required: true
+    },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    await dispatchFromCli("query", "nexus", "wiki", { symbol: args.symbol }, { command: "graph" });
+  }
+});
+var hotPathsCommand = defineCommand({
+  meta: {
+    name: "hot-paths",
+    description: "List highest-weight relation edges by Hebbian plasticity weight"
+  },
+  args: {
+    limit: { type: "string", description: "Max edges (default: 20)", default: "20" },
+    json: { type: "boolean", description: "Output as 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" },
+        { operation: "nexus.hot-paths", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, {
+      command: "graph-hot-paths",
+      operation: "nexus.hot-paths",
+      extensions: { duration_ms: durationMs }
+    });
+  }
+});
+var hotNodesCommand = defineCommand({
+  meta: { name: "hot-nodes", description: "List symbols with highest aggregate Hebbian weight" },
+  args: {
+    limit: { type: "string", description: "Max nodes (default: 20)", default: "20" },
+    json: { type: "boolean", description: "Output as 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" },
+        { operation: "nexus.hot-nodes", duration_ms: durationMs }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    cliOutput(response.data, {
+      command: "graph-hot-nodes",
+      operation: "nexus.hot-nodes",
+      extensions: { duration_ms: durationMs }
+    });
+  }
+});
+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 as JSON", default: false }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const days = Number.parseInt(args.days, 10) || 30;
+    await dispatchFromCli("query", "nexus", "cold-symbols", { days }, { command: "graph" });
+  }
+});
+var orphansCommand = defineCommand({
+  meta: { name: "orphans", description: "List graph nodes with no incoming or outgoing edges" },
+  async run() {
+    await dispatchFromCli("query", "nexus", "orphans.list", {}, { command: "graph" });
+  }
+});
+var queryCommand = defineCommand({
+  meta: { name: "query", description: "Execute recursive CTE queries against nexus.db" },
+  args: {
+    cte: {
+      type: "positional",
+      description: "CTE SQL or template alias",
+      required: true
+    },
+    params: { type: "string", description: "Comma-separated parameters" }
+  },
+  async run({ args }) {
+    const cteOrAlias = args.cte;
+    const paramsStr = args.params || "";
+    const ctParams = paramsStr.split(",").map((p) => p.trim()).filter(Boolean);
+    const startTime = Date.now();
+    const response = await dispatchRaw("query", "nexus", "query-cte", {
+      cte: cteOrAlias,
+      params: ctParams
+    });
+    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: "graph-query",
+        operation: "nexus.query-cte",
+        extensions: { duration_ms: durationMs }
+      }
+    );
+  }
+});
+var initCommand = defineCommand({
+  meta: { name: "init", description: "Initialize a new Nexus project database" },
+  async run() {
+    await dispatchFromCli("mutate", "nexus", "init", {}, { command: "graph" });
+  }
+});
+var syncCommand = defineCommand({
+  meta: {
+    name: "sync",
+    description: "Refresh registry metadata (task counts, labels, last-seen) for registered projects. Does NOT index source code \u2014 use `cleo nexus analyze` for the code graph."
+  },
+  args: {
+    path: { type: "positional", description: "Project path (default: cwd)", required: false },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    const repoPath = args.path ? path.resolve(args.path) : process.cwd();
+    pushWarning({
+      code: "W_GRAPH_SYNC_IS_METADATA_ONLY",
+      severity: "info",
+      message: "graph sync refreshes project REGISTRY metadata only \u2014 the `synced` count is registered projects, not source files. To build or refresh the code graph, run `cleo nexus analyze` and check `cleo nexus status`."
+    });
+    await dispatchFromCli("mutate", "nexus", "sync", { path: repoPath }, { command: "graph" });
+  }
+});
+var reconcileCommand = defineCommand({
+  meta: { name: "reconcile", description: "Reconcile graph state with on-disk source files" },
+  args: {
+    "project-id": { type: "string", description: "Project ID (default: auto-detected)" }
+  },
+  async run({ args }) {
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "reconcile",
+      { projectId: args["project-id"] },
+      { command: "graph" }
+    );
+  }
+});
+var livingFullContextCommand = 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 as JSON" }
+  },
+  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" },
+        { operation: "nexus.full-context" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const durationMs = Date.now() - startTime;
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "graph-living-full-context",
+        operation: "nexus.full-context",
+        extensions: { duration_ms: durationMs }
+      }
+    );
+  }
+});
+var livingTaskFootprintCommand = 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 as JSON" }
+  },
+  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" },
+        { operation: "nexus.task-footprint" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const durationMs = Date.now() - startTime;
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "graph-living-task-footprint",
+        operation: "nexus.task-footprint",
+        extensions: { duration_ms: durationMs }
+      }
+    );
+  }
+});
+var livingBrainAnchorsCommand = defineCommand({
+  meta: {
+    name: "brain-anchors",
+    description: "Show code anchors for a brain memory entry: linked nexus nodes, tasks, plasticity signal"
+  },
+  args: {
+    entryId: {
+      type: "positional",
+      description: "Brain entry node ID (e.g., observation:abc123)",
+      required: true
+    },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  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" },
+        { operation: "nexus.brain-anchors" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const durationMs = Date.now() - startTime;
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "graph-living-brain-anchors",
+        operation: "nexus.brain-anchors",
+        extensions: { duration_ms: durationMs }
+      }
+    );
+  }
+});
+var livingWhyCommand = defineCommand({
+  meta: {
+    name: "why",
+    description: "Trace why a code symbol is structured this way: walks BRAIN decisions, observations, tasks via code_reference edges"
+  },
+  args: {
+    symbol: {
+      type: "positional",
+      description: "Symbol name or nexus node ID",
+      required: true
+    },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  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" },
+        { operation: "nexus.why" }
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const durationMs = Date.now() - startTime;
+    cliOutput(
+      { ...response.data ?? {}, _durationMs: durationMs },
+      {
+        command: "graph-living-why",
+        operation: "nexus.why",
+        extensions: { duration_ms: durationMs }
+      }
+    );
+  }
+});
+var livingConduitScanCommand = defineCommand({
+  meta: {
+    name: "conduit-scan",
+    description: "Scan Conduit messaging patterns into the graph"
+  },
+  args: {
+    "project-id": { type: "string", description: "Project ID (default: auto-detected)" },
+    json: { type: "boolean", description: "Output as JSON" }
+  },
+  async run({ args }) {
+    applyJsonFlag(args.json);
+    await dispatchFromCli(
+      "mutate",
+      "nexus",
+      "conduit-scan",
+      { projectId: args["project-id"] },
+      { command: "graph" }
+    );
+  }
+});
+var livingCommand = defineCommand({
+  meta: {
+    name: "living",
+    description: "Living Brain ops \u2014 bridge code graph + BRAIN memory (task-footprint, brain-anchors, why, full-context, conduit-scan)"
+  },
+  subCommands: {
+    "full-context": livingFullContextCommand,
+    "task-footprint": livingTaskFootprintCommand,
+    "brain-anchors": livingBrainAnchorsCommand,
+    why: livingWhyCommand,
+    "conduit-scan": livingConduitScanCommand
+  },
+  async run({ cmd }) {
+    await showUsage(cmd);
+  }
+});
+var graphCommand = defineCommand({
+  meta: {
+    name: "graph",
+    description: "Project-scoped code intelligence: symbol graph, impact analysis, clusters, flows"
+  },
+  subCommands: {
+    status: statusCommand,
+    resolve: resolveCommand,
+    deps: depsCommand,
+    raw: rawCommand,
+    discover: discoverCommand,
+    search: searchCommand,
+    augment: augmentCommand,
+    context: contextCommand,
+    impact: impactCommand,
+    "impact-full": impactFullCommand,
+    clusters: clustersCommand,
+    flows: flowsCommand,
+    diff: diffCommand,
+    "route-map": routeMapCommand,
+    "shape-check": shapeCheckCommand,
+    "search-code": searchCodeCommand,
+    wiki: wikiCommand,
+    "hot-paths": hotPathsCommand,
+    "hot-nodes": hotNodesCommand,
+    "cold-symbols": coldSymbolsCommand,
+    orphans: orphansCommand,
+    query: queryCommand,
+    init: initCommand,
+    sync: syncCommand,
+    reconcile: reconcileCommand,
+    living: livingCommand
+  },
+  async run({ cmd, rawArgs }) {
+    const firstArg = rawArgs?.find((a) => !a.startsWith("-"));
+    if (firstArg && cmd.subCommands && firstArg in cmd.subCommands) return;
+    await showUsage(cmd);
+  }
+});
+export {
+  graphCommand
+};
+//# sourceMappingURL=graph-XIXMCFKG.js.map