@izantech/lineup-cli 2.0.0

package/dist/chunk-RQBQVCEG.js

@@ -0,0 +1,1451 @@
+// src/cli.ts
+import { readFileSync as readFileSync6 } from "fs";
+import path8 from "path";
+import process2 from "process";
+import { Command } from "commander";
+
+// src/lib/output.ts
+function printJson(payload) {
+  process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+}
+function printTableLine(text) {
+  process.stdout.write(`${text}
+`);
+}
+
+// src/lib/operations.ts
+import { rmSync as rmSync3 } from "fs";
+
+// src/lib/errors.ts
+var CliError = class extends Error {
+  code;
+  exitCode;
+  constructor(message, options) {
+    super(message);
+    this.name = "CliError";
+    this.code = options?.code ?? "cli_error";
+    this.exitCode = options?.exitCode ?? 1;
+  }
+};
+function asErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+// src/lib/host-claude.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import path4 from "path";
+
+// src/lib/constants.ts
+var GENERATED_BANNER = "<!-- AUTO-GENERATED. Edit canonical source in .lineup-core/. -->";
+var LINEUP_PLUGIN_NAME = "lineup";
+var CLAUDE_LEGACY_PLUGIN = "lineup@izantech";
+var CLAUDE_LOCAL_MARKETPLACE_NAME = "lineup-local";
+var CLAUDE_LOCAL_PLUGIN = `${LINEUP_PLUGIN_NAME}@${CLAUDE_LOCAL_MARKETPLACE_NAME}`;
+var SUPPORTED_HOSTS = ["claude", "codex"];
+var CODEX_SKILL_DIRS = [
+  "lineup-kick-off",
+  "lineup-configure",
+  "lineup-explain",
+  "lineup-playbook"
+];
+var CODEX_REQUIRED_FILES = [
+  ".agents/skills/lineup-kick-off/SKILL.md",
+  ".agents/skills/lineup-kick-off/INIT.md",
+  ".agents/skills/lineup-configure/SKILL.md",
+  ".agents/skills/lineup-explain/SKILL.md",
+  ".agents/skills/lineup-playbook/SKILL.md"
+];
+var HOST_TEMPLATE_SPECS = [
+  {
+    source: ".lineup-core/skills/kick-off/core.md",
+    targetFor: {
+      claude: "skills/{{SKILL_NAME_KICKOFF}}/SKILL.md",
+      codex: ".agents/skills/{{SKILL_NAME_KICKOFF}}/SKILL.md"
+    }
+  },
+  {
+    source: ".lineup-core/skills/kick-off/init.core.md",
+    targetFor: {
+      claude: "skills/{{SKILL_NAME_KICKOFF}}/INIT.md",
+      codex: ".agents/skills/{{SKILL_NAME_KICKOFF}}/INIT.md"
+    }
+  },
+  {
+    source: ".lineup-core/skills/configure/core.md",
+    targetFor: {
+      claude: "skills/{{SKILL_NAME_CONFIGURE}}/SKILL.md",
+      codex: ".agents/skills/{{SKILL_NAME_CONFIGURE}}/SKILL.md"
+    }
+  },
+  {
+    source: ".lineup-core/skills/explain/core.md",
+    targetFor: {
+      claude: "skills/{{SKILL_NAME_EXPLAIN}}/SKILL.md",
+      codex: ".agents/skills/{{SKILL_NAME_EXPLAIN}}/SKILL.md"
+    }
+  },
+  {
+    source: ".lineup-core/skills/playbook/core.md",
+    targetFor: {
+      claude: "skills/{{SKILL_NAME_PLAYBOOK}}/SKILL.md",
+      codex: ".agents/skills/{{SKILL_NAME_PLAYBOOK}}/SKILL.md"
+    }
+  }
+];
+
+// src/lib/generate.ts
+import { cpSync, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+import path3 from "path";
+
+// src/lib/validation.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync } from "fs";
+import path2 from "path";
+import Ajv2020 from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+import { parseDocument } from "yaml";
+
+// src/lib/paths.ts
+import { existsSync, readFileSync } from "fs";
+import os from "os";
+import path from "path";
+import { fileURLToPath } from "url";
+function packageRoot() {
+  const file = fileURLToPath(import.meta.url);
+  let current = path.dirname(file);
+  const filesystemRoot = path.parse(current).root;
+  while (true) {
+    const candidate = path.join(current, "package.json");
+    if (existsSync(candidate)) {
+      try {
+        const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+        if (parsed.name === "@izantech/lineup-cli") {
+          return current;
+        }
+      } catch {
+      }
+    }
+    if (current === filesystemRoot) {
+      break;
+    }
+    current = path.dirname(current);
+  }
+  return path.resolve(path.dirname(file), "..", "..");
+}
+function lineupHome(homeDir = os.homedir()) {
+  return path.join(homeDir, ".lineup");
+}
+function lineupStateFile(homeDir = os.homedir()) {
+  return path.join(lineupHome(homeDir), "state.json");
+}
+function lineupCacheDir(homeDir = os.homedir()) {
+  return path.join(lineupHome(homeDir), "cache");
+}
+function codexGlobalSkillsDir(homeDir = os.homedir()) {
+  return path.join(homeDir, ".agents", "skills");
+}
+function claudeHostRoot(homeDir = os.homedir()) {
+  return path.join(lineupHome(homeDir), "hosts", "claude");
+}
+function codexHostRoot(homeDir = os.homedir()) {
+  return path.join(lineupHome(homeDir), "hosts", "codex");
+}
+function claudeManagedPluginDir(version, homeDir = os.homedir()) {
+  return path.join(claudeMarketplaceRoot(homeDir), "plugins", "lineup", version);
+}
+function claudeMarketplaceRoot(homeDir = os.homedir()) {
+  return path.join(claudeHostRoot(homeDir), "marketplace");
+}
+function codexRepoLocalSkillsDir(cwd = process.cwd()) {
+  return path.join(cwd, ".agents", "skills");
+}
+function purgeTargets(hosts, homeDir = os.homedir()) {
+  const targets = [];
+  if (hosts.includes("claude")) {
+    targets.push(path.join(homeDir, ".claude", "lineup", "agents"));
+  }
+  if (hosts.includes("codex")) {
+    targets.push(path.join(homeDir, ".codex", "lineup", "agents"));
+    targets.push(path.join(homeDir, ".codex", "lineup", "memory"));
+  }
+  return targets;
+}
+
+// src/lib/validation.ts
+var ajv = new Ajv2020({ allErrors: true, strict: true, allowUnionTypes: true });
+addFormats(ajv);
+var validators = /* @__PURE__ */ new Map();
+function schemaPath(relativePath) {
+  return path2.join(packageRoot(), "schemas", relativePath);
+}
+function loadValidator(relativePath) {
+  const key = relativePath;
+  const existing = validators.get(key);
+  if (existing) {
+    return existing;
+  }
+  const content = readFileSync2(schemaPath(relativePath), "utf8");
+  const schema = JSON.parse(content);
+  const compiled = ajv.compile(schema);
+  validators.set(key, compiled);
+  return compiled;
+}
+function formatErrors(validate) {
+  const lines = (validate.errors ?? []).map((error) => {
+    const loc = error.instancePath || "/";
+    return `- ${loc} ${error.message ?? "invalid"}`;
+  });
+  return lines.join("\n");
+}
+function assertValid(schemaRelPath, payload, label) {
+  const validate = loadValidator(schemaRelPath);
+  const ok = validate(payload);
+  if (!ok) {
+    throw new CliError(`${label} failed schema validation:
+${formatErrors(validate)}`, {
+      code: "schema_validation_failed"
+    });
+  }
+}
+function validateHostAdapter(payload, source) {
+  assertValid("json/host-adapter.schema.json", payload, `Host adapter ${source}`);
+  return payload;
+}
+function validateInstallerState(payload, source) {
+  assertValid("json/state.schema.json", payload, `State file ${source}`);
+  return payload;
+}
+function validateReleaseManifest(payload, source) {
+  assertValid("json/release-manifest.schema.json", payload, `Release manifest ${source}`);
+  return payload;
+}
+function parseRestrictedYaml(content, source) {
+  if (/(^|\s)&[A-Za-z0-9_-]+/m.test(content)) {
+    throw new CliError(`${source}: YAML anchors are not allowed.`, {
+      code: "yaml_anchor_not_allowed"
+    });
+  }
+  if (/(^|\s)\*[A-Za-z0-9_-]+/m.test(content)) {
+    throw new CliError(`${source}: YAML aliases are not allowed.`, {
+      code: "yaml_alias_not_allowed"
+    });
+  }
+  if (/(^|\s)!\S+/m.test(content)) {
+    throw new CliError(`${source}: YAML custom tags are not allowed.`, {
+      code: "yaml_tag_not_allowed"
+    });
+  }
+  const doc = parseDocument(content, {
+    uniqueKeys: true,
+    merge: false
+  });
+  if (doc.errors.length > 0) {
+    const message = doc.errors.map((item) => item.message).join("\n");
+    throw new CliError(`${source}: YAML parse failed:
+${message}`, {
+      code: "yaml_parse_failed"
+    });
+  }
+  return doc.toJSON();
+}
+function validateTacticYaml(content, source) {
+  const parsed = parseRestrictedYaml(content, source);
+  assertValid("yaml/tactic.schema.json", parsed, `Tactic YAML ${source}`);
+}
+var AGENT_SCHEMA_MAP = {
+  researcher: "yaml/agent-output/researcher.schema.json",
+  architect: "yaml/agent-output/architect.schema.json",
+  developer: "yaml/agent-output/developer.schema.json",
+  reviewer: "yaml/agent-output/reviewer.schema.json",
+  documenter: "yaml/agent-output/documenter.schema.json",
+  teacher: "yaml/agent-output/teacher.schema.json"
+};
+function validateAgentOutputYaml(kind, content, source) {
+  const parsed = parseRestrictedYaml(content, source);
+  assertValid(AGENT_SCHEMA_MAP[kind], parsed, `${kind} output ${source}`);
+}
+function readJsonFile(filePath) {
+  return JSON.parse(readFileSync2(filePath, "utf8"));
+}
+function readTextFile(filePath) {
+  return readFileSync2(filePath, "utf8");
+}
+function listFilesWithExtension(directory, extension) {
+  if (!existsSync2(directory)) {
+    return [];
+  }
+  return readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(extension)).map((entry) => path2.join(directory, entry.name)).sort();
+}
+function validateSourceBundle(sourceRoot) {
+  const hostsDir = path2.join(sourceRoot, ".lineup-core", "hosts");
+  for (const hostFile of listFilesWithExtension(hostsDir, ".json")) {
+    validateHostAdapter(readJsonFile(hostFile), hostFile);
+  }
+  const tacticsDir = path2.join(sourceRoot, "tactics");
+  for (const tacticFile of listFilesWithExtension(tacticsDir, ".yaml")) {
+    validateTacticYaml(readTextFile(tacticFile), tacticFile);
+  }
+  const templateMap = {
+    researcher: "researcher",
+    architect: "architect",
+    developer: "developer",
+    reviewer: "reviewer",
+    documenter: "documenter",
+    teacher: "teacher"
+  };
+  const templatesDir = path2.join(sourceRoot, "templates");
+  for (const [name, kind] of Object.entries(templateMap)) {
+    const filePath = path2.join(templatesDir, `${name}.yaml`);
+    validateAgentOutputYaml(kind, readTextFile(filePath), filePath);
+  }
+}
+
+// src/lib/generate.ts
+function readJson(filePath) {
+  return JSON.parse(readFileSync3(filePath, "utf8"));
+}
+function readText(filePath) {
+  return readFileSync3(filePath, "utf8");
+}
+function loadHostAdapter(sourceRoot, host) {
+  const adapterPath = path3.join(sourceRoot, ".lineup-core", "hosts", `${host}.json`);
+  const payload = readJson(adapterPath);
+  return validateHostAdapter(payload, adapterPath);
+}
+function renderTemplate(rawTemplate, vars, source, host) {
+  return rawTemplate.replace(/\{\{([A-Z0-9_]+)\}\}/g, (full, token) => {
+    if (!(token in vars)) {
+      throw new CliError(`Missing template variable '${token}' while rendering ${source} for ${host}.`, {
+        code: "missing_template_variable"
+      });
+    }
+    return String(vars[token]);
+  });
+}
+function renderPathTemplate(pathTemplate, vars) {
+  return pathTemplate.replace(/\{\{([A-Z0-9_]+)\}\}/g, (full, token) => {
+    return vars[token] ?? full;
+  });
+}
+function withBanner(content) {
+  const trimmed = content.replace(/\s+$/u, "");
+  return `${GENERATED_BANNER}
+
+${trimmed}
+`;
+}
+function generateHostFiles(sourceRoot, host) {
+  const adapter = loadHostAdapter(sourceRoot, host);
+  const vars = adapter.vars;
+  return HOST_TEMPLATE_SPECS.map((spec) => {
+    const source = spec.source;
+    const template = readText(path3.join(sourceRoot, source));
+    const rendered = renderTemplate(template, vars, source, host);
+    const pathTemplate = spec.targetFor[host];
+    return {
+      host,
+      source,
+      target: renderPathTemplate(pathTemplate, vars),
+      content: withBanner(rendered)
+    };
+  });
+}
+function writeGeneratedFiles(files, outputRoot) {
+  for (const file of files) {
+    const absolute = path3.join(outputRoot, file.target);
+    mkdirSync(path3.dirname(absolute), { recursive: true });
+    writeFileSync(absolute, file.content, "utf8");
+  }
+}
+function prepareClaudePluginSkeleton(sourceRoot, outputRoot) {
+  const copyPaths = [".claude-plugin", "agents", "tactics", "templates", "examples", "AGENTS.md", "CLAUDE.md"];
+  for (const entry of copyPaths) {
+    const from = path3.join(sourceRoot, entry);
+    const to = path3.join(outputRoot, entry);
+    cpSync(from, to, { recursive: true });
+  }
+}
+
+// src/lib/process.ts
+import { spawn } from "child_process";
+async function runCommand(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (error) => {
+      if (error.code === "ENOENT") {
+        reject(
+          new CliError(`Required command not found: ${command}`, {
+            code: "command_not_found"
+          })
+        );
+        return;
+      }
+      reject(error);
+    });
+    child.on("close", (code) => {
+      resolve({
+        code: code ?? 1,
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+function assertSuccess(result, label, allowPatterns = []) {
+  if (result.code === 0) {
+    return;
+  }
+  const combined = `${result.stdout}
+${result.stderr}`;
+  if (allowPatterns.some((pattern) => pattern.test(combined))) {
+    return;
+  }
+  throw new CliError(
+    [
+      `${label} failed with exit code ${result.code}.`,
+      result.stdout.trim() ? `stdout:
+${result.stdout.trim()}` : null,
+      result.stderr.trim() ? `stderr:
+${result.stderr.trim()}` : null
+    ].filter(Boolean).join("\n"),
+    {
+      code: "command_failed"
+    }
+  );
+}
+
+// src/lib/host-claude.ts
+function parseInstallPresence(output2) {
+  return {
+    localInstalled: new RegExp(`${LINEUP_PLUGIN_NAME}@${CLAUDE_LOCAL_MARKETPLACE_NAME}`, "i").test(output2),
+    legacyInstalled: new RegExp(CLAUDE_LEGACY_PLUGIN, "i").test(output2)
+  };
+}
+function writeMarketplace(root, pluginSource, version) {
+  const dotClaude = path4.join(root, ".claude-plugin");
+  mkdirSync2(dotClaude, { recursive: true });
+  const marketplace = {
+    name: CLAUDE_LOCAL_MARKETPLACE_NAME,
+    owner: {
+      name: "izantech"
+    },
+    metadata: {
+      description: "CLI-managed local marketplace for Lineup",
+      version
+    },
+    plugins: [
+      {
+        name: LINEUP_PLUGIN_NAME,
+        source: `./${path4.relative(root, pluginSource)}`,
+        version,
+        description: "Lineup local managed plugin"
+      }
+    ]
+  };
+  const filePath = path4.join(dotClaude, "marketplace.json");
+  writeFileSync2(filePath, `${JSON.stringify(marketplace, null, 2)}
+`, "utf8");
+  return root;
+}
+function prepareClaudePluginFromSource(sourceRoot, version) {
+  const targetRoot = claudeManagedPluginDir(version);
+  mkdirSync2(targetRoot, { recursive: true });
+  prepareClaudePluginSkeleton(sourceRoot, targetRoot);
+  const files = generateHostFiles(sourceRoot, "claude");
+  writeGeneratedFiles(files, targetRoot);
+  const pluginManifest = path4.join(targetRoot, ".claude-plugin", "plugin.json");
+  if (!existsSync3(pluginManifest)) {
+    throw new CliError(`Generated Claude plugin is missing manifest: ${pluginManifest}`, {
+      code: "missing_plugin_manifest"
+    });
+  }
+  return targetRoot;
+}
+async function statusClaude() {
+  try {
+    const result = await runCommand("claude", ["plugin", "list"]);
+    if (result.code !== 0) {
+      return {
+        host: "claude",
+        installed: false,
+        version: null,
+        source: null,
+        last_action: null,
+        error: result.stderr.trim() || "Failed to run claude plugin list"
+      };
+    }
+    const output2 = `${result.stdout}
+${result.stderr}`;
+    const parsed = parseInstallPresence(output2);
+    return {
+      host: "claude",
+      installed: parsed.localInstalled || parsed.legacyInstalled,
+      version: null,
+      source: parsed.localInstalled ? "cli-managed" : parsed.legacyInstalled ? "legacy-marketplace" : null,
+      last_action: null,
+      ...parsed.legacyInstalled ? { error: "Legacy marketplace install detected." } : {}
+    };
+  } catch (error) {
+    return {
+      host: "claude",
+      installed: false,
+      version: null,
+      source: null,
+      last_action: null,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function installClaudeFromPreparedPlugin({
+  pluginSource,
+  version,
+  migrateLegacy
+}) {
+  const marketplaceRoot = claudeMarketplaceRoot();
+  const marketplacePath = writeMarketplace(marketplaceRoot, pluginSource, version);
+  if (migrateLegacy) {
+    const removeLegacy = await runCommand("claude", ["plugin", "remove", CLAUDE_LEGACY_PLUGIN]);
+    if (removeLegacy.code !== 0) {
+      const combined = `${removeLegacy.stdout}
+${removeLegacy.stderr}`;
+      if (!/not installed|unknown|could not find/i.test(combined)) {
+        assertSuccess(removeLegacy, "claude plugin remove lineup@izantech");
+      }
+    }
+  }
+  const addMarketplace = await runCommand("claude", ["plugin", "marketplace", "add", marketplacePath]);
+  assertSuccess(addMarketplace, "claude plugin marketplace add", [/already|exists|configured/i]);
+  const installPlugin = await runCommand("claude", ["plugin", "install", CLAUDE_LOCAL_PLUGIN]);
+  assertSuccess(installPlugin, `claude plugin install ${CLAUDE_LOCAL_PLUGIN}`, [/already installed|already exists/i]);
+}
+async function updateClaudeLocal() {
+  const update = await runCommand("claude", ["plugin", "update", CLAUDE_LOCAL_PLUGIN]);
+  assertSuccess(update, `claude plugin update ${CLAUDE_LOCAL_PLUGIN}`);
+}
+async function uninstallClaude() {
+  const removeLocal = await runCommand("claude", ["plugin", "remove", CLAUDE_LOCAL_PLUGIN]);
+  if (removeLocal.code !== 0) {
+    const output2 = `${removeLocal.stdout}
+${removeLocal.stderr}`;
+    if (!/not installed|unknown/i.test(output2)) {
+      assertSuccess(removeLocal, `claude plugin remove ${CLAUDE_LOCAL_PLUGIN}`);
+    }
+  }
+}
+async function detectLegacyClaudeInstall() {
+  const status = await statusClaude();
+  return status.source === "legacy-marketplace";
+}
+
+// src/lib/host-codex.ts
+import { cpSync as cpSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, renameSync, rmSync } from "fs";
+import path5 from "path";
+function ensureCodexGenerated(sourceRoot, outputRoot) {
+  const files = generateHostFiles(sourceRoot, "codex");
+  writeGeneratedFiles(files, outputRoot);
+  return path5.join(outputRoot, ".agents", "skills");
+}
+function requiredAbsolutePaths(baseDir) {
+  return CODEX_REQUIRED_FILES.map((relative) => path5.join(baseDir, ...relative.replace(/^\.agents\/skills\//, "").split("/")));
+}
+function validateCodexSkillsDir(baseDir) {
+  const missing = requiredAbsolutePaths(baseDir).filter((item) => !existsSync4(item));
+  if (missing.length > 0) {
+    throw new CliError([`Codex skills directory is missing required files in ${baseDir}:`, ...missing.map((item) => `- ${item}`)].join("\n"), {
+      code: "codex_skill_validation_failed"
+    });
+  }
+}
+function replaceDirectoryAtomic(sourceDir, targetDir) {
+  const parentDir = path5.dirname(targetDir);
+  const nonce = `${Date.now()}-${process.pid}`;
+  const tempDir = path5.join(parentDir, `.${path5.basename(targetDir)}.tmp-${nonce}`);
+  const backupDir = path5.join(parentDir, `.${path5.basename(targetDir)}.bak-${nonce}`);
+  mkdirSync3(parentDir, { recursive: true });
+  cpSync2(sourceDir, tempDir, { recursive: true });
+  let movedTarget = false;
+  try {
+    if (existsSync4(targetDir)) {
+      renameSync(targetDir, backupDir);
+      movedTarget = true;
+    }
+    renameSync(tempDir, targetDir);
+    if (movedTarget && existsSync4(backupDir)) {
+      rmSync(backupDir, { recursive: true, force: true });
+    }
+  } catch (error) {
+    if (existsSync4(tempDir)) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+    if (movedTarget && !existsSync4(targetDir) && existsSync4(backupDir)) {
+      renameSync(backupDir, targetDir);
+    }
+    throw error;
+  }
+}
+function installCodex({
+  sourceRoot,
+  workspaceRoot,
+  global = true
+}) {
+  const generatedRoot = path5.join(workspaceRoot, "generated", "codex");
+  const sourceSkills = ensureCodexGenerated(sourceRoot, generatedRoot);
+  validateCodexSkillsDir(sourceSkills);
+  const destinationRoot = global ? codexGlobalSkillsDir() : codexRepoLocalSkillsDir();
+  mkdirSync3(destinationRoot, { recursive: true });
+  for (const dirName of CODEX_SKILL_DIRS) {
+    const from = path5.join(sourceSkills, dirName);
+    const to = path5.join(destinationRoot, dirName);
+    replaceDirectoryAtomic(from, to);
+  }
+  validateCodexSkillsDir(destinationRoot);
+  return {
+    skills_dir: destinationRoot,
+    files_verified: CODEX_REQUIRED_FILES.length
+  };
+}
+function uninstallCodex(global = true) {
+  const root = global ? codexGlobalSkillsDir() : codexRepoLocalSkillsDir();
+  for (const dirName of CODEX_SKILL_DIRS) {
+    const target = path5.join(root, dirName);
+    if (existsSync4(target)) {
+      rmSync(target, { recursive: true, force: true });
+    }
+  }
+  return { skills_dir: root };
+}
+function statusCodex(global = true) {
+  const root = global ? codexGlobalSkillsDir() : codexRepoLocalSkillsDir();
+  const missing = requiredAbsolutePaths(root).filter((item) => !existsSync4(item));
+  return {
+    host: "codex",
+    installed: missing.length === 0,
+    version: null,
+    source: null,
+    last_action: null,
+    ...missing.length > 0 ? { error: `Missing ${missing.length} required files.` } : {}
+  };
+}
+
+// src/lib/prompts.ts
+import readline from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+function isInteractive() {
+  return Boolean(input.isTTY && output.isTTY);
+}
+function createInterface() {
+  return readline.createInterface({ input, output });
+}
+function parseYesNo(raw, defaultValue) {
+  const value = raw.trim().toLowerCase();
+  if (!value) {
+    return defaultValue;
+  }
+  if (value === "y" || value === "yes") {
+    return true;
+  }
+  if (value === "n" || value === "no") {
+    return false;
+  }
+  return null;
+}
+async function promptHostSelection() {
+  const rl = createInterface();
+  try {
+    output.write("Select host(s):\n");
+    output.write("  1. claude\n");
+    output.write("  2. codex\n");
+    output.write("  3. all\n");
+    while (true) {
+      const answer = await rl.question("Enter selection [1-3]: ");
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === "1" || normalized === "claude") {
+        return ["claude"];
+      }
+      if (normalized === "2" || normalized === "codex") {
+        return ["codex"];
+      }
+      if (normalized === "3" || normalized === "all") {
+        return ["claude", "codex"];
+      }
+      output.write("Invalid selection. Choose 1, 2, or 3.\n");
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function promptConfirm(message, defaultValue = false) {
+  const rl = createInterface();
+  try {
+    while (true) {
+      const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+      const answer = await rl.question(`${message} ${suffix} `);
+      const parsed = parseYesNo(answer, defaultValue);
+      if (parsed === null) {
+        output.write("Please answer yes or no.\n");
+        continue;
+      }
+      return parsed;
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function promptMigrationConfirm() {
+  return promptConfirm("Detected existing lineup@izantech install. Migrate to CLI-managed install now?", true);
+}
+async function promptUninstallPlan(hosts) {
+  const proceed = await promptConfirm(`Uninstall Lineup for host(s): ${hosts.join(", ")}?`, false);
+  if (!proceed) {
+    return { proceed: false, purge: false };
+  }
+  const purge = await promptConfirm(
+    "Also purge Lineup data (~/.claude/lineup/agents, ~/.codex/lineup/agents, ~/.codex/lineup/memory)?",
+    false
+  );
+  return { proceed: true, purge };
+}
+
+// src/lib/release.ts
+import { createHash } from "crypto";
+import {
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync4,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { readFile } from "fs/promises";
+import path6 from "path";
+var OWNER = "izantech";
+var REPO = "lineup";
+var API_BASE = `https://api.github.com/repos/${OWNER}/${REPO}`;
+var MANIFEST_ASSET_NAME = "lineup-manifest.json";
+async function fetchJson(url) {
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": "lineup-cli",
+      Accept: "application/vnd.github+json"
+    }
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new CliError(`Failed to fetch ${url}: ${response.status} ${body}`, {
+      code: "http_error"
+    });
+  }
+  return response.json();
+}
+async function fetchText(url) {
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": "lineup-cli",
+      Accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new CliError(`Failed to fetch ${url}: ${response.status} ${body}`, {
+      code: "http_error"
+    });
+  }
+  return response.text();
+}
+async function downloadBinary(url) {
+  const response = await fetch(url, {
+    headers: {
+      "User-Agent": "lineup-cli",
+      Accept: "application/octet-stream"
+    }
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new CliError(`Failed to download ${url}: ${response.status} ${body}`, {
+      code: "http_error"
+    });
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+}
+function cachePaths(tag) {
+  const cacheDir = path6.join(lineupCacheDir(), tag);
+  return {
+    cacheDir,
+    manifestPath: path6.join(cacheDir, "manifest.json"),
+    tarballPath: path6.join(cacheDir, "release.tar.gz"),
+    extractDir: path6.join(cacheDir, "extracted"),
+    sourceRoot: path6.join(cacheDir, "source")
+  };
+}
+function sha256File(filePath) {
+  const content = readFileSync4(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+async function resolveLatestTag() {
+  const payload = await fetchJson(`${API_BASE}/releases/latest`);
+  if (!payload.tag_name) {
+    throw new CliError("Unable to resolve latest release tag.", {
+      code: "missing_latest_tag"
+    });
+  }
+  return payload.tag_name;
+}
+async function resolveReleaseByTag(tag) {
+  const payload = await fetchJson(`${API_BASE}/releases/tags/${encodeURIComponent(tag)}`);
+  if (!payload.tag_name) {
+    throw new CliError(`Release tag not found: ${tag}`, {
+      code: "release_not_found"
+    });
+  }
+  return payload;
+}
+async function fetchReleaseManifest(tag) {
+  const release = await resolveReleaseByTag(tag);
+  const manifestAsset = (release.assets ?? []).find((asset) => asset.name === MANIFEST_ASSET_NAME);
+  const candidates = [];
+  if (manifestAsset?.browser_download_url) {
+    candidates.push(manifestAsset.browser_download_url);
+  }
+  candidates.push(`https://raw.githubusercontent.com/${OWNER}/${REPO}/${encodeURIComponent(tag)}/release-manifest.json`);
+  for (const url of candidates) {
+    try {
+      const text = await fetchText(url);
+      const parsed = JSON.parse(text);
+      const manifest = validateReleaseManifest(parsed, url);
+      if (manifest.tag !== tag) {
+        throw new CliError(`Manifest tag mismatch. expected=${tag} actual=${manifest.tag}`, {
+          code: "manifest_tag_mismatch"
+        });
+      }
+      return manifest;
+    } catch {
+      continue;
+    }
+  }
+  throw new CliError(`Could not fetch release manifest for ${tag}. Expected asset ${MANIFEST_ASSET_NAME} in release artifacts.`, {
+    code: "release_manifest_missing"
+  });
+}
+function validateExtractedSource(sourceRoot) {
+  const required = [
+    ".lineup-core/skills/kick-off/core.md",
+    ".lineup-core/hosts/claude.json",
+    ".lineup-core/hosts/codex.json",
+    "agents/researcher.md",
+    "templates/tactic.yaml"
+  ];
+  const missing = required.filter((item) => !existsSync5(path6.join(sourceRoot, item)));
+  if (missing.length > 0) {
+    throw new CliError(`Release source missing required files:
+${missing.map((item) => `- ${item}`).join("\n")}`, {
+      code: "release_source_invalid"
+    });
+  }
+}
+function chooseExtractedRoot(extractDir) {
+  const dirs = readdirSync2(extractDir, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+  if (dirs.length === 0) {
+    throw new CliError(`No extracted source directory found in ${extractDir}.`, {
+      code: "extract_failed"
+    });
+  }
+  return path6.join(extractDir, dirs[0].name);
+}
+async function extractTarball(tarballPath, extractDir) {
+  rmSync2(extractDir, { recursive: true, force: true });
+  mkdirSync4(extractDir, { recursive: true });
+  const result = await runCommand("tar", ["-xzf", tarballPath, "-C", extractDir]);
+  assertSuccess(result, `tar -xzf ${tarballPath}`);
+}
+function loadCachedManifest(manifestPath) {
+  if (!existsSync5(manifestPath)) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync4(manifestPath, "utf8"));
+    return validateReleaseManifest(parsed, manifestPath);
+  } catch {
+    return null;
+  }
+}
+async function resolveRelease(input2 = {}) {
+  const tag = input2.version && input2.version !== "latest" ? input2.version : await resolveLatestTag();
+  const { cacheDir, manifestPath, tarballPath, extractDir, sourceRoot } = cachePaths(tag);
+  mkdirSync4(cacheDir, { recursive: true });
+  const cachedManifest = loadCachedManifest(manifestPath);
+  if (cachedManifest && existsSync5(sourceRoot)) {
+    validateExtractedSource(sourceRoot);
+    return {
+      tag,
+      sourceRoot,
+      cacheDir,
+      manifest: cachedManifest
+    };
+  }
+  const manifest = await fetchReleaseManifest(tag);
+  writeFileSync3(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+  const tarball = await downloadBinary(manifest.tarball_url);
+  writeFileSync3(tarballPath, tarball);
+  const digest = sha256File(tarballPath);
+  if (digest.toLowerCase() !== manifest.sha256.toLowerCase()) {
+    rmSync2(tarballPath, { force: true });
+    throw new CliError(`Checksum mismatch for ${tag}. expected=${manifest.sha256} actual=${digest}`, {
+      code: "checksum_mismatch"
+    });
+  }
+  await extractTarball(tarballPath, extractDir);
+  const extractedRoot = chooseExtractedRoot(extractDir);
+  rmSync2(sourceRoot, { recursive: true, force: true });
+  renameSync2(extractedRoot, sourceRoot);
+  rmSync2(extractDir, { recursive: true, force: true });
+  validateExtractedSource(sourceRoot);
+  return {
+    tag,
+    sourceRoot,
+    cacheDir,
+    manifest
+  };
+}
+function resolveLocalRelease(dirPath) {
+  const resolvedPath = path6.resolve(dirPath);
+  if (!existsSync5(resolvedPath)) {
+    throw new CliError(`Local directory does not exist: ${resolvedPath}`, {
+      code: "local_dir_not_found"
+    });
+  }
+  validateExtractedSource(resolvedPath);
+  let tag = "local";
+  try {
+    const pkgPath = path6.join(resolvedPath, "cli", "package.json");
+    const parsed = JSON.parse(readFileSync4(pkgPath, "utf8"));
+    if (parsed.version) {
+      tag = parsed.version;
+    }
+  } catch {
+  }
+  return {
+    tag,
+    sourceRoot: resolvedPath,
+    cacheDir: resolvedPath,
+    manifest: {
+      tag,
+      tarball_url: "local",
+      sha256: "local"
+    }
+  };
+}
+
+// src/lib/state.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import path7 from "path";
+var STATE_SCHEMA_VERSION = 1;
+function defaultState() {
+  return {
+    schema_version: STATE_SCHEMA_VERSION,
+    updated_at: null,
+    hosts: {}
+  };
+}
+function loadState(filePath = lineupStateFile()) {
+  if (!existsSync6(filePath)) {
+    return defaultState();
+  }
+  try {
+    const raw = readFileSync5(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return validateInstallerState(parsed, filePath);
+  } catch {
+    return defaultState();
+  }
+}
+function saveState(state, filePath = lineupStateFile()) {
+  const payload = {
+    schema_version: STATE_SCHEMA_VERSION,
+    updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+    hosts: state.hosts
+  };
+  const valid = validateInstallerState(payload, filePath);
+  mkdirSync5(path7.dirname(filePath), { recursive: true });
+  writeFileSync4(filePath, `${JSON.stringify(valid, null, 2)}
+`, "utf8");
+  return valid;
+}
+function updateHostState(state, host, patch) {
+  const previous = state.hosts[host] ?? {
+    installed: false,
+    last_action: null,
+    last_updated_at: null
+  };
+  state.hosts[host] = {
+    ...previous,
+    ...patch,
+    last_updated_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return state;
+}
+
+// src/lib/operations.ts
+var defaultDeps = {
+  resolveRelease,
+  resolveLocalRelease,
+  validateSourceBundle,
+  detectLegacyClaudeInstall,
+  installClaudeFromPreparedPlugin,
+  prepareClaudePluginFromSource,
+  statusClaude,
+  uninstallClaude,
+  updateClaudeLocal,
+  installCodex,
+  statusCodex,
+  uninstallCodex,
+  codexHostRoot,
+  lineupStateFile,
+  purgeTargets,
+  isInteractive,
+  promptMigrationConfirm,
+  promptUninstallPlan,
+  loadState,
+  saveState,
+  updateHostState,
+  removePath: (target) => {
+    rmSync3(target, { recursive: true, force: true });
+  },
+  asErrorMessage
+};
+function summarizeFailures(failures, action) {
+  const lines = [
+    `Failed to ${action} Lineup for ${failures.length} host(s):`,
+    ...failures.map((failure) => `- ${failure.host}: ${failure.error}`)
+  ];
+  throw new CliError(lines.join("\n"), {
+    code: `host_${action}_failed`
+  });
+}
+function mergeStatus(stateHost, runtimeHost) {
+  return {
+    host: runtimeHost.host,
+    installed: runtimeHost.installed,
+    version: runtimeHost.version ?? stateHost?.version ?? null,
+    source: runtimeHost.source ?? stateHost?.source ?? null,
+    last_action: stateHost?.last_action ?? runtimeHost.last_action ?? null,
+    ...runtimeHost.error ? { error: runtimeHost.error } : {}
+  };
+}
+function createOperations(overrides = {}) {
+  const deps = {
+    ...defaultDeps,
+    ...overrides
+  };
+  async function shouldMigrateLegacyClaudeInstall(yes) {
+    const legacyDetected = await deps.detectLegacyClaudeInstall();
+    if (!legacyDetected) {
+      return false;
+    }
+    if (yes) {
+      return true;
+    }
+    if (!deps.isInteractive()) {
+      throw new CliError(
+        "Detected legacy Claude install (lineup@izantech). Re-run with --yes to migrate in non-interactive mode.",
+        {
+          code: "migration_confirmation_required"
+        }
+      );
+    }
+    const approved = await deps.promptMigrationConfirm();
+    if (!approved) {
+      throw new CliError("Migration cancelled by user.", {
+        code: "migration_cancelled"
+      });
+    }
+    return true;
+  }
+  async function performInstallOrUpdate2(input2) {
+    const release = input2.fromDir ? deps.resolveLocalRelease(input2.fromDir) : await deps.resolveRelease({ version: input2.version });
+    deps.validateSourceBundle(release.sourceRoot);
+    const state = deps.loadState();
+    const failures = [];
+    const results = [];
+    const migrateLegacyClaude = input2.hosts.includes("claude") ? await shouldMigrateLegacyClaudeInstall(input2.yes) : false;
+    for (const host of input2.hosts) {
+      try {
+        if (host === "claude") {
+          const pluginSource = deps.prepareClaudePluginFromSource(release.sourceRoot, release.tag);
+          await deps.installClaudeFromPreparedPlugin({
+            pluginSource,
+            version: release.tag,
+            migrateLegacy: migrateLegacyClaude
+          });
+          if (input2.action === "update") {
+            await deps.updateClaudeLocal();
+          }
+          deps.updateHostState(state, "claude", {
+            installed: true,
+            version: release.tag,
+            source: "cli-managed",
+            last_action: input2.action
+          });
+          results.push({
+            host,
+            ok: true,
+            message: `Claude ${input2.action} complete (${release.tag}).`
+          });
+        }
+        if (host === "codex") {
+          const codexResult = deps.installCodex({
+            sourceRoot: release.sourceRoot,
+            workspaceRoot: deps.codexHostRoot(),
+            global: true
+          });
+          deps.updateHostState(state, "codex", {
+            installed: true,
+            version: release.tag,
+            source: "cli-managed",
+            skills_dir: codexResult.skills_dir,
+            last_action: input2.action
+          });
+          results.push({
+            host,
+            ok: true,
+            message: `Codex ${input2.action} complete (${release.tag}).`
+          });
+        }
+      } catch (error) {
+        const message = deps.asErrorMessage(error);
+        failures.push({ host, error: message });
+        results.push({
+          host,
+          ok: false,
+          message
+        });
+      }
+    }
+    deps.saveState(state);
+    if (failures.length > 0) {
+      summarizeFailures(failures, input2.action);
+    }
+    return {
+      action: input2.action,
+      tag: release.tag,
+      results
+    };
+  }
+  async function performUninstall2(input2) {
+    let purge = input2.purge;
+    if (!input2.yes) {
+      if (!deps.isInteractive()) {
+        throw new CliError("Uninstall requires confirmation in interactive mode. Use --yes for non-interactive execution.", {
+          code: "uninstall_confirmation_required"
+        });
+      }
+      const plan = await deps.promptUninstallPlan(input2.hosts);
+      if (!plan.proceed) {
+        return {
+          action: "uninstall",
+          cancelled: true,
+          purged_paths: [],
+          results: []
+        };
+      }
+      purge = plan.purge;
+    }
+    const state = deps.loadState();
+    const failures = [];
+    const results = [];
+    for (const host of input2.hosts) {
+      try {
+        if (host === "claude") {
+          await deps.uninstallClaude();
+          deps.updateHostState(state, "claude", {
+            installed: false,
+            version: null,
+            source: null,
+            last_action: "uninstall"
+          });
+          results.push({
+            host,
+            ok: true,
+            message: "Claude uninstall complete."
+          });
+        }
+        if (host === "codex") {
+          deps.uninstallCodex(true);
+          deps.updateHostState(state, "codex", {
+            installed: false,
+            version: null,
+            source: null,
+            skills_dir: null,
+            last_action: "uninstall"
+          });
+          results.push({
+            host,
+            ok: true,
+            message: "Codex uninstall complete."
+          });
+        }
+      } catch (error) {
+        const message = deps.asErrorMessage(error);
+        failures.push({ host, error: message });
+        results.push({ host, ok: false, message });
+      }
+    }
+    const purged = [];
+    if (purge) {
+      const targets = deps.purgeTargets(input2.hosts);
+      for (const target of targets) {
+        deps.removePath(target);
+        purged.push(target);
+      }
+    }
+    deps.saveState(state);
+    if (failures.length > 0) {
+      summarizeFailures(failures, "uninstall");
+    }
+    return {
+      action: "uninstall",
+      cancelled: false,
+      purged_paths: purged,
+      results
+    };
+  }
+  async function readStatus2(hosts) {
+    const state = deps.loadState();
+    const outputHosts = {};
+    for (const host of hosts) {
+      if (host === "claude") {
+        const runtime = await deps.statusClaude();
+        const stateHost = state.hosts.claude ? {
+          host: "claude",
+          installed: state.hosts.claude.installed,
+          version: state.hosts.claude.version ?? null,
+          source: state.hosts.claude.source ?? null,
+          last_action: state.hosts.claude.last_action
+        } : void 0;
+        outputHosts.claude = mergeStatus(stateHost, runtime);
+      }
+      if (host === "codex") {
+        const runtime = deps.statusCodex(true);
+        const stateHost = state.hosts.codex ? {
+          host: "codex",
+          installed: state.hosts.codex.installed,
+          version: state.hosts.codex.version ?? null,
+          source: state.hosts.codex.source ?? null,
+          last_action: state.hosts.codex.last_action
+        } : void 0;
+        outputHosts.codex = mergeStatus(stateHost, runtime);
+      }
+    }
+    return {
+      schema_version: state.schema_version,
+      state_file: deps.lineupStateFile(),
+      hosts: outputHosts
+    };
+  }
+  return {
+    performInstallOrUpdate: performInstallOrUpdate2,
+    performUninstall: performUninstall2,
+    readStatus: readStatus2
+  };
+}
+var operations = createOperations();
+var performInstallOrUpdate = operations.performInstallOrUpdate;
+var performUninstall = operations.performUninstall;
+var readStatus = operations.readStatus;
+
+// src/lib/hosts.ts
+var HOST_SET = /* @__PURE__ */ new Set([...SUPPORTED_HOSTS, "all"]);
+function normalizeHostOption(raw) {
+  if (!raw) {
+    return null;
+  }
+  const normalized = raw.trim().toLowerCase();
+  if (!HOST_SET.has(normalized)) {
+    throw new CliError(`Invalid --host value: ${raw}. Expected claude, codex, or all.`, {
+      code: "invalid_host"
+    });
+  }
+  return normalized;
+}
+function hostOptionToHosts(option) {
+  if (option === "all") {
+    return [...SUPPORTED_HOSTS];
+  }
+  return [option];
+}
+async function resolveRequestedHosts(rawHost, options) {
+  const normalized = normalizeHostOption(rawHost);
+  if (normalized) {
+    return hostOptionToHosts(normalized);
+  }
+  const interactive = options?.interactive ?? isInteractive();
+  if (interactive) {
+    return (options?.prompt ?? promptHostSelection)();
+  }
+  throw new CliError("No host selected. Use --host claude|codex|all when running non-interactively.", {
+    code: "host_required"
+  });
+}
+
+// src/commands/install.ts
+async function runInstallCommand(options) {
+  const hosts = await resolveRequestedHosts(options.host);
+  const result = await performInstallOrUpdate({
+    action: "install",
+    hosts,
+    version: options.version,
+    fromDir: options.fromDir,
+    yes: Boolean(options.yes)
+  });
+  printTableLine(`Installed Lineup ${result.tag} for: ${hosts.join(", ")}`);
+  for (const item of result.results) {
+    printTableLine(`- ${item.host}: ${item.ok ? "ok" : "failed"} (${item.message})`);
+  }
+}
+
+// src/commands/status.ts
+function printHostStatus(host, item) {
+  printTableLine(`- ${host}: ${item.installed ? "installed" : "not installed"}`);
+  printTableLine(`  version: ${item.version ?? "unknown"}`);
+  printTableLine(`  source: ${item.source ?? "unknown"}`);
+  printTableLine(`  last_action: ${item.last_action ?? "none"}`);
+  if (item.error) {
+    printTableLine(`  error: ${item.error}`);
+  }
+}
+async function runStatusCommand(options) {
+  const hosts = await resolveRequestedHosts(options.host);
+  const status = await readStatus(hosts);
+  if (options.json) {
+    printJson(status);
+    return;
+  }
+  for (const host of hosts) {
+    const item = status.hosts[host];
+    if (!item) {
+      continue;
+    }
+    printHostStatus(host, item);
+  }
+  printTableLine(`state_file: ${status.state_file}`);
+}
+
+// src/commands/uninstall.ts
+async function runUninstallCommand(options) {
+  const hosts = await resolveRequestedHosts(options.host);
+  const result = await performUninstall({
+    hosts,
+    yes: Boolean(options.yes),
+    purge: Boolean(options.purge)
+  });
+  if (result.cancelled) {
+    printTableLine("Uninstall cancelled.");
+    return;
+  }
+  printTableLine(`Uninstalled Lineup for: ${hosts.join(", ")}`);
+  for (const item of result.results) {
+    printTableLine(`- ${item.host}: ${item.ok ? "ok" : "failed"} (${item.message})`);
+  }
+  if (result.purged_paths.length > 0) {
+    printTableLine("Purged data paths:");
+    for (const target of result.purged_paths) {
+      printTableLine(`- ${target}`);
+    }
+  }
+}
+
+// src/commands/update.ts
+async function runUpdateCommand(options) {
+  const hosts = await resolveRequestedHosts(options.host);
+  const result = await performInstallOrUpdate({
+    action: "update",
+    hosts,
+    version: options.version,
+    fromDir: options.fromDir,
+    yes: Boolean(options.yes)
+  });
+  printTableLine(`Updated Lineup ${result.tag} for: ${hosts.join(", ")}`);
+  for (const item of result.results) {
+    printTableLine(`- ${item.host}: ${item.ok ? "ok" : "failed"} (${item.message})`);
+  }
+}
+
+// src/cli.ts
+function packageVersion() {
+  const packageJsonPath = path8.join(packageRoot(), "package.json");
+  const raw = readFileSync6(packageJsonPath, "utf8");
+  const parsed = JSON.parse(raw);
+  return parsed.version ?? "0.0.0";
+}
+function buildProgram(handlers) {
+  const commandHandlers = {
+    install: runInstallCommand,
+    update: runUpdateCommand,
+    uninstall: runUninstallCommand,
+    status: runStatusCommand,
+    ...handlers
+  };
+  const program = new Command();
+  program.name("lineup").description("Lineup multi-host manager for Claude Code and Codex").version(packageVersion(), "--cli-version", "output CLI version").showHelpAfterError();
+  program.command("install").description("Install Lineup for selected host(s)").option("--host <host>", "Target host(s): claude|codex|all").option("--version <tag>", "Release tag to install", "latest").option("--from-dir <path>", "Install from local directory instead of GitHub release").option("--yes", "Auto-confirm prompts").action(commandHandlers.install);
+  program.command("update").description("Update Lineup for selected host(s)").option("--host <host>", "Target host(s): claude|codex|all").option("--version <tag>", "Release tag to install", "latest").option("--from-dir <path>", "Install from local directory instead of GitHub release").option("--yes", "Auto-confirm prompts").action(commandHandlers.update);
+  program.command("uninstall").description("Uninstall Lineup for selected host(s)").option("--host <host>", "Target host(s): claude|codex|all").option("--yes", "Auto-confirm prompts").option("--purge", "Purge Lineup data directories").action(commandHandlers.uninstall);
+  program.command("status").description("Show Lineup installation status").option("--host <host>", "Target host(s): claude|codex|all").option("--json", "Emit machine-readable JSON output").action(commandHandlers.status);
+  return program;
+}
+function printCliError(error) {
+  const message = asErrorMessage(error);
+  process2.stderr.write(`${message}
+`);
+}
+function resolveExitCode(error) {
+  if (error instanceof CliError) {
+    return error.exitCode;
+  }
+  return 1;
+}
+function handleFatalError(error) {
+  printCliError(error);
+  process2.exit(resolveExitCode(error));
+}
+async function run(argv = process2.argv) {
+  const program = buildProgram();
+  await program.parseAsync(argv);
+}
+function isDirectExecution(argv) {
+  const entry = argv[1];
+  if (!entry) {
+    return false;
+  }
+  return path8.resolve(entry) === path8.resolve(packageRoot(), "dist", "cli.js");
+}
+if (isDirectExecution(process2.argv)) {
+  run().catch(handleFatalError);
+}
+
+export {
+  validateHostAdapter,
+  validateInstallerState,
+  validateReleaseManifest,
+  buildProgram,
+  printCliError,
+  resolveExitCode,
+  handleFatalError,
+  run
+};