@ijfw/install 1.2.10 → 1.3.0

package/dist/install.js

@@ -1,28 +1,1790 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/install-helpers.js
+import {
+  existsSync as existsSync3,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  renameSync as renameSync2,
+  copyFileSync,
+  chmodSync,
+  mkdirSync as mkdirSync2,
+  realpathSync,
+  statSync
+} from "node:fs";
+import { dirname as dirname3, basename, join as join3, normalize, delimiter } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { createHash } from "node:crypto";
+function printOk(msg) {
+  process.stdout.write(`  [ok] ${msg}
+`);
+}
+function printNote(msg) {
+  process.stdout.write(`  [--] ${msg}
+`);
+}
+function printInfo(msg) {
+  process.stdout.write(`  -- ${msg}
+`);
+}
+function printWarn(msg) {
+  process.stdout.write(`  [!] ${msg}
+`);
+}
+function printSection(name) {
+  process.stdout.write(`
+[${name}]
+`);
+}
+function homeReal() {
+  const h = homedir2();
+  try {
+    return realpathSync(h);
+  } catch {
+    return h;
+  }
+}
+function nativePath(p) {
+  if (p == null) return p;
+  return normalize(String(p));
+}
+function writeAtomic(path3, contents, opts = {}) {
+  const mode = opts.mode ?? 384;
+  mkdirSync2(dirname3(path3), { recursive: true });
+  const tmp = `${path3}.tmp.${process.pid}`;
+  writeFileSync2(tmp, contents, { mode });
+  renameSync2(tmp, path3);
+  try {
+    chmodSync(path3, mode);
+  } catch {
+  }
+}
+function backup(path3, ts) {
+  try {
+    const st = statSync(path3);
+    if (!st.isFile()) return null;
+  } catch {
+    return null;
+  }
+  const dst = `${path3}.bak.${ts}`;
+  try {
+    copyFileSync(path3, dst);
+    printInfo(`backup: ${basename(path3)}.bak.${ts}`);
+    return dst;
+  } catch {
+    return null;
+  }
+}
+function safeChecksum(path3) {
+  try {
+    return createHash("sha1").update(readFileSync2(path3)).digest("hex");
+  } catch {
+    return "";
+  }
+}
+function installHook(src, dst, ts) {
+  if (!existsSync3(src)) return;
+  if (existsSync3(dst)) {
+    const srcSum = safeChecksum(src);
+    const dstSum = safeChecksum(dst);
+    if (!srcSum || !dstSum) {
+      try {
+        copyFileSync(dst, `${dst}.bak.${ts}`);
+      } catch {
+      }
+      printNote(`Updated ${basename(dst)} (no checksum util on host -- precautionary backup)`);
+    } else if (srcSum === dstSum) {
+      return;
+    } else {
+      try {
+        copyFileSync(dst, `${dst}.bak.${ts}`);
+      } catch {
+      }
+      printNote(`Updated ${basename(dst)} (your custom version backed up to ${basename(dst)}.bak.${ts})`);
+    }
+  }
+  mkdirSync2(dirname3(dst), { recursive: true });
+  copyFileSync(src, dst);
+  if (!IS_WIN) {
+    try {
+      chmodSync(dst, 493);
+    } catch {
+    }
+  }
+}
+function which(bin) {
+  if (!bin) return null;
+  const path3 = process.env.PATH || "";
+  const parts = path3.split(delimiter).filter(Boolean);
+  const exts = IS_WIN ? (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM").split(";").map((e) => e.toLowerCase()) : [""];
+  for (const dir of parts) {
+    for (const ext of exts) {
+      const candidate = join3(dir, bin + ext);
+      try {
+        if (existsSync3(candidate)) return candidate;
+      } catch {
+      }
+    }
+  }
+  return null;
+}
+function hasBin(bin) {
+  return which(bin) != null;
+}
+function isLive(targetId, home) {
+  const H = home || homeReal();
+  const APPDATA = process.env.APPDATA || "";
+  const appdataOr = (rel) => APPDATA ? join3(APPDATA, rel) : null;
+  switch (targetId) {
+    case "claude":
+      return hasBin("claude") || existsSync3(join3(H, ".claude"));
+    case "codex":
+      return hasBin("codex") || existsSync3(join3(H, ".codex"));
+    case "gemini":
+      return hasBin("gemini") || existsSync3(join3(H, ".gemini"));
+    case "cursor":
+      return hasBin("cursor");
+    case "windsurf":
+      return hasBin("windsurf") || existsSync3(join3(H, ".codeium", "windsurf"));
+    case "copilot": {
+      if (hasBin("code")) return true;
+      const candidates = [
+        join3(H, ".vscode"),
+        join3(H, ".config", "Code"),
+        join3(H, "Library", "Application Support", "Code"),
+        appdataOr("Code")
+      ].filter(Boolean);
+      return candidates.some((p) => existsSync3(p));
+    }
+    case "hermes":
+      return hasBin("hermes") || existsSync3(join3(H, ".hermes"));
+    case "wayland":
+      return hasBin("wayland") || existsSync3(join3(H, ".wayland"));
+    case "opencode":
+      return hasBin("opencode") || existsSync3(join3(H, ".config", "opencode"));
+    case "qwen":
+      return hasBin("qwen") || existsSync3(join3(H, ".qwen"));
+    case "cline": {
+      const ext = "saoudrizwan.claude-dev";
+      const candidates = [
+        // macOS
+        join3(H, "Library", "Application Support", "Code", "User", "globalStorage", ext),
+        join3(H, "Library", "Application Support", "Code - Insiders", "User", "globalStorage", ext),
+        join3(H, "Library", "Application Support", "VSCodium", "User", "globalStorage", ext),
+        // Linux
+        join3(H, ".config", "Code", "User", "globalStorage", ext),
+        join3(H, ".config", "VSCodium", "User", "globalStorage", ext),
+        join3(H, ".var", "app", "com.visualstudio.code", "config", "Code", "User", "globalStorage", ext),
+        join3(H, "snap", "code", "current", ".config", "Code", "User", "globalStorage", ext),
+        // Windows
+        appdataOr(join3("Code", "User", "globalStorage", ext)),
+        appdataOr(join3("Code - Insiders", "User", "globalStorage", ext)),
+        appdataOr(join3("VSCodium", "User", "globalStorage", ext)),
+        // Catch-all extensions dir
+        join3(H, ".vscode", "extensions")
+      ].filter(Boolean);
+      return candidates.some((p) => existsSync3(p));
+    }
+    case "kimi":
+      return hasBin("kimi") || existsSync3(join3(H, ".kimi"));
+    case "openclaw":
+      return hasBin("openclaw") || existsSync3(join3(H, ".openclaw"));
+    case "aider":
+      return hasBin("aider") || existsSync3(join3(H, ".aider.conf.yml"));
+    default:
+      return false;
+  }
+}
+function prettyName(targetId) {
+  const map = {
+    claude: "Claude Code",
+    codex: "Codex",
+    gemini: "Gemini",
+    cursor: "Cursor",
+    windsurf: "Windsurf",
+    copilot: "Copilot",
+    hermes: "Hermes",
+    wayland: "Wayland",
+    opencode: "OpenCode",
+    qwen: "Qwen Code",
+    cline: "Cline",
+    kimi: "Kimi Code",
+    openclaw: "OpenClaw",
+    aider: "Aider"
+  };
+  return map[targetId] || String(targetId);
+}
+function readJsonOrEmpty(path3) {
+  if (!existsSync3(path3)) return {};
+  try {
+    const raw = readFileSync2(path3, "utf8") || "{}";
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    return parsed;
+  } catch {
+    return {};
+  }
+}
+function mergeJson(dst, serverJs, ts) {
+  mkdirSync2(dirname3(dst), { recursive: true });
+  if (ts) backup(dst, ts);
+  const doc = readJsonOrEmpty(dst);
+  if (!doc.mcpServers || typeof doc.mcpServers !== "object") doc.mcpServers = {};
+  const isWin = IS_WIN;
+  const nodeDir = dirname3(process.execPath);
+  const home = homedir2();
+  const candidatePaths = isWin ? [] : [
+    nodeDir,
+    "/opt/homebrew/bin",
+    "/usr/local/bin",
+    `${home}/.nvm/versions/node/${process.version}/bin`,
+    "/usr/bin",
+    "/bin"
+  ];
+  const envPath = candidatePaths.filter((d) => {
+    try {
+      return typeof d === "string" && d.length > 0 && existsSync3(d);
+    } catch {
+      return false;
+    }
+  }).join(":");
+  const entry = { command: "node", args: [serverJs] };
+  if (envPath) entry.env = { PATH: envPath };
+  doc.mcpServers["ijfw-memory"] = entry;
+  writeAtomic(dst, JSON.stringify(doc, null, 2) + "\n", { mode: 384 });
+}
+function mergeToml(dst, serverJs, ts) {
+  mkdirSync2(dirname3(dst), { recursive: true });
+  if (ts) backup(dst, ts);
+  let text = "";
+  try {
+    text = existsSync3(dst) ? readFileSync2(dst, "utf8") : "";
+  } catch {
+    text = "";
+  }
+  text = stripTomlSection(text, "mcp_servers.ijfw-memory");
+  if (/^\[features\]/m.test(text)) {
+    if (!/^codex_hooks\s*=/m.test(text)) {
+      text = text.replace(/^(\[features\][^\n]*\n)/m, "$1codex_hooks = true\n");
+    }
+  } else {
+    text = text.replace(/\n+$/, "") + "\n\n[features]\ncodex_hooks = true\n";
+  }
+  if (!/^suppress_unstable_features_warning\s*=/m.test(text)) {
+    if (/^\[/m.test(text)) {
+      text = text.replace(/^(\[)/m, "suppress_unstable_features_warning = true\n\n$1");
+    } else {
+      text = text.replace(/\n+$/, "") + "\nsuppress_unstable_features_warning = true\n";
+    }
+  }
+  const escaped = String(serverJs).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  let block = "";
+  if (text && !text.endsWith("\n")) block += "\n";
+  block += "\n[mcp_servers.ijfw-memory]\n";
+  block += 'command = "node"\n';
+  block += `args = ["${escaped}"]
+`;
+  block += "enabled = true\n";
+  block += "startup_timeout_sec = 10\n";
+  block += "tool_timeout_sec = 30\n";
+  writeAtomic(dst, text + block, { mode: 384 });
+}
+function stripTomlSection(text, sectionName) {
+  const safe = sectionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const lines = text.split("\n");
+  const out = [];
+  let skip = false;
+  const headerRe = new RegExp(`^\\[${safe}\\][\\s]*$`);
+  for (const line of lines) {
+    if (headerRe.test(line)) {
+      skip = true;
+      continue;
+    }
+    if (skip && line.startsWith("[") && !headerRe.test(line)) skip = false;
+    if (skip) continue;
+    out.push(line);
+  }
+  return out.join("\n");
+}
+function mergeYamlMcp(dst, serverJs, ts) {
+  mkdirSync2(dirname3(dst), { recursive: true });
+  if (ts) backup(dst, ts);
+  let text = "";
+  try {
+    text = existsSync3(dst) ? readFileSync2(dst, "utf8") : "";
+  } catch {
+    text = "";
+  }
+  text = stripSentinelBlock(text, "# IJFW-MCP-BEGIN ijfw-memory", "# IJFW-MCP-END ijfw-memory");
+  if (!/^mcp_servers:/m.test(text)) {
+    if (text && !text.endsWith("\n")) text += "\n";
+    text += "\nmcp_servers:\n";
+  }
+  const escaped = String(serverJs).replace(/"/g, '\\"');
+  let block = "";
+  if (!text.endsWith("\n")) block += "\n";
+  block += "# IJFW-MCP-BEGIN ijfw-memory\n";
+  block += "  ijfw-memory:\n";
+  block += '    command: "node"\n';
+  block += `    args: ["${escaped}"]
+`;
+  block += "    enabled: true\n";
+  block += "# IJFW-MCP-END ijfw-memory\n";
+  writeAtomic(dst, text + block, { mode: 384 });
+}
+function stripSentinelBlock(text, beginMark, endMark) {
+  const lines = text.split("\n");
+  const out = [];
+  let skip = false;
+  for (const line of lines) {
+    if (line === beginMark) {
+      skip = true;
+      continue;
+    }
+    if (line === endMark) {
+      skip = false;
+      continue;
+    }
+    if (skip) continue;
+    out.push(line);
+  }
+  return out.join("\n");
+}
+function mergeYamlPluginsEnabled(dst, pluginName, ts) {
+  mkdirSync2(dirname3(dst), { recursive: true });
+  if (ts) backup(dst, ts);
+  let text = "";
+  try {
+    text = existsSync3(dst) ? readFileSync2(dst, "utf8") : "";
+  } catch {
+    text = "";
+  }
+  text = stripSentinelBlock(text, "# IJFW-PLUGINS-BEGIN", "# IJFW-PLUGINS-END");
+  const lines = text.split("\n");
+  let pluginsLineIdx = -1;
+  let enabledLineIdx = -1;
+  let inPluginsBlock = false;
+  let alreadyListed = false;
+  const itemRe = new RegExp(`^\\s+-\\s+${pluginName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\s*$`);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^plugins:\s*$/.test(line)) {
+      pluginsLineIdx = i;
+      inPluginsBlock = true;
+      continue;
+    }
+    if (inPluginsBlock) {
+      if (/^\S/.test(line) && line.trim() !== "") {
+        inPluginsBlock = false;
+      } else if (/^\s+enabled:\s*(\[\s*\])?\s*$/.test(line) || /^\s+enabled:\s*\[.*\]\s*$/.test(line)) {
+        enabledLineIdx = i;
+      } else if (enabledLineIdx >= 0 && itemRe.test(line)) {
+        alreadyListed = true;
+      }
+    }
+  }
+  if (pluginsLineIdx < 0) {
+    if (text && !text.endsWith("\n")) text += "\n";
+    text += "\nplugins:\n";
+    const newLines = text.split("\n");
+    pluginsLineIdx = newLines.length - 2;
+    enabledLineIdx = -1;
+  }
+  let cur = text.split("\n");
+  if (enabledLineIdx < 0) {
+    cur.splice(pluginsLineIdx + 1, 0, "  enabled: []");
+    enabledLineIdx = pluginsLineIdx + 1;
+  }
+  if (!alreadyListed) {
+    const enabledLine = cur[enabledLineIdx];
+    if (/^\s+enabled:\s*\[\s*\]\s*$/.test(enabledLine)) {
+      cur[enabledLineIdx] = "  enabled:";
+      cur.splice(enabledLineIdx + 1, 0, `    - ${pluginName}`);
+    } else if (/^\s+enabled:\s*\[.+\]\s*$/.test(enabledLine)) {
+      cur[enabledLineIdx] = enabledLine.replace(/\]\s*$/, `, ${pluginName}]`);
+    } else {
+      cur.splice(enabledLineIdx + 1, 0, `    - ${pluginName}`);
+    }
+  }
+  let outText = cur.join("\n");
+  if (outText && !outText.endsWith("\n")) outText += "\n";
+  outText += "# IJFW-PLUGINS-BEGIN\n";
+  outText += `# plugin ${pluginName} registered by IJFW installer
+`;
+  outText += "# IJFW-PLUGINS-END\n";
+  writeAtomic(dst, outText, { mode: 384 });
+}
+function opencodeMerge(dst, serverJs, ts) {
+  mkdirSync2(dirname3(dst), { recursive: true });
+  if (ts) backup(dst, ts);
+  const doc = readJsonOrEmpty(dst);
+  if (!doc.mcp || typeof doc.mcp !== "object") doc.mcp = {};
+  doc.mcp["ijfw-memory"] = { type: "local", command: ["node", serverJs] };
+  writeAtomic(dst, JSON.stringify(doc, null, 2), { mode: 384 });
+}
+function openclawMerge(dst, serverJs, ts) {
+  mkdirSync2(dirname3(dst), { recursive: true });
+  if (ts) backup(dst, ts);
+  const doc = readJsonOrEmpty(dst);
+  if (!doc.mcp || typeof doc.mcp !== "object") doc.mcp = {};
+  if (!doc.mcp.servers || typeof doc.mcp.servers !== "object") doc.mcp.servers = {};
+  doc.mcp.servers["ijfw-memory"] = { command: "node", args: [serverJs] };
+  writeAtomic(dst, JSON.stringify(doc, null, 2), { mode: 384 });
+}
+function clineMerge(serverJs, home, ts) {
+  const H = home || homeReal();
+  const APPDATA = process.env.APPDATA || join3(H, "AppData", "Roaming");
+  const ext = "saoudrizwan.claude-dev";
+  let candidates;
+  let osDefault;
+  if (process.platform === "darwin") {
+    candidates = [
+      join3(H, "Library", "Application Support", "Code", "User"),
+      join3(H, "Library", "Application Support", "Code - Insiders", "User"),
+      join3(H, "Library", "Application Support", "VSCodium", "User")
+    ];
+    osDefault = join3(H, "Library", "Application Support", "Code", "User");
+  } else if (IS_WIN) {
+    candidates = [
+      join3(APPDATA, "Code", "User"),
+      join3(APPDATA, "Code - Insiders", "User"),
+      join3(APPDATA, "VSCodium", "User")
+    ];
+    osDefault = join3(APPDATA, "Code", "User");
+  } else {
+    candidates = [
+      join3(H, ".config", "Code", "User"),
+      join3(H, ".config", "VSCodium", "User"),
+      join3(H, ".var", "app", "com.visualstudio.code", "config", "Code", "User"),
+      join3(H, "snap", "code", "current", ".config", "Code", "User")
+    ];
+    osDefault = join3(H, ".config", "Code", "User");
+  }
+  let userDir = "";
+  for (const c of candidates) {
+    if (existsSync3(join3(c, "globalStorage", ext))) {
+      userDir = c;
+      break;
+    }
+  }
+  if (!userDir) userDir = osDefault;
+  const dst = join3(userDir, "globalStorage", ext, "settings", "cline_mcp_settings.json");
+  mkdirSync2(dirname3(dst), { recursive: true });
+  if (ts) backup(dst, ts);
+  const doc = readJsonOrEmpty(dst);
+  if (!doc.mcpServers || typeof doc.mcpServers !== "object") doc.mcpServers = {};
+  doc.mcpServers["ijfw-memory"] = {
+    type: "stdio",
+    command: "node",
+    args: [serverJs],
+    disabled: false,
+    autoApprove: [],
+    timeout: 60
+  };
+  writeAtomic(dst, JSON.stringify(doc, null, 2), { mode: 384 });
+  return dst;
+}
+var IS_WIN;
+var init_install_helpers = __esm({
+  "src/install-helpers.js"() {
+    IS_WIN = process.platform === "win32";
+  }
+});
+
+// src/install-targets-1-7.js
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync3,
+  readdirSync,
+  statSync as statSync2,
+  copyFileSync as copyFileSync2,
+  cpSync,
+  chmodSync as chmodSync2
+} from "node:fs";
+import { join as join4, dirname as dirname4, isAbsolute } from "node:path";
+import { platform } from "node:os";
+function ensureDir(p) {
+  try {
+    mkdirSync3(p, { recursive: true });
+  } catch {
+  }
+}
+function copyIfAbsent(src, dst) {
+  if (!existsSync4(src)) return false;
+  if (existsSync4(dst)) return false;
+  ensureDir(dirname4(dst));
+  try {
+    copyFileSync2(src, dst);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function copyDirIfAbsent(src, dst) {
+  if (!existsSync4(src)) return false;
+  if (existsSync4(dst)) return false;
+  ensureDir(dirname4(dst));
+  try {
+    cpSync(src, dst, { recursive: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function listSubdirs(parent) {
+  if (!existsSync4(parent)) return [];
+  let names;
+  try {
+    names = readdirSync(parent);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (name === "__pycache__") continue;
+    const path3 = join4(parent, name);
+    try {
+      if (statSync2(path3).isDirectory()) out.push({ name, path: path3 });
+    } catch {
+    }
+  }
+  return out;
+}
+function listFiles(parent, extFilter) {
+  if (!existsSync4(parent)) return [];
+  let names;
+  try {
+    names = readdirSync(parent);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    if (extFilter && !name.endsWith(extFilter)) continue;
+    const path3 = join4(parent, name);
+    try {
+      if (statSync2(path3).isFile()) out.push({ name, path: path3 });
+    } catch {
+    }
+  }
+  return out;
+}
+function customDirNoop(ctx, targetId, displayName, reason) {
+  ctx.log.info(reason);
+  ctx.log.ok(`${displayName}: real platform config left untouched.`);
+  return { status: "noop" };
+}
+async function installClaude(ctx) {
+  if (ctx.ijfwCustomDir) {
+    return customDirNoop(
+      ctx,
+      "claude",
+      "Claude Code",
+      "Custom-dir install -- skipping ~/.claude/settings.json merge."
+    );
+  }
+  const claudePluginPath = join4(ctx.home, ".ijfw", "claude");
+  const claudeSettings = join4(ctx.home, ".claude", "settings.json");
+  const claudeMarketplaces = join4(
+    ctx.home,
+    ".claude",
+    "plugins",
+    "known_marketplaces.json"
+  );
+  ensureDir(join4(ctx.home, ".claude", "plugins"));
+  backup(claudeSettings, ctx.ts);
+  let settings = {};
+  if (existsSync4(claudeSettings)) {
+    try {
+      settings = JSON.parse(readFileSync3(claudeSettings, "utf8") || "{}");
+    } catch {
+      settings = {};
+    }
+  }
+  if (!settings || typeof settings !== "object") settings = {};
+  settings.enabledPlugins = settings.enabledPlugins || {};
+  settings.enabledPlugins["ijfw@ijfw"] = true;
+  settings.extraKnownMarketplaces = settings.extraKnownMarketplaces || {};
+  settings.extraKnownMarketplaces["ijfw"] = {
+    source: { source: "directory", path: claudePluginPath }
+  };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let mp = {};
+  if (existsSync4(claudeMarketplaces)) {
+    try {
+      mp = JSON.parse(readFileSync3(claudeMarketplaces, "utf8") || "{}");
+    } catch {
+      mp = {};
+    }
+  }
+  if (!mp || typeof mp !== "object") mp = {};
+  mp["ijfw"] = {
+    source: { source: "directory", path: claudePluginPath },
+    installLocation: claudePluginPath,
+    lastUpdated: now
+  };
+  writeAtomic(claudeMarketplaces, JSON.stringify(mp, null, 2) + "\n");
+  const existing = settings.mcpServers && settings.mcpServers["ijfw-memory"];
+  if (existing && existing.command) {
+    const cmd = existing.command;
+    if (isAbsolute(cmd) && !existsSync4(cmd)) {
+      delete settings.mcpServers["ijfw-memory"];
+    }
+  }
+  settings.mcpServers = settings.mcpServers || {};
+  settings.mcpServers["ijfw-memory"] = {
+    command: "node",
+    args: [ctx.serverJsNative],
+    env: {}
+  };
+  writeAtomic(claudeSettings, JSON.stringify(settings, null, 2) + "\n");
+  const launcherPath = join4(ctx.repoRoot, "mcp-server", "bin", "ijfw-memory");
+  if (platform() !== "win32" && existsSync4(launcherPath)) {
+    try {
+      chmodSync2(launcherPath, 493);
+    } catch {
+    }
+  }
+  ctx.log.ok("Claude Code ready.");
+  ctx.log.note(`.claudeignore template at ${ctx.repoRoot}/claude/.claudeignore`);
+  ctx.log.note("  Copy to your project root for instant context savings.");
+  return { status: "ok", restart: false };
+}
+async function installCodex(ctx) {
+  if (ctx.ijfwCustomDir) {
+    return customDirNoop(
+      ctx,
+      "codex",
+      "Codex",
+      "Custom-dir install -- skipping ~/.codex/ merges."
+    );
+  }
+  const configToml = join4(ctx.home, ".codex", "config.toml");
+  ensureDir(dirname4(configToml));
+  mergeToml(configToml, ctx.serverJsNative);
+  const hooksDst = join4(ctx.home, ".codex", "hooks.json");
+  const hooksSrc = join4(ctx.repoRoot, "codex", ".codex", "hooks.json");
+  const hooksBase = join4(ctx.home, ".codex", "hooks");
+  ensureDir(hooksBase);
+  if (existsSync4(hooksSrc)) {
+    let doc = {};
+    let rawForBackup = null;
+    if (existsSync4(hooksDst)) {
+      rawForBackup = readFileSync3(hooksDst, "utf8");
+      try {
+        doc = JSON.parse(rawForBackup || "{}");
+      } catch {
+        doc = {};
+      }
+    }
+    const isLegacyShape = Array.isArray(doc) || doc && typeof doc === "object" && doc.hooks && (Array.isArray(doc.hooks) || typeof doc.hooks !== "object");
+    if (isLegacyShape && rawForBackup) {
+      const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const bk = `${hooksDst}.legacy.bak.${ts}`;
+      try {
+        writeFileSync3(bk, rawForBackup);
+        ctx.log.note(`preserved legacy hooks.json at ${bk}`);
+      } catch {
+      }
+    }
+    if (!doc || typeof doc !== "object" || Array.isArray(doc)) doc = {};
+    if (!doc.hooks || typeof doc.hooks !== "object" || Array.isArray(doc.hooks)) {
+      doc.hooks = {};
+    }
+    const VALID_EVENTS = [
+      "SessionStart",
+      "UserPromptSubmit",
+      "PreToolUse",
+      "PostToolUse",
+      "Stop",
+      "PermissionRequest"
+    ];
+    for (const ev of VALID_EVENTS) {
+      if (!Array.isArray(doc.hooks[ev])) doc.hooks[ev] = [];
+      doc.hooks[ev] = doc.hooks[ev].filter((g) => {
+        if (!g || !Array.isArray(g.hooks)) return true;
+        return !g.hooks.some((h) => h && h._ijfw);
+      });
+    }
+    const shellQuote = (p) => {
+      if (/^[A-Za-z0-9_./@-]+$/.test(p)) return p;
+      return "'" + p.replace(/'/g, "'\\''") + "'";
+    };
+    let ijfw = {};
+    try {
+      ijfw = JSON.parse(readFileSync3(hooksSrc, "utf8"));
+    } catch {
+      ijfw = {};
+    }
+    const srcHooks = ijfw && ijfw.hooks ? ijfw.hooks : {};
+    for (const [ev, groups] of Object.entries(srcHooks)) {
+      if (!VALID_EVENTS.includes(ev)) continue;
+      if (!Array.isArray(groups)) continue;
+      for (const g of groups) {
+        if (!g || !Array.isArray(g.hooks)) continue;
+        const rewritten = g.hooks.map((h) => {
+          if (!h || h.type !== "command" || !h.command) return h;
+          const rel = String(h.command).replace(/^hooks\//, "");
+          const cmd = shellQuote(`${hooksBase}/${rel}`);
+          return { ...h, command: cmd };
+        });
+        doc.hooks[ev].push({
+          ...g.matcher ? { matcher: g.matcher } : {},
+          hooks: rewritten
+        });
+      }
+    }
+    writeAtomic(hooksDst, JSON.stringify(doc, null, 2) + "\n");
+  }
+  const hookScriptsDir = join4(ctx.repoRoot, "codex", ".codex", "hooks");
+  for (const f of listFiles(hookScriptsDir, ".sh")) {
+    installHook(f.path, join4(hooksBase, f.name), ctx.ts);
+  }
+  const codexCtx = join4(ctx.home, ".codex", "IJFW.md");
+  copyIfAbsent(join4(ctx.repoRoot, "codex", ".codex", "IJFW.md"), codexCtx);
+  const userSkills = join4(ctx.home, ".codex", "skills");
+  ensureDir(userSkills);
+  const repoSkills = join4(ctx.repoRoot, "codex", "skills");
+  for (const sd of listSubdirs(repoSkills)) {
+    copyDirIfAbsent(sd.path, join4(userSkills, sd.name));
+  }
+  const cwd = ctx.cwd || process.cwd();
+  if (existsSync4(join4(cwd, ".codex", "config.toml")) || existsSync4(join4(cwd, ".ijfw"))) {
+    const projSkills = join4(cwd, ".codex", "skills");
+    ensureDir(projSkills);
+    for (const sd of listSubdirs(repoSkills)) {
+      copyDirIfAbsent(sd.path, join4(projSkills, sd.name));
+    }
+  }
+  ctx.log.ok("Installed Codex bundle: MCP + hooks + 15 skills + context");
+  return { status: "ok" };
+}
+async function installGemini(ctx) {
+  if (ctx.ijfwCustomDir) {
+    return customDirNoop(
+      ctx,
+      "gemini",
+      "Gemini",
+      "Custom-dir install -- skipping ~/.gemini/ merges."
+    );
+  }
+  const dst = join4(ctx.home, ".gemini", "settings.json");
+  ensureDir(dirname4(dst));
+  mergeJson(dst, ctx.serverJsNative);
+  const extDst = join4(ctx.home, ".gemini", "extensions", "ijfw");
+  const extSrc = join4(ctx.repoRoot, "gemini", "extensions", "ijfw");
+  for (const sub of ["hooks", "skills", "commands", "agents", "policies"]) {
+    ensureDir(join4(extDst, sub));
+  }
+  for (const rel of [
+    "gemini-extension.json",
+    "IJFW.md",
+    "hooks/hooks.json",
+    "policies/ijfw.toml"
+  ]) {
+    const dstFile = join4(extDst, rel);
+    if (!existsSync4(dstFile)) {
+      ensureDir(dirname4(dstFile));
+      const srcFile = join4(extSrc, rel);
+      try {
+        if (existsSync4(srcFile)) copyFileSync2(srcFile, dstFile);
+      } catch {
+      }
+    }
+  }
+  const hooksJson = join4(extDst, "hooks", "hooks.json");
+  if (existsSync4(hooksJson)) {
+    let raw = "";
+    try {
+      raw = readFileSync3(hooksJson, "utf8");
+    } catch {
+      raw = "";
+    }
+    if (raw.includes("{{extensionPath}}")) {
+      const replaced = raw.split("{{extensionPath}}").join(extDst);
+      writeAtomic(hooksJson, replaced);
+    }
+  }
+  const hookScriptsDir = join4(extSrc, "hooks");
+  for (const f of listFiles(hookScriptsDir, ".sh")) {
+    installHook(f.path, join4(extDst, "hooks", f.name), ctx.ts);
+  }
+  const skillsSrc = join4(extSrc, "skills");
+  for (const sd of listSubdirs(skillsSrc)) {
+    copyDirIfAbsent(sd.path, join4(extDst, "skills", sd.name));
+  }
+  const cmdSrc = join4(extSrc, "commands");
+  for (const f of listFiles(cmdSrc, ".toml")) {
+    copyIfAbsent(f.path, join4(extDst, "commands", f.name));
+  }
+  const agentSrc = join4(extSrc, "agents");
+  for (const f of listFiles(agentSrc, ".md")) {
+    copyIfAbsent(f.path, join4(extDst, "agents", f.name));
+  }
+  ctx.log.ok("Installed Gemini bundle: MCP + extension + 15 skills + 11 hooks + policy");
+  return { status: "ok" };
+}
+async function installWayland(ctx) {
+  if (ctx.ijfwCustomDir) {
+    return customDirNoop(
+      ctx,
+      "wayland",
+      "Wayland",
+      "Custom-dir install -- skipping ~/.wayland/ merges."
+    );
+  }
+  const dst = join4(ctx.home, ".wayland", "config.yaml");
+  ensureDir(dirname4(dst));
+  mergeYamlMcp(dst, ctx.serverJsNative);
+  ensureDir(join4(ctx.home, ".wayland"));
+  copyIfAbsent(
+    join4(ctx.repoRoot, "wayland", "WAYLAND.md"),
+    join4(ctx.home, ".wayland", "WAYLAND.md")
+  );
+  ensureDir(join4(ctx.home, ".wayland", "skills"));
+  const sharedSkills = join4(ctx.repoRoot, "shared", "skills");
+  for (const sd of listSubdirs(sharedSkills)) {
+    copyDirIfAbsent(sd.path, join4(ctx.home, ".wayland", "skills", sd.name));
+  }
+  const pluginSrc = join4(ctx.repoRoot, "wayland", "plugins", "ijfw");
+  if (existsSync4(pluginSrc)) {
+    const pluginDst = join4(ctx.home, ".wayland", "plugins", "ijfw");
+    ensureDir(pluginDst);
+    let entries;
+    try {
+      entries = readdirSync(pluginSrc);
+    } catch {
+      entries = [];
+    }
+    for (const name of entries) {
+      if (name === "__pycache__") continue;
+      const src = join4(pluginSrc, name);
+      const dstEntry = join4(pluginDst, name);
+      try {
+        const st = statSync2(src);
+        if (st.isDirectory()) {
+          cpSync(src, dstEntry, { recursive: true, force: true });
+        } else if (st.isFile()) {
+          copyFileSync2(src, dstEntry);
+        }
+      } catch {
+      }
+    }
+  }
+  ctx.log.ok("Installed Wayland bundle: MCP + WAYLAND.md + skills + plugin");
+  return { status: "ok" };
+}
+async function installHermes(ctx) {
+  if (ctx.ijfwCustomDir) {
+    return customDirNoop(
+      ctx,
+      "hermes",
+      "Hermes",
+      "Custom-dir install -- skipping ~/.hermes/ merges."
+    );
+  }
+  const dst = join4(ctx.home, ".hermes", "config.yaml");
+  ensureDir(dirname4(dst));
+  mergeYamlMcp(dst, ctx.serverJsNative);
+  ensureDir(join4(ctx.home, ".hermes"));
+  copyIfAbsent(
+    join4(ctx.repoRoot, "hermes", "HERMES.md"),
+    join4(ctx.home, ".hermes", "HERMES.md")
+  );
+  ensureDir(join4(ctx.home, ".hermes", "skills"));
+  const sharedSkills = join4(ctx.repoRoot, "shared", "skills");
+  for (const sd of listSubdirs(sharedSkills)) {
+    copyDirIfAbsent(sd.path, join4(ctx.home, ".hermes", "skills", sd.name));
+  }
+  const pluginSrc = join4(ctx.repoRoot, "hermes", "plugins", "ijfw");
+  if (existsSync4(pluginSrc)) {
+    const pluginDst = join4(ctx.home, ".hermes", "plugins", "ijfw");
+    ensureDir(pluginDst);
+    let entries;
+    try {
+      entries = readdirSync(pluginSrc);
+    } catch {
+      entries = [];
+    }
+    for (const name of entries) {
+      if (name === "__pycache__") continue;
+      const src = join4(pluginSrc, name);
+      const dstEntry = join4(pluginDst, name);
+      try {
+        const st = statSync2(src);
+        if (st.isDirectory()) {
+          cpSync(src, dstEntry, { recursive: true, force: true });
+        } else if (st.isFile()) {
+          copyFileSync2(src, dstEntry);
+        }
+      } catch {
+      }
+    }
+  }
+  mergeYamlPluginsEnabled(dst, "ijfw");
+  ctx.log.ok("Installed Hermes bundle: MCP + HERMES.md + skills + plugin");
+  return { status: "ok" };
+}
+async function installCursor(ctx) {
+  if (ctx.isIjfwSource) {
+    ctx.log.info("IJFW source tree detected -- skipping Cursor project writes (would litter source).");
+    ctx.log.ok("Cursor: source tree left untouched.");
+    return { status: "noop" };
+  }
+  if (ctx.ijfwCustomDir) {
+    return customDirNoop(
+      ctx,
+      "cursor",
+      "Cursor",
+      "Custom-dir install -- skipping Cursor project writes."
+    );
+  }
+  const cwd = ctx.cwd || process.cwd();
+  const dst = join4(cwd, ".cursor", "mcp.json");
+  ensureDir(dirname4(dst));
+  mergeJson(dst, ctx.serverJsNative);
+  const rulesDir = join4(cwd, ".cursor", "rules");
+  ensureDir(rulesDir);
+  const ruleSrc = join4(ctx.repoRoot, "cursor", ".cursor", "rules", "ijfw.mdc");
+  if (existsSync4(ruleSrc)) {
+    try {
+      copyFileSync2(ruleSrc, join4(rulesDir, "ijfw.mdc"));
+    } catch {
+    }
+  }
+  ctx.log.ok("Merged MCP + installed rule to project ./.cursor/");
+  return { status: "ok" };
+}
+async function installWindsurf(ctx) {
+  if (ctx.ijfwCustomDir || ctx.isIjfwSource) {
+    return customDirNoop(
+      ctx,
+      "windsurf",
+      "Windsurf",
+      "Skipping Windsurf platform writes (custom-dir or IJFW source tree)."
+    );
+  }
+  const dst = join4(ctx.home, ".codeium", "windsurf", "mcp_config.json");
+  ensureDir(dirname4(dst));
+  mergeJson(dst, ctx.serverJsNative);
+  const cwd = ctx.cwd || process.cwd();
+  const projectRules = join4(cwd, ".windsurfrules");
+  const repoRules = join4(ctx.repoRoot, "windsurf", ".windsurfrules");
+  let installedRules = false;
+  if (!existsSync4(projectRules) && existsSync4(repoRules)) {
+    try {
+      copyFileSync2(repoRules, projectRules);
+      installedRules = true;
+    } catch {
+    }
+  }
+  if (installedRules) {
+    ctx.log.ok("Merged MCP + installed .windsurfrules");
+  } else {
+    ctx.log.ok(`Merged MCP into ${dst}`);
+  }
+  return { status: "ok" };
+}
+var init_install_targets_1_7 = __esm({
+  "src/install-targets-1-7.js"() {
+    init_install_helpers();
+  }
+});
+
+// src/install-targets-8-14.js
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync, spawnSync } from "node:child_process";
+function ensureDir2(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch {
+  }
+}
+function copyIfMissing(src, dst) {
+  try {
+    if (fs.existsSync(dst)) return false;
+    if (!fs.existsSync(src)) return false;
+    ensureDir2(path.dirname(dst));
+    fs.copyFileSync(src, dst);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function commandExists(name) {
+  const probeCmd = process.platform === "win32" ? "where" : "which";
+  const r = spawnSync(probeCmd, [name], { stdio: "ignore" });
+  return r.status === 0;
+}
+function installCopilot(ctx) {
+  if (ctx.ijfwCustomDir) {
+    printInfo("Custom-dir install -- skipping Copilot project writes.");
+    printOk("Copilot: real platform config left untouched.");
+    return { status: "noop" };
+  }
+  if (ctx.isIjfwSource) {
+    printInfo("IJFW source tree detected -- skipping Copilot project writes (would litter source).");
+    printOk("Copilot: source tree left untouched.");
+    return { status: "noop" };
+  }
+  const dst = path.join(process.cwd(), ".vscode", "mcp.json");
+  ensureDir2(path.dirname(dst));
+  mergeJson(dst, ctx.serverJsNative || ctx.serverJs);
+  const rulesDst = path.join(process.cwd(), ".github", "copilot-instructions.md");
+  const rulesSrc = path.join(ctx.repoRoot, "copilot", "copilot-instructions.md");
+  const wroteRules = copyIfMissing(rulesSrc, rulesDst);
+  if (wroteRules) {
+    printOk("Merged MCP + installed .github/copilot-instructions.md");
+  } else {
+    printOk("Merged MCP into project ./.vscode/mcp.json");
+  }
+  return { status: "ok" };
+}
+function installOpencode(ctx) {
+  if (ctx.ijfwCustomDir) {
+    printInfo("Custom-dir install -- skipping ~/.config/opencode/ merge.");
+    printOk("OpenCode: real platform config left untouched.");
+    return { status: "noop" };
+  }
+  const dst = path.join(ctx.home, ".config", "opencode", "opencode.json");
+  ensureDir2(path.dirname(dst));
+  opencodeMerge(dst, ctx.serverJsNative || ctx.serverJs);
+  printOk(`Merged MCP into ${dst} (opencode mcp.local schema)`);
+  return { status: "ok" };
+}
+function installQwen(ctx) {
+  if (ctx.ijfwCustomDir) {
+    printInfo("Custom-dir install -- skipping ~/.qwen/ merge.");
+    printOk("Qwen Code: real platform config left untouched.");
+    return { status: "noop" };
+  }
+  const dst = path.join(ctx.home, ".qwen", "settings.json");
+  ensureDir2(path.dirname(dst));
+  mergeJson(dst, ctx.serverJsNative || ctx.serverJs);
+  printOk(`Merged MCP into ${dst}`);
+  return { status: "ok" };
+}
+function installCline(ctx) {
+  if (ctx.ijfwCustomDir) {
+    printInfo("Custom-dir install -- skipping Cline merges.");
+    printOk("Cline: real platform config left untouched.");
+    return { status: "noop" };
+  }
+  const dst = clineMerge(ctx.serverJsNative || ctx.serverJs, ctx.home);
+  printOk(`Merged MCP into ${dst} (cline globalStorage schema)`);
+  return { status: "ok" };
+}
+function installKimi(ctx) {
+  if (ctx.ijfwCustomDir) {
+    printInfo("Custom-dir install -- skipping ~/.kimi/ merge.");
+    printOk("Kimi Code: real platform config left untouched.");
+    return { status: "noop" };
+  }
+  const dst = path.join(ctx.home, ".kimi", "mcp.json");
+  ensureDir2(path.dirname(dst));
+  mergeJson(dst, ctx.serverJsNative || ctx.serverJs);
+  printOk(`Merged MCP into ${dst}`);
+  return { status: "ok" };
+}
+function installOpenclaw(ctx) {
+  if (ctx.ijfwCustomDir) {
+    printInfo("Custom-dir install -- skipping OpenClaw merges.");
+    printOk("OpenClaw: real platform config left untouched.");
+    return { status: "noop" };
+  }
+  const dst = path.join(ctx.home, ".openclaw", "openclaw.json");
+  const serverJs = ctx.serverJsNative || ctx.serverJs;
+  if (commandExists("openclaw")) {
+    try {
+      const payload = JSON.stringify({ command: "node", args: [serverJs] });
+      execFileSync("openclaw", ["mcp", "set", "ijfw-memory", payload], { stdio: "ignore" });
+      printOk(`Registered ijfw-memory via 'openclaw mcp set' (${dst})`);
+      return { status: "ok" };
+    } catch {
+    }
+  }
+  ensureDir2(path.dirname(dst));
+  openclawMerge(dst, serverJs);
+  printOk(`Merged MCP into ${dst} (openclaw mcp.servers schema)`);
+  return { status: "ok" };
+}
+function installAider(ctx) {
+  if (ctx.ijfwCustomDir) {
+    printInfo("Custom-dir install -- skipping Aider merges.");
+    printOk("Aider: real platform config left untouched.");
+    return { status: "noop" };
+  }
+  const confSrc = path.join(ctx.repoRoot, "aider", "aider.conf.yml");
+  const confDst = path.join(ctx.home, ".aider.conf.yml");
+  copyIfMissing(confSrc, confDst);
+  const convSrc = path.join(ctx.repoRoot, "aider", "CONVENTIONS.md");
+  const convDst = path.join(ctx.home, "CONVENTIONS.md");
+  copyIfMissing(convSrc, convDst);
+  printOk("Aider: rules-only install (~/.aider.conf.yml + ~/CONVENTIONS.md). No MCP -- Aider lacks a native MCP client.");
+  return { status: "ok" };
+}
+var init_install_targets_8_14 = __esm({
+  "src/install-targets-8-14.js"() {
+    init_install_helpers();
+  }
+});
+
+// src/install-flow.js
+var install_flow_exports = {};
+__export(install_flow_exports, {
+  CANONICAL_ORDER: () => CANONICAL_ORDER,
+  default: () => install_flow_default,
+  runInstall: () => runInstall
+});
+import fs2 from "node:fs";
+import path2 from "node:path";
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+function isWindows() {
+  return process.platform === "win32";
+}
+function realpathOrSelf(p) {
+  try {
+    return fs2.realpathSync(p);
+  } catch {
+    return p;
+  }
+}
+function preflight({ repoRoot, serverJs }) {
+  const nodeMajor = parseInt(process.versions.node.split(".")[0], 10);
+  if (!Number.isFinite(nodeMajor) || nodeMajor < 18) {
+    throw new Error(
+      `Preflight: Node.js ${process.versions.node} is too old (need 18+).`
+    );
+  }
+  if (!repoRoot || typeof repoRoot !== "string") {
+    throw new Error("Preflight: repoRoot is required and must be a string.");
+  }
+  if (!fs2.existsSync(repoRoot)) {
+    throw new Error(`Preflight: repoRoot does not exist at ${repoRoot}`);
+  }
+  if (!fs2.existsSync(serverJs)) {
+    throw new Error(
+      `Preflight: MCP server.js missing at ${serverJs} -- re-clone the IJFW source tree.`
+    );
+  }
+}
+function linkPlugin({ repoRoot, ijfwHome, ts }) {
+  const pluginSrc = path2.join(repoRoot, "claude");
+  const pluginDst = path2.join(ijfwHome, "claude");
+  const pluginSrcReal = realpathOrSelf(pluginSrc);
+  const pluginDstReal = realpathOrSelf(pluginDst);
+  if (pluginSrcReal === pluginDstReal && fs2.existsSync(pluginDst)) {
+    printOk("Plugin source already at canonical path -- symlink not needed.");
+    return;
+  }
+  fs2.mkdirSync(ijfwHome, { recursive: true });
+  if (isWindows()) {
+    if (fs2.existsSync(pluginDst)) {
+      const st = fs2.lstatSync(pluginDst);
+      if (st.isSymbolicLink()) {
+        try {
+          fs2.unlinkSync(pluginDst);
+        } catch {
+        }
+      } else if (st.isDirectory()) {
+        fs2.cpSync(pluginSrc, pluginDst, { recursive: true });
+        printOk(`Plugin tree mirrored to ${pluginDst}`);
+        return;
+      } else {
+        try {
+          fs2.rmSync(pluginDst, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    }
+    fs2.cpSync(pluginSrc, pluginDst, { recursive: true });
+    printOk(`Plugin tree copied to ${pluginDst}`);
+    return;
+  }
+  let dstStat = null;
+  try {
+    dstStat = fs2.lstatSync(pluginDst);
+  } catch {
+    dstStat = null;
+  }
+  if (dstStat && dstStat.isSymbolicLink()) {
+    let cur = "";
+    try {
+      cur = fs2.readlinkSync(pluginDst);
+    } catch {
+      cur = "";
+    }
+    if (cur !== pluginSrc) {
+      try {
+        fs2.unlinkSync(pluginDst);
+      } catch {
+      }
+      fs2.symlinkSync(pluginSrc, pluginDst, "dir");
+      printOk(`Plugin link retargeted: ${pluginDst} -> ${pluginSrc}`);
+    } else {
+      printOk(`Plugin link already correct at ${pluginDst}`);
+    }
+  } else if (dstStat) {
+    const backup2 = `${pluginDst}.backup.${ts}`;
+    fs2.renameSync(pluginDst, backup2);
+    fs2.symlinkSync(pluginSrc, pluginDst, "dir");
+    printOk(`Plugin link created (existing dir preserved at ${backup2}).`);
+  } else {
+    fs2.symlinkSync(pluginSrc, pluginDst, "dir");
+    printOk(`Plugin link created: ${pluginDst} -> ${pluginSrc}`);
+  }
+  const manifest = path2.join(pluginDst, ".claude-plugin", "plugin.json");
+  if (!fs2.existsSync(manifest)) {
+    printWarn(
+      `Plugin at ${pluginDst} is missing .claude-plugin/plugin.json -- install may be incomplete.`
+    );
+  }
+}
+function seedState({ ijfwHome, repoRoot, nodeBin: _nodeBin }) {
+  const cacheDir = path2.join(ijfwHome, "cache");
+  const runDir = path2.join(ijfwHome, "run");
+  const logsDir = path2.join(ijfwHome, "logs");
+  fs2.mkdirSync(cacheDir, { recursive: true });
+  fs2.mkdirSync(runDir, { recursive: true });
+  fs2.mkdirSync(logsDir, { recursive: true });
+  try {
+    fs2.chmodSync(ijfwHome, 448);
+  } catch {
+  }
+  let installMethod = "manual";
+  if (fs2.existsSync(path2.join(repoRoot, ".git"))) {
+    installMethod = "git-clone";
+  }
+  try {
+    const npmGlobalRoot = process.env.npm_config_prefix ? path2.join(process.env.npm_config_prefix, "lib", "node_modules") : null;
+    if (npmGlobalRoot && repoRoot.startsWith(npmGlobalRoot) && repoRoot !== npmGlobalRoot) {
+      installMethod = "npm-global";
+    }
+  } catch {
+  }
+  let installedVer = "0.0.0";
+  try {
+    const pkgPath = path2.join(repoRoot, "installer", "package.json");
+    const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+    installedVer = pkg.version || "0.0.0";
+  } catch {
+  }
+  const nowTs = Math.floor(Date.now() / 1e3);
+  const state = {
+    schema_version: 1,
+    install_method: installMethod,
+    installed_version: installedVer,
+    last_applied_version: installedVer,
+    last_good_shasum: null,
+    settings_reseeded_at: null,
+    installed_at: nowTs
+  };
+  writeAtomic(
+    path2.join(ijfwHome, "state.json"),
+    JSON.stringify(state, null, 2) + "\n",
+    { mode: 384 }
+  );
+  const settingsPath = path2.join(ijfwHome, "settings.json");
+  if (!fs2.existsSync(settingsPath)) {
+    const seedPath = path2.join(
+      repoRoot,
+      "installer",
+      "src",
+      "settings-seed.json"
+    );
+    if (fs2.existsSync(seedPath)) {
+      const seed = fs2.readFileSync(seedPath, "utf8");
+      writeAtomic(settingsPath, seed, { mode: 384 });
+    }
+  }
+  writeAtomic(
+    path2.join(ijfwHome, "install-method"),
+    `${installMethod}
+`,
+    { mode: 384 }
+  );
+  printOk(`State seeded (${installMethod}, v${installedVer})`);
+  return { installMethod, installedVer };
+}
+function detectStatusline({ home, ijfwHome }) {
+  const claudeSettingsPath2 = path2.join(home, ".claude", "settings.json");
+  if (!fs2.existsSync(claudeSettingsPath2)) {
+    return;
+  }
+  let claudeSettings;
+  try {
+    claudeSettings = JSON.parse(fs2.readFileSync(claudeSettingsPath2, "utf8"));
+  } catch {
+    return;
+  }
+  const existingCmd = claudeSettings && claudeSettings.statusLine && claudeSettings.statusLine.command ? String(claudeSettings.statusLine.command) : "";
+  if (!existingCmd) {
+    printOk(
+      "statusLine off by default. Run 'ijfw statusline --install' to enable."
+    );
+    return;
+  }
+  const allowed = existingCmd.includes("/.claude/") || existingCmd.includes("/.gsd/") || existingCmd.includes("/.ijfw/claude/") || existingCmd.includes("/.cursor/");
+  if (!allowed) {
+    printWarn(
+      `Existing statusLine at ${existingCmd} -- not composing for security.`
+    );
+    printNote(
+      "Run 'ijfw statusline --install' to replace, or '--compose' if trusted."
+    );
+    return;
+  }
+  const settingsPath = path2.join(ijfwHome, "settings.json");
+  let s = {};
+  try {
+    s = JSON.parse(fs2.readFileSync(settingsPath, "utf8"));
+  } catch {
+    s = {};
+  }
+  if (!s.schema_version) s.schema_version = 1;
+  if (!s.statusline) s.statusline = {};
+  s.statusline.composed_command = existingCmd;
+  s.statusline.mode = "compose";
+  s.statusline.enabled = "auto";
+  try {
+    writeAtomic(settingsPath, JSON.stringify(s, null, 2) + "\n", {
+      mode: 384
+    });
+    printOk(
+      "Composed alongside existing statusLine. Run 'ijfw statusline --disable' to opt out."
+    );
+  } catch (err) {
+    printWarn(`Statusline compose write failed: ${err.message}`);
+  }
+}
+function patchPluginMcpJson({ ijfwHome, repoRoot, nodeBin, serverJs }) {
+  const pluginDst = path2.join(ijfwHome, "claude");
+  const mcpJsonPath = path2.join(pluginDst, ".mcp.json");
+  if (!fs2.existsSync(mcpJsonPath)) return;
+  const pluginDstReal = realpathOrSelf(pluginDst);
+  const repoRootReal = realpathOrSelf(repoRoot);
+  if (fs2.existsSync(path2.join(repoRoot, ".git")) && pluginDstReal.startsWith(repoRootReal) && pluginDstReal !== repoRootReal) {
+    return;
+  }
+  let d;
+  try {
+    d = JSON.parse(fs2.readFileSync(mcpJsonPath, "utf8"));
+  } catch {
+    return;
+  }
+  if (!d || !d.mcpServers || !d.mcpServers["ijfw-memory"]) return;
+  const nodeDir = path2.dirname(nodeBin);
+  d.mcpServers["ijfw-memory"].command = nodeBin;
+  d.mcpServers["ijfw-memory"].args = [serverJs];
+  const envSep = process.platform === "win32" ? ";" : ":";
+  const commonPaths = process.platform === "win32" ? [nodeDir, "C:\\Windows\\System32"] : [nodeDir, "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"];
+  const dedup = [...new Set(commonPaths.filter((x) => x && fs2.existsSync(x)))];
+  d.mcpServers["ijfw-memory"].env = { PATH: dedup.join(envSep) };
+  try {
+    writeAtomic(mcpJsonPath, JSON.stringify(d, null, 2) + "\n");
+  } catch (err) {
+    printWarn(`Plugin .mcp.json patch failed: ${err.message}`);
+  }
+}
+function nukePluginCache({ home }) {
+  const cacheDir = path2.join(home, ".claude", "plugins", "cache", "ijfw");
+  if (fs2.existsSync(cacheDir)) {
+    try {
+      fs2.rmSync(cacheDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function linkMcpSibling({ repoRoot, ijfwHome, ts }) {
+  const mcpSrc = path2.join(repoRoot, "mcp-server");
+  const mcpDst = path2.join(ijfwHome, "mcp-server");
+  const mcpSrcReal = realpathOrSelf(mcpSrc);
+  const mcpDstReal = realpathOrSelf(mcpDst);
+  if (mcpSrcReal === mcpDstReal && fs2.existsSync(mcpDst)) {
+    printOk("MCP source already at canonical path -- symlink not needed.");
+    return;
+  }
+  fs2.mkdirSync(ijfwHome, { recursive: true });
+  if (isWindows()) {
+    if (fs2.existsSync(mcpDst)) {
+      const st = fs2.lstatSync(mcpDst);
+      if (st.isSymbolicLink()) {
+        try {
+          fs2.unlinkSync(mcpDst);
+        } catch {
+        }
+      } else if (st.isDirectory()) {
+        fs2.cpSync(mcpSrc, mcpDst, { recursive: true });
+        return;
+      } else {
+        try {
+          fs2.rmSync(mcpDst, { recursive: true, force: true });
+        } catch {
+        }
+      }
+    }
+    fs2.cpSync(mcpSrc, mcpDst, { recursive: true });
+    return;
+  }
+  let dstStat = null;
+  try {
+    dstStat = fs2.lstatSync(mcpDst);
+  } catch {
+    dstStat = null;
+  }
+  if (dstStat && dstStat.isSymbolicLink()) {
+    let cur = "";
+    try {
+      cur = fs2.readlinkSync(mcpDst);
+    } catch {
+      cur = "";
+    }
+    if (cur !== mcpSrc) {
+      try {
+        fs2.unlinkSync(mcpDst);
+      } catch {
+      }
+      fs2.symlinkSync(mcpSrc, mcpDst, "dir");
+    }
+  } else if (dstStat) {
+    const backup2 = `${mcpDst}.backup.${ts}`;
+    fs2.renameSync(mcpDst, backup2);
+    fs2.symlinkSync(mcpSrc, mcpDst, "dir");
+  } else {
+    fs2.symlinkSync(mcpSrc, mcpDst, "dir");
+  }
+  if (!fs2.existsSync(path2.join(mcpDst, "src", "server.js"))) {
+    printWarn(
+      `MCP server at ${mcpDst} is missing src/server.js -- install may be incomplete.`
+    );
+  }
+}
+function pruneBackups({ home }) {
+  const THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
+  const cwd = process.cwd();
+  const dirs = [
+    path2.join(home, ".codex"),
+    path2.join(home, ".gemini"),
+    path2.join(home, ".codeium", "windsurf"),
+    path2.join(home, ".hermes"),
+    path2.join(home, ".wayland"),
+    path2.join(cwd, ".vscode"),
+    path2.join(cwd, ".cursor")
+  ];
+  const cutoff = Date.now() - THIRTY_DAYS_MS;
+  for (const d of dirs) {
+    if (!fs2.existsSync(d)) continue;
+    walkAndPrune(d, 2, cutoff);
+  }
+}
+function walkAndPrune(dir, depth, cutoff) {
+  if (depth < 0) return;
+  let entries = [];
+  try {
+    entries = fs2.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const full = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      walkAndPrune(full, depth - 1, cutoff);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (!entry.name.includes(".bak.")) continue;
+    let st;
+    try {
+      st = fs2.statSync(full);
+    } catch {
+      continue;
+    }
+    if (st.mtimeMs < cutoff) {
+      try {
+        fs2.unlinkSync(full);
+      } catch {
+      }
+    }
+  }
+}
+function printSummary({ live, standby, claudeNeedsRestart, repoRoot }) {
+  const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+  const c = useColor ? {
+    reset: "\x1B[0m",
+    bold: "\x1B[1m",
+    dim: "\x1B[2m",
+    cyan: "\x1B[36m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m"
+  } : { reset: "", bold: "", dim: "", cyan: "", green: "", yellow: "" };
+  const nativeRepo = nativePath(repoRoot);
+  process.stdout.write("\n");
+  process.stdout.write(
+    `  ${c.bold}${c.cyan}+----------------------------------------+${c.reset}
+`
+  );
+  process.stdout.write(
+    `  ${c.bold}${c.cyan}|${c.reset}                                        ${c.bold}${c.cyan}|${c.reset}
+`
+  );
+  process.stdout.write(
+    `  ${c.bold}${c.cyan}|${c.reset}  ${c.bold}${c.cyan}IJFW${c.reset}  ${c.dim}It just f*cking works.${c.reset}          ${c.bold}${c.cyan}|${c.reset}
+`
+  );
+  process.stdout.write(
+    `  ${c.bold}${c.cyan}|${c.reset}                                        ${c.bold}${c.cyan}|${c.reset}
+`
+  );
+  process.stdout.write(
+    `  ${c.bold}${c.cyan}+----------------------------------------+${c.reset}
+`
+  );
+  process.stdout.write("\n");
+  process.stdout.write(
+    `  ${c.dim}Installed at${c.reset}  ${nativeRepo}
+
+`
+  );
+  if (live.length) {
+    process.stdout.write(
+      `  ${c.bold}${c.green}==> LIVE NOW (${live.length})${c.reset}
+`
+    );
+    for (const p of live) {
+      process.stdout.write(`      ${c.green}o${c.reset}  ${p}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  if (standby.length) {
+    process.stdout.write(
+      `  ${c.bold}${c.yellow}==> STANDING BY (${standby.length})${c.reset}  ${c.dim}auto-activate on install${c.reset}
+`
+    );
+    for (const p of standby) {
+      process.stdout.write(`      ${c.yellow}o${c.reset}  ${p}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  if (live.length === 0 && standby.length === 0) {
+    process.stdout.write(
+      `  ${c.yellow}Ready to configure${c.reset}  -- pass a platform name to get started: ${c.bold}ijfw install claude${c.reset}
+
+`
+    );
+  }
+  if (claudeNeedsRestart) {
+    process.stdout.write(
+      `  ${c.bold}${c.yellow}==> RESTART REQUIRED${c.reset}  Claude Code is running -- ${c.bold}restart your sessions now to activate IJFW.${c.reset}
+
+`
+    );
+  }
+}
+function maybeInstallPostCommitHook({ noninteractive }) {
+  if (process.env.CI || noninteractive) return;
+  if (!fs2.existsSync(".git")) return;
+  printNote(
+    "Tip: background Trident critique on every commit -- pass --post-commit-hook to enable."
+  );
+}
+async function runInstall({
+  targets,
+  ijfwHome,
+  ijfwCustomDir,
+  repoRoot,
+  noninteractive
+} = {}) {
+  const home = homeReal();
+  const resolvedIjfwHome = ijfwHome && typeof ijfwHome === "string" && ijfwHome.length > 0 ? path2.resolve(ijfwHome) : path2.join(home, ".ijfw");
+  const customDir = !!ijfwCustomDir;
+  const resolvedRepoRoot = repoRoot && typeof repoRoot === "string" ? path2.resolve(repoRoot) : process.cwd();
+  let targetList = Array.isArray(targets) && targets.length > 0 ? targets.filter((t) => CANONICAL_ORDER.includes(t)) : CANONICAL_ORDER.slice();
+  targetList = CANONICAL_ORDER.filter((t) => targetList.includes(t));
+  const serverJs = path2.join(resolvedRepoRoot, "mcp-server", "src", "server.js");
+  const serverJsNative = nativePath(serverJs);
+  const nodeBin = process.execPath;
+  const ts = timestamp();
+  preflight({ repoRoot: resolvedRepoRoot, serverJs });
+  if (customDir) {
+    printOk(
+      "Custom-dir install -- skipping ~/.ijfw/ sibling links (canonical-dir feature)."
+    );
+  } else {
+    linkPlugin({ repoRoot: resolvedRepoRoot, ijfwHome: resolvedIjfwHome, ts });
+  }
+  seedState({
+    ijfwHome: resolvedIjfwHome,
+    repoRoot: resolvedRepoRoot,
+    nodeBin
+  });
+  if (!customDir) {
+    detectStatusline({ home, ijfwHome: resolvedIjfwHome });
+  }
+  if (!customDir) {
+    patchPluginMcpJson({
+      ijfwHome: resolvedIjfwHome,
+      repoRoot: resolvedRepoRoot,
+      nodeBin,
+      serverJs
+    });
+  }
+  if (!customDir) {
+    nukePluginCache({ home });
+  }
+  if (!customDir) {
+    linkMcpSibling({
+      repoRoot: resolvedRepoRoot,
+      ijfwHome: resolvedIjfwHome,
+      ts
+    });
+  }
+  pruneBackups({ home });
+  const live = [];
+  const standby = [];
+  const failed = [];
+  let claudeNeedsRestart = false;
+  for (const target of targetList) {
+    const fn = TARGET_FNS[target];
+    if (typeof fn !== "function") {
+      printWarn(`No installer registered for target '${target}' -- skipped.`);
+      continue;
+    }
+    printSection(`[${prettyName(target)}]`);
+    const ctx = {
+      home,
+      homeReal: home,
+      ijfwHome: resolvedIjfwHome,
+      ijfwCustomDir: customDir,
+      repoRoot: resolvedRepoRoot,
+      serverJs,
+      serverJsNative,
+      nodeBin,
+      ts,
+      log: {
+        ok: printOk,
+        note: printNote,
+        info: printInfo,
+        warn: printWarn
+      }
+    };
+    let outcome;
+    try {
+      outcome = await fn(ctx);
+    } catch (err) {
+      failed.push(prettyName(target));
+      printWarn(
+        `${prettyName(target)}: install failed -- ${err && err.message ? err.message : String(err)}`
+      );
+      continue;
+    }
+    if (outcome && outcome.restart === true && target === "claude") {
+      claudeNeedsRestart = true;
+    }
+    let liveNow = false;
+    try {
+      liveNow = !!isLive(target, home);
+    } catch {
+      liveNow = false;
+    }
+    const display = prettyName(target);
+    if (liveNow) {
+      live.push(display);
+    } else {
+      standby.push(display);
+    }
+  }
+  printSummary({
+    live,
+    standby,
+    claudeNeedsRestart,
+    repoRoot: resolvedRepoRoot
+  });
+  maybeInstallPostCommitHook({ noninteractive: !!noninteractive });
+  return { live, standby, failed, claudeNeedsRestart };
+}
+var CANONICAL_ORDER, TARGET_FNS, install_flow_default;
+var init_install_flow = __esm({
+  "src/install-flow.js"() {
+    init_install_helpers();
+    init_install_targets_1_7();
+    init_install_targets_8_14();
+    CANONICAL_ORDER = [
+      "claude",
+      "codex",
+      "gemini",
+      "wayland",
+      "hermes",
+      "cursor",
+      "windsurf",
+      "copilot",
+      "opencode",
+      "qwen",
+      "cline",
+      "kimi",
+      "openclaw",
+      "aider"
+    ];
+    TARGET_FNS = {
+      claude: installClaude,
+      codex: installCodex,
+      gemini: installGemini,
+      wayland: installWayland,
+      hermes: installHermes,
+      cursor: installCursor,
+      windsurf: installWindsurf,
+      copilot: installCopilot,
+      opencode: installOpencode,
+      qwen: installQwen,
+      cline: installCline,
+      kimi: installKimi,
+      openclaw: installOpenclaw,
+      aider: installAider
+    };
+    install_flow_default = { runInstall, CANONICAL_ORDER };
+  }
+});
 
 // src/install.js
-import { spawnSync } from "node:child_process";
-import { existsSync as existsSync2, rmSync, mkdirSync as mkdirSync2, realpathSync, renameSync as renameSync2 } from "node:fs";
-import { resolve as resolve2, join as join2, dirname as dirname2 } from "node:path";
-import { homedir as homedir2, platform } from "node:os";
-import { fileURLToPath } from "node:url";
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync5, rmSync, mkdirSync as mkdirSync4, realpathSync as realpathSync2, renameSync as renameSync3 } from "node:fs";
+import { resolve as resolve3, join as join5, dirname as dirname5 } from "node:path";
+import { homedir as homedir3, platform as platform2 } from "node:os";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/marketplace.js
 import { readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, mkdirSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
-function atomicWriteJson(path, data) {
-  const tmp = `${path}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
+function atomicWriteJson(path3, data) {
+  const tmp = `${path3}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
   writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
   try {
-    renameSync(tmp, path);
+    renameSync(tmp, path3);
   } catch (err) {
     try {
       unlinkSync(tmp);
     } catch {
     }
-    throw new Error(`atomic write failed for ${path}: ${err.message}`);
+    throw new Error(`atomic write failed for ${path3}: ${err.message}`);
   }
 }
 function claudeSettingsPath() {
@@ -110,6 +1872,57 @@ function mergeMarketplace(settingsPath = claudeSettingsPath(), options = {}) {
   return settings;
 }
 
+// src/post-install/cold-scan.js
+import { spawn } from "node:child_process";
+import { existsSync as existsSync2 } from "node:fs";
+import { join as join2, dirname as dirname2, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+var RUNNER_REL_FROM_HERE = "../../../mcp-server/src/cold-scan-runner.mjs";
+function triggerColdScan(projectRoot, options = {}) {
+  const root = String(projectRoot || process.cwd());
+  if (!existsSync2(root)) {
+    return { spawned: false, reason: "project root not present" };
+  }
+  const ijfwHome = options.ijfwHome || process.env.IJFW_HOME || "";
+  const candidates = [
+    resolve2(__dirname, RUNNER_REL_FROM_HERE),
+    // repo root from installer/src/post-install/
+    resolve2(__dirname, "../../mcp-server/src/cold-scan-runner.mjs"),
+    // legacy guess (kept for compat)
+    ijfwHome ? join2(ijfwHome, "mcp-server/src/cold-scan-runner.mjs") : "",
+    // explicit IJFW_HOME
+    resolve2(projectRoot, "mcp-server/src/cold-scan-runner.mjs")
+    // projectRoot itself is an IJFW checkout
+  ].filter(Boolean);
+  let runnerPath = null;
+  for (const c of candidates) {
+    if (c && existsSync2(c)) {
+      runnerPath = c;
+      break;
+    }
+  }
+  if (!runnerPath) {
+    return { spawned: false, reason: "cold-scan runner not present" };
+  }
+  const nodeBin = options.nodeBin || process.execPath;
+  const args = [runnerPath, "--project-root", root];
+  if (options.c9Available === false) args.push("--no-c9");
+  if (options.maxFiles) args.push("--max-files", String(options.maxFiles));
+  try {
+    const child = spawn(nodeBin, args, {
+      detached: true,
+      stdio: "ignore",
+      env: { ...process.env, IJFW_COLD_SCAN: "1" }
+    });
+    child.unref();
+    return { spawned: true, pid: child.pid };
+  } catch (err) {
+    return { spawned: false, reason: String(err && err.message ? err.message : err) };
+  }
+}
+
 // src/install.js
 var DEFAULT_REPO = "https://gitlab.com/therealseandonahoe/ijfw.git";
 var DEFAULT_BRANCH = "main";
@@ -133,7 +1946,7 @@ function parseArgs(argv) {
 }
 function latestTagFromGithub() {
   try {
-    const res = spawnSync("git", ["ls-remote", "--tags", "--refs", "--sort=-v:refname", DEFAULT_REPO], {
+    const res = spawnSync2("git", ["ls-remote", "--tags", "--refs", "--sort=-v:refname", DEFAULT_REPO], {
       encoding: "utf8",
       timeout: 1e4
     });
@@ -165,12 +1978,12 @@ Usage: npx @ijfw/install [--dir <path>] [--branch <name>] [--no-marketplace] [--
   --yes             non-interactive
 `);
 }
-function preflight() {
+function preflight2() {
   const issues = [];
   const [major] = process.versions.node.split(".").map(Number);
   if (major < 18) issues.push(`IJFW needs Node >=18 -- current: ${process.versions.node}. Upgrade Node, then retry.`);
-  if (!hasBin("git")) {
-    if (platform() === "win32") {
+  if (!hasBin2("git")) {
+    if (platform2() === "win32") {
       issues.push(
         "IJFW needs Git for Windows (it bundles git + bash). One command:\n    winget install --id Git.Git -e --source winget --accept-source-agreements --accept-package-agreements\n  Then close this PowerShell window, open a fresh one, and rerun:\n    npx -p @ijfw/install ijfw-install"
       );
@@ -178,38 +1991,29 @@ function preflight() {
       issues.push("IJFW needs git on PATH -- install git (https://git-scm.com), then retry.");
     }
   }
-  if (!findBash()) {
-    if (platform() === "win32") {
-      issues.push(
-        "IJFW could not locate bash.exe. Git for Windows installs it at\n    C:\\Program Files\\Git\\bin\\bash.exe\n  If you installed Git elsewhere, add its bin\\ to PATH and rerun.\n  Missing Git entirely? winget install --id Git.Git -e --source winget"
-      );
-    } else {
-      issues.push("IJFW needs bash on PATH -- install bash, then retry.");
-    }
-  }
   return issues;
 }
-function hasBin(bin) {
-  const res = spawnSync(bin, ["--version"], { stdio: "ignore", timeout: 3e3 });
+function hasBin2(bin) {
+  const res = spawnSync2(bin, ["--version"], { stdio: "ignore", timeout: 3e3 });
   if (res.error && res.error.code === "ENOENT") return false;
   if (res.status === 0) return true;
   return res.error == null;
 }
 function findBash() {
-  if (hasBin("bash") && platform() !== "win32") return "bash";
-  if (platform() !== "win32") return hasBin("bash") ? "bash" : null;
-  const whereGit = spawnSync("where", ["git"], { encoding: "utf8" });
+  if (hasBin2("bash") && platform2() !== "win32") return "bash";
+  if (platform2() !== "win32") return hasBin2("bash") ? "bash" : null;
+  const whereGit = spawnSync2("where", ["git"], { encoding: "utf8" });
   if (whereGit.status === 0) {
     const gitPath = (whereGit.stdout || "").split(/\r?\n/)[0].trim();
-    if (gitPath && existsSync2(gitPath)) {
-      const gitDir = dirname2(gitPath);
-      const gitRoot = dirname2(gitDir);
+    if (gitPath && existsSync5(gitPath)) {
+      const gitDir = dirname5(gitPath);
+      const gitRoot = dirname5(gitDir);
       const candidates = [
-        join2(gitDir, "bash.exe"),
-        join2(gitRoot, "bin", "bash.exe"),
-        join2(gitRoot, "usr", "bin", "bash.exe")
+        join5(gitDir, "bash.exe"),
+        join5(gitRoot, "bin", "bash.exe"),
+        join5(gitRoot, "usr", "bin", "bash.exe")
       ];
-      for (const c of candidates) if (existsSync2(c)) return c;
+      for (const c of candidates) if (existsSync5(c)) return c;
     }
   }
   for (const c of [
@@ -217,27 +2021,27 @@ function findBash() {
     "C:\\Program Files\\Git\\usr\\bin\\bash.exe",
     "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
     "C:\\Program Files (x86)\\Git\\usr\\bin\\bash.exe"
-  ]) if (existsSync2(c)) return c;
-  if (hasBin("bash")) return "bash";
+  ]) if (existsSync5(c)) return c;
+  if (hasBin2("bash")) return "bash";
   return null;
 }
 function resolveTarget(opt) {
-  if (opt.dir) return resolve2(opt.dir);
-  if (process.env.IJFW_HOME) return resolve2(process.env.IJFW_HOME);
-  return join2(homedir2(), ".ijfw");
+  if (opt.dir) return resolve3(opt.dir);
+  if (process.env.IJFW_HOME) return resolve3(process.env.IJFW_HOME);
+  return join5(homedir3(), ".ijfw");
 }
 function runCheck(cmd, args, opts) {
-  const r = spawnSync(cmd, args, { encoding: "utf8", ...opts });
+  const r = spawnSync2(cmd, args, { encoding: "utf8", ...opts });
   return { status: r.status, stdout: r.stdout || "", stderr: r.stderr || "", spawnError: r.error?.code, signal: r.signal };
 }
 function cloneOrPull(dir, branch) {
-  if (!existsSync2(dir)) {
-    mkdirSync2(dir, { recursive: true });
-    const r = spawnSync("git", ["clone", "--depth", "1", "--branch", branch, DEFAULT_REPO, dir], { stdio: "inherit" });
+  if (!existsSync5(dir)) {
+    mkdirSync4(dir, { recursive: true });
+    const r = spawnSync2("git", ["clone", "--depth", "1", "--branch", branch, DEFAULT_REPO, dir], { stdio: "inherit" });
     if (r.status !== 0) throw new Error(`IJFW repo fetch did not complete (exit ${r.status}) -- check network access and retry.`);
     return "cloned";
   }
-  const hasGit = existsSync2(join2(dir, ".git"));
+  const hasGit = existsSync5(join5(dir, ".git"));
   if (hasGit) {
     const { status: remoteStatus, stdout, stderr: remoteStderr, spawnError: remoteSpawnError, signal: remoteSignal } = runCheck("git", ["-C", dir, "remote", "get-url", "origin"]);
     if (remoteSpawnError) console.warn(`  git spawn error (${remoteSpawnError}) -- check git is on PATH`);
@@ -252,71 +2056,66 @@ function cloneOrPull(dir, branch) {
       ];
       const currentOrigin = (stdout || "").trim();
       if (STALE_ORIGINS.includes(currentOrigin)) {
-        const setUrl = spawnSync("git", ["-C", dir, "remote", "set-url", "origin", DEFAULT_REPO], { stdio: "inherit" });
+        const setUrl = spawnSync2("git", ["-C", dir, "remote", "set-url", "origin", DEFAULT_REPO], { stdio: "inherit" });
         if (setUrl.status !== 0) {
           console.warn(`  [!] origin migration failed -- could not repoint ${currentOrigin} to ${DEFAULT_REPO}`);
         } else {
           console.log(`  origin migration: ${currentOrigin} -> ${DEFAULT_REPO}`);
         }
       }
-      const fetch = spawnSync("git", ["-C", dir, "fetch", "--depth", "1", "origin", branch], { stdio: "inherit" });
+      const fetch = spawnSync2("git", ["-C", dir, "fetch", "--depth", "1", "origin", branch], { stdio: "inherit" });
       if (fetch.status !== 0) throw new Error(`IJFW fetch did not complete (exit ${fetch.status}) -- check network access and retry.`);
-      const co = spawnSync("git", ["-C", dir, "checkout", "-f", "FETCH_HEAD"], { stdio: "inherit" });
+      const co = spawnSync2("git", ["-C", dir, "checkout", "-f", "FETCH_HEAD"], { stdio: "inherit" });
       if (co.status !== 0) throw new Error(`IJFW checkout did not complete (exit ${co.status}) -- run ijfw doctor to check prerequisites.`);
       return "updated";
     }
   }
   const backupDir = dir + ".bak." + Date.now();
-  renameSync2(dir, backupDir);
+  renameSync3(dir, backupDir);
   try {
-    const r = spawnSync("git", ["clone", "--depth", "1", "--branch", branch, DEFAULT_REPO, dir], { stdio: "inherit" });
+    const r = spawnSync2("git", ["clone", "--depth", "1", "--branch", branch, DEFAULT_REPO, dir], { stdio: "inherit" });
     if (r.status !== 0) throw new Error(`IJFW repo fetch did not complete (exit ${r.status}) -- check network access and retry.`);
     for (const item of ["memory", "sessions", "install.log", ".session-counter"]) {
-      const src = join2(backupDir, item);
-      if (existsSync2(src)) {
-        const dst = join2(dir, item);
-        if (existsSync2(dst)) rmSync(dst, { recursive: true, force: true });
-        renameSync2(src, dst);
+      const src = join5(backupDir, item);
+      if (existsSync5(src)) {
+        const dst = join5(dir, item);
+        if (existsSync5(dst)) rmSync(dst, { recursive: true, force: true });
+        renameSync3(src, dst);
       }
     }
     rmSync(backupDir, { recursive: true, force: true });
     return "updated";
   } catch (err) {
-    if (existsSync2(dir)) rmSync(dir, { recursive: true, force: true });
-    renameSync2(backupDir, dir);
+    if (existsSync5(dir)) rmSync(dir, { recursive: true, force: true });
+    renameSync3(backupDir, dir);
     throw err;
   }
 }
-function runInstallScript(dir) {
-  const script = join2(dir, "scripts", "install.sh");
-  if (!existsSync2(script)) throw new Error(`IJFW install script not found at ${script} -- re-run the installer to restore it.`);
-  const canonicalDir = join2(homedir2(), ".ijfw");
-  const isCustomDir = resolve2(dir) !== canonicalDir ? "1" : "0";
-  const env = {
-    ...process.env,
-    IJFW_NONINTERACTIVE: process.env.CI ? "1" : process.env.IJFW_NONINTERACTIVE ?? "",
-    IJFW_HOME: dir,
-    IJFW_CUSTOM_DIR: isCustomDir
-  };
-  const bashExe = findBash();
-  if (!bashExe) {
-    throw new Error("IJFW could not locate bash (preflight should have caught this -- file an issue).");
-  }
-  const r = spawnSync(bashExe, ["scripts/install.sh"], { cwd: dir, stdio: "inherit", env });
-  if (r.status !== 0) throw new Error(`IJFW platform config step did not complete (exit ${r.status}) -- run ijfw doctor to see what to fix.`);
+async function runInstallScript(dir) {
+  const canonicalDir = join5(homedir3(), ".ijfw");
+  const isCustomDir = resolve3(dir) !== canonicalDir;
+  const { runInstall: runInstall2 } = await Promise.resolve().then(() => (init_install_flow(), install_flow_exports));
+  await runInstall2({
+    targets: void 0,
+    // undefined = canonical 14
+    ijfwHome: dir,
+    ijfwCustomDir: isCustomDir,
+    repoRoot: dir,
+    noninteractive: !!process.env.CI || process.env.IJFW_NONINTERACTIVE === "1"
+  });
 }
 async function main() {
   const opts = parseArgs(process.argv);
-  const issues = preflight();
+  const issues = preflight2();
   if (issues.length) {
     console.error("IJFW needs a couple of things first -- fix these and re-run:");
     for (const i of issues) console.error("  - " + i);
     process.exit(1);
   }
   const target = resolveTarget(opts);
-  const createdThisRun = !existsSync2(target);
+  const createdThisRun = !existsSync5(target);
   const sigint = () => {
-    if (createdThisRun && existsSync2(target)) {
+    if (createdThisRun && existsSync5(target)) {
       try {
         rmSync(target, { recursive: true, force: true });
       } catch {
@@ -330,15 +2129,20 @@ async function main() {
   console.log(`  version: ${ref}`);
   const action = cloneOrPull(target, ref);
   console.log(`  repo ${action}`);
-  runInstallScript(target);
+  await runInstallScript(target);
   console.log("  platform configs applied");
   if (!opts.noMarketplace) {
     const settingsPath = claudeSettingsPath();
     mergeMarketplace(settingsPath, { rootDir: target });
     console.log(`  marketplace registered in ${settingsPath}`);
   }
+  try {
+    const coldScanRoot = process.env.IJFW_PROJECT_DIR || process.cwd();
+    triggerColdScan(coldScanRoot, { ijfwHome: target });
+  } catch {
+  }
   console.log("");
-  console.log("IJFW now active across 13 platforms -- one memory layer, all your AIs, zero config.");
+  console.log("IJFW now active across 14 platforms -- one memory layer, all your models, zero config.");
   console.log("  Run `ijfw demo` to see the Trident in action.");
   console.log("  Run `ijfw doctor` to confirm which auditors are reachable.");
   console.log("  Privacy: everything stays local. See NO_TELEMETRY.md.");
@@ -346,8 +2150,8 @@ async function main() {
 }
 function isDirectRun() {
   try {
-    const entry = process.argv[1] && realpathSync(process.argv[1]);
-    const self = fileURLToPath(import.meta.url);
+    const entry = process.argv[1] && realpathSync2(process.argv[1]);
+    const self = fileURLToPath2(import.meta.url);
     return entry === self;
   } catch {
     return false;