cli-five 0.2.15 → 0.2.17

package/src/commands/add.mjs

@@ -0,0 +1,55 @@
+import kleur from 'kleur';
+import { log } from '../util/log.mjs';
+import { ADDON_NAMES, getAddon, listAddons } from '../addons/registry.mjs';
+
+/**
+ * `cli-five add <name>` — dispatch to a registered add-on.
+ *
+ * This pass ships the dispatcher only. Registered targets without a `run`
+ * function respond with a clear stub so the mechanism can be exercised
+ * end-to-end without pretending an integration exists.
+ */
+export async function add(args) {
+  const name = args._[1];
+
+  if (!name || name === '--help' || name === '-h' || name === 'help') {
+    printAddHelp();
+    return;
+  }
+
+  const addon = getAddon(name);
+  if (!addon) {
+    log.err(`Unknown add-on: ${name}`);
+    printAvailable(addon => addon.name);
+    process.exitCode = 2;
+    return;
+  }
+
+  if (typeof addon.run !== 'function') {
+    log.warn(`${addon.label} is registered but not implemented yet.`);
+    log.info('The add dispatcher works — this target is reserved for a future release.');
+    if (addon.note || addon.status) log.dim(addon.note || addon.status);
+    log.dim('Nothing was written to your project.');
+    return;
+  }
+
+  log.step(`add ${addon.name}`);
+  await addon.run({ cwd: args.cwd, args });
+}
+
+function printAddHelp() {
+  process.stdout.write(`${kleur.bold('cli-five add')} — install an optional add-on\n\n`);
+  process.stdout.write(`${kleur.bold('Usage')}\n  npx cli-five add <name>\n\n`);
+  printAvailable();
+}
+
+function printAvailable() {
+  process.stdout.write(`${kleur.bold('Available add-ons')}\n`);
+  for (const addon of listAddons()) {
+    const addable = typeof addon.run === 'function';
+    const statusText = (addable ? 'available' : 'planned').padEnd(10);
+    const status = addable ? kleur.green(statusText) : kleur.yellow(statusText);
+    process.stdout.write(`  ${addon.name.padEnd(12)} ${status} ${kleur.dim(addon.description)}\n`);
+  }
+  process.stdout.write(`\n${kleur.dim(`Known names: ${ADDON_NAMES.join(', ')}`)}\n`);
+}

package/src/commands/init.mjs

@@ -5,18 +5,30 @@ import { resolve, basename, join, extname } from 'node:path';
 import { log } from '../util/log.mjs';
 import { detect } from '../steps/detect.mjs';
 import { confirmOverwriteIfNeeded } from '../steps/confirm.mjs';
-import { interview } from '../steps/interview.mjs';
+import { interview, minimalInterview } from '../steps/interview.mjs';
 import { scaffold, summarize } from '../steps/scaffold.mjs';
 import { skillDiscovery } from '../steps/skills.mjs';
 import { instructionGeneration } from '../steps/instructions.mjs';
-import { choosePlatform, chooseModels } from '../steps/platform.mjs';
+import { choosePlatform, chooseModels, resolveCodegraphDefault } from '../steps/platform.mjs';
 import { isGitRepo, gitInit } from '../util/git.mjs';
 import { platformLabel } from '../util/platforms.mjs';
+import { autoProjectInfo } from '../util/project.mjs';
 
 export async function init(args) {
   const cwd = args.cwd;
   log.raw(kleur.bold().magenta('\ncli-five init') + kleur.gray(`  ${cwd}`));
 
+  // ── Mode ───────────────────────────────────────────────────────────
+  // Default init is minimal: the 5 agents + required tooling, asking only for
+  // platform and (when needed) name/one-liner. The legacy interview — docs,
+  // goals/constraints/persona, model customization, skills, instructions — is
+  // opt-in via --full-interview (or --doc). Per-feature flags can also force
+  // skills/instructions/persona without the whole interview.
+  const docs = Array.isArray(args.docs) ? args.docs : [];
+  const fullInterview = Boolean(args.fullInterview) || docs.length > 0;
+  const runSkills = args.skills !== null ? Boolean(args.skills) : fullInterview;
+  const runInstructions = args.instructions !== null ? Boolean(args.instructions) : fullInterview;
+
   // 1. Detect
   log.step('1/8 Detect workspace');
   const detected = detect(cwd);
@@ -27,10 +39,17 @@ export async function init(args) {
 
   // 2. Platform + CodeGraph
   log.step('2/8 Choose platform');
-  const { platform, codegraph } = await choosePlatform(args);
+  const codegraphDefault = resolveCodegraphDefault(args, fullInterview);
+  const { platform, codegraph } = await choosePlatform(args, {
+    autoDetect: !fullInterview,
+    askCodegraph: fullInterview && args.codegraph === null,
+    codegraphDefault,
+  });
   log.info(`Target:  ${kleur.bold(platformLabel(platform))}`);
   if (codegraph) log.info(`CodeGraph: ${kleur.green('enabled')}`);
-  else log.info('CodeGraph: disabled');
+  else if (fullInterview || args.codegraph === false) log.info('CodeGraph: disabled');
+  else log.info(`CodeGraph: ${kleur.gray('disabled')} ${kleur.dim('(enable with --codegraph or --full-interview)')}`);
+  if (!fullInterview) log.dim('Minimal init. Full interview: npx cli-five init --full-interview');
 
   // 3. git init if needed
   if (!detected.hasGit) {
@@ -51,43 +70,57 @@ export async function init(args) {
   }
   if (!detected.hasAgents && !detected.hasCopilotInstructions) log.dim('No collisions.');
 
-  // 5. Input mode — docs or manual interview
-  log.step('4/8 Project info');
+  // 5. Project info + model configuration
+  args.__platform = platform;
   let docHints;
+  let modelConfig;
+
+  if (fullInterview) {
+    log.step('4/8 Project info');
+    if (docs.length > 0) {
+      // --doc was passed on the CLI — validate with retry
+      docHints = loadDocs(docs, cwd);
+      if (docHints.files.length === 0) {
+        log.warn('None of the --doc files could be loaded.');
+      }
+    } else if (args.yes) {
+      docHints = loadDocs([], cwd);
+    } else {
+      docHints = await collectDocFiles(cwd);
+    }
 
-  if (args.docs.length > 0) {
-    // --doc was passed on the CLI — validate with retry
-    docHints = loadDocs(args.docs, cwd);
-    if (docHints.files.length === 0) {
-      log.warn('None of the --doc files could be loaded.');
+    if (docHints.files.length > 0 && docs.length > 0) {
+      log.info(`Loaded ${docHints.files.length} doc${docHints.files.length > 1 ? 's' : ''}: ${docHints.files.join(', ')}`);
+      if (docHints.projectName) log.dim(`  → project name: ${docHints.projectName}`);
+      if (docHints.oneLiner) log.dim(`  → description: ${docHints.oneLiner}`);
     }
-  } else if (args.yes) {
-    docHints = loadDocs([], cwd);
+
+    log.step('5/8 Model configuration');
+    modelConfig = await chooseModels(platform, args);
   } else {
-    docHints = await collectDocFiles(cwd);
-  }
+    log.step('4/8 Project info');
+    docHints = autoProjectInfo(cwd);
+    logAutoProjectInfo(docHints);
 
-  if (docHints.files.length > 0 && args.docs.length > 0) {
-    log.info(`Loaded ${docHints.files.length} doc${docHints.files.length > 1 ? 's' : ''}: ${docHints.files.join(', ')}`);
-    if (docHints.projectName) log.dim(`  → project name: ${docHints.projectName}`);
-    if (docHints.oneLiner) log.dim(`  → description: ${docHints.oneLiner}`);
+    log.step('5/8 Model configuration');
+    // Minimal path uses provider defaults without prompting (still honours --provider).
+    modelConfig = await chooseModels(platform, { ...args, yes: true });
   }
 
-  // 6. Model configuration
-  log.step('5/8 Model configuration');
-  const modelConfig = await chooseModels(platform, args);
   log.info(`Provider: ${kleur.bold(modelConfig.provider)}`);
   if (modelConfig.customized) log.info('Models:  customized');
   else log.info('Models:  defaults');
 
-  // 7. Interview (pre-filled from docs if available, otherwise manual)
-  args.__platform = platform;
-  const answers = await interview(detected, args, docHints);
+  // 6. Interview (minimal by default, full behind --full-interview)
+  const answers = fullInterview
+    ? await interview(detected, args, docHints)
+    : await minimalInterview(detected, args, docHints);
 
-  // CLI --cost-mode override
+  // CLI overrides — apply to both paths.
   if (args.costMode && ['premium', 'cheap', 'mixed'].includes(args.costMode)) {
     answers.costMode = args.costMode;
   }
+  if (args.persona !== null) answers.snark = Boolean(args.persona);
 
   // Attach platform/model choices to answers so scaffold can use them.
   answers.platform = platform;
@@ -101,30 +134,56 @@ export async function init(args) {
   }
   if (answers.frameworks.length) log.info(`Stack:  ${answers.stack.join(', ')} + ${answers.frameworks.join(', ')}`);
 
-  // 8. Scaffold
+  // 7. Scaffold
   log.step('6/8 Scaffold');
   const written = scaffold({ cwd, answers, args });
   if (args.dryRun) log.warn('--dry-run: no files written. Plan:');
   log.raw(summarize(written, cwd));
   if (!args.dryRun) log.ok(`Wrote ${written.length} files.`);
 
-  // 9. Skill discovery
+  // 8. Skill discovery
   log.step('7/8 Skill discovery');
-  await skillDiscovery({ cwd, answers, args });
+  if (runSkills) {
+    await skillDiscovery({ cwd, answers, args: { ...args, skills: true } });
+  } else {
+    log.dim('Skipped (minimal init). Enable with --skills or --full-interview.');
+  }
 
-  // 10. Custom instructions
+  // 9. Custom instructions
   log.step('8/8 Custom instructions');
-  const instrWritten = await instructionGeneration({ cwd, answers, args });
-  if (instrWritten && instrWritten.length > 0) {
-    if (args.dryRun) log.warn('--dry-run: instruction plan:');
-    for (const w of instrWritten) {
-      log.raw(`  ${w.written ? '+' : '~'} ${w.path.replace(cwd + '/', '')}`);
+  if (runInstructions) {
+    const instrWritten = await instructionGeneration({ cwd, answers, args });
+    if (instrWritten && instrWritten.length > 0) {
+      if (args.dryRun) log.warn('--dry-run: instruction plan:');
+      for (const w of instrWritten) {
+        log.raw(`  ${w.written ? '+' : '~'} ${w.path.replace(cwd + '/', '')}`);
+      }
+      if (!args.dryRun) log.ok(`Wrote ${instrWritten.length} instruction file${instrWritten.length > 1 ? 's' : ''}.`);
     }
-    if (!args.dryRun) log.ok(`Wrote ${instrWritten.length} instruction file${instrWritten.length > 1 ? 's' : ''}.`);
+  } else {
+    log.dim('Skipped (minimal init). Enable with --instructions or --full-interview.');
   }
 
-  // 11. Next steps
-  printNextSteps(answers);
+  // 10. Next steps
+  printNextSteps(answers, { generatedInstructions: runInstructions });
+}
+
+/** Log which project fields were auto-pulled from the workspace. */
+function logAutoProjectInfo(info) {
+  const name = info?.name || {};
+  const oneLiner = info?.oneLiner || {};
+
+  if (name.value && !name.ambiguous) {
+    log.info(`Name:    ${kleur.bold(name.value)} ${kleur.gray(`(${name.sources[0].source})`)}`);
+  } else if (name.ambiguous) {
+    log.warn(`Multiple project names found (${name.sources.map((s) => s.source).join(', ')}) — asking.`);
+  }
+
+  if (oneLiner.value && !oneLiner.ambiguous) {
+    log.info(`Tagline: ${oneLiner.value} ${kleur.gray(`(${oneLiner.sources[0].source})`)}`);
+  } else if (oneLiner.ambiguous) {
+    log.warn(`Multiple descriptions found (${oneLiner.sources.map((s) => s.source).join(', ')}) — asking.`);
+  }
 }
 
 async function ask(message, initial = false) {
@@ -132,7 +191,7 @@ async function ask(message, initial = false) {
   return Boolean(v);
 }
 
-function printNextSteps(answers) {
+function printNextSteps(answers, { generatedInstructions = false } = {}) {
   const hasDocs = answers.docFiles?.length > 0;
   const platform = answers.platform || 'copilot';
   const codegraph = answers.codegraph;
@@ -165,8 +224,10 @@ function printNextSteps(answers) {
   } else {
     log.raw(kleur.gray(`        read PROJECT.md and implement Phase 1.`));
   }
-  log.raw(`  6. Review generated instruction files in .github/instructions/.`);
-  log.raw(kleur.gray(`        Edit applyTo globs and guidelines to fit your project.`));
+  if (generatedInstructions) {
+    log.raw(`  6. Review generated instruction files in .github/instructions/.`);
+    log.raw(kleur.gray(`        Edit applyTo globs and guidelines to fit your project.`));
+  }
 
   if (codegraph) {
     log.raw('');
@@ -183,6 +244,9 @@ function printNextSteps(answers) {
     log.raw('');
     log.raw(kleur.dim('Edit agent models anytime by changing `model:` in .opencode/agents/*.md.'));
   }
+
+  log.raw('');
+  log.raw(kleur.dim('Optional integrations: npx cli-five list-addons'));
   log.raw('');
 }
 

package/src/commands/list-addons.mjs

@@ -0,0 +1,49 @@
+import kleur from 'kleur';
+import { log } from '../util/log.mjs';
+import { detectAddon, listAddons } from '../addons/registry.mjs';
+
+/**
+ * `cli-five list-addons` — show what is installed vs. available.
+ *
+ * "Installed" is detected read-only from workspace artifacts. Status text is
+ * deliberately honest: an add-on that ships partial capability (e.g. jev's
+ * tier-routing without the parked test-gate) must not read as fully installed.
+ */
+export function listAddonsCommand(args) {
+  const cwd = args.cwd;
+  log.raw(kleur.bold().magenta('\ncli-five list-addons') + kleur.gray(`  ${cwd}`));
+  log.raw('');
+
+  log.raw(`  ${kleur.gray(pad('ADD-ON', 12))} ${kleur.gray(pad('STATUS', 14))} ${kleur.gray(pad('ADD', 10))} ${kleur.gray('DETAIL')}`);
+  log.raw(`  ${'─'.repeat(12)} ${'─'.repeat(14)} ${'─'.repeat(10)} ${'─'.repeat(30)}`);
+
+  for (const addon of listAddons()) {
+    const signals = detectAddon(addon, cwd);
+    const installed = signals.length > 0;
+    const addable = typeof addon.run === 'function';
+
+    // An installed add-on with a `capability` note is partial — say so.
+    const statusLabel = installed
+      ? (addon.capability ? `installed (${addon.capability})` : 'installed')
+      : 'not found';
+
+    const detail = installed
+      ? [addon.status || signals.join(', ')].filter(Boolean).join(' — ')
+      : addon.note || addon.status || '';
+
+    const statusText = pad(statusLabel, 14);
+    const status = installed ? kleur.green(statusText) : kleur.gray(statusText);
+    const addableText = pad(addable ? 'available' : 'planned', 10);
+    const addableColored = addable ? kleur.green(addableText) : kleur.yellow(addableText);
+
+    log.raw(`  ${pad(addon.name, 12)} ${status} ${addableColored} ${kleur.dim(detail)}`);
+  }
+
+  log.raw('');
+  log.dim('Install with `npx cli-five add <name>`.');
+  log.raw('');
+}
+
+function pad(value, width) {
+  return String(value).padEnd(width);
+}

package/src/steps/interview.mjs

@@ -195,6 +195,65 @@ export async function interview(detected, args, docHints = {}) {
   });
 }
 
+/**
+ * Minimal interview — the default `init` path.
+ *
+ * Asks for the project name and one-liner only, and only when `projectInfo`
+ * could not confidently supply them. Everything else (stack, goals,
+ * constraints, persona, cost mode) falls back to `defaults`.
+ *
+ * `projectInfo` is the shape returned by `autoProjectInfo(cwd)`.
+ */
+export async function minimalInterview(detected, args, projectInfo = {}) {
+  const platform = args.__platform || 'copilot';
+  const nameInfo = projectInfo.name || {};
+  const oneLinerInfo = projectInfo.oneLiner || {};
+
+  let projectName = nameInfo.value || '';
+  let oneLiner = oneLinerInfo.value || '';
+
+  if (!args.yes) {
+    const questions = [];
+
+    if (!projectName || nameInfo.ambiguous) {
+      questions.push({
+        type: 'text',
+        name: 'projectName',
+        message: 'Project name',
+        initial: projectName || detected.projectName,
+      });
+    }
+
+    if (!oneLiner || oneLinerInfo.ambiguous) {
+      questions.push({
+        type: 'text',
+        name: 'oneLiner',
+        message: 'One-line description (becomes PROJECT.md vision)',
+        initial: oneLiner || '',
+      });
+    }
+
+    if (questions.length > 0) {
+      const answers = await prompts(questions, {
+        onCancel: () => {
+          throw new Error('Interview cancelled. Nothing was written.');
+        },
+      });
+      if (answers.projectName !== undefined) projectName = answers.projectName;
+      if (answers.oneLiner !== undefined) oneLiner = answers.oneLiner;
+    }
+  }
+
+  const base = defaults(detected, { projectName, oneLiner }, platform);
+  return normalize({
+    ...base,
+    projectName: (projectName || detected.projectName || '').trim(),
+    oneLiner: (oneLiner || '').trim(),
+    // Persona is opt-in on the minimal path (--persona / --full-interview).
+    snark: args.persona === true,
+  });
+}
+
 /** Default stack is first preset when nothing is detected and --yes is used. */
 function defaults(detected, docHints = {}, platform = 'copilot') {
   const hasDetected = detected.stacks.length > 0;

package/src/steps/platform.mjs

@@ -1,5 +1,7 @@
 import kleur from 'kleur';
 import prompts from 'prompts';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
 import {
   PLATFORM_COPILOT,
   PLATFORM_OPENCODE,
@@ -21,20 +23,50 @@ import {
 
 const CUSTOM_SENTINEL = '__custom__';
 
+/**
+ * Resolve whether CodeGraph should be enabled when no explicit `--codegraph`
+ * / `--no-codegraph` value was passed.
+ *
+ * The registration/opt-out mechanism is unchanged — this only decides the
+ * default: on for the full interview, off for minimal init.
+ */
+export function resolveCodegraphDefault(args, fullInterview) {
+  if (args.codegraph === true || args.codegraph === false) return args.codegraph;
+  return Boolean(fullInterview);
+}
+
 /**
  * Ask the user to choose a target platform.
  * If args.target is a valid platform, skip the prompt.
+ *
+ * Options:
+ *   autoDetect   — infer the platform from an existing scaffold before prompting
+ *   askCodegraph — whether to ask the CodeGraph opt-out question (full interview)
+ *   codegraphDefault — resolved default when no explicit flag was passed
+ *
+ * Note: CodeGraph registration and the `--no-codegraph` opt-out are unchanged;
+ * this only controls whether the question is asked / what the default is.
  */
-export async function choosePlatform(args) {
+export async function choosePlatform(args, { autoDetect = false, askCodegraph = true, codegraphDefault } = {}) {
+  if (codegraphDefault === undefined) codegraphDefault = args.codegraph !== false;
+
   if (args.target) {
     const t = String(args.target).toLowerCase();
     if (PLATFORMS.includes(t)) {
-      return { platform: t, codegraph: args.codegraph !== false };
+      return { platform: t, codegraph: codegraphDefault };
+    }
+  }
+
+  if (autoDetect) {
+    const existing = detectExistingPlatform(args.cwd);
+    if (existing) {
+      log.dim(`Detected existing ${platformLabel(existing)} scaffold.`);
+      return { platform: existing, codegraph: codegraphDefault };
     }
   }
 
   if (args.yes) {
-    return { platform: PLATFORM_COPILOT, codegraph: args.codegraph !== false };
+    return { platform: PLATFORM_COPILOT, codegraph: codegraphDefault };
   }
 
   const { platform } = await prompts({
@@ -60,6 +92,10 @@ export async function choosePlatform(args) {
     throw new Error('Platform selection cancelled. Nothing was written.');
   }
 
+  if (!askCodegraph) {
+    return { platform, codegraph: codegraphDefault };
+  }
+
   const { codegraph } = await prompts({
     type: 'confirm',
     name: 'codegraph',
@@ -70,6 +106,13 @@ export async function choosePlatform(args) {
   return { platform, codegraph: codegraph !== false };
 }
 
+/** Infer an existing scaffold's platform, or null when there is no scaffold. */
+export function detectExistingPlatform(cwd) {
+  if (existsSync(join(cwd, '.opencode', 'agents'))) return PLATFORM_OPENCODE;
+  if (existsSync(join(cwd, '.github', 'agents', 'orchestrator.agent.md'))) return PLATFORM_COPILOT;
+  return null;
+}
+
 /**
  * Ask the user whether to customize models, pick a provider, and optionally
  * override per-agent models.

package/src/steps/scaffold.mjs

@@ -3,6 +3,7 @@ import { log } from '../util/log.mjs';
 import { readTemplate, render, writeFile, listFilesRecursive, relTo, templatePath } from '../util/fs.mjs';
 import { readFileSync } from 'node:fs';
 import { PLATFORM_COPILOT, PLATFORM_OPENCODE, agentDirFor, agentFileFor } from '../util/platforms.mjs';
+import { addCodegraphTo } from '../addons/codegraph.mjs';
 
 const AGENT_NAMES = ['orchestrator', 'planner', 'coder', 'designer', 'reviewer'];
 const HISTORY_FILES = ['orchestrator.md', 'planner.md', 'coder.md', 'designer.md', 'reviewer.md'];
@@ -44,6 +45,9 @@ export function scaffold({ cwd, answers, args }) {
   }
 
   // Shared memory primitives
+  // NOTE: AGENTS.md is written WITHOUT the CodeGraph block here. When CodeGraph
+  // is enabled, the block is merged in afterward by addCodegraphTo() — the same
+  // code path `add codegraph` uses (one implementation, two entry points).
   for (const tmpl of [
     'AGENTS.md.tmpl',
     'PROJECT.md.tmpl',
@@ -61,6 +65,13 @@ export function scaffold({ cwd, answers, args }) {
     written.push(writeFile(join(cwd, 'histories', file), readTemplate('histories', file), args));
   }
 
+  // CodeGraph — delegated to the shared add codegraph implementation.
+  if (answers.codegraph) {
+    for (const t of addCodegraphTo({ cwd, platform, dryRun: args.dryRun })) {
+      written.push({ path: t.path, written: !args.dryRun && t.action !== 'unchanged' });
+    }
+  }
+
   return written;
 }
 
@@ -93,11 +104,6 @@ function scaffoldCopilot({ cwd, answers, args, vars }) {
     writeFile(join(cwd, '.github', 'skills', 'README.md'), readTemplate('.github', 'skills', 'README.md'), args),
   );
 
-  // CodeGraph MCP for VS Code Copilot
-  if (answers.codegraph) {
-    written.push(writeFile(join(cwd, '.vscode', 'mcp.json'), JSON.stringify(codegraphMcpJson(), null, 2), args));
-  }
-
   return written;
 }
 
@@ -144,34 +150,10 @@ function buildOpencodeConfig({ answers, orchestratorModel }) {
     subagent_depth: 2,
   };
 
-  if (answers.codegraph) {
-    config.mcp = {
-      codegraph: {
-        type: 'local',
-        command: ['codegraph', 'serve', '--mcp'],
-        enabled: true,
-      },
-    };
-  }
-
   return config;
 }
 
-function codegraphMcpJson() {
-  return {
-    inputs: [],
-    servers: {
-      codegraph: {
-        command: 'codegraph',
-        args: ['serve', '--mcp'],
-      },
-    },
-  };
-}
-
 function buildVars(a) {
-  const codegraphBlock = a.codegraph ? CODEGRAPH_BLOCK : '';
-
   return {
     PROJECT_NAME: a.projectName,
     ONE_LINER: a.oneLiner || 'TODO — write a one-line vision statement.',
@@ -190,7 +172,6 @@ ${a.docs}
 ` : '',
     DATE: new Date().toISOString().slice(0, 10),
     PERSONA_BLOCK: a.snark ? PERSONA_BLOCK : '',
-    CODEGRAPH_BLOCK: codegraphBlock,
   };
 }
 
@@ -221,22 +202,6 @@ const PERSONA_BLOCK = `# Persona
 
 `;
 
-const CODEGRAPH_BLOCK = `
-<!-- CODEGRAPH_START -->
-## CodeGraph
-
-This project is configured to use [CodeGraph](https://codegraph.ru) for graph-backed codebase context.
-When you need to understand relationships, call paths, or impacts, use:
-
-\`\`\`
-codegraph explore "<your question>"
-\`\`\`
-
-The CodeGraph MCP server is registered in the project config. Run \`codegraph init\` in this directory
-if the project has not been indexed yet.
-<!-- CODEGRAPH_END -->
-`;
-
 export function summarize(written, cwd) {
   const lines = [];
   for (const w of written) {