bopodev 0.1.15 → 0.1.16

package/dist/index.js

@@ -5,7 +5,7 @@ import { Command } from "commander";
 import { cancel, outro } from "@clack/prompts";
 
 // src/lib/checks.ts
-import { access as access2, constants, mkdir } from "fs/promises";
+import { access as access2, constants, stat } from "fs/promises";
 import { homedir } from "os";
 import { join as join2, resolve as resolve2 } from "path";
 
@@ -27,6 +27,12 @@ async function runCommandCapture(command, args, options) {
     });
     let stdout = "";
     let stderr = "";
+    const timeoutMs = Math.max(0, Math.floor(options?.timeoutMs ?? 1e4));
+    const timeoutHandle = timeoutMs > 0 ? setTimeout(() => {
+      stderr = `${stderr}
+Command '${command}' timed out after ${timeoutMs}ms.`.trim();
+      child.kill("SIGTERM");
+    }, timeoutMs) : null;
     child.stdout.on("data", (chunk) => {
       stdout += String(chunk);
     });
@@ -34,6 +40,9 @@ async function runCommandCapture(command, args, options) {
       stderr += String(chunk);
     });
     child.on("error", (error) => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
       resolvePromise({
         ok: false,
         code: null,
@@ -43,6 +52,9 @@ ${String(error)}`.trim()
       });
     });
     child.on("close", (code) => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
       resolvePromise({
         ok: code === 0,
         code,
@@ -89,6 +101,7 @@ async function fileExists(path) {
 }
 
 // src/lib/checks.ts
+var SAFE_PATH_SEGMENT_RE = /^[a-zA-Z0-9_-]+$/;
 async function runDoctorChecks(options) {
   const checks = [];
   const nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
@@ -104,6 +117,12 @@ async function runDoctorChecks(options) {
     details: pnpmAvailable ? "pnpm is available" : "pnpm is not installed or not in PATH"
   });
   const codexCommand = process.env.BOPO_CODEX_COMMAND?.trim() || "codex";
+  const gitRuntime = await checkRuntimeCommandHealth("git", options?.workspaceRoot);
+  checks.push({
+    label: "Git runtime",
+    ok: gitRuntime.available && gitRuntime.exitCode === 0,
+    details: gitRuntime.available && gitRuntime.exitCode === 0 ? "Command 'git' is available (required for repo bootstrap/worktree execution)" : gitRuntime.error ?? "Command 'git' is not available"
+  });
   const codex = await checkRuntimeCommandHealth(codexCommand, options?.workspaceRoot);
   checks.push({
     label: "Codex runtime",
@@ -117,32 +136,56 @@ async function runDoctorChecks(options) {
     ok: openCode.available && openCode.exitCode === 0,
     details: openCode.available && openCode.exitCode === 0 ? `Command '${openCodeCommand}' is available` : openCode.error ?? `Command '${openCodeCommand}' exited with ${String(openCode.exitCode)}`
   });
-  const instanceRoot = resolveInstanceRoot();
-  const storageRoot = join2(instanceRoot, "data", "storage");
-  const workspaceRoot = join2(instanceRoot, "workspaces");
+  const claudeCommand = process.env.BOPO_CLAUDE_COMMAND?.trim() || "claude";
+  const claude = await checkRuntimeCommandHealth(claudeCommand, options?.workspaceRoot);
   checks.push({
-    label: "Instance root writable",
-    ok: await ensureWritableDirectory(instanceRoot),
-    details: instanceRoot
+    label: "Claude Code runtime",
+    ok: claude.available && claude.exitCode === 0,
+    details: claude.available && claude.exitCode === 0 ? `Command '${claudeCommand}' is available` : claude.error ?? `Command '${claudeCommand}' exited with ${String(claude.exitCode)}`
   });
+  const geminiCommand = process.env.BOPO_GEMINI_COMMAND?.trim() || "gemini";
+  const gemini = await checkRuntimeCommandHealth(geminiCommand, options?.workspaceRoot);
   checks.push({
-    label: "Workspace root writable",
-    ok: await ensureWritableDirectory(workspaceRoot),
-    details: workspaceRoot
-  });
-  checks.push({
-    label: "Storage root writable",
-    ok: await ensureWritableDirectory(storageRoot),
-    details: storageRoot
+    label: "Gemini runtime",
+    ok: gemini.available && gemini.exitCode === 0,
+    details: gemini.available && gemini.exitCode === 0 ? `Command '${geminiCommand}' is available` : gemini.error ?? `Command '${geminiCommand}' exited with ${String(gemini.exitCode)}`
   });
+  try {
+    const instanceRoot = resolveInstanceRoot();
+    const storageRoot = join2(instanceRoot, "data", "storage");
+    const workspaceRoot = join2(instanceRoot, "workspaces");
+    checks.push({
+      label: "Instance root writable",
+      ok: await ensureWritableDirectory(instanceRoot),
+      details: instanceRoot
+    });
+    checks.push({
+      label: "Workspace root writable",
+      ok: await ensureWritableDirectory(workspaceRoot),
+      details: workspaceRoot
+    });
+    checks.push({
+      label: "Storage root writable",
+      ok: await ensureWritableDirectory(storageRoot),
+      details: storageRoot
+    });
+  } catch (error) {
+    checks.push({
+      label: "Instance path configuration",
+      ok: false,
+      details: String(error)
+    });
+  }
   if (options?.workspaceRoot) {
+    const driftCheck = await runWorkspacePathDriftCheck(options.workspaceRoot);
+    checks.push(driftCheck);
     const backfillCheck = await runWorkspaceBackfillDryRunCheck(options.workspaceRoot);
     checks.push(backfillCheck);
   }
   return checks;
 }
 async function checkRuntimeCommandHealth(command, cwd) {
-  const result = await runCommandCapture(command, ["--version"], { cwd });
+  const result = await runCommandCapture(command, ["--version"], { cwd, timeoutMs: 2500 });
   return {
     available: result.code !== null,
     exitCode: result.code,
@@ -151,7 +194,6 @@ async function checkRuntimeCommandHealth(command, cwd) {
 }
 async function ensureWritableDirectory(path) {
   try {
-    await mkdir(path, { recursive: true });
     await access2(path, constants.W_OK);
     return true;
   } catch {
@@ -165,6 +207,9 @@ function resolveInstanceRoot() {
   }
   const home = process.env.BOPO_HOME?.trim() ? expandHomePrefix(process.env.BOPO_HOME.trim()) : join2(homedir(), ".bopodev");
   const instanceId = process.env.BOPO_INSTANCE_ID?.trim() || "default";
+  if (!SAFE_PATH_SEGMENT_RE.test(instanceId)) {
+    throw new Error(`Invalid BOPO_INSTANCE_ID '${instanceId}'.`);
+  }
   return resolve2(home, "instances", instanceId);
 }
 function expandHomePrefix(value) {
@@ -219,6 +264,44 @@ async function runWorkspaceBackfillDryRunCheck(workspaceRoot) {
     };
   }
 }
+async function runWorkspacePathDriftCheck(workspaceRoot) {
+  const instanceRoot = resolveInstanceRoot();
+  const suspiciousEntries = await detectSuspiciousWorkspaceDirectories(workspaceRoot);
+  if (suspiciousEntries.length === 0) {
+    return {
+      label: "Workspace path drift",
+      ok: true,
+      details: "No suspicious workspace-like directories found outside managed root."
+    };
+  }
+  return {
+    label: "Workspace path drift",
+    ok: false,
+    details: `Found suspicious directories outside '${instanceRoot}': ${suspiciousEntries.join(", ")}`
+  };
+}
+async function detectSuspiciousWorkspaceDirectories(workspaceRoot) {
+  const candidates = [
+    join2(workspaceRoot, "relative"),
+    join2(workspaceRoot, "workspaces"),
+    join2(workspaceRoot, "workspace")
+  ];
+  const hits = [];
+  for (const candidate of candidates) {
+    if (await isDirectory(candidate)) {
+      hits.push(candidate);
+    }
+  }
+  return hits;
+}
+async function isDirectory(path) {
+  try {
+    const entry = await stat(path);
+    return entry.isDirectory();
+  } catch {
+    return false;
+  }
+}
 
 // src/lib/ui.ts
 import color from "picocolors";
@@ -258,9 +341,11 @@ function printDivider() {
   process.stdout.write(`${color.dim("----------------------------------------")}
 `);
 }
-function printCheck(state, label, details) {
-  const icon = state === "ok" ? color.green("[ok]") : state === "warn" ? color.yellow("[..]") : color.red("[x]");
-  process.stdout.write(`${icon} ${color.bold(label)}: ${details}
+function printCheck(state, label, details, options) {
+  const status = state === "ok" ? color.green("ok") : state === "warn" ? color.yellow("warn") : color.red("fail");
+  const indent = " ".repeat(Math.max(0, options?.indent ?? 0));
+  const paddedLabel = `${label}:`.padEnd(26);
+  process.stdout.write(`\u2502  ${indent}${color.bold(paddedLabel)} ${details}  ${status}
 `);
 }
 function printSummaryCard(lines) {
@@ -298,13 +383,17 @@ async function runDoctorCommand(cwd) {
 
 // src/commands/onboard.ts
 import { access as access3, copyFile, readFile, writeFile } from "fs/promises";
-import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve as resolve3 } from "path";
 import { confirm, isCancel, log, select, spinner, text } from "@clack/prompts";
 import dotenv from "dotenv";
 var DEFAULT_COMPANY_NAME_ENV = "BOPO_DEFAULT_COMPANY_NAME";
 var DEFAULT_COMPANY_ID_ENV = "BOPO_DEFAULT_COMPANY_ID";
 var DEFAULT_PUBLIC_COMPANY_ID_ENV = "NEXT_PUBLIC_DEFAULT_COMPANY_ID";
 var DEFAULT_AGENT_PROVIDER_ENV = "BOPO_DEFAULT_AGENT_PROVIDER";
+var DEFAULT_AGENT_MODEL_ENV = "BOPO_DEFAULT_AGENT_MODEL";
+var DEFAULT_TEMPLATE_ENV = "BOPO_DEFAULT_TEMPLATE_ID";
+var DEFAULT_DEPLOYMENT_MODE_ENV = "BOPO_DEPLOYMENT_MODE";
 var DEFAULT_ENV_TEMPLATE = "NEXT_PUBLIC_API_URL=http://localhost:4020\n";
 var CLI_ONBOARD_VISIBLE_PROVIDERS = [
   { value: "codex", label: "Codex" },
@@ -312,24 +401,31 @@ var CLI_ONBOARD_VISIBLE_PROVIDERS = [
   { value: "gemini_cli", label: "Gemini" },
   { value: "opencode", label: "OpenCode" }
 ];
+var CLI_ONBOARD_TEMPLATES = [
+  { value: "founder-startup-basic", label: "Founder Startup Basic" },
+  { value: "marketing-content-engine", label: "Marketing Content Engine" },
+  { value: "__custom__", label: "Custom template id/slug" }
+];
 var defaultDeps = {
   installDependencies: async (workspaceRoot) => {
-    const code = await runCommandStreaming("pnpm", ["install"], { cwd: workspaceRoot });
-    if (code !== 0) {
-      throw new Error(`pnpm install failed with exit code ${String(code)}`);
+    const result = await runCommandCapture("pnpm", ["install"], { cwd: workspaceRoot });
+    if (!result.ok) {
+      const details = [result.stderr, result.stdout].filter((value) => value.trim().length > 0).join("\n").trim();
+      throw new Error(details.length > 0 ? details : `pnpm install failed with exit code ${String(result.code)}`);
     }
   },
   runDoctor: (workspaceRoot) => runDoctorChecks({ workspaceRoot }),
   initializeDatabase: async (workspaceRoot, dbPath) => {
-    const code = await runCommandStreaming("pnpm", ["--filter", "bopodev-api", "db:init"], {
+    const result = await runCommandCapture("pnpm", ["--filter", "bopodev-api", "db:init"], {
       cwd: workspaceRoot,
       env: {
         ...process.env,
         ...dbPath ? { BOPO_DB_PATH: dbPath } : {}
       }
     });
-    if (code !== 0) {
-      throw new Error(`db:init failed with exit code ${String(code)}`);
+    if (!result.ok) {
+      const details = [result.stderr, result.stdout].filter((value) => value.trim().length > 0).join("\n").trim();
+      throw new Error(details.length > 0 ? details : `db:init failed with exit code ${String(result.code)}`);
     }
   },
   seedOnboardingDatabase: async (workspaceRoot, input) => {
@@ -339,6 +435,8 @@ var defaultDeps = {
         ...process.env,
         [DEFAULT_COMPANY_NAME_ENV]: input.companyName,
         [DEFAULT_AGENT_PROVIDER_ENV]: input.agentProvider,
+        ...process.env[DEFAULT_AGENT_MODEL_ENV] ? { [DEFAULT_AGENT_MODEL_ENV]: process.env[DEFAULT_AGENT_MODEL_ENV] } : {},
+        ...input.templateId ? { [DEFAULT_TEMPLATE_ENV]: input.templateId } : {},
         ...input.companyId ? { [DEFAULT_COMPANY_ID_ENV]: input.companyId } : {},
         ...input.dbPath ? { BOPO_DB_PATH: input.dbPath } : {}
       }
@@ -361,11 +459,15 @@ var defaultDeps = {
     }
     return answer.trim();
   },
-  promptForAgentProvider: async () => {
+  promptForAgentProvider: async (input) => {
+    const availableProviders = input?.availableProviders && input.availableProviders.length > 0 ? input.availableProviders : CLI_ONBOARD_VISIBLE_PROVIDERS.map((entry) => entry.value);
+    const options = CLI_ONBOARD_VISIBLE_PROVIDERS.filter((entry) => availableProviders.includes(entry.value));
+    const fallback = options[0]?.value ?? "codex";
+    const preferred = input?.preferredProvider && availableProviders.includes(input.preferredProvider) ? input.preferredProvider : fallback;
     const answer = await select({
       message: "Primary agent framework",
-      initialValue: "codex",
-      options: CLI_ONBOARD_VISIBLE_PROVIDERS
+      initialValue: preferred,
+      options
     });
     if (isCancel(answer)) {
       throw new Error("Onboarding cancelled.");
@@ -375,6 +477,57 @@ var defaultDeps = {
       throw new Error("Invalid primary agent framework selected.");
     }
     return provider;
+  },
+  promptForAgentModel: async ({ provider, preferredModel }) => {
+    const options = buildModelOptions(provider, preferredModel ?? void 0);
+    const defaultOption = options[0];
+    const answer = await select({
+      message: "Default model",
+      initialValue: defaultOption?.value ?? "",
+      options
+    });
+    if (isCancel(answer)) {
+      throw new Error("Onboarding cancelled.");
+    }
+    const selected = typeof answer === "string" ? answer.trim() : "";
+    if (selected === "__auto__") {
+      return void 0;
+    }
+    return selected.length > 0 ? selected : void 0;
+  },
+  promptForTemplateUsage: async ({ currentTemplateId }) => {
+    const answer = await confirm({
+      message: "Do you want to use a template?",
+      initialValue: Boolean(currentTemplateId)
+    });
+    if (isCancel(answer)) {
+      throw new Error("Onboarding cancelled.");
+    }
+    return Boolean(answer);
+  },
+  promptForTemplateSelection: async ({ currentTemplateId }) => {
+    const matchingDefault = CLI_ONBOARD_TEMPLATES.find((entry) => entry.value === currentTemplateId)?.value;
+    const answer = await select({
+      message: "Select template",
+      initialValue: matchingDefault ?? "founder-startup-basic",
+      options: CLI_ONBOARD_TEMPLATES.map((entry) => ({ value: entry.value, label: entry.label }))
+    });
+    if (isCancel(answer)) {
+      throw new Error("Onboarding cancelled.");
+    }
+    const selected = typeof answer === "string" ? answer.trim() : "";
+    if (selected === "__custom__") {
+      const custom = await text({
+        message: "Template id or slug",
+        placeholder: "founder-startup-basic",
+        validate: (value) => value.trim().length > 0 ? void 0 : "Template id/slug is required."
+      });
+      if (isCancel(custom)) {
+        throw new Error("Onboarding cancelled.");
+      }
+      return custom.trim();
+    }
+    return selected.length > 0 ? selected : void 0;
   }
 };
 async function runOnboardFlow(options, deps = defaultDeps) {
@@ -400,57 +553,132 @@ async function runOnboardFlow(options, deps = defaultDeps) {
   const shouldInstall = options.forceInstall || !await hasExistingInstall(workspaceRoot);
   if (shouldInstall) {
     const installSpin = spinner();
-    installSpin.start("Installing dependencies");
+    installSpin.start("Preparing dependencies");
     await deps.installDependencies(workspaceRoot);
-    installSpin.stop("Dependencies installed");
-  } else {
-    log.step("Dependencies already present. Skipping install (use --force-install to reinstall).");
-  }
-  const envSpin = spinner();
-  envSpin.start("Ensuring .env exists");
-  const envResult = await ensureEnvFile(workspaceRoot);
-  const envCreated = envResult.created;
-  if (!envResult.created) {
-    envSpin.stop(".env already present");
-  } else if (envResult.source === "example") {
-    envSpin.stop("Created .env from .env.example");
+    installSpin.stop("Dependencies ready");
   } else {
-    envSpin.stop("Created .env with defaults (.env.example not found)");
+    printCheck("ok", "Dependencies", "Already installed");
   }
   const envPath = join3(workspaceRoot, ".env");
-  dotenv.config({ path: envPath });
-  const envValues = await readEnvValues(envPath);
-  let companyName = envValues[DEFAULT_COMPANY_NAME_ENV]?.trim() ?? "";
+  const preEnvValues = await fileExists2(envPath) ? await readEnvValues(envPath) : {};
+  const doctorSpin = spinner();
+  doctorSpin.start("Running doctor checks");
+  const checks = await deps.runDoctor(workspaceRoot);
+  doctorSpin.stop("Doctor checks complete");
+  const runtimeAvailability = deriveAvailableAgentProviders(checks);
+  const passed = checks.filter((check) => check.ok).length;
+  const warnings = checks.length - passed;
+  printCheck("ok", "Doctor", "checks complete");
+  printCheck("ok", "Doctor summary", `${passed} passed, ${warnings} warning${warnings === 1 ? "" : "s"}`);
+  if (warnings === 0) {
+    printCheck("ok", "Doctor status", "All checks passed");
+  }
+  for (const check of checks) {
+    printCheck(check.ok ? "ok" : "warn", check.label, check.details);
+  }
+  let companyName = preEnvValues[DEFAULT_COMPANY_NAME_ENV]?.trim() ?? "";
   if (companyName.length > 0) {
     printCheck("ok", "Default company", companyName);
   } else {
     companyName = await deps.promptForCompanyName();
-    await updateEnvFile(envPath, { [DEFAULT_COMPANY_NAME_ENV]: companyName });
-    process.env[DEFAULT_COMPANY_NAME_ENV] = companyName;
     printCheck("ok", "Default company", companyName);
   }
-  let agentProvider = parseAgentProvider(envValues[DEFAULT_AGENT_PROVIDER_ENV]);
-  if (agentProvider) {
+  const selectableProviders = runtimeAvailability.length > 0 ? runtimeAvailability : CLI_ONBOARD_VISIBLE_PROVIDERS.map((entry) => entry.value);
+  const configuredProvider = parseAgentProvider(preEnvValues[DEFAULT_AGENT_PROVIDER_ENV]);
+  let agentProvider = configuredProvider ?? selectableProviders[0] ?? "codex";
+  const canReuseProvider = Boolean(configuredProvider && selectableProviders.includes(configuredProvider));
+  if (canReuseProvider) {
     printCheck("ok", "Primary agent framework", formatAgentProvider(agentProvider));
   } else {
-    agentProvider = await deps.promptForAgentProvider();
-    await updateEnvFile(envPath, { [DEFAULT_AGENT_PROVIDER_ENV]: agentProvider });
-    process.env[DEFAULT_AGENT_PROVIDER_ENV] = agentProvider;
+    agentProvider = await deps.promptForAgentProvider({
+      availableProviders: selectableProviders,
+      preferredProvider: configuredProvider
+    });
     printCheck("ok", "Primary agent framework", formatAgentProvider(agentProvider));
   }
+  const preferredModel = normalizeOptionalEnvValue(preEnvValues[DEFAULT_AGENT_MODEL_ENV]) ?? getDefaultModelForProvider(agentProvider);
+  const selectedAgentModel = options.yes ? preferredModel ?? void 0 : await deps.promptForAgentModel({
+    provider: agentProvider,
+    preferredModel
+  });
+  printCheck("ok", "Default model", selectedAgentModel ?? "Provider default");
+  const explicitTemplateId = normalizeOptionalEnvValue(options.template);
+  const envTemplateId = normalizeOptionalEnvValue(preEnvValues[DEFAULT_TEMPLATE_ENV]);
+  let requestedTemplateId = explicitTemplateId ?? envTemplateId;
+  if (!options.yes && !explicitTemplateId) {
+    const promptForTemplateUsage = deps.promptForTemplateUsage ?? defaultDeps.promptForTemplateUsage;
+    const promptForTemplateSelection = deps.promptForTemplateSelection ?? defaultDeps.promptForTemplateSelection;
+    if (!promptForTemplateUsage || !promptForTemplateSelection) {
+      throw new Error("Template onboarding prompts are not configured.");
+    }
+    const wantsTemplate = await promptForTemplateUsage({
+      currentTemplateId: envTemplateId ?? null
+    });
+    if (wantsTemplate) {
+      requestedTemplateId = await promptForTemplateSelection({
+        currentTemplateId: requestedTemplateId ?? null
+      }) ?? void 0;
+    } else {
+      requestedTemplateId = void 0;
+    }
+  }
+  if (requestedTemplateId) {
+    printCheck("ok", "Template", requestedTemplateId);
+  } else {
+    printCheck("ok", "Template", "Skipped");
+  }
+  const envSpin = spinner();
+  envSpin.start("Ensuring local environment");
+  const envResult = await ensureEnvFile(workspaceRoot);
+  await sanitizeBlankDbPathEnvEntry(envPath);
+  await updateEnvFile(envPath, {
+    [DEFAULT_DEPLOYMENT_MODE_ENV]: "local",
+    [DEFAULT_COMPANY_NAME_ENV]: companyName,
+    [DEFAULT_AGENT_PROVIDER_ENV]: agentProvider ?? "codex",
+    ...requestedTemplateId ? { [DEFAULT_TEMPLATE_ENV]: requestedTemplateId } : {},
+    ...selectedAgentModel ? { [DEFAULT_AGENT_MODEL_ENV]: selectedAgentModel } : {}
+  });
+  if (!requestedTemplateId) {
+    await removeEnvKeys(envPath, [DEFAULT_TEMPLATE_ENV]);
+  }
+  dotenv.config({ path: envPath, quiet: true });
+  const envValues = await readEnvValues(envPath);
+  const configuredDbPath = normalizeOptionalEnvValue(envValues.BOPO_DB_PATH);
+  if (configuredDbPath) {
+    process.env.BOPO_DB_PATH = configuredDbPath;
+  } else {
+    delete process.env.BOPO_DB_PATH;
+  }
+  process.env[DEFAULT_DEPLOYMENT_MODE_ENV] = "local";
+  process.env[DEFAULT_COMPANY_NAME_ENV] = companyName;
+  process.env[DEFAULT_AGENT_PROVIDER_ENV] = agentProvider ?? "codex";
+  if (requestedTemplateId) {
+    process.env[DEFAULT_TEMPLATE_ENV] = requestedTemplateId;
+  } else {
+    delete process.env[DEFAULT_TEMPLATE_ENV];
+  }
+  if (selectedAgentModel) {
+    process.env[DEFAULT_AGENT_MODEL_ENV] = selectedAgentModel;
+  } else {
+    delete process.env[DEFAULT_AGENT_MODEL_ENV];
+  }
+  envSpin.stop(
+    envResult.created ? envResult.source === "example" ? "Environment configured from .env.example" : "Environment configured from defaults" : "Environment updated"
+  );
   const dbSpin = spinner();
-  dbSpin.start("Initializing local database");
-  await deps.initializeDatabase(workspaceRoot, process.env.BOPO_DB_PATH);
-  dbSpin.stop("Database initialized");
+  dbSpin.start("Initializing and migrating database");
+  await deps.initializeDatabase(workspaceRoot, configuredDbPath);
+  dbSpin.stop("Database ready");
   const seedSpin = spinner();
-  seedSpin.start("Ensuring default company and CEO agent");
+  seedSpin.start("Seeding default company and CEO");
   const seedResult = await deps.seedOnboardingDatabase(workspaceRoot, {
-    dbPath: process.env.BOPO_DB_PATH,
+    dbPath: configuredDbPath,
     companyName,
     companyId: envValues[DEFAULT_COMPANY_ID_ENV]?.trim() || void 0,
-    agentProvider
+    agentProvider,
+    templateId: requestedTemplateId
   });
-  seedSpin.stop("Default company and CEO ready");
+  seedSpin.stop("Seed complete");
   await updateEnvFile(envPath, {
     [DEFAULT_COMPANY_NAME_ENV]: seedResult.companyName,
     [DEFAULT_COMPANY_ID_ENV]: seedResult.companyId,
@@ -461,33 +689,45 @@ async function runOnboardFlow(options, deps = defaultDeps) {
   process.env[DEFAULT_COMPANY_ID_ENV] = seedResult.companyId;
   process.env[DEFAULT_PUBLIC_COMPANY_ID_ENV] = seedResult.companyId;
   process.env[DEFAULT_AGENT_PROVIDER_ENV] = seedResult.ceoProviderType;
+  if (seedResult.ceoRuntimeModel) {
+    process.env[DEFAULT_AGENT_MODEL_ENV] = seedResult.ceoRuntimeModel;
+  } else if (selectedAgentModel) {
+    process.env[DEFAULT_AGENT_MODEL_ENV] = selectedAgentModel;
+  } else {
+    delete process.env[DEFAULT_AGENT_MODEL_ENV];
+  }
+  if (seedResult.templateId) {
+    process.env[DEFAULT_TEMPLATE_ENV] = seedResult.templateId;
+  } else if (!requestedTemplateId) {
+    delete process.env[DEFAULT_TEMPLATE_ENV];
+  }
   printCheck("ok", "Configured company", `${seedResult.companyName}${seedResult.companyCreated ? " (created)" : ""}`);
   printCheck(
     "ok",
     "CEO agent",
     `${seedResult.ceoCreated ? "Created CEO" : seedResult.ceoMigrated ? "Migrated existing CEO" : "CEO already present"} (${formatAgentProvider(seedResult.ceoProviderType)})`
   );
-  const doctorSpin = spinner();
-  doctorSpin.start("Running doctor checks");
-  const checks = await deps.runDoctor(workspaceRoot);
-  doctorSpin.stop("Doctor checks complete");
-  printDivider();
-  printSection("Doctor");
-  for (const check of checks) {
-    printCheck(check.ok ? "ok" : "warn", check.label, check.details);
+  if (requestedTemplateId) {
+    printCheck(
+      seedResult.templateApplied ? "ok" : "warn",
+      "Template apply",
+      seedResult.templateApplied ? `Applied ${seedResult.templateId ?? requestedTemplateId}` : `Template not applied (${requestedTemplateId})`
+    );
   }
-  const passed = checks.filter((check) => check.ok).length;
-  const failed = checks.length - passed;
-  printLine("");
+  const dbPathSummary = resolveDbPathSummary(configuredDbPath);
   printSummaryCard([
-    `Summary: ${passed} passed, ${failed} warnings`,
-    "Web URL: http://127.0.0.1:4010 (auto-fallback if occupied)",
-    "API URL: http://127.0.0.1:4020 (auto-fallback if occupied)"
+    `Mode    ${padSummaryValue("local")}`,
+    `Deploy  ${padSummaryValue("local_mac")}`,
+    `Doctor  ${padSummaryValue(`${passed} passed, ${warnings} warning${warnings === 1 ? "" : "s"}`)}`,
+    `Company ${padSummaryValue(`${seedResult.companyName} (${seedResult.companyId})`)}`,
+    `Agent   ${padSummaryValue(formatAgentProvider(seedResult.ceoProviderType))}`,
+    `Model   ${padSummaryValue(seedResult.ceoRuntimeModel ?? selectedAgentModel ?? "provider default")}`,
+    `API     ${padSummaryValue("http://127.0.0.1:4020")}`,
+    `UI      ${padSummaryValue("http://127.0.0.1:4010")}`,
+    `DB      ${padSummaryValue(dbPathSummary)}`
   ]);
-  printLine("");
   if (options.start) {
-    printSection("Starting services");
-    printLine("Running `pnpm start:quiet` (production mode)...");
+    printLine("Starting services in quiet mode and opening admin...");
     printDivider();
     await deps.startServices(workspaceRoot);
   } else {
@@ -499,7 +739,7 @@ async function runOnboardFlow(options, deps = defaultDeps) {
   }
   return {
     workspaceRoot,
-    envCreated,
+    envCreated: envResult.created,
     dbInitialized: true,
     checks
   };
@@ -542,9 +782,138 @@ async function updateEnvFile(envPath, updates) {
   await writeFile(envPath, nextContent.endsWith("\n") ? nextContent : `${nextContent}
 `, "utf8");
 }
+async function sanitizeBlankDbPathEnvEntry(envPath) {
+  const existingContent = await readFile(envPath, "utf8");
+  const lines = existingContent.split(/\r?\n/);
+  let changed = false;
+  const nextLines = lines.map((line) => {
+    if (!line.startsWith("BOPO_DB_PATH=")) {
+      return line;
+    }
+    const value = line.slice("BOPO_DB_PATH=".length).trim();
+    if (value.length > 0) {
+      return line;
+    }
+    changed = true;
+    return "# BOPO_DB_PATH=  # optional override; leave unset to use default instance path";
+  });
+  if (!changed) {
+    return;
+  }
+  const nextContent = nextLines.join("\n");
+  await writeFile(envPath, nextContent.endsWith("\n") ? nextContent : `${nextContent}
+`, "utf8");
+}
+async function removeEnvKeys(envPath, keys) {
+  if (keys.length === 0) {
+    return;
+  }
+  const existingContent = await readFile(envPath, "utf8");
+  const nextLines = existingContent.split(/\r?\n/).filter((line) => !keys.some((key) => line.startsWith(`${key}=`)));
+  const nextContent = nextLines.join("\n");
+  await writeFile(envPath, nextContent.endsWith("\n") ? nextContent : `${nextContent}
+`, "utf8");
+}
 function serializeEnvValue(value) {
   return /[\s#"'`]/.test(value) ? JSON.stringify(value) : value;
 }
+function normalizeOptionalEnvValue(value) {
+  const normalized = value?.trim();
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+function deriveAvailableAgentProviders(checks) {
+  const providers = [];
+  for (const check of checks) {
+    if (!check.ok) {
+      continue;
+    }
+    if (check.label === "Codex runtime") {
+      providers.push("codex");
+    }
+    if (check.label === "Claude Code runtime") {
+      providers.push("claude_code");
+    }
+    if (check.label === "Gemini runtime") {
+      providers.push("gemini_cli");
+    }
+    if (check.label === "OpenCode runtime") {
+      providers.push("opencode");
+    }
+  }
+  return Array.from(new Set(providers));
+}
+function resolveDbPathSummary(configuredDbPath) {
+  if (configuredDbPath) {
+    return resolve3(expandHomePrefix2(configuredDbPath));
+  }
+  const home = process.env.BOPO_HOME?.trim() ? expandHomePrefix2(process.env.BOPO_HOME.trim()) : join3(homedir2(), ".bopodev");
+  const instanceId = process.env.BOPO_INSTANCE_ID?.trim() || "default";
+  return resolve3(home, "instances", instanceId, "db", "bopodev.db");
+}
+function expandHomePrefix2(value) {
+  if (value === "~") {
+    return homedir2();
+  }
+  if (value.startsWith("~/")) {
+    return resolve3(homedir2(), value.slice(2));
+  }
+  return value;
+}
+function padSummaryValue(value) {
+  return `| ${value}`;
+}
+function getDefaultModelForProvider(provider) {
+  if (provider === "codex" || provider === "openai_api") {
+    return process.env.BOPO_OPENAI_MODEL?.trim() || "gpt-5";
+  }
+  if (provider === "claude_code" || provider === "anthropic_api") {
+    return process.env.BOPO_ANTHROPIC_MODEL?.trim() || "claude-sonnet-4-6";
+  }
+  if (provider === "opencode") {
+    return process.env.BOPO_OPENCODE_MODEL?.trim() || "opencode/default";
+  }
+  if (provider === "gemini_cli") {
+    return process.env.BOPO_GEMINI_MODEL?.trim() || "gemini-2.5-pro";
+  }
+  if (provider === "shell") {
+    return "n/a";
+  }
+  return null;
+}
+function buildModelOptions(provider, preferredModel) {
+  const providerDefault = { value: "", label: "Provider default" };
+  const defaultModel = getDefaultModelForProvider(provider);
+  const modelIds = /* @__PURE__ */ new Set();
+  const presets = getModelPresetsForProvider(provider);
+  for (const model of presets) {
+    modelIds.add(model);
+  }
+  if (preferredModel && preferredModel.trim().length > 0) {
+    modelIds.add(preferredModel.trim());
+  }
+  if (defaultModel) {
+    modelIds.add(defaultModel);
+  }
+  return [
+    providerDefault,
+    ...Array.from(modelIds).map((model) => ({ value: model, label: model }))
+  ];
+}
+function getModelPresetsForProvider(provider) {
+  if (provider === "codex" || provider === "openai_api") {
+    return ["gpt-5", "gpt-5-mini", "gpt-4.1"];
+  }
+  if (provider === "claude_code" || provider === "anthropic_api") {
+    return ["claude-sonnet-4-6", "claude-opus-4-1"];
+  }
+  if (provider === "gemini_cli") {
+    return ["gemini-2.5-pro", "gemini-2.5-flash"];
+  }
+  if (provider === "opencode") {
+    return ["opencode/default"];
+  }
+  return [];
+}
 function parseSeedResult(stdout) {
   const lines = stdout.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
   const lastLine = lines[lines.length - 1];
@@ -552,7 +921,7 @@ function parseSeedResult(stdout) {
     throw new Error("onboard:seed did not return a result.");
   }
   const parsed = JSON.parse(lastLine);
-  if (typeof parsed.companyId !== "string" || typeof parsed.companyName !== "string" || typeof parsed.companyCreated !== "boolean" || typeof parsed.ceoCreated !== "boolean" || typeof parsed.ceoMigrated !== "boolean" || !parseAgentProvider(parsed.ceoProviderType)) {
+  if (typeof parsed.companyId !== "string" || typeof parsed.companyName !== "string" || typeof parsed.companyCreated !== "boolean" || typeof parsed.ceoCreated !== "boolean" || !(parsed.ceoRuntimeModel === null || typeof parsed.ceoRuntimeModel === "string" || typeof parsed.ceoRuntimeModel === "undefined") || typeof parsed.ceoMigrated !== "boolean" || !parseAgentProvider(parsed.ceoProviderType)) {
     throw new Error("onboard:seed returned an invalid result.");
   }
   return {
@@ -561,7 +930,10 @@ function parseSeedResult(stdout) {
     companyCreated: parsed.companyCreated,
     ceoCreated: parsed.ceoCreated,
     ceoProviderType: parseAgentProvider(parsed.ceoProviderType) ?? "shell",
-    ceoMigrated: parsed.ceoMigrated
+    ceoRuntimeModel: typeof parsed.ceoRuntimeModel === "string" ? parsed.ceoRuntimeModel : null,
+    ceoMigrated: parsed.ceoMigrated,
+    templateApplied: typeof parsed.templateApplied === "boolean" ? parsed.templateApplied : void 0,
+    templateId: typeof parsed.templateId === "string" ? parsed.templateId : null
   };
 }
 function parseAgentProvider(value) {
@@ -621,13 +993,14 @@ async function runStartCommand(cwd, options) {
 // src/index.ts
 var program = new Command();
 program.name("bopodev").description("Bopodev CLI");
-program.command("onboard").description("Install, configure, and start Bopodev locally").option("--yes", "Run non-interactively using defaults", false).option("--force-install", "Force reinstall dependencies even if already installed", false).option("--no-start", "Run setup and doctor checks without starting services").action(async (options) => {
+program.command("onboard").description("Install, configure, and start Bopodev locally").option("--yes", "Run non-interactively using defaults", false).option("--force-install", "Force reinstall dependencies even if already installed", false).option("--template <template>", "Apply template by id or slug during onboarding").option("--no-start", "Run setup and doctor checks without starting services").action(async (options) => {
   try {
     await runOnboardFlow({
       cwd: process.cwd(),
       yes: options.yes,
       start: options.start,
-      forceInstall: options.forceInstall
+      forceInstall: options.forceInstall,
+      template: options.template
     });
     if (!options.start) {
       outro("Onboarding finished.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bopodev",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "license": "MIT",
   "type": "module",
   "bin": {