cognova 0.2.13 → 0.2.15

package/dist/cli/index.js

@@ -156,7 +156,7 @@ var require_src = __commonJS({
 
 // src/commands/init.ts
 import { execSync as execSync5 } from "child_process";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 import crypto3 from "crypto";
 
 // ../node_modules/.pnpm/@clack+core@1.0.1/node_modules/@clack/core/dist/index.mjs
@@ -1189,7 +1189,7 @@ ${l}
 } }).prompt();
 
 // src/commands/init.ts
-var import_picocolors5 = __toESM(require_picocolors(), 1);
+var import_picocolors6 = __toESM(require_picocolors(), 1);
 
 // src/lib/prerequisites.ts
 import { execSync } from "child_process";
@@ -1201,6 +1201,9 @@ function checkCommand(cmd) {
     return null;
   }
 }
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 async function checkPrerequisites() {
   R2.step("Checking prerequisites...");
   const nodeOut = checkCommand("node --version");
@@ -1250,14 +1253,80 @@ async function checkPrerequisites() {
   } else {
     R2.success(`Claude Code ${claudeOut}`);
   }
+  let dockerInstalled = !!dockerOut;
+  let dockerReady = false;
   if (dockerOut) {
-    R2.success(`Docker available ${import_picocolors3.default.dim("(for local PostgreSQL)")}`);
+    const daemonRunning = checkCommand("docker info");
+    if (daemonRunning) {
+      dockerReady = true;
+      R2.success(`Docker available ${import_picocolors3.default.dim("(for local PostgreSQL)")}`);
+    } else {
+      R2.warn("Docker is installed but the daemon is not running");
+      const startDocker = await Re({
+        message: "Start Docker now?",
+        initialValue: true
+      });
+      if (!Ct(startDocker) && startDocker) {
+        const s = bt2();
+        s.start("Starting Docker daemon");
+        try {
+          if (process.platform === "darwin") {
+            execSync("open -a Docker", { stdio: "pipe" });
+          } else if (process.platform === "linux") {
+            execSync("sudo systemctl start docker", { stdio: "inherit" });
+          }
+          for (let i = 0; i < 30; i++) {
+            await sleep(1e3);
+            if (checkCommand("docker info")) {
+              dockerReady = true;
+              s.stop("Docker daemon is running");
+              break;
+            }
+          }
+          if (!dockerReady) {
+            s.stop("Docker daemon did not start in time");
+            R2.warn("You can start it manually and continue with local PostgreSQL, or use remote PostgreSQL");
+          }
+        } catch {
+          s.stop("Failed to start Docker daemon");
+          R2.warn("Start Docker manually: https://docs.docker.com/get-docker/");
+        }
+      } else {
+        R2.info("You can use a remote PostgreSQL instead");
+      }
+    }
   } else {
-    R2.info(`Docker not found ${import_picocolors3.default.dim("(needed only for local PostgreSQL)")}`);
+    const installDocker = await Re({
+      message: "Docker not found. Install it? (needed only for local PostgreSQL)",
+      initialValue: false
+    });
+    if (!Ct(installDocker) && installDocker) {
+      const s = bt2();
+      s.start("Installing Docker");
+      try {
+        if (process.platform === "darwin") {
+          execSync("brew install --cask docker", { stdio: "inherit" });
+          s.stop("Docker Desktop installed \u2014 open it from Applications to finish setup");
+          R2.info("Open Docker Desktop from Applications, then re-run this installer");
+        } else {
+          const cmd = process.platform === "linux" ? "sudo apt-get update -qq && sudo apt-get install -y -qq docker.io docker-compose-plugin" : "apt-get update -qq && apt-get install -y -qq docker.io docker-compose-plugin";
+          execSync(cmd, { stdio: "inherit" });
+          s.stop("Docker installed");
+        }
+        dockerInstalled = !!checkCommand("docker --version");
+        dockerReady = !!checkCommand("docker info");
+      } catch {
+        s.stop("Docker installation failed");
+        R2.warn("Install Docker manually: https://docs.docker.com/get-docker/");
+      }
+    } else {
+      R2.info("Skipped \u2014 you can use a remote PostgreSQL instead");
+    }
   }
   return {
     ok: true,
-    hasDocker: !!dockerOut,
+    dockerInstalled,
+    dockerReady,
     nodeVersion: nodeOut || "",
     pythonVersion: pythonOut || "",
     pnpmVersion: pnpmOut || "",
@@ -1447,13 +1516,15 @@ async function setupInstallDir(installDir) {
   copyAppSource(packageDir, installDir);
   s.stop("Application files installed");
 }
-function writeMetadata(installDir, vaultPath, version) {
+function writeMetadata(installDir, vaultPath, version, dbPassword, dbPort) {
   const metadata = {
     version,
     installedAt: (/* @__PURE__ */ new Date()).toISOString(),
     updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     installDir,
-    vaultPath
+    vaultPath,
+    dbPassword,
+    dbPort
   };
   writeFileSync(join2(installDir, ".cognova"), JSON.stringify(metadata, null, 2));
   const homeMeta = join2(process.env.HOME || "~", ".cognova");
@@ -1493,9 +1564,37 @@ async function setupVault() {
 
 // src/lib/database.ts
 import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
 import crypto from "crypto";
 var import_picocolors4 = __toESM(require_picocolors(), 1);
-async function setupDatabase(hasDocker) {
+function checkPortInUse(port) {
+  try {
+    const containers = execSync2(`docker ps --filter "publish=${port}" --format "{{.Names}}"`, {
+      encoding: "utf-8"
+    }).trim();
+    return containers.length > 0;
+  } catch {
+    try {
+      execSync2(`lsof -i :${port}`, { stdio: "pipe" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function readMetadata2() {
+  try {
+    const metaPath = join4(process.env.HOME || "~", ".cognova");
+    if (!existsSync4(metaPath))
+      return null;
+    const content = readFileSync2(metaPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+async function setupDatabase(dockerReady) {
   const dbType = await Je({
     message: "Database setup",
     options: [
@@ -1505,14 +1604,15 @@ async function setupDatabase(hasDocker) {
   });
   if (Ct(dbType)) process.exit(0);
   if (dbType === "local") {
-    if (!hasDocker) {
-      R2.error("Docker is required for local PostgreSQL.");
-      R2.info("Install Docker: https://docs.docker.com/get-docker/");
+    if (!dockerReady) {
+      R2.error("Docker daemon is not running.");
+      R2.info("Start Docker Desktop (macOS) or run: sudo systemctl start docker (Linux)");
       R2.info('Or choose "Remote PostgreSQL" and use Neon: https://neon.tech');
       process.exit(1);
     }
     const password = crypto.randomBytes(16).toString("hex");
     const containerName = "cognova-db";
+    let port = 5432;
     try {
       const existing = execSync2(`docker ps -a --filter name=${containerName} --format "{{.Status}}"`, {
         encoding: "utf-8"
@@ -1527,6 +1627,17 @@ async function setupDatabase(hasDocker) {
         if (reuse) {
           if (!existing.startsWith("Up"))
             execSync2(`docker start ${containerName}`, { stdio: "pipe" });
+          const metadata = readMetadata2();
+          if (metadata?.dbPassword && metadata?.dbPort) {
+            const connectionString3 = `postgres://postgres:${metadata.dbPassword}@localhost:${metadata.dbPort}/cognova`;
+            R2.info(`Using stored credentials (port ${metadata.dbPort})`);
+            return {
+              type: "local",
+              connectionString: connectionString3,
+              password: metadata.dbPassword,
+              port: metadata.dbPort
+            };
+          }
           R2.info("Using existing container. Ensure DATABASE_URL in .env matches its credentials.");
           const connStr = await Ze({
             message: "Connection string for existing container",
@@ -1540,6 +1651,23 @@ async function setupDatabase(hasDocker) {
       }
     } catch {
     }
+    if (checkPortInUse(port)) {
+      R2.warn(`Port ${port} is already in use`);
+      const altPort = await Ze({
+        message: "Choose an alternative port",
+        placeholder: "5433",
+        defaultValue: "5433",
+        validate: (v) => {
+          const num = parseInt(v);
+          if (isNaN(num) || num < 1024 || num > 65535)
+            return "Port must be between 1024 and 65535";
+          if (checkPortInUse(num))
+            return `Port ${num} is also in use`;
+        }
+      });
+      if (Ct(altPort)) process.exit(0);
+      port = parseInt(altPort);
+    }
     const s = bt2();
     s.start("Starting PostgreSQL container");
     try {
@@ -1549,7 +1677,7 @@ async function setupDatabase(hasDocker) {
         `-e POSTGRES_USER=postgres`,
         `-e POSTGRES_PASSWORD=${password}`,
         `-e POSTGRES_DB=cognova`,
-        `-p 5432:5432`,
+        `-p ${port}:5432`,
         `--restart unless-stopped`,
         `postgres:16-alpine`
       ].join(" "), { stdio: "pipe" });
@@ -1560,7 +1688,7 @@ async function setupDatabase(hasDocker) {
           ready = true;
           break;
         } catch {
-          await sleep(1e3);
+          await sleep2(1e3);
         }
       }
       if (!ready) {
@@ -1574,9 +1702,14 @@ async function setupDatabase(hasDocker) {
       R2.error(`Docker error: ${err}`);
       process.exit(1);
     }
-    const connectionString2 = `postgres://postgres:${password}@localhost:5432/cognova`;
+    const connectionString2 = `postgres://postgres:${password}@localhost:${port}/cognova`;
     R2.info(`Connection: ${import_picocolors4.default.dim(connectionString2)}`);
-    return { type: "local", connectionString: connectionString2 };
+    return {
+      type: "local",
+      connectionString: connectionString2,
+      password,
+      port
+    };
   }
   const connectionString = await Ze({
     message: "PostgreSQL connection string",
@@ -1589,13 +1722,13 @@ async function setupDatabase(hasDocker) {
   if (Ct(connectionString)) process.exit(0);
   return { type: "remote", connectionString };
 }
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 // src/lib/config.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
 
 // src/templates/env.ts
 import crypto2 from "crypto";
@@ -1634,11 +1767,11 @@ function generateEnvFile(config) {
 // src/lib/config.ts
 function writeEnvFile(config) {
   const content = generateEnvFile(config);
-  writeFileSync2(join4(config.installDir, ".env"), content);
+  writeFileSync2(join5(config.installDir, ".env"), content);
 }
 function loadEnvFile(installDir) {
   try {
-    const content = readFileSync2(join4(installDir, ".env"), "utf-8");
+    const content = readFileSync3(join5(installDir, ".env"), "utf-8");
     const env = {};
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
@@ -1654,8 +1787,8 @@ function loadEnvFile(installDir) {
 }
 
 // src/lib/claude-config.ts
-import { cpSync as cpSync2, mkdirSync as mkdirSync3, existsSync as existsSync4, writeFileSync as writeFileSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join5 } from "path";
+import { cpSync as cpSync2, mkdirSync as mkdirSync3, existsSync as existsSync5, writeFileSync as writeFileSync3, readFileSync as readFileSync4 } from "fs";
+import { join as join6 } from "path";
 
 // src/templates/claude-md.ts
 function generateClaudeMd(config) {
@@ -1899,27 +2032,27 @@ function generateSettingsJson(config) {
 // src/lib/claude-config.ts
 async function installClaudeConfig(config, options) {
   const claudeDir = getClaudeDir();
-  const sourceDir = join5(getPackageDir(), "Claude");
+  const sourceDir = join6(getPackageDir(), "Claude");
   const installAll = !options;
   mkdirSync3(claudeDir, { recursive: true });
   if (installAll || options?.skills) {
-    const skillsSrc = join5(sourceDir, "skills");
-    if (existsSync4(skillsSrc))
-      cpSync2(skillsSrc, join5(claudeDir, "skills"), { recursive: true, force: true });
+    const skillsSrc = join6(sourceDir, "skills");
+    if (existsSync5(skillsSrc))
+      cpSync2(skillsSrc, join6(claudeDir, "skills"), { recursive: true, force: true });
   }
   if (installAll || options?.hooks) {
-    const hooksSrc = join5(sourceDir, "hooks");
-    if (existsSync4(hooksSrc))
-      cpSync2(hooksSrc, join5(claudeDir, "hooks"), { recursive: true, force: true });
+    const hooksSrc = join6(sourceDir, "hooks");
+    if (existsSync5(hooksSrc))
+      cpSync2(hooksSrc, join6(claudeDir, "hooks"), { recursive: true, force: true });
   }
   if (installAll || options?.rules) {
-    const rulesSrc = join5(sourceDir, "rules");
-    if (existsSync4(rulesSrc))
-      cpSync2(rulesSrc, join5(claudeDir, "rules"), { recursive: true, force: true });
+    const rulesSrc = join6(sourceDir, "rules");
+    if (existsSync5(rulesSrc))
+      cpSync2(rulesSrc, join6(claudeDir, "rules"), { recursive: true, force: true });
   }
   if (installAll || options?.claudeMd) {
-    const claudeMdPath = join5(claudeDir, "CLAUDE.md");
-    if (existsSync4(claudeMdPath) && installAll) {
+    const claudeMdPath = join6(claudeDir, "CLAUDE.md");
+    if (existsSync5(claudeMdPath) && installAll) {
       const overwrite = await Re({
         message: "~/.claude/CLAUDE.md already exists. Overwrite?",
         initialValue: false
@@ -1935,10 +2068,10 @@ async function installClaudeConfig(config, options) {
     }
   }
   if (installAll || options?.settings) {
-    const settingsPath = join5(claudeDir, "settings.json");
-    if (existsSync4(settingsPath) && installAll) {
+    const settingsPath = join6(claudeDir, "settings.json");
+    if (existsSync5(settingsPath) && installAll) {
       try {
-        const existing = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+        const existing = JSON.parse(readFileSync4(settingsPath, "utf-8"));
         const generated = JSON.parse(generateSettingsJson(config));
         const merged = mergeSettings(existing, generated);
         writeFileSync3(settingsPath, JSON.stringify(merged, null, 2) + "\n");
@@ -1953,23 +2086,23 @@ async function installClaudeConfig(config, options) {
 }
 function syncClaudeConfig(sourceDir) {
   const claudeDir = getClaudeDir();
-  const claudeSrc = join5(sourceDir, "Claude");
-  if (!existsSync4(claudeSrc)) return;
+  const claudeSrc = join6(sourceDir, "Claude");
+  if (!existsSync5(claudeSrc)) return;
   mkdirSync3(claudeDir, { recursive: true });
-  const skillsSrc = join5(claudeSrc, "skills");
-  if (existsSync4(skillsSrc)) {
-    mkdirSync3(join5(claudeDir, "skills"), { recursive: true });
-    cpSync2(skillsSrc, join5(claudeDir, "skills"), { recursive: true, force: true });
+  const skillsSrc = join6(claudeSrc, "skills");
+  if (existsSync5(skillsSrc)) {
+    mkdirSync3(join6(claudeDir, "skills"), { recursive: true });
+    cpSync2(skillsSrc, join6(claudeDir, "skills"), { recursive: true, force: true });
   }
-  const hooksSrc = join5(claudeSrc, "hooks");
-  if (existsSync4(hooksSrc)) {
-    mkdirSync3(join5(claudeDir, "hooks"), { recursive: true });
-    cpSync2(hooksSrc, join5(claudeDir, "hooks"), { recursive: true, force: true });
+  const hooksSrc = join6(claudeSrc, "hooks");
+  if (existsSync5(hooksSrc)) {
+    mkdirSync3(join6(claudeDir, "hooks"), { recursive: true });
+    cpSync2(hooksSrc, join6(claudeDir, "hooks"), { recursive: true, force: true });
   }
-  const rulesSrc = join5(claudeSrc, "rules");
-  if (existsSync4(rulesSrc)) {
-    mkdirSync3(join5(claudeDir, "rules"), { recursive: true });
-    cpSync2(rulesSrc, join5(claudeDir, "rules"), { recursive: true, force: true });
+  const rulesSrc = join6(claudeSrc, "rules");
+  if (existsSync5(rulesSrc)) {
+    mkdirSync3(join6(claudeDir, "rules"), { recursive: true });
+    cpSync2(rulesSrc, join6(claudeDir, "rules"), { recursive: true, force: true });
   }
 }
 function mergeSettings(existing, generated) {
@@ -1985,8 +2118,8 @@ function mergeSettings(existing, generated) {
 
 // src/lib/process-manager.ts
 import { execSync as execSync3 } from "child_process";
-import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync5 } from "fs";
-import { join as join6 } from "path";
+import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, existsSync as existsSync6 } from "fs";
+import { join as join7 } from "path";
 
 // src/templates/pm2-ecosystem.ts
 function generatePm2Ecosystem(config) {
@@ -2058,11 +2191,11 @@ async function setupAndStart(config) {
       return;
     }
   }
-  const logsDir = join6(config.installDir, "logs");
-  if (!existsSync5(logsDir))
+  const logsDir = join7(config.installDir, "logs");
+  if (!existsSync6(logsDir))
     mkdirSync4(logsDir, { recursive: true });
   const ecosystem = generatePm2Ecosystem(config);
-  writeFileSync4(join6(config.installDir, "ecosystem.config.cjs"), ecosystem);
+  writeFileSync4(join7(config.installDir, "ecosystem.config.cjs"), ecosystem);
   const s = bt2();
   s.start("Starting Cognova with PM2");
   try {
@@ -2099,103 +2232,278 @@ async function waitForHealth(url, maxWaitSeconds = 30) {
   return false;
 }
 
+// src/lib/progress.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync5, unlinkSync } from "fs";
+import { join as join8 } from "path";
+var PROGRESS_FILE = join8(process.env.HOME || "~", ".cognova-setup.json");
+function loadProgress() {
+  try {
+    if (!existsSync7(PROGRESS_FILE))
+      return null;
+    const content = readFileSync5(PROGRESS_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveProgress(progress) {
+  try {
+    const content = JSON.stringify(progress, null, 2);
+    writeFileSync5(PROGRESS_FILE, content, "utf-8");
+  } catch (err) {
+    console.warn(`Failed to save progress: ${err}`);
+  }
+}
+function clearProgress() {
+  try {
+    if (existsSync7(PROGRESS_FILE))
+      unlinkSync(PROGRESS_FILE);
+  } catch {
+  }
+}
+
+// src/lib/retry.ts
+var import_picocolors5 = __toESM(require_picocolors(), 1);
+var SkipError = class extends Error {
+  constructor() {
+    super("Step skipped by user");
+    this.name = "SkipError";
+  }
+};
+async function withRetry(label, fn, options = {}) {
+  const { maxRetries = 3, canSkip = true } = options;
+  let attempt = 0;
+  while (true) {
+    try {
+      return await fn();
+    } catch (err) {
+      attempt++;
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      R2.error(`${label} failed: ${errorMsg}`);
+      if (attempt >= maxRetries) {
+        R2.error(`Maximum retry attempts (${maxRetries}) reached`);
+        if (!canSkip) {
+          R2.error("This step cannot be skipped. Setup aborted.");
+          process.exit(1);
+        }
+      }
+      const choices = [
+        { value: "retry", label: "Retry", hint: "Try again" }
+      ];
+      if (canSkip) {
+        choices.push({ value: "skip", label: "Skip", hint: "Continue without this step" });
+      }
+      choices.push({ value: "abort", label: "Abort", hint: "Exit setup" });
+      const action = await Je({
+        message: `${label} failed. What would you like to do?`,
+        options: choices
+      });
+      if (Ct(action) || action === "abort") {
+        R2.warn("Setup aborted by user");
+        process.exit(1);
+      }
+      if (action === "skip") {
+        throw new SkipError();
+      }
+      R2.info(import_picocolors5.default.dim(`Retrying ${label}...`));
+    }
+  }
+}
+
 // src/commands/init.ts
 async function init() {
-  We(import_picocolors5.default.bgCyan(import_picocolors5.default.black(" Cognova Setup ")));
-  const prereqs = await checkPrerequisites();
-  R2.step(import_picocolors5.default.bold("Agent Personality"));
-  const personality = await promptPersonality();
-  R2.step(import_picocolors5.default.bold("Installation"));
-  const defaultDir = join7(process.env.HOME || "~", "cognova");
-  const installDir = await Ze({
-    message: "Where should Cognova be installed?",
-    placeholder: defaultDir,
-    defaultValue: defaultDir
-  });
-  if (Ct(installDir)) process.exit(0);
-  const resolvedInstallDir = installDir.replace("~", process.env.HOME || "");
-  await setupInstallDir(resolvedInstallDir);
-  R2.step(import_picocolors5.default.bold("Vault"));
-  const vault = await setupVault();
-  R2.step(import_picocolors5.default.bold("Database"));
-  const database = await setupDatabase(prereqs.hasDocker);
-  R2.step(import_picocolors5.default.bold("Network Access"));
-  const accessMode = await Je({
-    message: "How will you access Cognova?",
-    options: [
-      { value: "localhost", label: "Local only", hint: "http://localhost:3000" },
-      { value: "specific", label: "Specific IP or domain", hint: "LAN IP, hostname, or domain" },
-      { value: "any", label: "Any connection", hint: "Accepts requests from any origin (0.0.0.0)" }
-    ]
-  });
-  if (Ct(accessMode)) process.exit(0);
-  let appUrl = "http://localhost:3000";
-  if (accessMode === "specific") {
-    const host = await Ze({
-      message: "IP address or domain (include port if not 80/443)",
-      placeholder: "192.168.1.100:3000"
+  We(import_picocolors6.default.bgCyan(import_picocolors6.default.black(" Cognova Setup ")));
+  const existingProgress = loadProgress();
+  let progress = existingProgress || {
+    completedSteps: [],
+    partialConfig: {},
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (existingProgress) {
+    R2.warn("Previous setup was interrupted");
+    const resume = await Re({
+      message: "Resume from where you left off?",
+      initialValue: true
     });
-    if (Ct(host)) process.exit(0);
-    appUrl = host.startsWith("http") ? host : `http://${host}`;
-  }
-  R2.warn(import_picocolors5.default.yellow(import_picocolors5.default.bold("Security Notice")));
-  R2.warn([
-    "Cognova gives an AI agent unrestricted access to this machine.",
-    "It can read, write, and execute anything via the embedded terminal",
-    "and Claude Code CLI.",
-    "",
-    `  ${import_picocolors5.default.dim("\u2022")} Do not run on a personal machine or alongside sensitive data`,
-    `  ${import_picocolors5.default.dim("\u2022")} Use a dedicated VM, container, or isolated environment`,
-    `  ${import_picocolors5.default.dim("\u2022")} Put a reverse proxy with TLS in front for remote access`,
-    `  ${import_picocolors5.default.dim("\u2022")} Do not store SSH keys, cloud creds, or production secrets here`
-  ].join("\n"));
-  if (accessMode === "any") {
-    R2.warn(import_picocolors5.default.red(
-      "Binding to 0.0.0.0 exposes this to your entire network."
-    ));
-  }
-  const proceed = await Re({
-    message: "I understand the risks. Continue?",
-    initialValue: false
-  });
-  if (Ct(proceed) || !proceed) process.exit(0);
-  R2.step(import_picocolors5.default.bold("Authentication"));
-  const adminEmail = await Ze({
-    message: "Admin email",
-    placeholder: "admin@example.com",
-    defaultValue: "admin@example.com"
-  });
-  if (Ct(adminEmail)) process.exit(0);
-  let adminPassword;
-  while (true) {
-    const pw = await He({
-      message: "Admin password",
-      validate: (v) => {
-        if (!v || v.length < 8) return "Minimum 8 characters";
+    if (Ct(resume)) process.exit(0);
+    if (!resume) {
+      clearProgress();
+      progress = {
+        completedSteps: [],
+        partialConfig: {},
+        startedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+  const prereqs = progress.completedSteps.includes("prerequisites") ? { ok: true, dockerInstalled: true, dockerReady: true, nodeVersion: "", pythonVersion: "", pnpmVersion: "", claudeInstalled: true } : await checkPrerequisites();
+  if (!progress.completedSteps.includes("prerequisites")) {
+    progress.completedSteps.push("prerequisites");
+    saveProgress(progress);
+  }
+  R2.step(import_picocolors6.default.bold("Agent Personality"));
+  const personality = progress.partialConfig.personality || await promptPersonality();
+  if (!progress.completedSteps.includes("personality")) {
+    progress.partialConfig.personality = personality;
+    progress.completedSteps.push("personality");
+    saveProgress(progress);
+  }
+  R2.step(import_picocolors6.default.bold("Installation"));
+  const defaultDir = join9(process.env.HOME || "~", "cognova");
+  let resolvedInstallDir;
+  if (progress.partialConfig.installDir) {
+    resolvedInstallDir = progress.partialConfig.installDir;
+    R2.info(`Using install directory: ${resolvedInstallDir}`);
+  } else {
+    const installDir = await Ze({
+      message: "Where should Cognova be installed?",
+      placeholder: defaultDir,
+      defaultValue: defaultDir
+    });
+    if (Ct(installDir)) process.exit(0);
+    resolvedInstallDir = installDir.replace("~", process.env.HOME || "");
+    await setupInstallDir(resolvedInstallDir);
+    progress.partialConfig.installDir = resolvedInstallDir;
+    progress.completedSteps.push("installDir");
+    saveProgress(progress);
+  }
+  R2.step(import_picocolors6.default.bold("Vault"));
+  const vault = progress.partialConfig.vault || await setupVault();
+  if (!progress.completedSteps.includes("vault")) {
+    progress.partialConfig.vault = vault;
+    progress.completedSteps.push("vault");
+    saveProgress(progress);
+  }
+  R2.step(import_picocolors6.default.bold("Database"));
+  let database = progress.partialConfig.database;
+  if (!database) {
+    try {
+      database = await withRetry(
+        "Database setup",
+        () => setupDatabase(prereqs.dockerReady),
+        { canSkip: false }
+      );
+      progress.partialConfig.database = database;
+      progress.completedSteps.push("database");
+      saveProgress(progress);
+    } catch (err) {
+      if (err instanceof SkipError) {
+        R2.error("Database setup is required and cannot be skipped");
       }
+      process.exit(1);
+    }
+  }
+  R2.step(import_picocolors6.default.bold("Network Access"));
+  let accessMode;
+  let appUrl;
+  if (progress.partialConfig.accessMode && progress.partialConfig.appUrl) {
+    accessMode = progress.partialConfig.accessMode;
+    appUrl = progress.partialConfig.appUrl;
+    R2.info(`Using access mode: ${accessMode} (${appUrl})`);
+  } else {
+    accessMode = await Je({
+      message: "How will you access Cognova?",
+      options: [
+        { value: "localhost", label: "Local only", hint: "http://localhost:3000" },
+        { value: "specific", label: "Specific IP or domain", hint: "LAN IP, hostname, or domain" },
+        { value: "any", label: "Any connection", hint: "Accepts requests from any origin (0.0.0.0)" }
+      ]
     });
-    if (Ct(pw)) process.exit(0);
-    const confirm = await He({
-      message: "Confirm password"
+    if (Ct(accessMode)) process.exit(0);
+    appUrl = "http://localhost:3000";
+    if (accessMode === "specific") {
+      const host = await Ze({
+        message: "IP address or domain (include port if not 80/443)",
+        placeholder: "192.168.1.100:3000"
+      });
+      if (Ct(host)) process.exit(0);
+      appUrl = host.startsWith("http") ? host : `http://${host}`;
+    }
+    progress.partialConfig.accessMode = accessMode;
+    progress.partialConfig.appUrl = appUrl;
+    progress.completedSteps.push("network");
+    saveProgress(progress);
+  }
+  if (!progress.completedSteps.includes("security")) {
+    R2.warn(import_picocolors6.default.yellow(import_picocolors6.default.bold("Security Notice")));
+    R2.warn([
+      "Cognova gives an AI agent unrestricted access to this machine.",
+      "It can read, write, and execute anything via the embedded terminal",
+      "and Claude Code CLI.",
+      "",
+      `  ${import_picocolors6.default.dim("\u2022")} Do not run on a personal machine or alongside sensitive data`,
+      `  ${import_picocolors6.default.dim("\u2022")} Use a dedicated VM, container, or isolated environment`,
+      `  ${import_picocolors6.default.dim("\u2022")} Put a reverse proxy with TLS in front for remote access`,
+      `  ${import_picocolors6.default.dim("\u2022")} Do not store SSH keys, cloud creds, or production secrets here`
+    ].join("\n"));
+    if (accessMode === "any") {
+      R2.warn(import_picocolors6.default.red(
+        "Binding to 0.0.0.0 exposes this to your entire network."
+      ));
+    }
+    const proceed = await Re({
+      message: "I understand the risks. Continue?",
+      initialValue: false
+    });
+    if (Ct(proceed) || !proceed) process.exit(0);
+    progress.completedSteps.push("security");
+    saveProgress(progress);
+  }
+  R2.step(import_picocolors6.default.bold("Authentication"));
+  let adminEmail;
+  let adminPassword;
+  let adminName;
+  if (progress.partialConfig.auth) {
+    adminEmail = progress.partialConfig.auth.adminEmail;
+    adminPassword = progress.partialConfig.auth.adminPassword;
+    adminName = progress.partialConfig.auth.adminName;
+    R2.info(`Using admin: ${adminEmail}`);
+  } else {
+    const emailInput = await Ze({
+      message: "Admin email",
+      placeholder: "admin@example.com",
+      defaultValue: "admin@example.com"
     });
-    if (Ct(confirm)) process.exit(0);
-    if (pw === confirm) {
-      adminPassword = pw;
-      break;
+    if (Ct(emailInput)) process.exit(0);
+    adminEmail = emailInput;
+    while (true) {
+      const pw = await He({
+        message: "Admin password",
+        validate: (v) => {
+          if (!v || v.length < 8) return "Minimum 8 characters";
+        }
+      });
+      if (Ct(pw)) process.exit(0);
+      const confirm = await He({
+        message: "Confirm password"
+      });
+      if (Ct(confirm)) process.exit(0);
+      if (pw === confirm) {
+        adminPassword = pw;
+        break;
+      }
+      R2.warn("Passwords do not match. Try again.");
     }
-    R2.warn("Passwords do not match. Try again.");
+    const nameInput = await Ze({
+      message: "Admin display name",
+      placeholder: personality.userName,
+      defaultValue: personality.userName
+    });
+    if (Ct(nameInput)) process.exit(0);
+    adminName = nameInput;
+    progress.partialConfig.auth = {
+      adminEmail,
+      adminPassword,
+      adminName,
+      authSecret: crypto3.randomBytes(32).toString("base64")
+    };
+    progress.completedSteps.push("auth");
+    saveProgress(progress);
   }
-  const adminName = await Ze({
-    message: "Admin display name",
-    placeholder: personality.userName,
-    defaultValue: personality.userName
-  });
-  if (Ct(adminName)) process.exit(0);
   const config = {
     personality,
     vault,
     database,
-    auth: {
+    auth: progress.partialConfig.auth || {
       adminEmail,
       adminPassword,
       adminName,
@@ -2205,7 +2513,7 @@ async function init() {
     accessMode,
     installDir: resolvedInstallDir
   };
-  R2.step(import_picocolors5.default.bold("Configuration"));
+  R2.step(import_picocolors6.default.bold("Configuration"));
   const s = bt2();
   s.start("Writing .env");
   writeEnvFile(config);
@@ -2213,24 +2521,86 @@ async function init() {
   s.start("Installing Claude Code configuration");
   await installClaudeConfig(config);
   s.stop("Claude config installed to ~/.claude/");
-  writeMetadata(resolvedInstallDir, vault.path, getPackageVersion());
-  R2.step(import_picocolors5.default.bold("Setup"));
-  s.start("Installing dependencies");
-  execSync5("pnpm install", { cwd: resolvedInstallDir, stdio: "pipe" });
-  s.stop("Dependencies installed");
-  R2.step(import_picocolors5.default.bold("Launch"));
-  await setupAndStart(config);
-  await waitForHealth("http://localhost:3000");
-  R2.step(import_picocolors5.default.bold("Summary"));
+  writeMetadata(
+    resolvedInstallDir,
+    vault.path,
+    getPackageVersion(),
+    database.password,
+    database.port
+  );
+  R2.step(import_picocolors6.default.bold("Setup"));
+  if (!progress.completedSteps.includes("install")) {
+    try {
+      await withRetry(
+        "Dependency installation",
+        async () => {
+          s.start("Installing dependencies");
+          execSync5("pnpm install", { cwd: resolvedInstallDir, stdio: "pipe" });
+          s.stop("Dependencies installed");
+        },
+        { canSkip: false }
+      );
+      progress.completedSteps.push("install");
+      saveProgress(progress);
+    } catch (err) {
+      s.stop("Dependency installation failed");
+      if (err instanceof SkipError) {
+        R2.error("Dependency installation is required and cannot be skipped");
+      }
+      process.exit(1);
+    }
+  } else {
+    R2.info("Dependencies already installed");
+  }
+  R2.step(import_picocolors6.default.bold("Launch"));
+  if (!progress.completedSteps.includes("pm2")) {
+    try {
+      await withRetry(
+        "PM2 setup and start",
+        () => setupAndStart(config),
+        { canSkip: false }
+      );
+      progress.completedSteps.push("pm2");
+      saveProgress(progress);
+    } catch (err) {
+      if (err instanceof SkipError) {
+        R2.error("PM2 setup is required and cannot be skipped");
+      }
+      process.exit(1);
+    }
+  } else {
+    R2.info("PM2 already configured");
+  }
+  if (!progress.completedSteps.includes("health")) {
+    try {
+      await withRetry(
+        "Health check",
+        () => waitForHealth("http://localhost:3000"),
+        { canSkip: true }
+      );
+      progress.completedSteps.push("health");
+      saveProgress(progress);
+    } catch (err) {
+      if (err instanceof SkipError) {
+        R2.warn("Health check skipped - app may not be fully started");
+        R2.info("Check status with: pm2 status");
+      } else {
+        process.exit(1);
+      }
+    }
+  } else {
+    R2.info("App already healthy");
+  }
+  R2.step(import_picocolors6.default.bold("Summary"));
   R2.info([
     "",
-    `  ${import_picocolors5.default.cyan("App URL:")}        ${config.appUrl}`,
-    `  ${import_picocolors5.default.cyan("Admin Login:")}    ${config.auth.adminEmail}`,
-    `  ${import_picocolors5.default.cyan("Vault:")}          ${vault.path}`,
-    `  ${import_picocolors5.default.cyan("Install Dir:")}    ${resolvedInstallDir}`,
-    `  ${import_picocolors5.default.cyan("Agent:")}          ${personality.agentName}`,
+    `  ${import_picocolors6.default.cyan("App URL:")}        ${config.appUrl}`,
+    `  ${import_picocolors6.default.cyan("Admin Login:")}    ${config.auth.adminEmail}`,
+    `  ${import_picocolors6.default.cyan("Vault:")}          ${vault.path}`,
+    `  ${import_picocolors6.default.cyan("Install Dir:")}    ${resolvedInstallDir}`,
+    `  ${import_picocolors6.default.cyan("Agent:")}          ${personality.agentName}`,
     "",
-    `  ${import_picocolors5.default.dim("Manage:")}`,
+    `  ${import_picocolors6.default.dim("Manage:")}`,
     `    cognova start     Start the app`,
     `    cognova stop      Stop the app`,
     `    cognova restart   Restart the app`,
@@ -2242,17 +2612,18 @@ async function init() {
     `    pm2 monit              Monitor resources`,
     ""
   ].join("\n"));
-  Le(`${personality.agentName} is ready. Open ${import_picocolors5.default.underline(config.appUrl)} to get started.`);
+  Le(`${personality.agentName} is ready. Open ${import_picocolors6.default.underline(config.appUrl)} to get started.`);
+  clearProgress();
 }
 
 // src/commands/start.ts
 import { execSync as execSync6 } from "child_process";
-import { existsSync as existsSync6 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join10 } from "path";
 async function start() {
   const installDir = findInstallDir();
-  const ecosystem = join8(installDir, "ecosystem.config.cjs");
-  if (!existsSync6(ecosystem)) {
+  const ecosystem = join10(installDir, "ecosystem.config.cjs");
+  if (!existsSync8(ecosystem)) {
     console.error("No ecosystem.config.cjs found. Run `cognova init` first.");
     process.exit(1);
   }
@@ -2278,9 +2649,9 @@ async function restart() {
 
 // src/commands/update.ts
 import { execSync as execSync7 } from "child_process";
-import { existsSync as existsSync7, cpSync as cpSync3, rmSync } from "fs";
-import { join as join9 } from "path";
-var import_picocolors6 = __toESM(require_picocolors(), 1);
+import { existsSync as existsSync9, cpSync as cpSync3, rmSync } from "fs";
+import { join as join11 } from "path";
+var import_picocolors7 = __toESM(require_picocolors(), 1);
 var BACKUP_ITEMS = [
   "app",
   "server",
@@ -2294,33 +2665,33 @@ var BACKUP_ITEMS = [
   "pnpm-lock.yaml"
 ];
 function createBackup(installDir) {
-  const backupDir = join9(installDir, ".update-backup");
-  if (existsSync7(backupDir))
+  const backupDir = join11(installDir, ".update-backup");
+  if (existsSync9(backupDir))
     rmSync(backupDir, { recursive: true });
   for (const item of BACKUP_ITEMS) {
-    const src = join9(installDir, item);
-    if (!existsSync7(src)) continue;
-    const dest = join9(backupDir, item);
+    const src = join11(installDir, item);
+    if (!existsSync9(src)) continue;
+    const dest = join11(backupDir, item);
     cpSync3(src, dest, { recursive: true });
   }
   return backupDir;
 }
 function restoreBackup(installDir, backupDir) {
   for (const item of BACKUP_ITEMS) {
-    const src = join9(backupDir, item);
-    if (!existsSync7(src)) continue;
-    const dest = join9(installDir, item);
-    if (existsSync7(dest))
+    const src = join11(backupDir, item);
+    if (!existsSync9(src)) continue;
+    const dest = join11(installDir, item);
+    if (existsSync9(dest))
       rmSync(dest, { recursive: true });
     cpSync3(src, dest, { recursive: true });
   }
 }
 function cleanupBackup(backupDir) {
-  if (existsSync7(backupDir))
+  if (existsSync9(backupDir))
     rmSync(backupDir, { recursive: true });
 }
 async function update() {
-  We(import_picocolors6.default.bgCyan(import_picocolors6.default.black(" Cognova Update ")));
+  We(import_picocolors7.default.bgCyan(import_picocolors7.default.black(" Cognova Update ")));
   const installDir = findInstallDir();
   const metadata = readMetadata(installDir);
   if (!metadata) {
@@ -2342,7 +2713,7 @@ async function update() {
     Le("Nothing to update.");
     return;
   }
-  s.stop(`Update available: ${metadata.version} \u2192 ${import_picocolors6.default.green(latestVersion)}`);
+  s.stop(`Update available: ${metadata.version} \u2192 ${import_picocolors7.default.green(latestVersion)}`);
   s.start("Creating backup");
   const backupDir = createBackup(installDir);
   s.stop("Backup created");
@@ -2371,14 +2742,14 @@ async function update() {
     s.stop("Migrations complete");
   } catch (err) {
     updateFailed = true;
-    s.stop(import_picocolors6.default.red("Update failed"));
+    s.stop(import_picocolors7.default.red("Update failed"));
     const execErr = err;
     R2.error(`Error: ${execErr.message || err}`);
     if (execErr.stdout)
-      R2.error(import_picocolors6.default.dim(String(execErr.stdout).trim()));
+      R2.error(import_picocolors7.default.dim(String(execErr.stdout).trim()));
     if (execErr.stderr)
-      R2.error(import_picocolors6.default.dim(String(execErr.stderr).trim()));
-    R2.step(import_picocolors6.default.bold("Rolling back"));
+      R2.error(import_picocolors7.default.dim(String(execErr.stderr).trim()));
+    R2.step(import_picocolors7.default.bold("Rolling back"));
     const rollbackSpinner = bt2();
     rollbackSpinner.start("Restoring previous version");
     try {
@@ -2387,7 +2758,7 @@ async function update() {
       rollbackSpinner.stop("Previous version restored");
       R2.info("Your previous installation has been restored.");
     } catch (rollbackErr) {
-      rollbackSpinner.stop(import_picocolors6.default.red("Rollback failed"));
+      rollbackSpinner.stop(import_picocolors7.default.red("Rollback failed"));
       R2.error(`Rollback failed: ${rollbackErr instanceof Error ? rollbackErr.message : rollbackErr}`);
       R2.error(`Manual recovery: backup is at ${backupDir}`);
       Le("Update and rollback both failed. See errors above.");
@@ -2409,17 +2780,17 @@ async function update() {
   } catch {
     s.stop("PM2 restart failed \u2014 start manually with `cognova start`");
   }
-  R2.info(`Run ${import_picocolors6.default.cyan("cognova reset")} to regenerate CLAUDE.md or settings.json.`);
+  R2.info(`Run ${import_picocolors7.default.cyan("cognova reset")} to regenerate CLAUDE.md or settings.json.`);
   Le(`Updated to v${latestVersion}`);
 }
 
 // src/commands/doctor.ts
 import { execSync as execSync8 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
-import { join as join10 } from "path";
-var import_picocolors7 = __toESM(require_picocolors(), 1);
+import { existsSync as existsSync10 } from "fs";
+import { join as join12 } from "path";
+var import_picocolors8 = __toESM(require_picocolors(), 1);
 async function doctor() {
-  We(import_picocolors7.default.bgCyan(import_picocolors7.default.black(" Cognova Doctor ")));
+  We(import_picocolors8.default.bgCyan(import_picocolors8.default.black(" Cognova Doctor ")));
   const installDir = findInstallDir();
   const claudeDir = getClaudeDir();
   const metadata = readMetadata(installDir);
@@ -2429,35 +2800,55 @@ async function doctor() {
   const checks = [
     {
       name: ".env file",
-      check: () => existsSync8(join10(installDir, ".env"))
+      check: () => existsSync10(join12(installDir, ".env")),
+      fixDescription: 'Run "cognova reset" to regenerate'
     },
     {
       name: "node_modules",
-      check: () => existsSync8(join10(installDir, "node_modules"))
+      check: () => existsSync10(join12(installDir, "node_modules")),
+      fix: async () => {
+        const s = bt2();
+        s.start("Installing dependencies");
+        execSync8("pnpm install", { cwd: installDir, stdio: "inherit" });
+        s.stop("Dependencies installed");
+      },
+      fixDescription: "Install dependencies"
     },
     {
       name: "Build output",
-      check: () => existsSync8(join10(installDir, ".output", "server", "index.mjs"))
+      check: () => existsSync10(join12(installDir, ".output", "server", "index.mjs")),
+      fix: async () => {
+        const s = bt2();
+        s.start("Building application");
+        execSync8("pnpm build", { cwd: installDir, stdio: "inherit" });
+        s.stop("Build complete");
+      },
+      fixDescription: "Build the application"
     },
     {
       name: "~/.claude/CLAUDE.md",
-      check: () => existsSync8(join10(claudeDir, "CLAUDE.md"))
+      check: () => existsSync10(join12(claudeDir, "CLAUDE.md")),
+      fixDescription: 'Run "cognova reset --claude" to reinstall'
     },
     {
       name: "~/.claude/skills/",
-      check: () => existsSync8(join10(claudeDir, "skills"))
+      check: () => existsSync10(join12(claudeDir, "skills")),
+      fixDescription: 'Run "cognova reset --claude" to reinstall'
     },
     {
       name: "~/.claude/hooks/",
-      check: () => existsSync8(join10(claudeDir, "hooks"))
+      check: () => existsSync10(join12(claudeDir, "hooks")),
+      fixDescription: 'Run "cognova reset --claude" to reinstall'
     },
     {
       name: "~/.claude/rules/",
-      check: () => existsSync8(join10(claudeDir, "rules"))
+      check: () => existsSync10(join12(claudeDir, "rules")),
+      fixDescription: 'Run "cognova reset --claude" to reinstall'
     },
     {
       name: "~/.claude/settings.json",
-      check: () => existsSync8(join10(claudeDir, "settings.json"))
+      check: () => existsSync10(join12(claudeDir, "settings.json")),
+      fixDescription: 'Run "cognova reset --claude" to reinstall'
     },
     {
       name: "Claude Code CLI",
@@ -2468,7 +2859,8 @@ async function doctor() {
         } catch {
           return false;
         }
-      }
+      },
+      fixDescription: "Install with: npm install -g @anthropic-ai/claude-code"
     },
     {
       name: "Python 3",
@@ -2479,7 +2871,36 @@ async function doctor() {
         } catch {
           return false;
         }
-      }
+      },
+      fixDescription: "Install from https://python.org/"
+    },
+    {
+      name: "Docker daemon",
+      check: () => {
+        try {
+          execSync8("docker info", { stdio: "pipe" });
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      fix: async () => {
+        const s = bt2();
+        s.start("Starting Docker daemon");
+        try {
+          if (process.platform === "darwin") {
+            execSync8("open -a Docker", { stdio: "pipe" });
+            R2.info("Docker Desktop is starting - this may take a moment");
+          } else if (process.platform === "linux") {
+            execSync8("sudo systemctl start docker", { stdio: "inherit" });
+          }
+          s.stop("Docker daemon start command issued");
+        } catch (err) {
+          s.stop("Failed to start Docker daemon");
+          throw err;
+        }
+      },
+      fixDescription: "Start Docker daemon"
     },
     {
       name: "PM2 process",
@@ -2493,7 +2914,19 @@ async function doctor() {
         } catch {
           return false;
         }
-      }
+      },
+      fix: async () => {
+        const s = bt2();
+        s.start("Starting PM2 process");
+        try {
+          execSync8("pm2 start ecosystem.config.cjs", { cwd: installDir, stdio: "inherit" });
+          s.stop("PM2 process started");
+        } catch (err) {
+          s.stop("Failed to start PM2");
+          throw err;
+        }
+      },
+      fixDescription: "Start the PM2 process"
     },
     {
       name: "App health endpoint",
@@ -2523,7 +2956,7 @@ async function doctor() {
       name: "Vault directory",
       check: () => {
         if (!metadata) return false;
-        return existsSync8(metadata.vaultPath);
+        return existsSync10(metadata.vaultPath);
       }
     },
     {
@@ -2539,32 +2972,63 @@ async function doctor() {
       }
     }
   ];
-  let passed = 0;
-  let failed = 0;
-  for (const { name, check } of checks) {
+  const results = [];
+  for (const check of checks) {
     try {
-      const result = check();
+      const result = check.check();
       if (result === true) {
-        R2.success(`${import_picocolors7.default.green("PASS")} ${name}`);
-        passed++;
+        R2.success(`${import_picocolors8.default.green("PASS")} ${check.name}`);
+        results.push({ check, status: "pass" });
       } else if (result === false) {
-        R2.error(`${import_picocolors7.default.red("FAIL")} ${name}`);
-        failed++;
+        R2.error(`${import_picocolors8.default.red("FAIL")} ${check.name}`);
+        if (check.fixDescription)
+          R2.info(`  \u2192 ${import_picocolors8.default.dim(check.fixDescription)}`);
+        results.push({ check, status: "fail" });
       } else {
-        R2.warn(`${import_picocolors7.default.yellow("WARN")} ${name}: ${result}`);
+        R2.warn(`${import_picocolors8.default.yellow("WARN")} ${check.name}: ${result}`);
+        results.push({ check, status: "warn", message: result });
       }
     } catch {
-      R2.error(`${import_picocolors7.default.red("FAIL")} ${name}`);
-      failed++;
+      R2.error(`${import_picocolors8.default.red("FAIL")} ${check.name}`);
+      if (check.fixDescription)
+        R2.info(`  \u2192 ${import_picocolors8.default.dim(check.fixDescription)}`);
+      results.push({ check, status: "fail" });
+    }
+  }
+  const passed = results.filter((r) => r.status === "pass").length;
+  const failed = results.filter((r) => r.status === "fail").length;
+  const fixableFailures = results.filter((r) => r.status === "fail" && r.check.fix);
+  if (fixableFailures.length > 0) {
+    R2.info("");
+    const runFixes = await Re({
+      message: `${fixableFailures.length} issue(s) can be auto-fixed. Run fixes now?`,
+      initialValue: true
+    });
+    if (!Ct(runFixes) && runFixes) {
+      for (const { check } of fixableFailures) {
+        if (!check.fix) continue;
+        R2.step(import_picocolors8.default.bold(`Fixing: ${check.name}`));
+        try {
+          await check.fix();
+          const result = check.check();
+          if (result === true) {
+            R2.success(`${import_picocolors8.default.green("\u2713")} ${check.name} is now fixed`);
+          } else {
+            R2.warn(`${import_picocolors8.default.yellow("!")} ${check.name} still failing after fix attempt`);
+          }
+        } catch (err) {
+          R2.error(`${import_picocolors8.default.red("\u2717")} Failed to fix ${check.name}: ${err}`);
+        }
+      }
     }
   }
   Le(`${passed} passed, ${failed} failed`);
 }
 
 // src/commands/reset.ts
-var import_picocolors8 = __toESM(require_picocolors(), 1);
+var import_picocolors9 = __toESM(require_picocolors(), 1);
 async function reset() {
-  We(import_picocolors8.default.bgCyan(import_picocolors8.default.black(" Cognova Reset ")));
+  We(import_picocolors9.default.bgCyan(import_picocolors9.default.black(" Cognova Reset ")));
   const installDir = findInstallDir();
   const metadata = readMetadata(installDir);
   if (!metadata) {