@mstar-harness/cli 0.4.0 → 0.5.1

package/dist/mstar-harness.js

@@ -2344,8 +2344,8 @@ var require_commander = __commonJS((exports) => {
 });
 
 // src/index.ts
-import fs5 from "fs";
-import path7 from "path";
+import fs6 from "fs";
+import path8 from "path";
 import { fileURLToPath } from "url";
 
 // ../../node_modules/@inquirer/core/dist/lib/key.js
@@ -4241,9 +4241,9 @@ function buildModelAssignments(selections) {
 }
 
 // src/adapters/codex.ts
-import fs2 from "node:fs";
-import os from "node:os";
-import path3 from "node:path";
+import fs3 from "node:fs";
+import os2 from "node:os";
+import path4 from "node:path";
 
 // src/utils.ts
 import fs from "node:fs";
@@ -4283,21 +4283,169 @@ function resolveProjectRoot() {
   return process.cwd();
 }
 
+// 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 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 (!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 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 MARKETPLACE_PATH = path3.join(os.homedir(), ".agents", "plugins", "marketplace.json");
-var PLUGIN_NAME = "morning-star-harness";
-var PLUGIN_URL = "https://github.com/btspoony/mstar-harness.git";
-var PLUGIN_REF = "main";
+var GLOBAL_MARKETPLACE_PATH = path4.join(os2.homedir(), ".agents", "plugins", "marketplace.json");
 var PLUGIN_CATEGORY = "Productivity";
-function mstarEntry() {
+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: "url",
-      url: PLUGIN_URL,
-      ref: PLUGIN_REF
+      source: "local",
+      path: sourcePath
     },
     policy: {
       installation: "AVAILABLE",
@@ -4319,12 +4467,12 @@ function normalizeMarketplace(raw) {
   }
   return next;
 }
-function upsertEntry(raw) {
+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());
+  plugins.push(mstarEntry(scope));
   next.plugins = plugins;
   return next;
 }
@@ -4334,19 +4482,19 @@ function findEntry(raw) {
     return entry && typeof entry === "object" && !Array.isArray(entry) && entry.name === PLUGIN_NAME;
   });
 }
-function validateEntryShape(entry) {
+function validateEntryShape(entry, scope, marketplacePath) {
   const errors2 = [];
   if (!entry) {
-    errors2.push(`Missing ${PLUGIN_NAME} entry in ${MARKETPLACE_PATH}.`);
+    errors2.push(`Missing ${PLUGIN_NAME} entry in ${marketplacePath}.`);
     return errors2;
   }
   const source = ensureObject(entry.source);
-  if (source.source !== "url")
-    errors2.push("Codex marketplace entry source.source must be `url`.");
-  if (source.url !== PLUGIN_URL)
-    errors2.push(`Codex marketplace entry source.url must be ${PLUGIN_URL}.`);
-  if (source.ref !== PLUGIN_REF)
-    errors2.push(`Codex marketplace entry source.ref must be ${PLUGIN_REF}.`);
+  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.");
@@ -4356,120 +4504,157 @@ function validateEntryShape(entry) {
     errors2.push(`Codex marketplace entry category must be ${PLUGIN_CATEGORY}.`);
   return errors2;
 }
-function runInit(dryRun) {
-  const current = readJson(MARKETPLACE_PATH);
-  const next = upsertEntry(current);
+function marketplacePath(scope) {
+  if (scope === "global")
+    return globalMarketplacePath();
+  return projectMarketplacePath();
+}
+function ensureAgentLinks(scope, dryRun) {
+  const 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));
+  }
+  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(MARKETPLACE_PATH, next);
+    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: MARKETPLACE_PATH,
-    notes: [
-      existingEntry ? `Updated ${PLUGIN_NAME} entry in personal Codex marketplace.` : `Added ${PLUGIN_NAME} entry to personal Codex marketplace.`,
-      `Source URL: ${PLUGIN_URL}#${PLUGIN_REF}`,
-      `Install after init: codex plugin add ${PLUGIN_NAME} --marketplace ${String(next.name)}`
-    ]
+    location: pathToMarketplace,
+    notes
   };
 }
-function runDoctor() {
-  const errors2 = [];
-  if (!fs2.existsSync(MARKETPLACE_PATH)) {
-    return { location: MARKETPLACE_PATH, errors: [`Missing Codex personal marketplace: ${MARKETPLACE_PATH}`] };
+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(MARKETPLACE_PATH);
+  const marketplace = readJson(pathToMarketplace);
   if (marketplace.name !== MARKETPLACE_NAME) {
     errors2.push(`Codex personal marketplace name must be ${MARKETPLACE_NAME}.`);
   }
-  errors2.push(...validateEntryShape(findEntry(marketplace)));
-  return { location: MARKETPLACE_PATH, errors: errors2 };
+  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(dryRun),
-  runInstallDoctor: () => runDoctor()
+  runInstallInit: (scope, dryRun) => runInit(scope, dryRun),
+  runInstallDoctor: (scope) => runDoctor(scope)
 };
 
 // src/adapters/cursor.ts
-import fs3 from "node:fs";
-import os2 from "node:os";
-import path4 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";
+import fs4 from "node:fs";
+import os3 from "node:os";
+import path5 from "node:path";
+var CURSOR_PLUGIN_NAME = "morning-star-harness";
 var CURSOR_PLUGIN_MARKER = ".cursor-plugin/plugin.json";
+var CURSOR_PLUGIN_LINK = ".cursor/plugins/morning-star-harness";
+var CURSOR_AGENT_SMOKE_NAMES = ["fullstack-dev", "qc-specialist"];
 function globalInstallPath() {
-  return path4.join(os2.homedir(), ".cursor", "plugins", "local", CURSOR_PLUGIN_NAME);
+  return path5.join(os3.homedir(), ".cursor", "plugins", "local", CURSOR_PLUGIN_NAME);
 }
 function projectInstallPath() {
-  return path4.join(resolveProjectRoot(), ".cursor", "plugins", CURSOR_PLUGIN_NAME);
-}
-function ensureDir(dirPath, dryRun) {
-  if (dryRun)
-    return;
-  if (!fs3.existsSync(dirPath))
-    fs3.mkdirSync(dirPath, { recursive: true });
+  return path5.join(resolveProjectRoot(), CURSOR_PLUGIN_LINK);
 }
-function runCommand(command, cwd, dryRun) {
-  if (dryRun)
-    return;
-  execFileSync(command[0], command.slice(1), { cwd, stdio: "pipe", encoding: "utf8" });
+function validatePluginAgents() {
+  const errors2 = [];
+  const agentsDir = path5.join(HARNESS_REPO_PATH, "agents");
+  if (!fs4.existsSync(agentsDir)) {
+    errors2.push(`Missing plugin agents directory: ${agentsDir}`);
+    return errors2;
+  }
+  for (const agentName of CURSOR_AGENT_SMOKE_NAMES) {
+    const agentPath = path5.join(agentsDir, `${agentName}.md`);
+    if (!fs4.existsSync(agentPath)) {
+      errors2.push(`Missing plugin agent file: ${agentPath}`);
+      continue;
+    }
+    const content = fs4.readFileSync(agentPath, "utf8");
+    if (!/^---\nname:\s/m.test(content)) {
+      errors2.push(`Plugin agent ${agentName}.md must use Cursor-first frontmatter (name, description, model before OpenCode fields).`);
+    }
+  }
+  return errors2;
 }
 function globalInit(dryRun) {
   const location = globalInstallPath();
-  const notes = [];
-  if (fs3.existsSync(location)) {
-    notes.push(`Plugin already exists at ${location}`);
-    return { location, notes };
-  }
-  ensureDir(path4.dirname(location), dryRun);
-  runCommand(["git", "clone", REPO_URL, location], path4.dirname(location), dryRun);
-  notes.push(`Cloned ${REPO_URL} to ${location}`);
+  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 (fs3.existsSync(location)) {
-    notes.push(`Submodule path already exists at ${location}`);
-    return { location, notes };
-  }
-  runCommand(["git", "rev-parse", "--is-inside-work-tree"], projectRoot, dryRun);
-  ensureDir(path4.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_PLUGIN_LINK], dryRun));
   return { location, notes };
 }
 function globalDoctor() {
   const location = globalInstallPath();
-  const errors2 = [];
-  if (!fs3.existsSync(location)) {
-    errors2.push(`Missing plugin directory: ${location}`);
-    return { location, errors: errors2 };
-  }
-  const marker = path4.join(location, CURSOR_PLUGIN_MARKER);
-  if (!fs3.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}`);
   }
+  errors2.push(...validatePluginAgents());
   return { location, errors: errors2 };
 }
 function projectDoctor() {
   const projectRoot = resolveProjectRoot();
   const location = projectInstallPath();
-  const errors2 = [];
-  if (!fs3.existsSync(location)) {
-    errors2.push(`Missing submodule directory: ${location}`);
-  }
-  const gitmodulesPath = path4.join(projectRoot, ".gitmodules");
-  if (!fs3.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 = fs3.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_PLUGIN_LINK)) {
+    errors2.push(`Missing .gitignore entry: ${CURSOR_PLUGIN_LINK}`);
   }
+  errors2.push(...validatePluginAgents());
   return { location, errors: errors2 };
 }
 var cursorAdapter = {
@@ -4488,8 +4673,8 @@ var cursorAdapter = {
 };
 
 // src/adapters/opencode.ts
-import os3 from "node:os";
-import path5 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";
@@ -4518,11 +4703,11 @@ function getOpencodeModels() {
 function resolveOpencodeConfigPath(scope, outputPath) {
   if (outputPath && outputPath.trim()) {
     const raw = outputPath.trim();
-    return path5.isAbsolute(raw) ? raw : path5.join(resolveProjectRoot(), raw);
+    return path6.isAbsolute(raw) ? raw : path6.join(resolveProjectRoot(), raw);
   }
   if (scope === "global")
-    return path5.join(os3.homedir(), ".config", "opencode", "opencode.json");
-  return path5.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);
@@ -4630,17 +4815,17 @@ function getAdapter(target) {
 var SUPPORTED_TARGETS = ["opencode", "cursor", "codex"];
 
 // src/utils.ts
-import fs4 from "node:fs";
-import path6 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 readJson2(filePath) {
-  if (!fs4.existsSync(filePath))
+  if (!fs5.existsSync(filePath))
     return {};
-  const content = fs4.readFileSync(filePath, "utf8").trim();
+  const content = fs5.readFileSync(filePath, "utf8").trim();
   if (!content)
     return {};
   try {
@@ -4650,18 +4835,18 @@ function readJson2(filePath) {
   }
 }
 function writeJson2(filePath, value) {
-  const parent = path6.dirname(filePath);
-  if (!fs4.existsSync(parent))
-    fs4.mkdirSync(parent, { recursive: true });
-  fs4.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+  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 = path7.resolve(path7.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(fs5.readFileSync(packageJsonPath, "utf8"));
+    const parsed = JSON.parse(fs6.readFileSync(packageJsonPath, "utf8"));
     return parsed.version || "0.0.0";
   } catch {
     return "0.0.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mstar-harness/cli",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Morning Star harness installer CLI (OpenCode, Cursor, Codex).",
   "license": "MIT",
   "repository": {