@meshxdata/fops 0.0.3 → 0.0.4

package/src/doctor.js

@@ -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) {
@@ -100,15 +100,15 @@ export async function runDoctor(opts = {}, registry = null) {
   const fixes = []; // collect fix actions to run at the end
 
   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}`) : ""));
+    console.log(chalk.yellow("  ⚠ ") + name + (detail ? chalk.dim(` — ${detail}`) : ""));
     warned++;
   };
   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 });
   };
@@ -160,7 +160,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 +215,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 {
@@ -514,6 +514,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,12 +637,12 @@ 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);
@@ -599,7 +657,7 @@ 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"));
+      console.log(chalk.dim("  Run fops doctor again to verify.\n"));
     } else {
       console.log("");
       process.exit(1);

package/src/feature-flags.js

@@ -0,0 +1,197 @@
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { execa } from "execa";
+import inquirer from "inquirer";
+
+/**
+ * Canonical feature flags — the complete set known to the platform.
+ * Label is a human-readable short description for the toggle UI.
+ */
+const KNOWN_FLAGS = {
+  MX_FF_STORAGE_EXPLORER_ENABLED: "Storage Explorer",
+  MX_FF_USER_MANAGEMENT_ENABLED: "User Management",
+  MX_FF_SETTINGS_PAGE_ENABLED: "Settings Page",
+  MX_FF_ENCRYPTION_STATUS_DISPLAY: "Encryption Status",
+  MX_FF_USER_PAT_ENABLED: "User PAT (Personal Access Tokens)",
+  MX_FF_SENTRY_ENABLED: "Sentry Error Tracking",
+  MX_FF_EXPLORER_ENABLED: "Data Explorer",
+  MX_FF_NEW_PROFILE_ENABLED: "New Profile Page",
+};
+
+/**
+ * Parse docker-compose.yaml for all MX_FF_* entries.
+ * Returns a map: flagName → { value, services: Set<string>, lines: [{ lineNum, original }] }
+ */
+function parseComposeFlags(composePath) {
+  const content = fs.readFileSync(composePath, "utf8");
+  const lines = content.split("\n");
+  const flags = {};
+
+  // Track which service block we're in
+  let currentService = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Service definition: exactly 2-space indent, ends with colon only
+    const svcMatch = line.match(/^  ([a-z][\w-]+):\s*$/);
+    if (svcMatch) {
+      currentService = svcMatch[1];
+    }
+
+    // Match MX_FF_* in both YAML map and list formats
+    // Map format:  MX_FF_NAME: "value"
+    const mapMatch = line.match(/\b(MX_FF_\w+)\s*:\s*"?(true|false)"?/);
+    // List format:  - MX_FF_NAME=value
+    const listMatch = !mapMatch && line.match(/[-]\s*(MX_FF_\w+)\s*=\s*(true|false)/);
+
+    const match = mapMatch || listMatch;
+    if (match) {
+      const name = match[1];
+      const value = match[2] === "true";
+
+      if (!flags[name]) {
+        flags[name] = { value, services: new Set(), lines: [] };
+      }
+      flags[name].lines.push({ lineNum: i, original: line });
+      if (currentService) flags[name].services.add(currentService);
+      // If any occurrence is true, treat the flag as enabled
+      if (value) flags[name].value = true;
+    }
+  }
+
+  return flags;
+}
+
+/**
+ * Update docker-compose.yaml by flipping flag values on specific lines.
+ */
+function updateComposeFlags(composePath, changes) {
+  const content = fs.readFileSync(composePath, "utf8");
+  const lines = content.split("\n");
+
+  for (const { lineNum, newValue } of changes) {
+    const line = lines[lineNum];
+    lines[lineNum] = line
+      .replace(/(MX_FF_\w+\s*:\s*)"?(true|false)"?/, `$1"${newValue}"`)
+      .replace(/(MX_FF_\w+=)(true|false)/, `$1${newValue}`);
+  }
+
+  fs.writeFileSync(composePath, lines.join("\n"));
+}
+
+/**
+ * Interactive feature flag configuration.
+ * Reads flags from compose, presents toggle UI, applies changes, restarts services.
+ */
+export async function runFeatureFlags(root) {
+  const composePath = path.join(root, "docker-compose.yaml");
+  if (!fs.existsSync(composePath)) {
+    console.log(chalk.red("  No docker-compose.yaml found."));
+    return;
+  }
+
+  console.log(chalk.bold.cyan("\n  Feature Flags\n"));
+
+  // Parse current state from compose
+  const composeFlags = parseComposeFlags(composePath);
+
+  // Build the full flag list: compose flags + canonical flags not yet in compose
+  const allFlags = {};
+  for (const [name, info] of Object.entries(composeFlags)) {
+    allFlags[name] = { ...info, inCompose: true };
+  }
+  for (const name of Object.keys(KNOWN_FLAGS)) {
+    if (!allFlags[name]) {
+      allFlags[name] = { value: false, services: new Set(), lines: [], inCompose: false };
+    }
+  }
+
+  const flagNames = Object.keys(allFlags).sort();
+
+  // Show current state
+  for (const name of flagNames) {
+    const flag = allFlags[name];
+    const label = KNOWN_FLAGS[name] || name;
+    const services = flag.services.size > 0 ? chalk.dim(` (${[...flag.services].join(", ")})`) : "";
+    if (flag.value) {
+      console.log(chalk.green(`  ✓ ${label}`) + services);
+    } else {
+      console.log(chalk.dim(`  · ${label}`) + services);
+    }
+  }
+  console.log("");
+
+  // Checkbox prompt
+  const choices = flagNames.map((name) => ({
+    name: KNOWN_FLAGS[name] || name,
+    value: name,
+    checked: allFlags[name].value,
+  }));
+
+  const { enabled } = await inquirer.prompt([{
+    type: "checkbox",
+    name: "enabled",
+    message: "Toggle feature flags:",
+    choices,
+  }]);
+
+  // Calculate changes
+  const changes = [];
+  const affectedServices = new Set();
+
+  for (const name of flagNames) {
+    const flag = allFlags[name];
+    const newValue = enabled.includes(name);
+
+    if (newValue !== flag.value) {
+      if (flag.inCompose) {
+        for (const line of flag.lines) {
+          changes.push({ lineNum: line.lineNum, newValue: String(newValue) });
+        }
+        for (const svc of flag.services) affectedServices.add(svc);
+      } else if (newValue) {
+        console.log(chalk.yellow(`  ⚠ ${KNOWN_FLAGS[name] || name} not in docker-compose.yaml — add it to service environments to take effect`));
+      }
+    }
+  }
+
+  if (changes.length === 0) {
+    console.log(chalk.dim("\n  No changes.\n"));
+    return;
+  }
+
+  // Apply changes to compose file
+  updateComposeFlags(composePath, changes);
+  console.log(chalk.green(`\n  ✓ Updated ${changes.length} flag value(s) in docker-compose.yaml`));
+
+  if (affectedServices.size === 0) {
+    console.log("");
+    return;
+  }
+
+  // Restart affected services
+  const serviceList = [...affectedServices];
+  console.log(chalk.dim(`  Affected: ${serviceList.join(", ")}`));
+
+  const { restart } = await inquirer.prompt([{
+    type: "confirm",
+    name: "restart",
+    message: `Restart ${serviceList.length} service(s)?`,
+    default: true,
+  }]);
+
+  if (restart) {
+    console.log(chalk.cyan(`\n  ▶ docker compose up -d ${serviceList.join(" ")}\n`));
+    await execa("docker", ["compose", "up", "-d", ...serviceList], {
+      cwd: root,
+      stdio: "inherit",
+      reject: false,
+      timeout: 120_000,
+    });
+    console.log(chalk.green("\n  ✓ Services restarted.\n"));
+  } else {
+    console.log(chalk.dim("\n  Changes saved. Restart manually: docker compose up -d\n"));
+  }
+}

package/src/plugins/api.js

@@ -42,5 +42,19 @@ export function createPluginApi(pluginId, registry) {
         search: source.search,
       });
     },
+
+    registerAutoRunPattern(pattern) {
+      registry.autoRunPatterns.push({ pluginId, pattern });
+    },
+
+    registerAgent(agent) {
+      registry.agents.push({
+        pluginId,
+        name: agent.name,
+        description: agent.description || "",
+        systemPrompt: agent.systemPrompt,
+        contextMode: agent.contextMode || "full",
+      });
+    },
   };
 }

package/src/plugins/builtins/stack-api.js

@@ -0,0 +1,36 @@
+import http from "node:http";
+
+/**
+ * Built-in Stack API plugin.
+ * Registers a doctor check (health ping) and auto-run patterns for curl commands.
+ */
+export function register(api) {
+  // Doctor check — ping GET /health on localhost:3090
+  api.registerDoctorCheck({
+    name: "Stack API",
+    fn: async (ok, warn) => {
+      try {
+        const body = await new Promise((resolve, reject) => {
+          const req = http.get("http://localhost:3090/health", { timeout: 3000 }, (res) => {
+            let data = "";
+            res.on("data", (chunk) => { data += chunk; });
+            res.on("end", () => {
+              if (res.statusCode === 200) resolve(data);
+              else reject(new Error(`HTTP ${res.statusCode}`));
+            });
+          });
+          req.on("error", reject);
+          req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
+        });
+        ok("Stack API", `healthy — ${body.trim().slice(0, 60)}`);
+      } catch {
+        warn("Stack API", "not reachable on localhost:3090");
+      }
+    },
+  });
+
+  // Auto-run: GET curl commands to the stack API execute without confirmation
+  api.registerAutoRunPattern("curl http://localhost:3090/");
+  api.registerAutoRunPattern("curl -s http://localhost:3090/");
+  api.registerAutoRunPattern("curl --silent http://localhost:3090/");
+}

package/src/plugins/loader.js

@@ -1,10 +1,50 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { createRegistry } from "./registry.js";
 import { validateManifest } from "./manifest.js";
 import { discoverPlugins } from "./discovery.js";
 import { createPluginApi } from "./api.js";
+import { loadBuiltinAgents } from "../agent/agents.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Ensure ~/.fops/plugins/node_modules symlinks to the CLI's node_modules.
+ * This lets global plugins resolve bare imports (chalk, execa, inquirer, etc.)
+ * via Node's upward directory walk.
+ */
+function ensurePluginNodeModules() {
+  const cliNodeModules = path.resolve(__dirname, "../../node_modules");
+  const pluginsDir = path.join(os.homedir(), ".fops", "plugins");
+  const link = path.join(pluginsDir, "node_modules");
+
+  if (!fs.existsSync(cliNodeModules)) return;
+  if (!fs.existsSync(pluginsDir)) return;
+
+  try {
+    const stat = fs.lstatSync(link);
+    // Already a symlink — check it points to the right place
+    if (stat.isSymbolicLink()) {
+      const target = fs.readlinkSync(link);
+      if (path.resolve(pluginsDir, target) === cliNodeModules) return;
+      // Stale symlink — remove and recreate
+      fs.unlinkSync(link);
+    } else {
+      // Not a symlink (somehow a real dir) — leave it alone
+      return;
+    }
+  } catch {
+    // Doesn't exist — create it
+  }
+
+  try {
+    fs.symlinkSync(cliNodeModules, link, "junction");
+  } catch {
+    // Non-fatal — plugins that use only node: builtins still work
+  }
+}
 
 /**
  * Parse SKILL.md frontmatter (lightweight, same logic as skills.js).
@@ -37,12 +77,39 @@ function isPluginEnabled(pluginId) {
   return true;
 }
 
+/**
+ * Load built-in plugins from ./builtins/ directory.
+ * Each module must export a register(api) function.
+ */
+async function loadBuiltinPlugins(registry) {
+  const builtinsDir = path.join(__dirname, "builtins");
+  if (!fs.existsSync(builtinsDir)) return;
+
+  const entries = fs.readdirSync(builtinsDir).filter((f) => f.endsWith(".js"));
+  for (const file of entries) {
+    try {
+      const mod = await import(path.join(builtinsDir, file));
+      const plugin = mod.default || mod;
+      if (typeof plugin.register === "function") {
+        const pluginId = `builtin:${path.basename(file, ".js")}`;
+        const api = createPluginApi(pluginId, registry);
+        await plugin.register(api);
+      }
+    } catch (err) {
+      console.error(`  Built-in plugin "${file}" failed to load: ${err.message}`);
+    }
+  }
+}
+
 /**
  * Load and activate all discovered plugins.
  * Returns a populated PluginRegistry.
  */
 export async function loadPlugins() {
+  ensurePluginNodeModules();
   const registry = createRegistry();
+  loadBuiltinAgents(registry);
+  await loadBuiltinPlugins(registry);
   const candidates = discoverPlugins();
 
   for (const candidate of candidates) {

package/src/plugins/registry.js

@@ -11,5 +11,7 @@ export function createRegistry() {
     hooks: [],         // { pluginId, event, handler, priority }
     skills: [],        // { pluginId, name, description, content }
     knowledgeSources: [], // { pluginId, name, description, search }
+    autoRunPatterns: [], // { pluginId, pattern: string } — commands matching these prefixes auto-execute
+    agents: [],        // { pluginId, name, description, systemPrompt, contextMode }
   };
 }

package/src/project.js

@@ -49,12 +49,31 @@ export function rootDir(cwd = process.cwd()) {
   return null;
 }
 
+/**
+ * Check whether the Foundation project is fully initialised.
+ * Returns null when ready, or a short reason string when not.
+ */
+export function checkInitState(root) {
+  if (!root) return "no project root";
+  if (!fs.existsSync(path.join(root, ".env"))) return "missing .env";
+  // Check that at least one submodule dir has content
+  const markers = ["foundation-backend", "foundation-frontend", "foundation-storage-engine"];
+  const empty = markers.filter((d) => {
+    const dir = path.join(root, d);
+    if (!fs.existsSync(dir)) return true;
+    try { return fs.readdirSync(dir).length === 0; } catch { return true; }
+  });
+  if (empty.length === markers.length) return "submodules not cloned";
+  return null;
+}
+
 export function requireRoot(program) {
   const r = rootDir();
   if (!r) {
     console.error(
-      chalk.red("Not a Foundation project (no docker-compose + Makefile). Run from foundation-compose or set FOUNDATION_ROOT.")
+      chalk.red("Not a Foundation project (no docker-compose + Makefile).")
     );
+    console.error(chalk.dim("  Run `fops init` to set up, or set FOUNDATION_ROOT."));
     program.error({ exitCode: 1 });
   }
   return r;

package/src/setup/aws.js

@@ -32,8 +32,8 @@ export function saveFopsConfig(config) {
  */
 export async function promptAwsSsoConfig() {
   console.log(chalk.cyan("\n  AWS SSO Configuration\n"));
-  console.log(chalk.gray("  We'll set up an AWS CLI profile for ECR image pulls."));
-  console.log(chalk.gray("  You can find these values in your AWS SSO portal.\n"));
+  console.log(chalk.dim("  We'll set up an AWS CLI profile for ECR image pulls."));
+  console.log(chalk.dim("  You can find these values in your AWS SSO portal.\n"));
 
   const answers = await inquirer.prompt([
     {
@@ -143,7 +143,7 @@ export function detectAwsSsoProfiles() {
  */
 function ask(question, defaultVal) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const suffix = defaultVal ? chalk.gray(` (${defaultVal})`) : "";
+  const suffix = defaultVal ? chalk.dim(` (${defaultVal})`) : "";
   return new Promise((resolve) => {
     rl.question(`  ${question}${suffix}: `, (answer) => {
       rl.close();
@@ -164,7 +164,7 @@ export async function ensureSsoConfig() {
   if (/sso_start_url\s*=/.test(content)) return; // already configured
 
   console.log(chalk.cyan("\n  AWS SSO is not configured. Let's set it up.\n"));
-  console.log(chalk.gray("  You can find these values in your AWS SSO portal.\n"));
+  console.log(chalk.dim("  You can find these values in your AWS SSO portal.\n"));
 
   const sessionName = await ask("SSO session name", "meshx");
   const startUrl = await ask("SSO start URL");
@@ -212,7 +212,7 @@ export async function fixAwsSso() {
   }
 
   const profile = profiles[0];
-  console.log(chalk.gray(`  Using AWS profile: ${profile.name}`));
+  console.log(chalk.dim(`  Using AWS profile: ${profile.name}`));
   console.log(chalk.cyan(`  ▶ aws sso login --profile ${profile.name}`));
 
   // Open /dev/tty directly so SSO login gets a real terminal even when
@@ -358,8 +358,8 @@ export async function checkEcrRepos(dir, awsConfig) {
     const missing = neededRepos.filter((r) => !existingRepos.includes(r));
     if (missing.length > 0) {
       console.log(chalk.yellow("\n⚠ These ECR repos are referenced but don't exist (will need local build):"));
-      for (const r of missing) console.log(chalk.gray(`  ✗ ${r}`));
-      console.log(chalk.gray("  These services will be built from source instead.\n"));
+      for (const r of missing) console.log(chalk.dim(`  ✗ ${r}`));
+      console.log(chalk.dim("  These services will be built from source instead.\n"));
     } else {
       console.log(chalk.green("All required ECR repos exist."));
     }

package/src/setup/setup.js

@@ -24,7 +24,7 @@ export function runSetup(dir, opts = {}) {
         fs.copyFileSync(envExample, envPath);
         console.log(chalk.green("Created .env from .env.example. Edit .env with your settings."));
       } else if (fs.existsSync(envPath)) {
-        console.log(chalk.gray(".env already exists."));
+        console.log(chalk.dim(".env already exists."));
       }
     }
     if (netrcCheck) {
@@ -33,25 +33,26 @@ export function runSetup(dir, opts = {}) {
       const hasGitHub = hasNetrc && fs.readFileSync(netrcPath, "utf8").includes("machine github.com");
       if (!hasGitHub) {
         console.log(chalk.yellow("⚠ GitHub: ensure ~/.netrc has credentials for github.com (needed for submodules)."));
-        console.log(chalk.gray("  See README: Configure GitHub Authentication"));
+        console.log(chalk.dim("  See README: Configure GitHub Authentication"));
       }
     }
     if (submodules) {
       console.log(chalk.blue(`Initializing git submodules (checking out ${CLONE_BRANCH})...`));
       try {
-        await execa("git", ["submodule", "update", "--init", "--remote", "--recursive"], { cwd: dir, stdio: "inherit" });
+        await execa("git", ["submodule", "update", "--init", "--force", "--remote", "--recursive"], { cwd: dir, stdio: "inherit" });
         // Check out the target branch on each submodule
         await execa("git", ["submodule", "foreach", `git fetch origin && git checkout origin/${CLONE_BRANCH} 2>/dev/null || git checkout origin/main`], { cwd: dir, stdio: "inherit" });
         console.log(chalk.green(`Submodules initialized — on ${CLONE_BRANCH} (falling back to main).`));
       } catch {
-        console.log(chalk.yellow(`⚠ Some submodules had issues. Attempting to check out ${CLONE_BRANCH} individually...`));
+        console.log(chalk.yellow(`⚠ Some submodules had issues. Attempting to recover individually...`));
         try {
-          await execa("git", ["submodule", "init"], { cwd: dir, stdio: "inherit" });
+          await execa("git", ["submodule", "absorbgitdirs"], { cwd: dir, stdio: "inherit" });
+          await execa("git", ["submodule", "update", "--init", "--force", "--recursive"], { cwd: dir, stdio: "inherit" });
           await execa("git", ["submodule", "foreach", `git fetch origin && git checkout origin/${CLONE_BRANCH} 2>/dev/null || git checkout origin/main`], { cwd: dir, stdio: "inherit" });
           console.log(chalk.green("Submodules recovered."));
         } catch {
           console.log(chalk.yellow("Some submodules still failed. Fix manually with:"));
-          console.log(chalk.gray(`  cd ${dir} && git submodule foreach 'git checkout ${CLONE_BRANCH} || git checkout main && git pull'`));
+          console.log(chalk.dim(`  cd ${dir} && git submodule foreach 'git checkout ${CLONE_BRANCH} || git checkout main && git pull'`));
         }
       }
     }
@@ -101,7 +102,7 @@ export function runSetup(dir, opts = {}) {
           else fs.writeFileSync(awsConfigPath, ssoConfig, { mode: 0o600 });
           console.log(chalk.green(`  Created AWS profile '${awsConfig.profileName}' in ~/.aws/config`));
         } else {
-          console.log(chalk.gray("  Skipping AWS setup. Private ECR images won't be available."));
+          console.log(chalk.dim("  Skipping AWS setup. Private ECR images won't be available."));
           console.log(chalk.blue("Downloading public container images..."));
           try {
             await make(dir, "download");
@@ -157,8 +158,8 @@ export function runSetup(dir, opts = {}) {
         await make(dir, "download");
       } catch {
         console.log(chalk.yellow("\n⚠ Some images failed to download. Public images are fine."));
-        console.log(chalk.gray(`  For private ECR images, ensure: aws sso login --profile ${awsConfig.profileName}`));
-        console.log(chalk.gray("  Then re-run: fops init --download\n"));
+        console.log(chalk.dim(`  For private ECR images, ensure: aws sso login --profile ${awsConfig.profileName}`));
+        console.log(chalk.dim("  Then re-run: fops init --download\n"));
       }
     }
     console.log(chalk.green("Setup complete. Run: fops up"));