@meshxdata/fops 0.0.3 → 0.0.5

package/src/commands/index.js

@@ -4,12 +4,14 @@ import path from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
 import { PKG } from "../config.js";
-import { rootDir, requireRoot, hasComposeInDir, isFoundationRoot, findComposeRootUp } from "../project.js";
-import { make } from "../shell.js";
+import { rootDir, requireRoot, hasComposeInDir, isFoundationRoot, findComposeRootUp, checkInitState } from "../project.js";
+import { execa } from "execa";
+import { make, dockerCompose } from "../shell.js";
 import { runSetup, runInitWizard } from "../setup/index.js";
 import { ensureEcrAuth } from "../setup/aws.js";
 import { runAgentSingleTurn, runAgentInteractive } from "../agent/index.js";
 import { runDoctor } from "../doctor.js";
+import { runFeatureFlags } from "../feature-flags.js";
 import { runLogin, runCodaLogin } from "../auth/index.js";
 import { runHook, loadSkills } from "../plugins/index.js";
 
@@ -104,14 +106,53 @@ export function registerCommands(program, registry) {
     .option("--no-chat", "Skip interactive AI assistant after startup")
     .action(async (opts) => {
       const root = requireRoot(program);
+
+      // Pre-flight: check if project is initialised
+      const initIssue = checkInitState(root);
+      if (initIssue) {
+        console.error(chalk.red(`\n  Project not ready: ${initIssue}.`));
+        console.error(chalk.dim("  Run `fops init` first to set up the project.\n"));
+        process.exit(1);
+      }
+
       await ensureEcrAuth(root);
       await runHook(registry, "before:up", { root });
-      const result = await make(root, "start");
+
+      // Detect stuck containers (restarting / unhealthy) and force-recreate them
+      const forceRecreate = [];
+      try {
+        const { stdout } = await execa("docker", ["compose", "ps", "--format", "json"], {
+          cwd: root, reject: false, timeout: 10000,
+        });
+        if (stdout?.trim()) {
+          for (const line of stdout.trim().split("\n").filter(Boolean)) {
+            try {
+              const svc = JSON.parse(line);
+              const state = (svc.State || "").toLowerCase();
+              const health = (svc.Health || "").toLowerCase();
+              if (state === "restarting" || health === "unhealthy") {
+                forceRecreate.push(svc.Service || svc.Name);
+              }
+            } catch {}
+          }
+        }
+      } catch {}
+
+      if (forceRecreate.length > 0) {
+        console.log(chalk.yellow(`  Recreating stuck containers: ${forceRecreate.join(", ")}`));
+        await dockerCompose(root, ["rm", "-f", "-s", ...forceRecreate]);
+      }
+
+      console.log(chalk.green("  Starting services..."));
+      const result = await dockerCompose(root, ["up", "-d", "--remove-orphans", "--pull", "always"]);
+      // Clear any trailing \r progress line from docker compose output
+      process.stdout.write("\x1b[2K\r");
       await runHook(registry, "after:up", { root });
       if (result.exitCode !== 0) {
         console.error(chalk.red(`\n  Some services failed to start (exit code ${result.exitCode}).`));
-        console.error(chalk.gray("  Run `fops doctor` to diagnose or `fops logs` to inspect.\n"));
-        process.exit(result.exitCode);
+        console.error(chalk.dim("  Dropping into debug agent to diagnose...\n"));
+        await runAgentInteractive(root, { registry, initialAgent: "debug" });
+        return;
       }
       if (opts.chat !== false) await runAgentInteractive(root, { registry });
     });
@@ -164,10 +205,28 @@ export function registerCommands(program, registry) {
 
   program
     .command("config")
-    .description("Launch interactive configuration (make config)")
+    .description("Toggle MX_FF_* feature flags and restart affected services")
+    .action(async () => {
+      const root = requireRoot(program);
+      await runFeatureFlags(root);
+    });
+
+  program
+    .command("build")
+    .description("Build all Foundation service images from source")
+    .action(async () => {
+      const root = requireRoot(program);
+      await ensureEcrAuth(root);
+      await make(root, "build");
+    });
+
+  program
+    .command("download")
+    .description("Pull all container images from registry (requires ECR auth)")
     .action(async () => {
       const root = requireRoot(program);
-      await make(root, "config");
+      await ensureEcrAuth(root);
+      await make(root, "download");
     });
 
   program
@@ -197,14 +256,14 @@ export function registerCommands(program, registry) {
     .action(async () => {
       const skills = await loadSkills(registry);
       if (skills.length === 0) {
-        console.log(chalk.gray("  No skills available."));
+        console.log(chalk.dim("  No skills available."));
         return;
       }
       console.log(chalk.bold.cyan("\n  Agent Skills\n"));
       for (const s of skills) {
-        const source = s.pluginId ? chalk.gray(`(plugin: ${s.pluginId})`) : chalk.gray("(built-in)");
+        const source = s.pluginId ? chalk.dim(`(plugin: ${s.pluginId})`) : chalk.dim("(built-in)");
         console.log(`  ${chalk.green("●")} ${chalk.bold(s.name)} ${source}`);
-        if (s.description) console.log(chalk.gray(`    ${s.description}`));
+        if (s.description) console.log(chalk.dim(`    ${s.description}`));
       }
       console.log("");
     });
@@ -214,20 +273,41 @@ export function registerCommands(program, registry) {
     .command("plugin")
     .description("Manage fops plugins");
 
+  // Helper: read/write plugin enabled state in ~/.fops.json
+  const fopsConfigPath = path.join(os.homedir(), ".fops.json");
+  const readFopsConfig = () => {
+    try { return fs.existsSync(fopsConfigPath) ? JSON.parse(fs.readFileSync(fopsConfigPath, "utf8")) : {}; } catch { return {}; }
+  };
+  const setPluginEnabled = (id, enabled) => {
+    const cfg = readFopsConfig();
+    if (!cfg.plugins) cfg.plugins = {};
+    if (!cfg.plugins.entries) cfg.plugins.entries = {};
+    if (!cfg.plugins.entries[id]) cfg.plugins.entries[id] = {};
+    cfg.plugins.entries[id].enabled = enabled;
+    fs.writeFileSync(fopsConfigPath, JSON.stringify(cfg, null, 2) + "\n");
+  };
+  const isPluginEnabled = (id) => {
+    const cfg = readFopsConfig();
+    return cfg?.plugins?.entries?.[id]?.enabled !== false;
+  };
+
   pluginCmd
     .command("list")
     .description("List installed plugins with status")
     .action(async () => {
       if (registry.plugins.length === 0) {
-        console.log(chalk.gray("  No plugins installed."));
-        console.log(chalk.gray("  Install plugins to ~/.fops/plugins/ or via npm (fops-plugin-*)."));
+        console.log(chalk.dim("  No plugins installed."));
+        console.log(chalk.dim("  Install plugins to ~/.fops/plugins/ or via npm (fops-plugin-*)."));
         return;
       }
       console.log(chalk.bold.cyan("\n  Installed Plugins\n"));
       for (const p of registry.plugins) {
-        const source = chalk.gray(`(${p.source})`);
-        console.log(`  ${chalk.green("●")} ${chalk.bold(p.name)} ${chalk.gray("v" + p.version)} ${source}`);
-        console.log(chalk.gray(`    id: ${p.id}  path: ${p.path}`));
+        const enabled = isPluginEnabled(p.id);
+        const dot = enabled ? chalk.green("●") : chalk.red("○");
+        const status = enabled ? "" : chalk.red(" (disabled)");
+        const source = chalk.dim(`(${p.source})`);
+        console.log(`  ${dot} ${chalk.bold(p.name)} ${chalk.dim("v" + p.version)} ${source}${status}`);
+        console.log(chalk.dim(`    id: ${p.id}  path: ${p.path}`));
       }
       console.log("");
     });
@@ -279,4 +359,30 @@ export function registerCommands(program, registry) {
       fs.rmSync(pluginDir, { recursive: true, force: true });
       console.log(chalk.green(`  ✓ Removed plugin "${id}"`));
     });
+
+  pluginCmd
+    .command("enable <id>")
+    .description("Enable a plugin")
+    .action(async (id) => {
+      const found = registry.plugins.find((p) => p.id === id);
+      if (!found) {
+        console.error(chalk.red(`Plugin "${id}" not found. Run: fops plugin list`));
+        process.exit(1);
+      }
+      setPluginEnabled(id, true);
+      console.log(chalk.green(`  ✓ Enabled plugin "${id}". Restart fops to apply.`));
+    });
+
+  pluginCmd
+    .command("disable <id>")
+    .description("Disable a plugin without removing it")
+    .action(async (id) => {
+      const found = registry.plugins.find((p) => p.id === id);
+      if (!found) {
+        console.error(chalk.red(`Plugin "${id}" not found. Run: fops plugin list`));
+        process.exit(1);
+      }
+      setPluginEnabled(id, false);
+      console.log(chalk.yellow(`  ○ Disabled plugin "${id}". Restart fops to apply.`));
+    });
 }

package/src/config.js

@@ -18,7 +18,7 @@ export const CLI_BRAND = {
 export function printFoundationBanner(cwd) {
   const cwdShort = cwd.replace(os.homedir(), "~");
   console.log(chalk.cyan(`  ${CLI_BRAND.title} ${CLI_BRAND.version}`));
-  console.log(chalk.gray(`  ${CLI_BRAND.byline}`));
-  console.log(chalk.gray(`  ${cwdShort}`));
+  console.log(chalk.dim(`  ${CLI_BRAND.byline}`));
+  console.log(chalk.dim(`  ${cwdShort}`));
   console.log("");
 }

package/src/doctor.js

@@ -6,8 +6,8 @@ import path from "node:path";
 import chalk from "chalk";
 import { execa } from "execa";
 import { rootDir } from "./project.js";
+import inquirer from "inquirer";
 import { detectEcrRegistry, detectAwsSsoProfiles, fixAwsSso, fixEcr } from "./setup/aws.js";
-import { confirm } from "./ui/index.js";
 
 const KEY_PORTS = {
   5432: "Postgres",
@@ -22,7 +22,7 @@ const KEY_PORTS = {
 
 function header(title) {
   console.log(chalk.bold.cyan(`\n  ${title}`));
-  console.log(chalk.gray("  " + "─".repeat(40)));
+  console.log(chalk.dim("  " + "─".repeat(40)));
 }
 
 async function checkPort(port) {
@@ -34,6 +34,25 @@ async function checkPort(port) {
   });
 }
 
+/**
+ * Ensure Homebrew is available (macOS). Installs if missing.
+ * Returns true if brew is usable after the call.
+ */
+async function ensureBrew() {
+  try { await execa("brew", ["--version"]); return true; } catch {}
+  console.log(chalk.cyan("  ▶ Installing Homebrew…"));
+  try {
+    await execa("bash", ["-c", 'NONINTERACTIVE=1 /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"'], {
+      stdio: "inherit", timeout: 300_000,
+    });
+    const brewPaths = ["/opt/homebrew/bin/brew", "/usr/local/bin/brew"];
+    for (const bp of brewPaths) {
+      if (fs.existsSync(bp)) { process.env.PATH = path.dirname(bp) + ":" + process.env.PATH; break; }
+    }
+    return true;
+  } catch { return false; }
+}
+
 async function cmdVersion(cmd, args = ["--version"]) {
   try {
     const { stdout } = await execa(cmd, args, { reject: false, timeout: 5000 });
@@ -98,19 +117,21 @@ export async function runDoctor(opts = {}, registry = null) {
   let failed = 0;
 
   const fixes = []; // collect fix actions to run at the end
+  const fixFns = new Set(); // deduplicate by function reference
 
   const ok = (name, detail) => {
-    console.log(chalk.green("  ✓ ") + name + (detail ? chalk.gray(` — ${detail}`) : ""));
+    console.log(chalk.green("  ✓ ") + name + (detail ? chalk.dim(` — ${detail}`) : ""));
     passed++;
   };
-  const warn = (name, detail) => {
-    console.log(chalk.yellow("  ⚠ ") + name + (detail ? chalk.gray(` — ${detail}`) : ""));
+  const warn = (name, detail, fixFn) => {
+    console.log(chalk.yellow("  ⚠ ") + name + (detail ? chalk.dim(` — ${detail}`) : ""));
     warned++;
+    if (fixFn && !fixFns.has(fixFn)) { fixes.push({ name, fn: fixFn }); fixFns.add(fixFn); }
   };
   const fail = (name, detail, fixFn) => {
-    console.log(chalk.red("  ✗ ") + name + (detail ? chalk.gray(` — ${detail}`) : ""));
+    console.log(chalk.red("  ✗ ") + name + (detail ? chalk.dim(` — ${detail}`) : ""));
     failed++;
-    if (fixFn) fixes.push({ name, fn: fixFn });
+    if (fixFn && !fixFns.has(fixFn)) { fixes.push({ name, fn: fixFn }); fixFns.add(fixFn); }
   };
 
   // ── Prerequisites ──────────────────────────────────
@@ -160,7 +181,7 @@ export async function runDoctor(opts = {}, registry = null) {
           return;
         }
         // macOS / Windows: wait for daemon to become ready
-        console.log(chalk.gray("  Waiting for Docker daemon to start…"));
+        console.log(chalk.dim("  Waiting for Docker daemon to start…"));
         for (let i = 0; i < 30; i++) {
           await new Promise((r) => setTimeout(r, 2000));
           try {
@@ -215,7 +236,7 @@ export async function runDoctor(opts = {}, registry = null) {
         return;
       }
       // macOS / Windows: wait for daemon after install
-      console.log(chalk.gray("  Waiting for Docker daemon to start…"));
+      console.log(chalk.dim("  Waiting for Docker daemon to start…"));
       for (let i = 0; i < 30; i++) {
         await new Promise((r) => setTimeout(r, 2000));
         try {
@@ -235,7 +256,20 @@ export async function runDoctor(opts = {}, registry = null) {
   // Git
   const gitVer = await cmdVersion("git");
   if (gitVer) ok("Git available", gitVer);
-  else fail("Git not found", "install git");
+  else fail("Git not found", "install git", async () => {
+    if (process.platform === "darwin") {
+      if (!(await ensureBrew())) throw new Error("Homebrew required");
+      console.log(chalk.cyan("  ▶ brew install git"));
+      await execa("brew", ["install", "git"], { stdio: "inherit", timeout: 300_000 });
+    } else if (process.platform === "win32") {
+      if (!hasWinget) throw new Error("winget required");
+      console.log(chalk.cyan("  ▶ winget install Git.Git"));
+      await execa("winget", ["install", "Git.Git", "--accept-source-agreements", "--accept-package-agreements"], { stdio: "inherit", timeout: 300_000 });
+    } else {
+      console.log(chalk.cyan("  ▶ sudo apt-get install -y git"));
+      await execa("sudo", ["apt-get", "install", "-y", "git"], { stdio: "inherit", timeout: 300_000 });
+    }
+  });
 
   // Node.js version
   const nodeVer = process.versions.node;
@@ -246,28 +280,121 @@ export async function runDoctor(opts = {}, registry = null) {
   // Claude CLI (bundled as a dependency)
   const claudeVer = await cmdVersion("claude");
   if (claudeVer) ok("Claude CLI", claudeVer);
-  else fail("Claude CLI not found", "run: npm install (included as a dependency)");
+  else fail("Claude CLI not found", "included as a dependency", async () => {
+    console.log(chalk.cyan("  ▶ npm install"));
+    await execa("npm", ["install"], { stdio: "inherit", timeout: 300_000 });
+  });
 
   // AWS CLI (optional)
   const awsVer = await cmdVersion("aws");
   if (awsVer) ok("AWS CLI", awsVer);
-  else warn("AWS CLI not found", "optional — needed for ECR login");
+  else warn("AWS CLI not found", "needed for ECR login", async () => {
+    if (process.platform === "darwin") {
+      if (!(await ensureBrew())) throw new Error("Homebrew required");
+      console.log(chalk.cyan("  ▶ brew install awscli"));
+      await execa("brew", ["install", "awscli"], { stdio: "inherit", timeout: 300_000 });
+    } else if (process.platform === "win32") {
+      if (!hasWinget) throw new Error("winget required");
+      console.log(chalk.cyan("  ▶ winget install Amazon.AWSCLI"));
+      await execa("winget", ["install", "Amazon.AWSCLI", "--accept-source-agreements", "--accept-package-agreements"], { stdio: "inherit", timeout: 300_000 });
+    } else {
+      console.log(chalk.cyan("  ▶ curl + unzip install"));
+      await execa("sh", ["-c", 'curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o /tmp/awscliv2.zip && unzip -qo /tmp/awscliv2.zip -d /tmp && sudo /tmp/aws/install'], {
+        stdio: "inherit", timeout: 300_000,
+      });
+    }
+  });
 
-  // ~/.netrc GitHub credentials (optional — validate against API + repo access)
+  // 1Password CLI (optional — needed for secret sync)
+  const opVer = await cmdVersion("op");
+  if (opVer) ok("1Password CLI (op)", opVer);
+  else warn("1Password CLI (op) not installed", "needed for secret sync", async () => {
+    if (process.platform === "darwin") {
+      if (!(await ensureBrew())) throw new Error("Homebrew required");
+      console.log(chalk.cyan("  ▶ brew install --cask 1password-cli"));
+      await execa("brew", ["install", "--cask", "1password-cli"], { stdio: "inherit", timeout: 300_000 });
+    } else if (process.platform === "win32") {
+      if (!hasWinget) throw new Error("winget required");
+      console.log(chalk.cyan("  ▶ winget install AgileBits.1Password.CLI"));
+      await execa("winget", ["install", "AgileBits.1Password.CLI", "--accept-source-agreements", "--accept-package-agreements"], { stdio: "inherit", timeout: 300_000 });
+    } else {
+      console.log(chalk.dim("  Install manually: https://developer.1password.com/docs/cli/get-started/#install"));
+    }
+  });
+
+  // GitHub CLI
+  const ghVer = await cmdVersion("gh");
+  if (ghVer) ok("GitHub CLI (gh)", ghVer);
+  else warn("GitHub CLI (gh) not installed", "needed for auth", async () => {
+    if (process.platform === "darwin") {
+      if (!(await ensureBrew())) throw new Error("Homebrew required");
+      console.log(chalk.cyan("  ▶ brew install gh"));
+      await execa("brew", ["install", "gh"], { stdio: "inherit", timeout: 300_000 });
+    } else if (process.platform === "win32") {
+      if (!hasWinget) throw new Error("winget required");
+      console.log(chalk.cyan("  ▶ winget install GitHub.cli"));
+      await execa("winget", ["install", "GitHub.cli", "--accept-source-agreements", "--accept-package-agreements"], { stdio: "inherit", timeout: 300_000 });
+    } else {
+      console.log(chalk.dim("  Install: https://cli.github.com/"));
+    }
+  });
+
+  // ~/.netrc GitHub credentials (required for private repo access)
   const netrcPath = path.join(os.homedir(), ".netrc");
+  const netrcFixFn = async () => {
+    // Install gh if missing
+    let hasGh = false;
+    try { await execa("gh", ["--version"]); hasGh = true; } catch {}
+    if (!hasGh) {
+      if (process.platform === "darwin") {
+        if (!(await ensureBrew())) throw new Error("Homebrew required to install gh");
+        console.log(chalk.cyan("  ▶ brew install gh"));
+        await execa("brew", ["install", "gh"], { stdio: "inherit", timeout: 300_000 });
+        hasGh = true;
+      } else if (process.platform === "win32") {
+        console.log(chalk.cyan("  ▶ winget install GitHub.cli"));
+        await execa("winget", ["install", "GitHub.cli", "--accept-source-agreements", "--accept-package-agreements"], { stdio: "inherit", timeout: 300_000 });
+        hasGh = true;
+      }
+    }
+    // Authenticate via gh
+    console.log(chalk.cyan("\n  ▶ gh auth login -p https -h github.com -w"));
+    await execa("gh", ["auth", "login", "-p", "https", "-h", "github.com", "-w"], {
+      stdio: "inherit", timeout: 120_000,
+    });
+    console.log(chalk.cyan("  ▶ gh auth setup-git"));
+    await execa("gh", ["auth", "setup-git"], { stdio: "inherit", timeout: 10_000 }).catch(() => {});
+    // Extract token and write to .netrc for tools that need it directly
+    try {
+      const { stdout: ghToken } = await execa("gh", ["auth", "token"], { timeout: 5000 });
+      const { stdout: ghUser } = await execa("gh", ["api", "/user", "--jq", ".login"], { timeout: 10000 });
+      if (ghToken?.trim() && ghUser?.trim()) {
+        const entry = `machine github.com\nlogin ${ghUser.trim()}\npassword ${ghToken.trim()}\n`;
+        if (fs.existsSync(netrcPath)) {
+          const content = fs.readFileSync(netrcPath, "utf8");
+          if (!content.includes("github.com")) {
+            fs.appendFileSync(netrcPath, "\n" + entry);
+          }
+        } else {
+          fs.writeFileSync(netrcPath, entry, { mode: 0o600 });
+        }
+        console.log(chalk.green("  ✓ ~/.netrc updated with GitHub credentials"));
+      }
+    } catch {}
+  };
   if (fs.existsSync(netrcPath)) {
     try {
       const content = fs.readFileSync(netrcPath, "utf8");
       if (!content.includes("github.com")) {
-        warn("~/.netrc exists but no github.com entry");
+        fail("~/.netrc exists but no github.com entry", "needed for private repos", netrcFixFn);
       } else {
         const token = readNetrcToken(content, "github.com");
         if (!token) {
-          warn("~/.netrc has github.com but no password/token");
+          fail("~/.netrc has github.com but no password/token", "add token", netrcFixFn);
         } else {
           const userRes = await ghApiGet("/user", token);
           if (userRes.status !== 200) {
-            fail("~/.netrc GitHub token invalid or expired", "regenerate at github.com/settings/tokens");
+            fail("~/.netrc GitHub token invalid or expired", "regenerate at github.com/settings/tokens", netrcFixFn);
           } else {
             const login = userRes.body.login || "authenticated";
             ok("~/.netrc GitHub credentials", `authenticated as ${login}`);
@@ -283,10 +410,10 @@ export async function runDoctor(opts = {}, registry = null) {
         }
       }
     } catch {
-      warn("~/.netrc not readable");
+      fail("~/.netrc not readable", "check file permissions", netrcFixFn);
     }
   } else {
-    warn("~/.netrc not found", "optional — used for private repo access");
+    fail("~/.netrc not found", "needed for private repo access", netrcFixFn);
   }
 
   // ~/.fops.json config (optional)
@@ -324,7 +451,7 @@ export async function runDoctor(opts = {}, registry = null) {
       }
     }
   } else {
-    warn("~/.aws/config not found", "optional — needed for ECR");
+    warn("~/.aws/config not found", "needed for ECR", fixAwsSso);
   }
 
   // Validate ECR access if project references ECR images
@@ -332,7 +459,7 @@ export async function runDoctor(opts = {}, registry = null) {
   if (ecrInfo) {
     const ecrUrl = `${ecrInfo.accountId}.dkr.ecr.${ecrInfo.region}.amazonaws.com`;
     if (!awsSessionValid) {
-      fail(`ECR registry ${ecrUrl}`, "fix AWS session first", () => fixEcr(ecrInfo));
+      fail(`ECR registry ${ecrUrl}`, "fix AWS session first");
     } else {
       // Check we can get an ECR login password (same call the actual login uses)
       const ssoProfiles = detectAwsSsoProfiles();
@@ -514,6 +641,64 @@ export async function runDoctor(opts = {}, registry = null) {
     }
   }
 
+  // ── Logs ──────────────────────────────────────────────
+  if (dir && dockerVer) {
+    header("Logs");
+
+    try {
+      const { stdout: logOut } = await execa("docker", [
+        "compose", "logs", "--tail", "50", "--no-color",
+      ], { cwd: dir, reject: false, timeout: 30000 });
+
+      if (logOut?.trim()) {
+        const serviceIssues = {};
+        const ERROR_RE = /\b(ERROR|FATAL|PANIC|CRITICAL)\b/;
+        const CRASH_RE = /\b(OOM|OutOfMemory|out of memory|segmentation fault|segfault)\b/i;
+        const CONN_RE = /\b(ECONNREFUSED|ETIMEDOUT|connection refused)\b/i;
+
+        for (const line of logOut.split("\n")) {
+          const sep = line.indexOf(" | ");
+          if (sep === -1) continue;
+          const service = line.slice(0, sep).trim();
+          const msg = line.slice(sep + 3);
+
+          let level = null;
+          if (CRASH_RE.test(msg)) level = "crash";
+          else if (ERROR_RE.test(msg)) level = "error";
+          else if (CONN_RE.test(msg)) level = "conn";
+          else continue;
+
+          if (!serviceIssues[service]) serviceIssues[service] = { errors: 0, crashes: 0, conn: 0, last: "" };
+          const entry = serviceIssues[service];
+          if (level === "crash") entry.crashes++;
+          else if (level === "conn") entry.conn++;
+          else entry.errors++;
+          entry.last = msg.trim();
+        }
+
+        const services = Object.keys(serviceIssues);
+        if (services.length === 0) {
+          ok("No errors in recent logs");
+        } else {
+          for (const svc of services) {
+            const { errors, crashes, conn, last } = serviceIssues[svc];
+            const parts = [];
+            if (crashes) parts.push(`${crashes} crash`);
+            if (errors) parts.push(`${errors} error${errors > 1 ? "s" : ""}`);
+            if (conn) parts.push(`${conn} conn issue${conn > 1 ? "s" : ""}`);
+            const sample = last.length > 120 ? last.slice(0, 120) + "…" : last;
+            if (crashes) fail(svc, `${parts.join(", ")} — ${sample}`);
+            else warn(svc, `${parts.join(", ")} — ${sample}`);
+          }
+        }
+      } else {
+        ok("No log output", "services may not be running");
+      }
+    } catch {
+      warn("Could not fetch logs", "Docker Compose error");
+    }
+  }
+
   // ── Images ──────────────────────────────────────────
   if (dir && dockerVer) {
     header("Images");
@@ -579,15 +764,19 @@ export async function runDoctor(opts = {}, registry = null) {
   }
 
   // ── Summary ────────────────────────────────────────
-  console.log(chalk.gray("\n  " + "─".repeat(40)));
+  console.log(chalk.dim("\n  " + "─".repeat(40)));
   const parts = [];
   if (passed) parts.push(chalk.green(`${passed} passed`));
   if (warned) parts.push(chalk.yellow(`${warned} warnings`));
   if (failed) parts.push(chalk.red(`${failed} failed`));
-  console.log("  " + parts.join(chalk.gray(" · ")));
+  console.log("  " + parts.join(chalk.dim(" · ")));
 
-  if (failed > 0 && fixes.length > 0) {
-    const shouldFix = opts.fix || await confirm(`\n  Fix ${fixes.length} issue(s) automatically?`, true);
+  if (fixes.length > 0) {
+    let shouldFix = opts.fix;
+    if (!shouldFix) {
+      const { ans } = await inquirer.prompt([{ type: "confirm", name: "ans", message: `Fix ${fixes.length} issue(s) automatically?`, default: true }]);
+      shouldFix = ans;
+    }
     if (shouldFix) {
       console.log("");
       for (const fix of fixes) {
@@ -599,8 +788,8 @@ export async function runDoctor(opts = {}, registry = null) {
           console.log(chalk.red(`  ✗ Fix failed: ${err.message}\n`));
         }
       }
-      console.log(chalk.gray("  Run fops doctor again to verify.\n"));
-    } else {
+      console.log(chalk.dim("  Run fops doctor again to verify.\n"));
+    } else if (failed > 0) {
       console.log("");
       process.exit(1);
     }