cli-five 0.2.13 → 0.2.16

package/src/commands/doctor.mjs

@@ -2,9 +2,15 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import kleur from 'kleur';
 import { log } from '../util/log.mjs';
-import { AGENT_FILES, validateAgentSource } from '../util/agents.mjs';
+import {
+  AGENT_FILES,
+  OPENCODE_AGENT_FILES,
+  validateAgentSource,
+  validateOpenCodeAgentSource,
+} from '../util/agents.mjs';
+import { PLATFORM_COPILOT, PLATFORM_OPENCODE } from '../util/platforms.mjs';
 
-const REQUIRED = [
+const COPILOT_REQUIRED = [
   '.github/copilot-instructions.md',
   '.github/agents/orchestrator.agent.md',
   '.github/agents/planner.agent.md',
@@ -17,6 +23,19 @@ const REQUIRED = [
   'agent-diary.md',
 ];
 
+const OPENCODE_REQUIRED = [
+  'opencode.json',
+  '.opencode/agents/orchestrator.md',
+  '.opencode/agents/planner.md',
+  '.opencode/agents/coder.md',
+  '.opencode/agents/designer.md',
+  '.opencode/agents/reviewer.md',
+  'PROJECT.md',
+  'STATE.md',
+  'decisions.md',
+  'agent-diary.md',
+];
+
 const OPTIONAL = [
   '.github/instructions',
   '.github/skills',
@@ -26,11 +45,15 @@ const OPTIONAL = [
 
 export async function doctor(args) {
   const cwd = args.cwd;
+  const platform = detectPlatform(cwd);
   log.raw(kleur.bold().magenta('\ncli-five doctor') + kleur.gray(`  ${cwd}`));
+  log.info(`Detected platform: ${kleur.bold(platform)}`);
   let fail = 0;
 
+  const required = platform === PLATFORM_OPENCODE ? OPENCODE_REQUIRED : COPILOT_REQUIRED;
+
   log.step('Required');
-  for (const p of REQUIRED) {
+  for (const p of required) {
     const ok = existsSync(join(cwd, p));
     if (ok) log.ok(p);
     else {
@@ -40,22 +63,60 @@ export async function doctor(args) {
   }
 
   log.step('Agent integrity');
-  for (const file of AGENT_FILES) {
-    const relPath = join('.github', 'agents', file);
-    const fullPath = join(cwd, relPath);
-    if (!existsSync(fullPath)) continue;
+  if (platform === PLATFORM_OPENCODE) {
+    for (const file of OPENCODE_AGENT_FILES) {
+      const relPath = join('.opencode', 'agents', file);
+      const fullPath = join(cwd, relPath);
+      if (!existsSync(fullPath)) continue;
 
-    const errors = validateAgentSource(readFileSync(fullPath, 'utf8'), file);
-    if (errors.length === 0) {
-      log.ok(relPath);
-      continue;
+      const errors = validateOpenCodeAgentSource(readFileSync(fullPath, 'utf8'), file);
+      if (errors.length === 0) {
+        log.ok(relPath);
+        continue;
+      }
+
+      log.err(relPath);
+      for (const error of errors) {
+        log.raw(kleur.red(`  - ${error}`));
+      }
+      fail++;
     }
+  } else {
+    for (const file of AGENT_FILES) {
+      const relPath = join('.github', 'agents', file);
+      const fullPath = join(cwd, relPath);
+      if (!existsSync(fullPath)) continue;
+
+      const errors = validateAgentSource(readFileSync(fullPath, 'utf8'), file);
+      if (errors.length === 0) {
+        log.ok(relPath);
+        continue;
+      }
+
+      log.err(relPath);
+      for (const error of errors) {
+        log.raw(kleur.red(`  - ${error}`));
+      }
+      fail++;
+    }
+  }
 
-    log.err(relPath);
-    for (const error of errors) {
-      log.raw(kleur.red(`  - ${error}`));
+  if (platform === PLATFORM_OPENCODE) {
+    log.step('OpenCode config');
+    const opencodePath = join(cwd, 'opencode.json');
+    if (existsSync(opencodePath)) {
+      try {
+        const cfg = JSON.parse(readFileSync(opencodePath, 'utf8'));
+        if (cfg.mcp?.codegraph) {
+          log.ok('opencode.json has CodeGraph MCP entry');
+        } else {
+          log.warn('opencode.json missing CodeGraph MCP entry (ok if CodeGraph disabled)');
+        }
+      } catch (err) {
+        log.err(`opencode.json is not valid JSON: ${err.message}`);
+        fail++;
+      }
     }
-    fail++;
   }
 
   log.step('Optional');
@@ -72,3 +133,9 @@ export async function doctor(args) {
     process.exit(1);
   }
 }
+
+function detectPlatform(cwd) {
+  if (existsSync(join(cwd, '.opencode', 'agents'))) return PLATFORM_OPENCODE;
+  if (existsSync(join(cwd, '.github', 'agents', 'orchestrator.agent.md'))) return PLATFORM_COPILOT;
+  return PLATFORM_COPILOT;
+}

package/src/commands/init.mjs

@@ -5,25 +5,53 @@ 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, 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/6 Detect workspace');
+  log.step('1/8 Detect workspace');
   const detected = detect(cwd);
   log.info(`Project: ${kleur.bold(detected.projectName)}`);
   log.info(`Mode:    ${detected.isBrownfield ? kleur.yellow('brownfield') : kleur.green('greenfield')}`);
   if (detected.stacks.length) log.info(`Stack:   ${detected.stacks.map((s) => s.label).join(', ')}`);
   if (!detected.hasGit) log.warn('Not a git repository.');
 
-  // 2. git init if needed
+  // 2. Platform + CodeGraph
+  log.step('2/8 Choose platform');
+  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 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) {
     if (args.yes || (await ask('Run `git init`?', true))) {
       gitInit(cwd);
@@ -33,8 +61,8 @@ export async function init(args) {
     }
   }
 
-  // 3. Overwrite gate
-  log.step('2/6 Confirm overwrites');
+  // 4. Overwrite gate
+  log.step('3/8 Confirm overwrites');
   const ok = await confirmOverwriteIfNeeded(detected, args);
   if (!ok) {
     log.warn('Aborted. Nothing written.');
@@ -42,65 +70,120 @@ export async function init(args) {
   }
   if (!detected.hasAgents && !detected.hasCopilotInstructions) log.dim('No collisions.');
 
-  // 4. Input mode — docs or manual interview
-  log.step('3/6 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 });
   }
 
-  // 5. Interview (pre-filled from docs if available, otherwise manual)
-  const answers = await interview(detected, args, docHints);
+  log.info(`Provider: ${kleur.bold(modelConfig.provider)}`);
+  if (modelConfig.customized) log.info('Models:  customized');
+  else log.info('Models:  defaults');
+
+  // 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;
+  answers.codegraph = codegraph;
+  answers.provider = modelConfig.provider;
+  answers.modelMap = modelConfig.modelMap;
+  answers.customizedModels = modelConfig.customized;
 
   if (answers.presetId && answers.presetId !== 'custom') {
     log.info(`Preset: ${answers.presetId}`);
   }
   if (answers.frameworks.length) log.info(`Stack:  ${answers.stack.join(', ')} + ${answers.frameworks.join(', ')}`);
 
-  // 5. Scaffold
-  log.step('4/6 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.`);
 
-  // 6. Skill discovery
-  log.step('5/6 Skill discovery');
-  await skillDiscovery({ cwd, answers, args });
-
-  // 7. Custom instructions
-  log.step('6/6 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 + '/', '')}`);
+  // 8. Skill discovery
+  log.step('7/8 Skill discovery');
+  if (runSkills) {
+    await skillDiscovery({ cwd, answers, args: { ...args, skills: true } });
+  } else {
+    log.dim('Skipped (minimal init). Enable with --skills or --full-interview.');
+  }
+
+  // 9. Custom instructions
+  log.step('8/8 Custom instructions');
+  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.');
   }
 
-  // 8. 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) {
@@ -108,17 +191,31 @@ 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;
 
   log.raw('');
   log.raw(kleur.bold().green('Done. Next steps:'));
   log.raw('');
-  log.raw(`  1. Open this folder in VS Code Insiders.`);
-  log.raw(`  2. Enable Copilot subagent invocations (settings.json):`);
-  log.raw(kleur.gray(`        "chat.subagents.allowInvocationsFromSubagents": true`));
-  log.raw(`  3. Open Copilot Chat — select an agent from the dropdown (${kleur.bold('not')} @mention).`);
-  log.raw(`  4. Select ${kleur.bold('Orchestrator')} — it routes tasks autonomously to Planner, Coder, Designer, and Reviewer.`);
+
+  if (platform === 'opencode') {
+    log.raw(`  1. Install the CodeGraph CLI if you haven't:`);
+    log.raw(kleur.gray(`        npm i -g @colbymchenry/codegraph`));
+    log.raw(`  2. Index this project with CodeGraph:`);
+    log.raw(kleur.gray(`        codegraph init`));
+    log.raw(`  3. Run OpenCode from this directory:`);
+    log.raw(kleur.gray(`        opencode`));
+    log.raw(`  4. Select ${kleur.bold('Orchestrator')} and describe what you want built.`);
+  } else {
+    log.raw(`  1. Open this folder in VS Code Insiders.`);
+    log.raw(`  2. Enable Copilot subagent invocations (settings.json):`);
+    log.raw(kleur.gray(`        "chat.subagents.allowInvocationsFromSubagents": true`));
+    log.raw(`  3. Open Copilot Chat — select an agent from the dropdown (${kleur.bold('not')} @mention).`);
+    log.raw(`  4. Select ${kleur.bold('Orchestrator')} — it routes tasks autonomously to Planner, Coder, Designer, and Reviewer.`);
+  }
+
   log.raw(`  5. ${hasDocs ? 'Kickoff prompt (paste this into Orchestrator):' : 'Start building:'}`);
   if (hasDocs) {
     const docList = answers.docFiles.join(', ');
@@ -127,13 +224,29 @@ 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.`));
-  log.raw('');
-  log.raw(kleur.dim('  Quick plugin install (personal, no project config):'));
-  log.raw(kleur.dim('    copilot plugin install idusortus/cli-five'));
+  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('');
+    log.raw(kleur.dim('  CodeGraph is configured. Remember to run `codegraph init` before asking agents to explore the codebase.'));
+  }
+
+  if (platform === 'copilot') {
+    log.raw('');
+    log.raw(kleur.dim('  Quick plugin install (personal, no project config):'));
+    log.raw(kleur.dim('    copilot plugin install idusortus/cli-five'));
+    log.raw('');
+    log.raw(kleur.dim('Edit cost mode anytime by changing `model:` in .github/agents/*.agent.md.'));
+  } else {
+    log.raw('');
+    log.raw(kleur.dim('Edit agent models anytime by changing `model:` in .opencode/agents/*.md.'));
+  }
+
   log.raw('');
-  log.raw(kleur.dim('Edit cost mode anytime by changing `model:` in .github/agents/*.agent.md.'));
+  log.raw(kleur.dim('Optional integrations: npx cli-five list-addons'));
   log.raw('');
 }
 

package/src/commands/list-addons.mjs

@@ -0,0 +1,40 @@
+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. CodeGraph is
+ * listed honestly even though its `add` plumbing has not moved yet.
+ */
+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', 12))} ${kleur.gray(pad('ADD', 10))} ${kleur.gray('DETAIL')}`);
+  log.raw(`  ${'─'.repeat(12)} ${'─'.repeat(12)} ${'─'.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';
+    const detail = installed ? signals.join(', ') : addon.note || '';
+
+    const statusText = pad(installed ? 'installed' : 'not found', 12);
+    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>` once a target is available.');
+  log.raw('');
+}
+
+function pad(value, width) {
+  return String(value).padEnd(width);
+}

package/src/steps/confirm.mjs

@@ -34,5 +34,7 @@ function collideList(detected) {
   const out = [];
   if (detected.hasAgents) out.push('.github/agents/');
   if (detected.hasCopilotInstructions) out.push('.github/copilot-instructions.md');
+  if (detected.hasOpencodeAgents) out.push('.opencode/agents/');
+  if (detected.hasOpencodeConfig) out.push('opencode.json');
   return out;
 }

package/src/steps/detect.mjs

@@ -29,6 +29,8 @@ export function detect(cwd) {
   const hasGithub = names.has('.github');
   const hasAgents = existsSync(join(cwd, '.github', 'agents'));
   const hasCopilotInstructions = existsSync(join(cwd, '.github', 'copilot-instructions.md'));
+  const hasOpencodeAgents = existsSync(join(cwd, '.opencode', 'agents'));
+  const hasOpencodeConfig = existsSync(join(cwd, 'opencode.json'));
   const projectName = guessName(cwd, names);
 
   return {
@@ -38,6 +40,8 @@ export function detect(cwd) {
     hasGithub,
     hasAgents,
     hasCopilotInstructions,
+    hasOpencodeAgents,
+    hasOpencodeConfig,
     isBrownfield: stacks.length > 0,
     stacks,
   };

package/src/steps/interview.mjs

@@ -69,7 +69,8 @@ const COST_MODES = [
 ];
 
 export async function interview(detected, args, docHints = {}) {
-  if (args.yes) return defaults(detected, docHints);
+  const platform = args.__platform || 'copilot';
+  if (args.yes) return defaults(detected, docHints, platform);
 
   const onCancel = () => {
     throw new Error('Interview cancelled. Nothing was written.');
@@ -146,39 +147,44 @@ export async function interview(detected, args, docHints = {}) {
   }
 
   // ── Remaining questions ───────────────────────────────────────────
-  const rest = await prompts(
-    [
-      {
-        type: 'text',
-        name: 'goals',
-        message: `Primary goal of this project (one sentence)${skipHint}`,
-        initial: docHints.goals || '',
-      },
-      {
-        type: 'text',
-        name: 'constraints',
-        message: `Hard constraints (perf, deps, deploy, compliance — one sentence, optional)${skipHint}`,
-        initial: docHints.constraints || '',
-      },
-      {
-        type: 'select',
-        name: 'costMode',
-        message: 'Agent cost mode',
-        choices: COST_MODES,
-        initial: 0,
-      },
-      {
-        type: 'confirm',
-        name: 'snark',
-        message: 'Include the snarky persona block in copilot-instructions.md?',
-        initial: true,
-      },
-    ],
-    { onCancel },
-  );
+  const remainingQuestions = [
+    {
+      type: 'text',
+      name: 'goals',
+      message: `Primary goal of this project (one sentence)${skipHint}`,
+      initial: docHints.goals || '',
+    },
+    {
+      type: 'text',
+      name: 'constraints',
+      message: `Hard constraints (perf, deps, deploy, compliance — one sentence, optional)${skipHint}`,
+      initial: docHints.constraints || '',
+    },
+  ];
+
+  if (platform === 'copilot') {
+    remainingQuestions.push({
+      type: 'select',
+      name: 'costMode',
+      message: 'Agent cost mode',
+      choices: COST_MODES,
+      initial: 0,
+    });
+  }
+
+  remainingQuestions.push({
+    type: 'confirm',
+    name: 'snark',
+    message: platform === 'copilot'
+      ? 'Include the snarky persona block in copilot-instructions.md?'
+      : 'Include the snarky persona block in AGENTS.md?',
+    initial: true,
+  });
+
+  const rest = await prompts(remainingQuestions, { onCancel });
 
   return normalize({
-    ...defaults(detected, docHints),
+    ...defaults(detected, docHints, platform),
     ...basic,
     ...stackAnswers,
     ...rest,
@@ -189,8 +195,67 @@ 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 = {}) {
+function defaults(detected, docHints = {}, platform = 'copilot') {
   const hasDetected = detected.stacks.length > 0;
   const fallback = STACK_PRESETS[0];
   return {
@@ -200,7 +265,7 @@ function defaults(detected, docHints = {}) {
     frameworks: hasDetected ? [] : fallback.frameworks,
     goals: docHints.goals || '',
     constraints: docHints.constraints || '',
-    costMode: 'premium',
+    costMode: platform === 'copilot' ? 'premium' : 'none',
     snark: true,
     presetId: hasDetected ? 'custom' : fallback.value,
     quickstart: hasDetected ? '' : fallback.quickstart,