@neat.is/core 0.5.2 → 0.5.3

package/dist/cli.js

@@ -9,7 +9,7 @@ import {
   resolveNeatVersion,
   validateConnectorEntry,
   writeDaemonRecord
-} from "./chunk-DPEPI2N6.js";
+} from "./chunk-X2AMX3QZ.js";
 import {
   buildSearchIndex
 } from "./chunk-BIY46Q6U.js";
@@ -68,7 +68,7 @@ import {
   startPersistLoop,
   startStalenessLoop,
   upsertConnectorEntry
-} from "./chunk-BI3XKGVG.js";
+} from "./chunk-GJHEZC5K.js";
 import {
   startOtelGrpcReceiver
 } from "./chunk-I72HTUOG.js";
@@ -82,8 +82,8 @@ import {
 } from "./chunk-CFDPIMRP.js";
 
 // src/cli.ts
-import path9 from "path";
-import { promises as fs7 } from "fs";
+import path10 from "path";
+import { promises as fs8 } from "fs";
 
 // src/banner.ts
 import path from "path";
@@ -3852,8 +3852,181 @@ async function runConnectorCommand(rawArgs, deps = {}) {
   }
 }
 
-// src/cli-verbs.ts
+// src/hooks-cli.ts
 import path8 from "path";
+import os from "os";
+import { promises as fs7 } from "fs";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var HOOK_FILENAME = "neat-search-nudge.mjs";
+var GUIDE_FILENAME = "GRAPH_FIRST.md";
+var GUIDE_INSTALL_NAME = "neat-graph-first.md";
+var HOOK_MATCHER = "Grep|Glob|Bash";
+function moduleDir() {
+  return typeof __dirname !== "undefined" ? __dirname : path8.dirname(fileURLToPath3(import.meta.url));
+}
+async function readSkillAsset(rel) {
+  const here = moduleDir();
+  const candidates = [
+    path8.resolve(here, "../../claude-skill", rel),
+    path8.resolve(here, "../../../claude-skill", rel),
+    path8.resolve(here, "../claude-skill", rel)
+  ];
+  for (const candidate of candidates) {
+    try {
+      return await fs7.readFile(candidate, "utf8");
+    } catch {
+    }
+  }
+  throw new Error(
+    `neat hooks: could not find @neat.is/claude-skill/${rel} \u2014 is the package installed?`
+  );
+}
+function neatHome() {
+  const override = process.env.NEAT_HOME;
+  if (override && override.length > 0) return path8.resolve(override);
+  return path8.join(os.homedir(), ".neat");
+}
+function claudeSettingsPath() {
+  const override = process.env.NEAT_CLAUDE_SETTINGS;
+  if (override && override.length > 0) return path8.resolve(override);
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? os.homedir();
+  return path8.join(home, ".claude", "settings.json");
+}
+function installedHookPath() {
+  return path8.join(neatHome(), "hooks", HOOK_FILENAME);
+}
+function isNeatSearchEntry(entry2) {
+  return (entry2.hooks ?? []).some(
+    (h) => typeof h.command === "string" && h.command.includes(HOOK_FILENAME)
+  );
+}
+function neatHookEntry(command) {
+  return { matcher: HOOK_MATCHER, hooks: [{ type: "command", command }] };
+}
+function hookCommand(scriptPath) {
+  return `node "${scriptPath}"`;
+}
+async function runHooks(opts) {
+  if (opts.printHook) {
+    process.stdout.write(await readSkillAsset(`hooks/${HOOK_FILENAME}`));
+    return { exitCode: 0 };
+  }
+  if (opts.printGuide) {
+    process.stdout.write(await readSkillAsset(GUIDE_FILENAME));
+    return { exitCode: 0 };
+  }
+  if (opts.printSettings) {
+    const block = {
+      hooks: { PreToolUse: [neatHookEntry(hookCommand(installedHookPath()))] }
+    };
+    process.stdout.write(JSON.stringify(block, null, 2) + "\n");
+    return { exitCode: 0 };
+  }
+  if (opts.apply) {
+    const hookScript = await readSkillAsset(`hooks/${HOOK_FILENAME}`);
+    const guide = await readSkillAsset(GUIDE_FILENAME);
+    const scriptPath = installedHookPath();
+    await fs7.mkdir(path8.dirname(scriptPath), { recursive: true });
+    await fs7.writeFile(scriptPath, hookScript, { mode: 493 });
+    const guidePath = path8.join(neatHome(), GUIDE_INSTALL_NAME);
+    await fs7.writeFile(guidePath, guide, "utf8");
+    const settingsFile = claudeSettingsPath();
+    let settings = {};
+    try {
+      settings = JSON.parse(await fs7.readFile(settingsFile, "utf8"));
+    } catch (err) {
+      if (err.code !== "ENOENT") {
+        console.error(
+          `neat hooks: failed to read ${settingsFile} \u2014 ${err.message}`
+        );
+        return { exitCode: 1 };
+      }
+    }
+    const hooks = settings.hooks ?? {};
+    const preToolUse = Array.isArray(hooks.PreToolUse) ? [...hooks.PreToolUse] : [];
+    const command = hookCommand(scriptPath);
+    const existingIdx = preToolUse.findIndex(isNeatSearchEntry);
+    if (existingIdx >= 0) {
+      preToolUse[existingIdx] = neatHookEntry(command);
+    } else {
+      preToolUse.push(neatHookEntry(command));
+    }
+    const merged = {
+      ...settings,
+      hooks: { ...hooks, PreToolUse: preToolUse }
+    };
+    await fs7.mkdir(path8.dirname(settingsFile), { recursive: true });
+    await fs7.writeFile(settingsFile, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    console.log(`neat hooks: installed the search-nudge hook`);
+    console.log(`  script:   ${scriptPath}`);
+    console.log(`  settings: ${settingsFile} (PreToolUse \u2192 ${HOOK_MATCHER})`);
+    console.log(`  guidance: ${guidePath}`);
+    console.log("");
+    console.log("restart Claude Code to load the hook. On a Grep/Glob or a Bash grep,");
+    console.log("your agent will now be nudged to query NEAT first.");
+    console.log("");
+    console.log("The hook is Claude-Code-specific. For agents on other harnesses, paste");
+    console.log(`the guidance above into your project instructions (CLAUDE.md / AGENTS.md).`);
+    return { exitCode: 0 };
+  }
+  usage();
+  return { exitCode: 0 };
+}
+function usage() {
+  console.log("neat hooks \u2014 wire NEAT into your agent so it queries the graph before grepping");
+  console.log("");
+  console.log("  --apply          install the Claude Code search-nudge hook and write the");
+  console.log("                   graph-first guidance to ~/.neat/, merging into");
+  console.log("                   ~/.claude/settings.json without touching your other hooks");
+  console.log("  --print-hook     print the hook script to stdout");
+  console.log("  --print-guide    print the agent-agnostic graph-first guidance to stdout");
+  console.log("  --print-settings print the settings.json PreToolUse block --apply would add");
+  console.log("");
+  console.log("The hook is a gentle, non-blocking nudge \u2014 searches still run. It is");
+  console.log("Claude-Code-specific; other harnesses get the same steer from the guidance.");
+}
+async function runHooksCommand(args) {
+  const opts = {
+    apply: false,
+    printHook: false,
+    printGuide: false,
+    printSettings: false
+  };
+  for (const arg of args) {
+    switch (arg) {
+      case "--apply":
+        opts.apply = true;
+        break;
+      case "--print-hook":
+        opts.printHook = true;
+        break;
+      case "--print-guide":
+        opts.printGuide = true;
+        break;
+      case "--print-settings":
+        opts.printSettings = true;
+        break;
+      case "-h":
+      case "--help":
+        usage();
+        return 0;
+      default:
+        console.error(`neat hooks: unknown flag "${arg}"`);
+        usage();
+        return 2;
+    }
+  }
+  try {
+    const { exitCode } = await runHooks(opts);
+    return exitCode;
+  } catch (err) {
+    console.error(err.message);
+    return 1;
+  }
+}
+
+// src/cli-verbs.ts
+import path9 from "path";
 
 // src/cli-client.ts
 import { Provenance as Provenance2 } from "@neat.is/types";
@@ -3881,10 +4054,10 @@ function createHttpClient(baseUrl, bearerToken) {
   const root = baseUrl.replace(/\/$/, "");
   const authHeader = bearerToken && bearerToken.length > 0 ? { authorization: `Bearer ${bearerToken}` } : {};
   return {
-    async get(path10) {
+    async get(path11) {
       let res;
       try {
-        res = await fetch(`${root}${path10}`, {
+        res = await fetch(`${root}${path11}`, {
           headers: { ...authHeader }
         });
       } catch (err) {
@@ -3896,16 +4069,16 @@ function createHttpClient(baseUrl, bearerToken) {
         const body = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on GET ${path10}: ${body}`,
+          `${res.status} ${res.statusText} on GET ${path11}: ${body}`,
           body
         );
       }
       return await res.json();
     },
-    async post(path10, body) {
+    async post(path11, body) {
       let res;
       try {
-        res = await fetch(`${root}${path10}`, {
+        res = await fetch(`${root}${path11}`, {
           method: "POST",
           headers: { "content-type": "application/json", ...authHeader },
           body: JSON.stringify(body)
@@ -3919,7 +4092,7 @@ function createHttpClient(baseUrl, bearerToken) {
         const text = await res.text().catch(() => "");
         throw new HttpError(
           res.status,
-          `${res.status} ${res.statusText} on POST ${path10}: ${text}`,
+          `${res.status} ${res.statusText} on POST ${path11}: ${text}`,
           text
         );
       }
@@ -3933,12 +4106,12 @@ function projectPath(project, suffix) {
 }
 async function runRootCause(client, input) {
   const qs = input.errorId ? `?errorId=${encodeURIComponent(input.errorId)}` : "";
-  const path10 = projectPath(
+  const path11 = projectPath(
     input.project,
     `/graph/root-cause/${encodeURIComponent(input.errorNode)}${qs}`
   );
   try {
-    const result = await client.get(path10);
+    const result = await client.get(path11);
     const arrowPath = result.traversalPath.join(" \u2190 ");
     const provenances = result.edgeProvenances.length ? result.edgeProvenances.join(", ") : "(direct, no edges traversed)";
     const summary = `Root cause for ${input.errorNode} is ${result.rootCauseNode}. ` + result.rootCauseReason + (result.fixRecommendation ? ` Recommended fix: ${result.fixRecommendation}.` : "");
@@ -3964,12 +4137,12 @@ async function runRootCause(client, input) {
 }
 async function runBlastRadius(client, input) {
   const qs = input.depth !== void 0 ? `?depth=${input.depth}` : "";
-  const path10 = projectPath(
+  const path11 = projectPath(
     input.project,
     `/graph/blast-radius/${encodeURIComponent(input.nodeId)}${qs}`
   );
   try {
-    const result = await client.get(path10);
+    const result = await client.get(path11);
     if (result.totalAffected === 0) {
       return {
         summary: `${result.origin} has no dependents. Nothing else would break if it failed.`
@@ -4003,12 +4176,12 @@ function formatBlastEntry(n) {
 }
 async function runDependencies(client, input) {
   const depth = input.depth ?? 3;
-  const path10 = projectPath(
+  const path11 = projectPath(
     input.project,
     `/graph/dependencies/${encodeURIComponent(input.nodeId)}?depth=${depth}`
   );
   try {
-    const result = await client.get(path10);
+    const result = await client.get(path11);
     if (result.total === 0) {
       return {
         summary: depth === 1 ? `${input.nodeId} has no direct dependencies in the graph.` : `${input.nodeId} has no dependencies (BFS to depth ${depth}).`
@@ -4100,9 +4273,9 @@ function formatDuration(ms) {
   return `${Math.round(h / 24)}d`;
 }
 async function runIncidents(client, input) {
-  const path10 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
+  const path11 = input.nodeId ? projectPath(input.project, `/incidents/${encodeURIComponent(input.nodeId)}`) : projectPath(input.project, "/incidents");
   try {
-    const body = await client.get(path10);
+    const body = await client.get(path11);
     const events = body.events;
     if (events.length === 0) {
       return {
@@ -4392,7 +4565,7 @@ async function resolveProjectEntry(opts) {
   const cwd = opts.cwd ?? process.cwd();
   const resolvedCwd = await normalizeProjectPath(cwd);
   for (const entry2 of entries) {
-    if (resolvedCwd === entry2.path || resolvedCwd.startsWith(`${entry2.path}${path8.sep}`)) {
+    if (resolvedCwd === entry2.path || resolvedCwd.startsWith(`${entry2.path}${path9.sep}`)) {
       return entry2;
     }
   }
@@ -4557,7 +4730,7 @@ function isNpxInvocation() {
 function commandPrefix() {
   return isNpxInvocation() ? "npx neat.is" : "neat";
 }
-function usage() {
+function usage2() {
   const neat = commandPrefix();
   console.log("Installed via npx? Prefix commands with `npx neat.is`, or install once: `npm i -g neat.is`.");
   console.log("");
@@ -4594,6 +4767,14 @@ function usage() {
   console.log("                 Flags:");
   console.log("                   --print-config   print the JSON snippet to stdout");
   console.log("                   --apply          merge mcpServers.neat into ~/.claude.json");
+  console.log("  hooks          Wire NEAT into your agent so it queries the graph before");
+  console.log("                 grepping. Installs a gentle Claude Code search-nudge hook and");
+  console.log("                 writes agent-agnostic graph-first guidance for other harnesses.");
+  console.log("                 Flags:");
+  console.log("                   --apply          install the hook + guidance");
+  console.log("                   --print-hook     print the hook script");
+  console.log("                   --print-guide    print the graph-first guidance");
+  console.log("                   --print-settings print the settings.json block --apply adds");
   console.log("  deploy         Detect the deploy substrate, generate NEAT_AUTH_TOKEN,");
   console.log("                 emit a docker-compose / systemd / docker run artifact, and");
   console.log("                 print the OTel env-vars block to paste into your platform.");
@@ -4838,7 +5019,7 @@ async function buildPatchSections(services, project) {
 }
 async function runInit(opts) {
   const written = [];
-  const stat = await fs7.stat(opts.scanPath).catch(() => null);
+  const stat = await fs8.stat(opts.scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) {
     console.error(`neat init: ${opts.scanPath} is not a directory`);
     return { exitCode: 2, writtenFiles: written };
@@ -4847,13 +5028,13 @@ async function runInit(opts) {
   printDiscoveryReport(opts, services);
   const sections = opts.noInstall ? [] : await buildPatchSections(services, opts.project);
   const patch = renderPatch(sections);
-  const patchPath = path9.join(opts.scanPath, "neat.patch");
+  const patchPath = path10.join(opts.scanPath, "neat.patch");
   if (opts.dryRun) {
-    await fs7.writeFile(patchPath, patch, "utf8");
+    await fs8.writeFile(patchPath, patch, "utf8");
     written.push(patchPath);
     console.log(`dry-run: patch written to ${patchPath}`);
-    const gitignorePath = path9.join(opts.scanPath, ".gitignore");
-    const gitignoreExists = await fs7.stat(gitignorePath).then(() => true).catch(() => false);
+    const gitignorePath = path10.join(opts.scanPath, ".gitignore");
+    const gitignoreExists = await fs8.stat(gitignorePath).then(() => true).catch(() => false);
     const verb = gitignoreExists ? "append" : "create";
     console.log(`dry-run: would ${verb} ${gitignorePath} (add neat-out/)`);
     console.log("rerun without --dry-run to register and snapshot.");
@@ -4864,9 +5045,9 @@ async function runInit(opts) {
   const graph = getGraph(graphKey);
   const projectPaths = pathsForProject(
     graphKey,
-    path9.join(opts.scanPath, "neat-out")
+    path10.join(opts.scanPath, "neat-out")
   );
-  const errorsPath = path9.join(path9.dirname(opts.outPath), path9.basename(projectPaths.errorsPath));
+  const errorsPath = path10.join(path10.dirname(opts.outPath), path10.basename(projectPaths.errorsPath));
   const result = await extractFromDirectory(graph, opts.scanPath, { errorsPath });
   await saveGraphToDisk(graph, opts.outPath);
   written.push(opts.outPath);
@@ -4945,7 +5126,7 @@ async function runInit(opts) {
         console.log("Run `npm install` (or your language equivalent) to refresh lockfiles.");
       }
     } else {
-      await fs7.writeFile(patchPath, patch, "utf8");
+      await fs8.writeFile(patchPath, patch, "utf8");
       written.push(patchPath);
     }
   }
@@ -4985,9 +5166,9 @@ var CLAUDE_SKILL_CONFIG = {
 };
 function claudeConfigPath() {
   const override = process.env.NEAT_CLAUDE_CONFIG;
-  if (override && override.length > 0) return path9.resolve(override);
+  if (override && override.length > 0) return path10.resolve(override);
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  return path9.join(home, ".claude.json");
+  return path10.join(home, ".claude.json");
 }
 async function runSkill(opts) {
   const snippet = JSON.stringify(CLAUDE_SKILL_CONFIG, null, 2) + "\n";
@@ -4999,7 +5180,7 @@ async function runSkill(opts) {
     const target = claudeConfigPath();
     let existing = {};
     try {
-      existing = JSON.parse(await fs7.readFile(target, "utf8"));
+      existing = JSON.parse(await fs8.readFile(target, "utf8"));
     } catch (err) {
       if (err.code !== "ENOENT") {
         console.error(`neat skill: failed to read ${target} \u2014 ${err.message}`);
@@ -5011,10 +5192,13 @@ async function runSkill(opts) {
       ...existing,
       mcpServers: { ...mcp, neat: CLAUDE_SKILL_CONFIG.mcpServers.neat }
     };
-    await fs7.mkdir(path9.dirname(target), { recursive: true });
-    await fs7.writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    await fs8.mkdir(path10.dirname(target), { recursive: true });
+    await fs8.writeFile(target, JSON.stringify(merged, null, 2) + "\n", "utf8");
     console.log(`neat skill: wrote mcpServers.neat to ${target}`);
     console.log("restart Claude Code to pick up the new MCP server.");
+    console.log("");
+    console.log("Tip: run `neat hooks --apply` to also install the search-nudge hook, so");
+    console.log("your agent reaches for the graph before it grep-scans the repo.");
     return { exitCode: 0 };
   }
   console.log("neat skill \u2014 Claude Code MCP drop-in for NEAT");
@@ -5027,13 +5211,16 @@ async function runSkill(opts) {
   console.log("");
   console.log("The MCP server reads NEAT_CORE_URL for the daemon URL \u2014 point it at a");
   console.log("non-default daemon by editing that value in the generated config.");
+  console.log("");
+  console.log("See also `neat hooks --apply` \u2014 the search-nudge hook + graph-first guidance");
+  console.log("that steer an agent to query the graph before falling back to text search.");
   return { exitCode: 0 };
 }
 async function main() {
   const argv = process.argv.slice(2);
   const cmd0 = argv[0];
   if (cmd0 === "-h" || cmd0 === "--help") {
-    usage();
+    usage2();
     process.exit(0);
   }
   if (cmd0 === "--version" || cmd0 === "-v" || cmd0 === "version") {
@@ -5045,6 +5232,11 @@ async function main() {
     if (code !== 0) process.exit(code);
     return;
   }
+  if (cmd0 === "hooks") {
+    const code = await runHooksCommand(argv.slice(1));
+    if (code !== 0) process.exit(code);
+    return;
+  }
   const argvParsed = parseArgs(argv);
   if (argvParsed.positional.length === 0) {
     const orchestratorCode2 = await tryOrchestrator(process.cwd(), argvParsed);
@@ -5059,19 +5251,19 @@ async function main() {
     const target = positional[0];
     if (!target) {
       console.error("neat init: missing <path>");
-      usage();
+      usage2();
       process.exit(2);
     }
     if (apply3 && dryRun) {
       console.error("neat init: --apply and --dry-run are mutually exclusive");
       process.exit(2);
     }
-    const scanPath = path9.resolve(target);
+    const scanPath = path10.resolve(target);
     const projectExplicit = parsed.project !== null;
-    const projectName = projectExplicit ? project : path9.basename(scanPath);
+    const projectName = projectExplicit ? project : path10.basename(scanPath);
     const projectKey = projectExplicit ? project : DEFAULT_PROJECT;
-    const fallback = pathsForProject(projectKey, path9.join(scanPath, "neat-out")).snapshotPath;
-    const outPath = path9.resolve(process.env.NEAT_OUT_PATH ?? fallback);
+    const fallback = pathsForProject(projectKey, path10.join(scanPath, "neat-out")).snapshotPath;
+    const outPath = path10.resolve(process.env.NEAT_OUT_PATH ?? fallback);
     const result = await runInit({
       scanPath,
       outPath,
@@ -5089,24 +5281,24 @@ async function main() {
     const target = positional[0];
     if (!target) {
       console.error("neat watch: missing <path>");
-      usage();
+      usage2();
       process.exit(2);
     }
-    const scanPath = path9.resolve(target);
-    const stat = await fs7.stat(scanPath).catch(() => null);
+    const scanPath = path10.resolve(target);
+    const stat = await fs8.stat(scanPath).catch(() => null);
     if (!stat || !stat.isDirectory()) {
       console.error(`neat watch: ${scanPath} is not a directory`);
       process.exit(2);
     }
-    const projectPaths = pathsForProject(project, path9.join(scanPath, "neat-out"));
-    const outPath = path9.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
-    const errorsPath = path9.resolve(
-      process.env.NEAT_ERRORS_PATH ?? path9.join(path9.dirname(outPath), path9.basename(projectPaths.errorsPath))
+    const projectPaths = pathsForProject(project, path10.join(scanPath, "neat-out"));
+    const outPath = path10.resolve(process.env.NEAT_OUT_PATH ?? projectPaths.snapshotPath);
+    const errorsPath = path10.resolve(
+      process.env.NEAT_ERRORS_PATH ?? path10.join(path10.dirname(outPath), path10.basename(projectPaths.errorsPath))
     );
-    const staleEventsPath = path9.resolve(
-      process.env.NEAT_STALE_EVENTS_PATH ?? path9.join(path9.dirname(outPath), path9.basename(projectPaths.staleEventsPath))
+    const staleEventsPath = path10.resolve(
+      process.env.NEAT_STALE_EVENTS_PATH ?? path10.join(path10.dirname(outPath), path10.basename(projectPaths.staleEventsPath))
     );
-    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? path9.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
+    const embeddingsCachePath = process.env.NEAT_EMBEDDINGS_CACHE_PATH ? path10.resolve(process.env.NEAT_EMBEDDINGS_CACHE_PATH) : void 0;
     const handle = await startWatch(getGraph(project), {
       scanPath,
       outPath,
@@ -5148,7 +5340,7 @@ async function main() {
     const name = positional[0];
     if (!name) {
       console.error("neat pause: missing <name>");
-      usage();
+      usage2();
       process.exit(2);
     }
     const daemon = await findDaemonByProject(name);
@@ -5173,7 +5365,7 @@ async function main() {
     const name = positional[0];
     if (!name) {
       console.error("neat resume: missing <name>");
-      usage();
+      usage2();
       process.exit(2);
     }
     const daemon = await findDaemonByProject(name);
@@ -5203,7 +5395,7 @@ async function main() {
     const name = positional[0];
     if (!name) {
       console.error("neat uninstall: missing <name>");
-      usage();
+      usage2();
       process.exit(2);
     }
     const daemon = await findDaemonByProject(name);
@@ -5285,15 +5477,15 @@ async function main() {
     return;
   }
   console.error(`neat: unknown command "${cmd}"`);
-  usage();
+  usage2();
   process.exit(1);
 }
 async function tryOrchestrator(cmd, parsed) {
-  const scanPath = path9.resolve(cmd);
-  const stat = await fs7.stat(scanPath).catch(() => null);
+  const scanPath = path10.resolve(cmd);
+  const stat = await fs8.stat(scanPath).catch(() => null);
   if (!stat || !stat.isDirectory()) return null;
   const projectExplicit = parsed.project !== null;
-  const projectName = projectExplicit ? parsed.project : path9.basename(scanPath);
+  const projectName = projectExplicit ? parsed.project : path10.basename(scanPath);
   const result = await runOrchestrator({
     scanPath,
     project: projectName,
@@ -5549,6 +5741,6 @@ export {
   runInit,
   runQueryVerb,
   runSkill,
-  usage
+  usage2 as usage
 };
 //# sourceMappingURL=cli.js.map