@mstar-harness/cli 0.3.1 → 0.5.0

package/dist/mstar-harness.js

@@ -2344,8 +2344,8 @@ var require_commander = __commonJS((exports) => {
 });
 
 // src/index.ts
-import fs3 from "fs";
-import path6 from "path";
+import fs6 from "fs";
+import path8 from "path";
 import { fileURLToPath } from "url";
 
 // ../../node_modules/@inquirer/core/dist/lib/key.js
@@ -4240,13 +4240,13 @@ function buildModelAssignments(selections) {
   return { ...assignments, ...pickRandom(others, selections.others) };
 }
 
-// src/adapters/cursor.ts
-import fs from "node:fs";
-import os from "node:os";
-import path3 from "node:path";
-import { execFileSync } from "node:child_process";
+// src/adapters/codex.ts
+import fs3 from "node:fs";
+import os2 from "node:os";
+import path4 from "node:path";
 
 // src/utils.ts
+import fs from "node:fs";
 import path2 from "node:path";
 function normalizeModelList(raw) {
   return raw.split(`
@@ -4257,6 +4257,25 @@ function ensureObject(value) {
     return value;
   return {};
 }
+function readJson(filePath) {
+  if (!fs.existsSync(filePath))
+    return {};
+  const content = fs.readFileSync(filePath, "utf8").trim();
+  if (!content)
+    return {};
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Invalid JSON in ${filePath}: ${error.message}`);
+  }
+}
+function writeJson(filePath, value) {
+  const parent = path2.dirname(filePath);
+  if (!fs.existsSync(parent))
+    fs.mkdirSync(parent, { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
 function resolveProjectRoot() {
   const candidate = process.env.MSTAR_CLI_PROJECT_ROOT || process.env.INIT_CWD || process.env.PWD;
   if (candidate && candidate.trim())
@@ -4264,62 +4283,336 @@ function resolveProjectRoot() {
   return process.cwd();
 }
 
-// src/adapters/cursor.ts
+// src/adapters/shared-install.ts
+import fs2 from "node:fs";
+import os from "node:os";
+import path3 from "node:path";
+import { execFileSync } from "node:child_process";
 var REPO_URL = "https://github.com/btspoony/mstar-harness.git";
-var CURSOR_PLUGIN_NAME = "mstar-harness";
-var CURSOR_PLUGIN_MARKER = ".cursor-plugin/plugin.json";
-function globalInstallPath() {
-  return path3.join(os.homedir(), ".cursor", "plugins", "local", CURSOR_PLUGIN_NAME);
-}
-function projectInstallPath() {
-  return path3.join(resolveProjectRoot(), ".cursor", "plugins", CURSOR_PLUGIN_NAME);
+var PLUGIN_NAME = "morning-star-harness";
+var HARNESS_REPO_PATH = path3.join(os.homedir(), ".mstar", "harness");
+var HARNESS_MARKER = ".codex-plugin/plugin.json";
+function pathOrSymlinkExists(filePath) {
+  try {
+    fs2.lstatSync(filePath);
+    return true;
+  } catch {
+    return false;
+  }
 }
 function ensureDir(dirPath, dryRun) {
   if (dryRun)
     return;
-  if (!fs.existsSync(dirPath))
-    fs.mkdirSync(dirPath, { recursive: true });
+  if (!fs2.existsSync(dirPath))
+    fs2.mkdirSync(dirPath, { recursive: true });
 }
 function runCommand(command, cwd, dryRun) {
   if (dryRun)
     return;
   execFileSync(command[0], command.slice(1), { cwd, stdio: "pipe", encoding: "utf8" });
 }
-function globalInit(dryRun) {
-  const location = globalInstallPath();
+function ensureLocalHarnessRepo(dryRun) {
+  const notes = [];
+  if (fs2.existsSync(HARNESS_REPO_PATH)) {
+    const errors2 = validateLocalHarnessRepo();
+    if (errors2.length) {
+      throw new Error(errors2.join(`
+`));
+    }
+    notes.push(`Using existing local harness repo at ${HARNESS_REPO_PATH}`);
+    return notes;
+  }
+  ensureDir(path3.dirname(HARNESS_REPO_PATH), dryRun);
+  runCommand(["git", "clone", REPO_URL, HARNESS_REPO_PATH], path3.dirname(HARNESS_REPO_PATH), dryRun);
+  notes.push(`Cloned ${REPO_URL} to ${HARNESS_REPO_PATH}`);
+  return notes;
+}
+function validateLocalHarnessRepo() {
+  const errors2 = [];
+  if (!fs2.existsSync(HARNESS_REPO_PATH)) {
+    errors2.push(`Missing local harness repo: ${HARNESS_REPO_PATH}`);
+    return errors2;
+  }
+  const marker = path3.join(HARNESS_REPO_PATH, HARNESS_MARKER);
+  if (!fs2.existsSync(marker)) {
+    errors2.push(`Local harness repo is missing marker file: ${marker}`);
+  }
+  return errors2;
+}
+function ensureSymlink(target, linkPath, dryRun) {
+  if (pathOrSymlinkExists(linkPath)) {
+    const stat = fs2.lstatSync(linkPath);
+    if (!stat.isSymbolicLink()) {
+      throw new Error(`Path exists and is not a symlink: ${linkPath}`);
+    }
+    if (!fs2.existsSync(target)) {
+      throw new Error(`Symlink target is missing: ${target}`);
+    }
+    const actual = fs2.realpathSync(linkPath);
+    const expected = fs2.realpathSync(target);
+    if (actual !== expected) {
+      throw new Error(`Symlink ${linkPath} points to ${actual}, expected ${expected}`);
+    }
+    return `Symlink already exists: ${linkPath} -> ${target}`;
+  }
+  ensureDir(path3.dirname(linkPath), dryRun);
+  if (!dryRun)
+    fs2.symlinkSync(target, linkPath);
+  return `Linked ${linkPath} -> ${target}`;
+}
+function validateSymlink(target, linkPath) {
+  const errors2 = [];
+  if (!pathOrSymlinkExists(linkPath)) {
+    errors2.push(`Missing symlink: ${linkPath}`);
+    return errors2;
+  }
+  const stat = fs2.lstatSync(linkPath);
+  if (!stat.isSymbolicLink()) {
+    errors2.push(`Path exists but is not a symlink: ${linkPath}`);
+    return errors2;
+  }
+  if (!fs2.existsSync(target)) {
+    errors2.push(`Symlink target is missing: ${target}`);
+    return errors2;
+  }
+  const actual = fs2.realpathSync(linkPath);
+  const expected = fs2.realpathSync(target);
+  if (actual !== expected) {
+    errors2.push(`Symlink ${linkPath} points to ${actual}, expected ${expected}`);
+  }
+  return errors2;
+}
+function appendGitignore(projectRoot, entries, dryRun) {
+  const gitignorePath = path3.join(projectRoot, ".gitignore");
+  const current = fs2.existsSync(gitignorePath) ? fs2.readFileSync(gitignorePath, "utf8") : "";
+  const lines = new Set(current.split(/\r?\n/).map((line) => line.trim()));
+  const missing = entries.filter((entry) => !lines.has(entry));
+  if (!missing.length)
+    return [];
+  if (!dryRun) {
+    const prefix = current && !current.endsWith(`
+`) ? `
+` : "";
+    fs2.appendFileSync(gitignorePath, `${prefix}${missing.join(`
+`)}
+`, "utf8");
+  }
+  return missing.map((entry) => `Added ${entry} to .gitignore`);
+}
+function homeRelativeSourcePath(targetPath) {
+  const rel = path3.relative(os.homedir(), targetPath).split(path3.sep).join("/");
+  return rel.startsWith("..") ? targetPath : `./${rel}`;
+}
+
+// src/adapters/codex.ts
+var MARKETPLACE_NAME = "personal";
+var MARKETPLACE_DISPLAY_NAME = "Personal";
+var GLOBAL_MARKETPLACE_PATH = path4.join(os2.homedir(), ".agents", "plugins", "marketplace.json");
+var PLUGIN_CATEGORY = "Productivity";
+var CODEX_PLUGIN_LINK = ".codex/plugins/mstar-harness";
+var CODEX_AGENT_NAMES = [
+  "product-manager",
+  "architect",
+  "fullstack-dev",
+  "fullstack-dev-2",
+  "frontend-dev",
+  "qa-engineer",
+  "qc-specialist",
+  "qc-specialist-2",
+  "qc-specialist-3",
+  "ops-engineer",
+  "writing-specialist",
+  "prompt-engineer"
+];
+function globalMarketplacePath() {
+  return GLOBAL_MARKETPLACE_PATH;
+}
+function projectMarketplacePath() {
+  return path4.join(resolveProjectRoot(), ".agents", "plugins", "marketplace.json");
+}
+function agentSourcePath(agentName) {
+  return path4.join(HARNESS_REPO_PATH, "codex", "agents", `${agentName}.toml`);
+}
+function globalAgentLinkPath(agentName) {
+  return path4.join(os2.homedir(), ".codex", "agents", `${agentName}.toml`);
+}
+function projectAgentLinkPath(agentName) {
+  return path4.join(resolveProjectRoot(), ".codex", "agents", `${agentName}.toml`);
+}
+function mstarEntry(scope) {
+  const sourcePath = scope === "global" ? homeRelativeSourcePath(HARNESS_REPO_PATH) : `./${CODEX_PLUGIN_LINK}`;
+  return {
+    name: PLUGIN_NAME,
+    source: {
+      source: "local",
+      path: sourcePath
+    },
+    policy: {
+      installation: "AVAILABLE",
+      authentication: "ON_INSTALL"
+    },
+    category: PLUGIN_CATEGORY
+  };
+}
+function normalizeMarketplace(raw) {
+  const next = ensureObject(raw);
+  next.name = MARKETPLACE_NAME;
+  const iface = ensureObject(next.interface);
+  if (typeof iface.displayName !== "string" || !iface.displayName.trim()) {
+    iface.displayName = MARKETPLACE_DISPLAY_NAME;
+  }
+  next.interface = iface;
+  if (!Array.isArray(next.plugins)) {
+    next.plugins = [];
+  }
+  return next;
+}
+function upsertEntry(raw, scope) {
+  const next = normalizeMarketplace(raw);
+  const plugins = next.plugins.filter((entry) => {
+    return !(entry && typeof entry === "object" && !Array.isArray(entry) && entry.name === PLUGIN_NAME);
+  });
+  plugins.push(mstarEntry(scope));
+  next.plugins = plugins;
+  return next;
+}
+function findEntry(raw) {
+  const plugins = Array.isArray(raw.plugins) ? raw.plugins : [];
+  return plugins.find((entry) => {
+    return entry && typeof entry === "object" && !Array.isArray(entry) && entry.name === PLUGIN_NAME;
+  });
+}
+function validateEntryShape(entry, scope, marketplacePath) {
+  const errors2 = [];
+  if (!entry) {
+    errors2.push(`Missing ${PLUGIN_NAME} entry in ${marketplacePath}.`);
+    return errors2;
+  }
+  const source = ensureObject(entry.source);
+  const expectedSourcePath = mstarEntry(scope).source.path;
+  if (source.source !== "local")
+    errors2.push("Codex marketplace entry source.source must be `local`.");
+  if (source.path !== expectedSourcePath) {
+    errors2.push(`Codex marketplace entry source.path must be ${expectedSourcePath}.`);
+  }
+  const policy = ensureObject(entry.policy);
+  if (policy.installation !== "AVAILABLE")
+    errors2.push("Codex marketplace entry policy.installation must be AVAILABLE.");
+  if (policy.authentication !== "ON_INSTALL")
+    errors2.push("Codex marketplace entry policy.authentication must be ON_INSTALL.");
+  if (entry.category !== PLUGIN_CATEGORY)
+    errors2.push(`Codex marketplace entry category must be ${PLUGIN_CATEGORY}.`);
+  return errors2;
+}
+function marketplacePath(scope) {
+  if (scope === "global")
+    return globalMarketplacePath();
+  return projectMarketplacePath();
+}
+function ensureAgentLinks(scope, dryRun) {
   const notes = [];
-  if (fs.existsSync(location)) {
-    notes.push(`Plugin already exists at ${location}`);
-    return { location, notes };
+  for (const agentName of CODEX_AGENT_NAMES) {
+    const source = agentSourcePath(agentName);
+    const linkPath = scope === "global" ? globalAgentLinkPath(agentName) : projectAgentLinkPath(agentName);
+    notes.push(ensureSymlink(source, linkPath, dryRun));
+  }
+  return notes;
+}
+function validateAgentLinks(scope) {
+  const errors2 = [];
+  for (const agentName of CODEX_AGENT_NAMES) {
+    const source = agentSourcePath(agentName);
+    const linkPath = scope === "global" ? globalAgentLinkPath(agentName) : projectAgentLinkPath(agentName);
+    errors2.push(...validateSymlink(source, linkPath));
   }
-  ensureDir(path3.dirname(location), dryRun);
-  runCommand(["git", "clone", REPO_URL, location], path3.dirname(location), dryRun);
-  notes.push(`Cloned ${REPO_URL} to ${location}`);
+  return errors2;
+}
+function runInit(scope, dryRun) {
+  const pathToMarketplace = marketplacePath(scope);
+  const current = readJson(pathToMarketplace);
+  const next = upsertEntry(current, scope);
+  const existingEntry = findEntry(current);
+  const notes = ensureLocalHarnessRepo(dryRun);
+  if (scope === "project") {
+    const projectRoot = resolveProjectRoot();
+    notes.push(ensureSymlink(HARNESS_REPO_PATH, path4.join(projectRoot, CODEX_PLUGIN_LINK), dryRun));
+    notes.push(...appendGitignore(projectRoot, [CODEX_PLUGIN_LINK, ".codex/agents/*.toml"], dryRun));
+  }
+  notes.push(...ensureAgentLinks(scope, dryRun));
+  if (!dryRun)
+    writeJson(pathToMarketplace, next);
+  notes.push(existingEntry ? `Updated ${PLUGIN_NAME} local marketplace entry.` : `Added ${PLUGIN_NAME} local marketplace entry.`);
+  notes.push(`Source path: ${mstarEntry(scope).source.path}`);
+  notes.push(`Install after init: codex plugin add ${PLUGIN_NAME} --marketplace ${MARKETPLACE_NAME}`);
+  return {
+    location: pathToMarketplace,
+    notes
+  };
+}
+function runDoctor(scope) {
+  const pathToMarketplace = marketplacePath(scope);
+  const errors2 = validateLocalHarnessRepo();
+  if (!fs3.existsSync(pathToMarketplace)) {
+    return { location: pathToMarketplace, errors: [...errors2, `Missing Codex marketplace: ${pathToMarketplace}`] };
+  }
+  const marketplace = readJson(pathToMarketplace);
+  if (marketplace.name !== MARKETPLACE_NAME) {
+    errors2.push(`Codex personal marketplace name must be ${MARKETPLACE_NAME}.`);
+  }
+  errors2.push(...validateEntryShape(findEntry(marketplace), scope, pathToMarketplace));
+  if (scope === "project") {
+    const projectRoot = resolveProjectRoot();
+    errors2.push(...validateSymlink(HARNESS_REPO_PATH, path4.join(projectRoot, CODEX_PLUGIN_LINK)));
+    const gitignorePath = path4.join(projectRoot, ".gitignore");
+    const gitignore = fs3.existsSync(gitignorePath) ? fs3.readFileSync(gitignorePath, "utf8") : "";
+    const lines = gitignore.split(/\r?\n/);
+    if (!lines.includes(CODEX_PLUGIN_LINK))
+      errors2.push(`Missing .gitignore entry: ${CODEX_PLUGIN_LINK}`);
+    if (!lines.includes(".codex/agents/*.toml"))
+      errors2.push("Missing .gitignore entry: .codex/agents/*.toml");
+  }
+  errors2.push(...validateAgentLinks(scope));
+  return { location: pathToMarketplace, errors: errors2 };
+}
+var codexAdapter = {
+  target: "codex",
+  mode: "install",
+  runInstallInit: (scope, dryRun) => runInit(scope, dryRun),
+  runInstallDoctor: (scope) => runDoctor(scope)
+};
+
+// src/adapters/cursor.ts
+import fs4 from "node:fs";
+import os3 from "node:os";
+import path5 from "node:path";
+var CURSOR_PLUGIN_NAME = "mstar-harness";
+var CURSOR_PLUGIN_MARKER = ".cursor-plugin/plugin.json";
+function globalInstallPath() {
+  return path5.join(os3.homedir(), ".cursor", "plugins", "local", CURSOR_PLUGIN_NAME);
+}
+function projectInstallPath() {
+  return path5.join(resolveProjectRoot(), ".cursor", "plugins", CURSOR_PLUGIN_NAME);
+}
+function globalInit(dryRun) {
+  const location = globalInstallPath();
+  const notes = ensureLocalHarnessRepo(dryRun);
+  notes.push(ensureSymlink(HARNESS_REPO_PATH, location, dryRun));
   return { location, notes };
 }
 function projectInit(dryRun) {
   const projectRoot = resolveProjectRoot();
   const location = projectInstallPath();
-  const notes = [];
-  if (fs.existsSync(location)) {
-    notes.push(`Submodule path already exists at ${location}`);
-    return { location, notes };
-  }
-  runCommand(["git", "rev-parse", "--is-inside-work-tree"], projectRoot, dryRun);
-  ensureDir(path3.join(projectRoot, ".cursor", "plugins"), dryRun);
-  runCommand(["git", "submodule", "add", REPO_URL, ".cursor/plugins/mstar-harness"], projectRoot, dryRun);
-  notes.push("Added mstar-harness as git submodule at .cursor/plugins/mstar-harness");
+  const notes = ensureLocalHarnessRepo(dryRun);
+  notes.push(ensureSymlink(HARNESS_REPO_PATH, location, dryRun));
+  notes.push(...appendGitignore(projectRoot, [".cursor/plugins/mstar-harness"], dryRun));
   return { location, notes };
 }
 function globalDoctor() {
   const location = globalInstallPath();
-  const errors2 = [];
-  if (!fs.existsSync(location)) {
-    errors2.push(`Missing plugin directory: ${location}`);
-    return { location, errors: errors2 };
-  }
-  const marker = path3.join(location, CURSOR_PLUGIN_MARKER);
-  if (!fs.existsSync(marker)) {
+  const errors2 = validateLocalHarnessRepo();
+  errors2.push(...validateSymlink(HARNESS_REPO_PATH, location));
+  const marker = path5.join(location, CURSOR_PLUGIN_MARKER);
+  if (!fs4.existsSync(marker)) {
     errors2.push(`Missing Cursor plugin marker file: ${marker}`);
   }
   return { location, errors: errors2 };
@@ -4327,18 +4620,16 @@ function globalDoctor() {
 function projectDoctor() {
   const projectRoot = resolveProjectRoot();
   const location = projectInstallPath();
-  const errors2 = [];
-  if (!fs.existsSync(location)) {
-    errors2.push(`Missing submodule directory: ${location}`);
-  }
-  const gitmodulesPath = path3.join(projectRoot, ".gitmodules");
-  if (!fs.existsSync(gitmodulesPath)) {
-    errors2.push("Missing .gitmodules (expected cursor plugin submodule entry).");
-    return { location, errors: errors2 };
+  const errors2 = validateLocalHarnessRepo();
+  errors2.push(...validateSymlink(HARNESS_REPO_PATH, location));
+  const marker = path5.join(location, CURSOR_PLUGIN_MARKER);
+  if (!fs4.existsSync(marker)) {
+    errors2.push(`Missing Cursor plugin marker file: ${marker}`);
   }
-  const gitmodules = fs.readFileSync(gitmodulesPath, "utf8");
-  if (!gitmodules.includes("path = .cursor/plugins/mstar-harness")) {
-    errors2.push("Missing .cursor/plugins/mstar-harness entry in .gitmodules.");
+  const gitignorePath = path5.join(projectRoot, ".gitignore");
+  const gitignore = fs4.existsSync(gitignorePath) ? fs4.readFileSync(gitignorePath, "utf8") : "";
+  if (!gitignore.split(/\r?\n/).includes(".cursor/plugins/mstar-harness")) {
+    errors2.push("Missing .gitignore entry: .cursor/plugins/mstar-harness");
   }
   return { location, errors: errors2 };
 }
@@ -4358,8 +4649,8 @@ var cursorAdapter = {
 };
 
 // src/adapters/opencode.ts
-import os2 from "node:os";
-import path4 from "node:path";
+import os4 from "node:os";
+import path6 from "node:path";
 import { execFileSync as execFileSync2 } from "node:child_process";
 var OPENCODE_CONFIG_SCHEMA = "https://opencode.ai/config.json";
 var MSTAR_OPENCODE_PLUGIN = "@mstar-harness/opencode@latest";
@@ -4388,11 +4679,11 @@ function getOpencodeModels() {
 function resolveOpencodeConfigPath(scope, outputPath) {
   if (outputPath && outputPath.trim()) {
     const raw = outputPath.trim();
-    return path4.isAbsolute(raw) ? raw : path4.join(resolveProjectRoot(), raw);
+    return path6.isAbsolute(raw) ? raw : path6.join(resolveProjectRoot(), raw);
   }
   if (scope === "global")
-    return path4.join(os2.homedir(), ".config", "opencode", "opencode.json");
-  return path4.join(resolveProjectRoot(), "opencode.json");
+    return path6.join(os4.homedir(), ".config", "opencode", "opencode.json");
+  return path6.join(resolveProjectRoot(), "opencode.json");
 }
 function ensureConfigSchema(config) {
   const next = ensureObject(config);
@@ -4486,7 +4777,8 @@ var opencodeAdapter = {
 // src/adapters/index.ts
 var adapters = {
   opencode: opencodeAdapter,
-  cursor: cursorAdapter
+  cursor: cursorAdapter,
+  codex: codexAdapter
 };
 function getAdapter(target) {
   const adapter = adapters[target];
@@ -4496,20 +4788,20 @@ function getAdapter(target) {
 }
 
 // src/types.ts
-var SUPPORTED_TARGETS = ["opencode", "cursor"];
+var SUPPORTED_TARGETS = ["opencode", "cursor", "codex"];
 
 // src/utils.ts
-import fs2 from "node:fs";
-import path5 from "node:path";
+import fs5 from "node:fs";
+import path7 from "node:path";
 function parseCsv(raw) {
   if (!raw)
     return;
   return raw.split(",").map((item) => item.trim()).filter(Boolean);
 }
-function readJson(filePath) {
-  if (!fs2.existsSync(filePath))
+function readJson2(filePath) {
+  if (!fs5.existsSync(filePath))
     return {};
-  const content = fs2.readFileSync(filePath, "utf8").trim();
+  const content = fs5.readFileSync(filePath, "utf8").trim();
   if (!content)
     return {};
   try {
@@ -4518,19 +4810,19 @@ function readJson(filePath) {
     throw new Error(`Invalid JSON in ${filePath}: ${error.message}`);
   }
 }
-function writeJson(filePath, value) {
-  const parent = path5.dirname(filePath);
-  if (!fs2.existsSync(parent))
-    fs2.mkdirSync(parent, { recursive: true });
-  fs2.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+function writeJson2(filePath, value) {
+  const parent = path7.dirname(filePath);
+  if (!fs5.existsSync(parent))
+    fs5.mkdirSync(parent, { recursive: true });
+  fs5.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 
 // src/index.ts
-var packageJsonPath = path6.resolve(path6.dirname(fileURLToPath(import.meta.url)), "../package.json");
+var packageJsonPath = path8.resolve(path8.dirname(fileURLToPath(import.meta.url)), "../package.json");
 var packageVersion = (() => {
   try {
-    const parsed = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(fs6.readFileSync(packageJsonPath, "utf8"));
     return parsed.version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -4609,7 +4901,7 @@ async function resolveSelections(options, models) {
     })
   };
 }
-async function runInit(options) {
+async function runInit2(options) {
   const target = options.target || (options.yes ? "opencode" : await pickTargetInteractive());
   const scope = options.scope || "project";
   const adapter = getAdapter(target);
@@ -4641,7 +4933,7 @@ async function runInit(options) {
   const configPath = adapter.resolveConfigPath?.(scope, options.output);
   if (!configPath)
     throw new Error(`Adapter ${target} does not implement config path resolution.`);
-  const current = readJson(configPath);
+  const current = readJson2(configPath);
   const updated = adapter.mutateConfigForInit?.(current, assignments);
   if (!updated)
     throw new Error(`Adapter ${target} does not implement init mutation.`);
@@ -4653,8 +4945,8 @@ async function runInit(options) {
 - `)}`);
   }
   if (!options.dryRun) {
-    writeJson(configPath, updated);
-    const persistedErrors = adapter.validateConfig?.(readJson(configPath)) || [];
+    writeJson2(configPath, updated);
+    const persistedErrors = adapter.validateConfig?.(readJson2(configPath)) || [];
     if (persistedErrors.length) {
       throw new Error(`Post-write verification failed:
 - ${persistedErrors.join(`
@@ -4671,7 +4963,7 @@ async function runInit(options) {
     console.log(`  - ${roleId}: ${modelId}`);
   }
 }
-function runDoctor(options) {
+function runDoctor2(options) {
   const target = options.target || "opencode";
   const adapter = getAdapter(target);
   const scope = options.scope || "project";
@@ -4696,7 +4988,7 @@ function runDoctor(options) {
   if (!configPath) {
     throw new Error(`Adapter ${target} does not implement config doctor flow.`);
   }
-  const config = readJson(configPath);
+  const config = readJson2(configPath);
   const errors2 = adapter.validateConfig?.(config) || [];
   console.log(`Config file: ${configPath}`);
   if (!errors2.length) {
@@ -4716,10 +5008,10 @@ function runDoctor(options) {
 }
 program2.name("mstar-harness").description("Morning Star harness CLI for target-based agent bootstrap").version(packageVersion);
 program2.command("init").description("Interactive/non-interactive setup for target agent bootstrap").option("-y, --yes", "Non-interactive mode").option("--target <target>", "Install target", "opencode").option("--scope <scope>", "Config scope: global|project (default: project)").option("--output <path>", "Config file path override, relative to project root").option("--dry-run", "Preview result without writing config").option("--pm-model <model>", "Model for project-manager").option("--strategic-models <a,b,c>", "Models for architect/product-manager/prompt-engineer").option("--dev-models <a,b,c>", "Models for fullstack-dev/fullstack-dev-2/frontend-dev").option("--qc-models <a,b,c>", "Models for qc trio").option("--other-models <a,b,c>", "Models for random assignment to remaining roles").action(async (options) => {
-  await runInit(options);
+  await runInit2(options);
 });
 program2.command("doctor").description("Validate Morning Star setup for a target agent config").option("--target <target>", "Target agent for doctor checks", "opencode").option("--scope <scope>", "Config scope: global|project", "project").option("--output <path>", "Config file path override, relative to project root").action((options) => {
-  runDoctor(options);
+  runDoctor2(options);
 });
 program2.parseAsync(process.argv).catch((error) => {
   console.error(import_picocolors.default.red(`Setup failed: ${error.message}`));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mstar-harness/cli",
-  "version": "0.3.1",
-  "description": "Morning Star harness installer CLI (OpenCode, Cursor).",
+  "version": "0.5.0",
+  "description": "Morning Star harness installer CLI (OpenCode, Cursor, Codex).",
   "license": "MIT",
   "repository": {
     "type": "git",