agemon 0.1.0

package/dist/index.js

@@ -0,0 +1,2388 @@
+// src/cli/index.ts
+import { fileURLToPath } from "url";
+import { Command, CommanderError } from "commander";
+
+// src/platform/detect.ts
+import { constants } from "fs";
+import { access, readFile } from "fs/promises";
+import { delimiter, join } from "path";
+var REQUIRED_BINARIES = [
+  "python3",
+  "pip",
+  "pipx",
+  "uv",
+  "crg"
+];
+var UnsupportedPlatformError = class extends Error {
+  constructor(osId, osReleasePath) {
+    super(
+      `agemon v1 supports Ubuntu only. Detected '${osId}' in ${osReleasePath}. Windows and macOS support are planned for v2.`
+    );
+  }
+};
+function normalizeOsReleaseValue(value) {
+  const trimmedValue = value.trim();
+  if (trimmedValue.startsWith('"') && trimmedValue.endsWith('"') || trimmedValue.startsWith("'") && trimmedValue.endsWith("'")) {
+    return trimmedValue.slice(1, -1);
+  }
+  return trimmedValue;
+}
+function parseOsReleaseId(osReleaseContents) {
+  const lines = osReleaseContents.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (trimmedLine.length === 0 || trimmedLine.startsWith("#")) {
+      continue;
+    }
+    const separatorIndex = trimmedLine.indexOf("=");
+    if (separatorIndex === -1) {
+      continue;
+    }
+    const key = trimmedLine.slice(0, separatorIndex).trim();
+    if (key !== "ID") {
+      continue;
+    }
+    return normalizeOsReleaseValue(
+      trimmedLine.slice(separatorIndex + 1)
+    ).toLowerCase();
+  }
+  return "unknown";
+}
+async function findBinaryPath(binaryName, pathEnv) {
+  for (const pathEntry of pathEnv.split(delimiter)) {
+    if (!pathEntry) {
+      continue;
+    }
+    const binaryPath = join(pathEntry, binaryName);
+    try {
+      await access(binaryPath, constants.X_OK);
+      return binaryPath;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function detectBinaries(pathEnv) {
+  const binaryResults = await Promise.all(
+    REQUIRED_BINARIES.map(async (binaryName) => {
+      const binaryPath = await findBinaryPath(binaryName, pathEnv);
+      return {
+        name: binaryName,
+        present: binaryPath !== void 0,
+        path: binaryPath
+      };
+    })
+  );
+  return Object.fromEntries(
+    binaryResults.map((binaryResult) => [binaryResult.name, binaryResult])
+  );
+}
+function resolveOsReleasePath(input) {
+  return input.osReleasePath ?? process.env.AGEMON_OS_RELEASE_PATH ?? "/etc/os-release";
+}
+async function detectPlatform(input = {}) {
+  const osReleasePath = resolveOsReleasePath(input);
+  const osReleaseContents = await readFile(osReleasePath, "utf8");
+  const osId = parseOsReleaseId(osReleaseContents);
+  if (osId !== "ubuntu") {
+    throw new UnsupportedPlatformError(osId, osReleasePath);
+  }
+  return {
+    os: "ubuntu",
+    osReleasePath,
+    binaries: await detectBinaries(input.pathEnv ?? process.env.PATH ?? "")
+  };
+}
+
+// src/platform/service-manager/fake.ts
+import { mkdir, readFile as readFile2, rm, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+function resolveHomeDir(homeDir) {
+  return homeDir ?? process.env.HOME ?? homedir();
+}
+function resolveUser(user) {
+  return user ?? process.env.USER ?? "unknown-user";
+}
+function markerPath(homeDir, unitName) {
+  return join2(homeDir, ".agemon", "fake-services", `${unitName}.json`);
+}
+async function readMarker(homeDir, unitName) {
+  try {
+    const markerContents = await readFile2(
+      markerPath(homeDir, unitName),
+      "utf8"
+    );
+    return JSON.parse(markerContents);
+  } catch {
+    return null;
+  }
+}
+function createFakeServiceManager(input) {
+  const homeDir = resolveHomeDir(input.homeDir);
+  const user = resolveUser(input.user);
+  const isActive = async (unitName) => {
+    const marker = await readMarker(homeDir, unitName);
+    return { active: marker?.active === true };
+  };
+  const registerAutostart = async (registration) => {
+    const destinationPath = markerPath(homeDir, registration.unitName);
+    await mkdir(join2(homeDir, ".agemon", "fake-services"), { recursive: true });
+    const state = {
+      unitName: registration.unitName,
+      unitContents: registration.unitContents,
+      user,
+      active: true,
+      lingerEnabledByAgemon: true
+    };
+    await writeFile(
+      destinationPath,
+      `${JSON.stringify(state, null, 2)}
+`,
+      "utf8"
+    );
+    return {
+      unitPath: destinationPath,
+      lingerEnabledByAgemon: state.lingerEnabledByAgemon
+    };
+  };
+  const unregisterAutostart = async (registration) => {
+    await rm(markerPath(homeDir, registration.unitName), { force: true });
+  };
+  return {
+    isActive,
+    registerAutostart,
+    unregisterAutostart
+  };
+}
+
+// src/platform/service-manager/linux.ts
+import { mkdir as mkdir2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join3 } from "path";
+var SYSTEM_COMMAND_TIMEOUT_MS = 2e4;
+function resolveHomeDir2(homeDir) {
+  return homeDir ?? process.env.HOME ?? homedir2();
+}
+function resolveUser2(user) {
+  const resolvedUser = user ?? process.env.USER;
+  if (!resolvedUser) {
+    try {
+      const fallbackUser = process.env.LOGNAME ?? process.env.USERNAME;
+      if (fallbackUser) {
+        return fallbackUser;
+      }
+    } catch {
+    }
+    throw new Error(
+      "Unable to resolve current user for loginctl commands. Set USER, LOGNAME, or pass an explicit user."
+    );
+  }
+  return resolvedUser;
+}
+function resolveUnitPath(homeDir, unitName) {
+  return join3(homeDir, ".config", "systemd", "user", unitName);
+}
+function isMissingUnitError(stderr) {
+  const normalized = stderr.toLowerCase();
+  return normalized.includes("not loaded") || normalized.includes("no such file") || normalized.includes("not found");
+}
+async function assertSucceeded(run, command, args, failureMessage) {
+  const result = await run(command, args, {
+    timeoutMs: SYSTEM_COMMAND_TIMEOUT_MS
+  });
+  if (result.code !== 0) {
+    throw new Error(result.stderr || failureMessage);
+  }
+  return { stdout: result.stdout, stderr: result.stderr };
+}
+function createLinuxServiceManager(input) {
+  const homeDir = resolveHomeDir2(input.homeDir);
+  const user = resolveUser2(input.user);
+  const isActive = async (unitName) => {
+    const result = await input.run(
+      "systemctl",
+      ["--user", "is-active", unitName],
+      {
+        timeoutMs: SYSTEM_COMMAND_TIMEOUT_MS
+      }
+    );
+    return { active: result.code === 0 };
+  };
+  const registerAutostart = async (registration) => {
+    const unitPath = resolveUnitPath(homeDir, registration.unitName);
+    await mkdir2(dirname(unitPath), { recursive: true });
+    await writeFile2(unitPath, registration.unitContents, "utf8");
+    const lingerStatus = await assertSucceeded(
+      input.run,
+      "loginctl",
+      ["show-user", user, "--property=Linger", "--value"],
+      "Unable to read linger status."
+    );
+    const lingerWasOn = lingerStatus.stdout.trim() === "yes";
+    if (!lingerWasOn) {
+      await assertSucceeded(
+        input.run,
+        "loginctl",
+        ["enable-linger", user],
+        "Unable to enable linger for current user."
+      );
+    }
+    await assertSucceeded(
+      input.run,
+      "systemctl",
+      ["--user", "daemon-reload"],
+      "Unable to reload systemd user units."
+    );
+    await assertSucceeded(
+      input.run,
+      "systemctl",
+      ["--user", "enable", "--now", registration.unitName],
+      "Unable to enable/start the daemon unit."
+    );
+    return {
+      unitPath,
+      lingerEnabledByAgemon: !lingerWasOn
+    };
+  };
+  const unregisterAutostart = async (registration) => {
+    const disableResult = await input.run(
+      "systemctl",
+      ["--user", "disable", "--now", registration.unitName],
+      {
+        timeoutMs: SYSTEM_COMMAND_TIMEOUT_MS
+      }
+    );
+    if (disableResult.code !== 0 && !isMissingUnitError(disableResult.stderr || "")) {
+      throw new Error(
+        disableResult.stderr || "Unable to disable/stop the daemon unit during uninstall."
+      );
+    }
+    const unitPath = resolveUnitPath(homeDir, registration.unitName);
+    await rm2(unitPath, { force: true });
+    await assertSucceeded(
+      input.run,
+      "systemctl",
+      ["--user", "daemon-reload"],
+      "Unable to reload systemd user units."
+    );
+    if (registration.disableLinger) {
+      await assertSucceeded(
+        input.run,
+        "loginctl",
+        ["disable-linger", user],
+        "Unable to disable linger for current user."
+      );
+    }
+  };
+  return {
+    isActive,
+    registerAutostart,
+    unregisterAutostart
+  };
+}
+
+// src/platform/service-manager/index.ts
+function createServiceManager(input) {
+  if (process.env.AGEMON_FAKE_SERVICES === "1") {
+    return createFakeServiceManager({
+      homeDir: input.homeDir,
+      user: input.user
+    });
+  }
+  return createLinuxServiceManager({
+    run: input.run,
+    homeDir: input.homeDir,
+    user: input.user
+  });
+}
+
+// src/core/state-manifest.ts
+import { randomUUID } from "crypto";
+import { mkdir as mkdir3, readFile as readFile3, rename, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2, join as join4 } from "path";
+var MANIFEST_RELATIVE_PATH = ".agemon/state.json";
+function createDefaultState(now) {
+  return {
+    version: 1,
+    createdAt: now,
+    updatedAt: now,
+    os: "linux",
+    actions: []
+  };
+}
+function isManifestAction(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const typed = value;
+  return typeof typed.id === "string" && typeof typed.plugin === "string" && typeof typed.type === "string" && typeof typed.target === "string" && typeof typed.preExisting === "boolean" && typeof typed.createdAt === "string";
+}
+function isStateManifestData(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const typed = value;
+  return typed.version === 1 && typed.os === "linux" && typeof typed.createdAt === "string" && typeof typed.updatedAt === "string" && Array.isArray(typed.actions) && typed.actions.every((action) => isManifestAction(action));
+}
+var StateManifest = class _StateManifest {
+  constructor(manifestPath, state) {
+    this.manifestPath = manifestPath;
+    this.state = state;
+  }
+  manifestPath;
+  state;
+  static async load(cwd) {
+    const manifestPath = join4(cwd, MANIFEST_RELATIVE_PATH);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const contents = await readFile3(manifestPath, "utf8");
+      const parsed = JSON.parse(contents);
+      if (!isStateManifestData(parsed)) {
+        throw new Error("State manifest has an invalid schema");
+      }
+      return new _StateManifest(manifestPath, parsed);
+    } catch (error) {
+      const errno = error;
+      if (errno.code === "ENOENT") {
+        return new _StateManifest(manifestPath, createDefaultState(now));
+      }
+      throw new Error(
+        `Unable to load manifest at ${manifestPath}: ${String(error)}`
+      );
+    }
+  }
+  getActions() {
+    return [...this.state.actions];
+  }
+  hasActions() {
+    return this.state.actions.length > 0;
+  }
+  hasActionForPlugin(plugin) {
+    return this.state.actions.some((action) => action.plugin === plugin);
+  }
+  async recordAction(input) {
+    const action = {
+      id: randomUUID(),
+      plugin: input.plugin,
+      type: input.type,
+      target: input.target,
+      preExisting: input.preExisting,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.state.actions.push(action);
+    await this.persist();
+    return action;
+  }
+  async removeActionsForPlugin(plugin) {
+    const nextActions = this.state.actions.filter(
+      (action) => action.plugin !== plugin
+    );
+    if (nextActions.length === this.state.actions.length) {
+      return;
+    }
+    this.state.actions = nextActions;
+    await this.persist();
+  }
+  async pruneIfEmpty() {
+    if (this.state.actions.length > 0) {
+      return;
+    }
+    const manifestDir = dirname2(this.manifestPath);
+    await rm3(this.manifestPath, { force: true });
+    try {
+      await rm3(manifestDir, { recursive: false });
+    } catch {
+      return;
+    }
+  }
+  async persist() {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.state.updatedAt = now;
+    const payload = `${JSON.stringify(this.state, null, 2)}
+`;
+    const manifestDir = dirname2(this.manifestPath);
+    const tempPath = `${this.manifestPath}.tmp-${process.pid}-${Date.now()}`;
+    await mkdir3(manifestDir, { recursive: true });
+    await writeFile3(tempPath, payload, "utf8");
+    await rename(tempPath, this.manifestPath);
+  }
+};
+
+// src/core/subprocess-runner.ts
+import { spawn } from "child_process";
+function formatCommand(command, args) {
+  return [command, ...args].join(" ");
+}
+var fakeCrgInstalledState = null;
+var fakeInstalledSkillNames = null;
+var fakeInstalledGlobalNpmPackageNames = null;
+var fakeStateSignature = null;
+function buildFakeStateSignature() {
+  return [
+    process.env.AGEMON_FAKE_PREINSTALLED_CRG ?? "",
+    process.env.AGEMON_FAKE_PREINSTALLED_SKILLS ?? "",
+    process.env.AGEMON_FAKE_PREINSTALLED_NPM_PACKAGES ?? ""
+  ].join("||");
+}
+function initializeFakeStateIfNeeded() {
+  const currentStateSignature = buildFakeStateSignature();
+  if (fakeCrgInstalledState !== null && fakeStateSignature === currentStateSignature) {
+    return;
+  }
+  fakeStateSignature = currentStateSignature;
+  fakeCrgInstalledState = process.env.AGEMON_FAKE_PREINSTALLED_CRG === "1";
+  const preinstalledSkills = process.env.AGEMON_FAKE_PREINSTALLED_SKILLS?.split(
+    ","
+  ).map((skillName) => skillName.trim()).filter((skillName) => skillName.length > 0);
+  fakeInstalledSkillNames = new Set(preinstalledSkills ?? []);
+  const preinstalledGlobalNpmPackages = process.env.AGEMON_FAKE_PREINSTALLED_NPM_PACKAGES?.split(",").map((packageName) => packageName.trim()).filter((packageName) => packageName.length > 0);
+  fakeInstalledGlobalNpmPackageNames = new Set(
+    preinstalledGlobalNpmPackages ?? []
+  );
+}
+function readOptionValue(args, optionName) {
+  const optionIndex = args.indexOf(optionName);
+  if (optionIndex < 0) {
+    return void 0;
+  }
+  return args[optionIndex + 1];
+}
+function buildFakeSkillsList() {
+  const skills = Array.from(fakeInstalledSkillNames ?? []).map((name) => ({
+    name,
+    path: `/fake/.claude/skills/${name}`,
+    scope: "project",
+    agents: ["Claude Code"]
+  }));
+  return {
+    code: 0,
+    stdout: `${JSON.stringify(skills, null, 2)}
+`,
+    stderr: ""
+  };
+}
+function buildFakeSkillsAdd(args) {
+  const packageSource = args[2];
+  if (!packageSource) {
+    return {
+      code: 1,
+      stdout: "",
+      stderr: "skills add requires a package source"
+    };
+  }
+  const skillName = readOptionValue(args, "--skill") ?? packageSource;
+  fakeInstalledSkillNames?.add(skillName);
+  return {
+    code: 0,
+    stdout: `installed skill ${skillName} from ${packageSource}
+`,
+    stderr: ""
+  };
+}
+function buildFakeSkillsRemove(args) {
+  const skillNames = args.slice(2).filter((arg) => arg.length > 0 && !arg.startsWith("-"));
+  for (const skillName of skillNames) {
+    fakeInstalledSkillNames?.delete(skillName);
+  }
+  return {
+    code: 0,
+    stdout: `removed ${skillNames.length} skill(s)
+`,
+    stderr: ""
+  };
+}
+function buildFakeNpxResponse(args) {
+  if (args[0] !== "skills") {
+    return void 0;
+  }
+  const subcommand = args[1];
+  if (subcommand === "list" || subcommand === "ls") {
+    return buildFakeSkillsList();
+  }
+  if (subcommand === "add") {
+    return buildFakeSkillsAdd(args);
+  }
+  if (subcommand === "remove" || subcommand === "rm") {
+    return buildFakeSkillsRemove(args);
+  }
+  return {
+    code: 0,
+    stdout: `[fake subprocess] npx ${args.join(" ")}
+`,
+    stderr: ""
+  };
+}
+function buildFakeCrgResponse(args) {
+  if (!fakeCrgInstalledState) {
+    return {
+      code: 1,
+      stdout: "",
+      stderr: "code-review-graph: command not found"
+    };
+  }
+  if (args[0] === "status") {
+    return {
+      code: 0,
+      stdout: "Files: 1\nNodes: 1\nEdges: 1\n",
+      stderr: ""
+    };
+  }
+  if (args[0] === "build") {
+    return {
+      code: 0,
+      stdout: "Graph build complete\n",
+      stderr: ""
+    };
+  }
+  return {
+    code: 0,
+    stdout: "code-review-graph 0.0.0-fake\n",
+    stderr: ""
+  };
+}
+function buildFakePipxResponse(args) {
+  if (args[0] === "run" && args[1] === "--spec" && args[2] === "code-review-graph" && args[3] === "code-review-graph") {
+    return buildFakeCrgResponse(args.slice(4));
+  }
+  const [operation, packageName] = args;
+  if (packageName !== "code-review-graph") {
+    return void 0;
+  }
+  if (operation === "install") {
+    fakeCrgInstalledState = true;
+    return {
+      code: 0,
+      stdout: "installed package code-review-graph\n",
+      stderr: ""
+    };
+  }
+  if (operation === "uninstall") {
+    fakeCrgInstalledState = false;
+    return {
+      code: 0,
+      stdout: "uninstalled package code-review-graph\n",
+      stderr: ""
+    };
+  }
+  return void 0;
+}
+function parseGlobalNpmPackageNames(args) {
+  const packageNames = [];
+  for (let index = 1; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg || arg.startsWith("-")) {
+      continue;
+    }
+    packageNames.push(arg);
+  }
+  return packageNames;
+}
+function buildFakeNpmResponse(args) {
+  const operation = args[0];
+  if (!operation) {
+    return void 0;
+  }
+  const hasGlobalFlag = args.includes("-g") || args.includes("--global");
+  if (!hasGlobalFlag) {
+    return {
+      code: 0,
+      stdout: `[fake subprocess] npm ${args.join(" ")}
+`,
+      stderr: ""
+    };
+  }
+  const packageNames = parseGlobalNpmPackageNames(args);
+  if (operation === "install") {
+    for (const packageName of packageNames) {
+      fakeInstalledGlobalNpmPackageNames?.add(packageName);
+    }
+    return {
+      code: 0,
+      stdout: `installed ${packageNames.length} package(s) globally
+`,
+      stderr: ""
+    };
+  }
+  if (operation === "uninstall") {
+    for (const packageName of packageNames) {
+      fakeInstalledGlobalNpmPackageNames?.delete(packageName);
+    }
+    return {
+      code: 0,
+      stdout: `removed ${packageNames.length} package(s) globally
+`,
+      stderr: ""
+    };
+  }
+  return {
+    code: 0,
+    stdout: `[fake subprocess] npm ${args.join(" ")}
+`,
+    stderr: ""
+  };
+}
+function buildFakeAgnixResponse(args) {
+  if (!fakeInstalledGlobalNpmPackageNames?.has("agnix")) {
+    return {
+      code: 1,
+      stdout: "",
+      stderr: "agnix: command not found"
+    };
+  }
+  if (args[0] === "--version") {
+    return {
+      code: 0,
+      stdout: "agnix 0.0.0-fake\n",
+      stderr: ""
+    };
+  }
+  if (args[0] === "lint") {
+    return {
+      code: 0,
+      stdout: "agnix lint passed\n",
+      stderr: ""
+    };
+  }
+  return {
+    code: 0,
+    stdout: `[fake subprocess] agnix ${args.join(" ")}
+`,
+    stderr: ""
+  };
+}
+async function runSubprocess(command, args, options = {}) {
+  if (process.env.AGEMON_FAKE_SUBPROCESS === "1") {
+    initializeFakeStateIfNeeded();
+    if (command === "pipx") {
+      const pipxResponse = buildFakePipxResponse(args);
+      if (pipxResponse) {
+        return pipxResponse;
+      }
+    }
+    if (command === "npx") {
+      const npxResponse = buildFakeNpxResponse(args);
+      if (npxResponse) {
+        return npxResponse;
+      }
+    }
+    if (command === "npm") {
+      const npmResponse = buildFakeNpmResponse(args);
+      if (npmResponse) {
+        return npmResponse;
+      }
+    }
+    if (command === "code-review-graph") {
+      return buildFakeCrgResponse(args);
+    }
+    if (command === "agnix") {
+      return buildFakeAgnixResponse(args);
+    }
+    return {
+      code: 0,
+      stdout: `[fake subprocess] ${formatCommand(command, args)}
+`,
+      stderr: ""
+    };
+  }
+  return await new Promise((resolve) => {
+    let settled = false;
+    let timeoutHandle;
+    let hardKillHandle;
+    let timedOut = false;
+    const finalize = (result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      if (hardKillHandle) {
+        clearTimeout(hardKillHandle);
+      }
+      resolve(result);
+    };
+    const childProcess = spawn(command, args, {
+      cwd: process.cwd(),
+      env: process.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (options.timeoutMs && options.timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        timedOut = true;
+        const signal = options.killSignal ?? "SIGTERM";
+        const terminated = childProcess.kill(signal);
+        if (!terminated) {
+          finalize({
+            code: 124,
+            stdout,
+            stderr: `${stderr}
+Command timed out after ${options.timeoutMs}ms and could not be signaled with ${signal}.`
+          });
+          return;
+        }
+        hardKillHandle = setTimeout(() => {
+          if (!settled) {
+            childProcess.kill("SIGKILL");
+          }
+        }, 2e3);
+      }, options.timeoutMs);
+    }
+    let stdout = "";
+    let stderr = "";
+    childProcess.stdout.on("data", (chunk) => {
+      stdout += Buffer.from(chunk).toString("utf8");
+    });
+    childProcess.stderr.on("data", (chunk) => {
+      stderr += Buffer.from(chunk).toString("utf8");
+    });
+    childProcess.on("error", (error) => {
+      const errorMessage = stderr ? `${stderr}
+process spawn error: ${error.message}` : `process spawn error: ${error.message}`;
+      finalize({
+        code: 1,
+        stdout,
+        stderr: errorMessage
+      });
+    });
+    childProcess.on(
+      "close",
+      (code, signal) => {
+        if (timedOut) {
+          const timeoutMessage = `Command timed out after ${options.timeoutMs}ms.`;
+          const timeoutStderr = stderr ? `${stderr}
+${timeoutMessage}` : timeoutMessage;
+          finalize({
+            code: 124,
+            stdout,
+            stderr: timeoutStderr
+          });
+          return;
+        }
+        if (signal) {
+          finalize({
+            code: 1,
+            stdout,
+            stderr: `${stderr}Process terminated by signal: ${signal}`
+          });
+          return;
+        }
+        finalize({
+          code: code ?? 1,
+          stdout,
+          stderr
+        });
+      }
+    );
+  });
+}
+
+// src/core/context.ts
+async function createContext(input) {
+  const platform = await detectPlatform({
+    osReleasePath: process.env.AGEMON_OS_RELEASE_PATH
+  });
+  for (const binaryName of REQUIRED_BINARIES) {
+    const binary = platform.binaries[binaryName];
+    const status = binary.present ? `present (${binary.path ?? "resolved via PATH"})` : "missing";
+    input.ui.info(`Binary check: ${binaryName} ${status}`);
+  }
+  return {
+    cwd: process.cwd(),
+    os: platform.os,
+    binaries: REQUIRED_BINARIES.map((name) => platform.binaries[name]),
+    dryRun: input.dryRun,
+    yes: input.yes,
+    log: console,
+    ui: input.ui,
+    run: runSubprocess,
+    manifest: await StateManifest.load(process.cwd()),
+    serviceManager: createServiceManager({
+      os: platform.os,
+      run: runSubprocess,
+      homeDir: process.env.HOME,
+      user: process.env.USER
+    })
+  };
+}
+
+// src/core/dev-mode.ts
+var FAKE_BACKEND_ENV_VARS = [
+  "AGEMON_FAKE_SUBPROCESS",
+  "AGEMON_FAKE_SERVICES"
+];
+function assertFakeBackendsAreDevOnly() {
+  const activeFakeVars = FAKE_BACKEND_ENV_VARS.filter(
+    (name) => process.env[name] === "1"
+  );
+  if (activeFakeVars.length > 0 && process.env.AGEMON_DEV !== "1") {
+    throw new Error(
+      `${activeFakeVars.join(", ")} must never be set outside the sandbox harness \u2014 refusing to start.`
+    );
+  }
+}
+
+// src/core/orchestrator.ts
+function parseOnlyPluginIds(only) {
+  if (!only) return [];
+  return only.split(",").map((id) => id.trim()).filter((id) => id.length > 0);
+}
+function resolvePluginOrder(allPlugins, onlyIds) {
+  const pluginById = new Map(allPlugins.map((plugin) => [plugin.id, plugin]));
+  const unresolvedOnlyIds = onlyIds.filter((id) => !pluginById.has(id));
+  if (unresolvedOnlyIds.length > 0) {
+    throw new Error(`Unknown plugin id(s): ${unresolvedOnlyIds.join(", ")}`);
+  }
+  const selected = onlyIds.length === 0 ? [...allPlugins] : allPlugins.filter((plugin) => onlyIds.includes(plugin.id));
+  const temporary = /* @__PURE__ */ new Set();
+  const permanent = /* @__PURE__ */ new Set();
+  const ordered = [];
+  const visit = (plugin) => {
+    if (permanent.has(plugin.id)) {
+      return;
+    }
+    if (temporary.has(plugin.id)) {
+      throw new Error(`Circular dependency detected at plugin '${plugin.id}'.`);
+    }
+    temporary.add(plugin.id);
+    for (const dependencyId of plugin.dependsOn ?? []) {
+      const dependencyPlugin = pluginById.get(dependencyId);
+      if (!dependencyPlugin) {
+        throw new Error(
+          `Plugin '${plugin.id}' depends on missing plugin '${dependencyId}'.`
+        );
+      }
+      visit(dependencyPlugin);
+    }
+    temporary.delete(plugin.id);
+    permanent.add(plugin.id);
+    ordered.push(plugin);
+  };
+  for (const plugin of selected) {
+    visit(plugin);
+  }
+  return ordered;
+}
+function buildVerificationMessage(pluginId, detail) {
+  if (!detail) return `Installed ${pluginId}`;
+  return `Installed ${pluginId} (${detail})`;
+}
+async function installPlugins(ctx, allPlugins, options) {
+  const onlyIds = parseOnlyPluginIds(options.only);
+  const plugins = resolvePluginOrder(allPlugins, onlyIds);
+  if (plugins.length === 0) {
+    ctx.ui.info("Nothing to do \u2014 no plugins selected.");
+    return;
+  }
+  for (const plugin of plugins) {
+    ctx.ui.start(`Installing ${plugin.id}`);
+    const presence = await plugin.detect(ctx);
+    if (presence.present) {
+      ctx.ui.succeed(`Already installed ${plugin.id}`);
+      continue;
+    }
+    await plugin.install(ctx);
+    const verification = await plugin.verify(ctx);
+    if (!verification.ok) {
+      ctx.ui.fail(`Verification failed for ${plugin.id}`);
+      throw new Error(
+        verification.detail ?? `Verification failed for plugin '${plugin.id}'.`
+      );
+    }
+    ctx.ui.succeed(buildVerificationMessage(plugin.id, verification.detail));
+  }
+}
+async function uninstallPlugins(ctx, allPlugins, options) {
+  const onlyIds = parseOnlyPluginIds(options.only);
+  const plugins = resolvePluginOrder(allPlugins, onlyIds).reverse();
+  if (plugins.length === 0) {
+    ctx.ui.info("Nothing to do \u2014 no plugins selected.");
+    return;
+  }
+  for (const plugin of plugins) {
+    ctx.ui.start(`Uninstalling ${plugin.id}`);
+    await plugin.uninstall(ctx);
+    ctx.ui.succeed(`Uninstalled ${plugin.id}`);
+  }
+  await ctx.manifest.pruneIfEmpty();
+}
+
+// src/plugins/cli-tool/catalog.ts
+var CLI_TOOL_BUNDLE = [
+  {
+    id: "agnix",
+    packageName: "agnix",
+    binaryName: "agnix"
+  }
+];
+
+// src/plugins/cli-tool/index.ts
+var PLUGIN_ID = "cli-tool";
+var ACTION_TYPE_INSTALLED_CLI_TOOL = "installed-cli-tool";
+var ACTION_TYPE_PREEXISTING_CLI_TOOL = "preexisting-cli-tool";
+var VERSION_CHECK_TIMEOUT_MS = 2e4;
+var INSTALL_TIMEOUT_MS = 18e4;
+var UNINSTALL_TIMEOUT_MS = 6e4;
+function getPluginActions(ctx) {
+  return ctx.manifest.getActions().filter((action) => action.plugin === PLUGIN_ID);
+}
+function hasManagedInstallRecord(ctx, toolId) {
+  return getPluginActions(ctx).some(
+    (action) => action.type === ACTION_TYPE_INSTALLED_CLI_TOOL && action.target === toolId && action.preExisting === false
+  );
+}
+function hasPreexistingRecord(ctx, toolId) {
+  return getPluginActions(ctx).some(
+    (action) => action.type === ACTION_TYPE_PREEXISTING_CLI_TOOL && action.target === toolId && action.preExisting === true
+  );
+}
+function hasAnyRecordForTool(ctx, toolId) {
+  return hasManagedInstallRecord(ctx, toolId) || hasPreexistingRecord(ctx, toolId);
+}
+async function isToolBinaryAvailable(ctx, entry) {
+  const result = await ctx.run(entry.binaryName, ["--version"], {
+    timeoutMs: VERSION_CHECK_TIMEOUT_MS
+  });
+  return result.code === 0;
+}
+async function detectCliTools(ctx) {
+  const bundleAvailability = await Promise.all(
+    CLI_TOOL_BUNDLE.map(async (entry) => ({
+      entry,
+      available: await isToolBinaryAvailable(ctx, entry)
+    }))
+  );
+  if (bundleAvailability.some((tool) => !tool.available)) {
+    return { present: false, preExisting: false };
+  }
+  const allManaged = CLI_TOOL_BUNDLE.every(
+    (entry) => hasManagedInstallRecord(ctx, entry.id)
+  );
+  if (allManaged) {
+    return { present: true, preExisting: false };
+  }
+  if (!ctx.dryRun) {
+    for (const { entry } of bundleAvailability) {
+      if (hasAnyRecordForTool(ctx, entry.id)) {
+        continue;
+      }
+      await ctx.manifest.recordAction({
+        plugin: PLUGIN_ID,
+        type: ACTION_TYPE_PREEXISTING_CLI_TOOL,
+        target: entry.id,
+        preExisting: true
+      });
+    }
+  }
+  return { present: true, preExisting: true };
+}
+async function installCliTools(ctx) {
+  if (ctx.dryRun) {
+    for (const entry of CLI_TOOL_BUNDLE) {
+      ctx.ui.info(`Would install ${entry.packageName} globally via npm`);
+    }
+    return;
+  }
+  for (const entry of CLI_TOOL_BUNDLE) {
+    const toolIsAvailable = await isToolBinaryAvailable(ctx, entry);
+    if (toolIsAvailable) {
+      if (!hasAnyRecordForTool(ctx, entry.id)) {
+        await ctx.manifest.recordAction({
+          plugin: PLUGIN_ID,
+          type: ACTION_TYPE_PREEXISTING_CLI_TOOL,
+          target: entry.id,
+          preExisting: true
+        });
+      }
+      continue;
+    }
+    const installResult = await ctx.run(
+      "npm",
+      ["install", "--global", entry.packageName],
+      {
+        timeoutMs: INSTALL_TIMEOUT_MS
+      }
+    );
+    if (installResult.code !== 0) {
+      throw new Error(
+        installResult.stderr || `npm global install failed for ${entry.packageName}`
+      );
+    }
+    await ctx.manifest.recordAction({
+      plugin: PLUGIN_ID,
+      type: ACTION_TYPE_INSTALLED_CLI_TOOL,
+      target: entry.id,
+      preExisting: false
+    });
+  }
+}
+async function verifyCliTools(ctx) {
+  if (ctx.dryRun) {
+    return { ok: true, detail: "dry-run" };
+  }
+  const missingToolIds = [];
+  for (const entry of CLI_TOOL_BUNDLE) {
+    const toolIsAvailable = await isToolBinaryAvailable(ctx, entry);
+    if (!toolIsAvailable) {
+      missingToolIds.push(entry.id);
+    }
+  }
+  if (missingToolIds.length > 0) {
+    return {
+      ok: false,
+      detail: `Missing CLI tool(s): ${missingToolIds.join(", ")}`
+    };
+  }
+  return {
+    ok: true,
+    detail: `${CLI_TOOL_BUNDLE.length} CLI tool bundle entries present`
+  };
+}
+async function uninstallCliTools(ctx) {
+  const managedActions = getPluginActions(ctx).filter(
+    (action) => action.type === ACTION_TYPE_INSTALLED_CLI_TOOL && action.preExisting === false
+  );
+  if (ctx.dryRun) {
+    if (managedActions.length === 0) {
+      ctx.ui.info("Would keep pre-existing CLI tools untouched");
+      return;
+    }
+    for (const action of managedActions) {
+      const bundleEntry = CLI_TOOL_BUNDLE.find(
+        (entry) => entry.id === action.target
+      );
+      const packageName = bundleEntry?.packageName ?? action.target;
+      ctx.ui.info(`Would uninstall global npm package ${packageName}`);
+    }
+    return;
+  }
+  for (const action of managedActions) {
+    const bundleEntry = CLI_TOOL_BUNDLE.find(
+      (entry) => entry.id === action.target
+    );
+    const packageName = bundleEntry?.packageName ?? action.target;
+    const uninstallResult = await ctx.run(
+      "npm",
+      ["uninstall", "--global", packageName],
+      {
+        timeoutMs: UNINSTALL_TIMEOUT_MS
+      }
+    );
+    if (uninstallResult.code !== 0) {
+      throw new Error(
+        uninstallResult.stderr || `npm global uninstall failed for ${packageName}`
+      );
+    }
+  }
+  await ctx.manifest.removeActionsForPlugin(PLUGIN_ID);
+}
+var cliToolPlugin = {
+  id: PLUGIN_ID,
+  detect: detectCliTools,
+  install: installCliTools,
+  verify: verifyCliTools,
+  uninstall: uninstallCliTools
+};
+
+// src/plugins/crg/index.ts
+var PLUGIN_ID2 = "crg";
+var PACKAGE_NAME = "code-review-graph";
+var PIPX_RUN_PREFIX = ["run", "--spec", PACKAGE_NAME, "code-review-graph"];
+var VERSION_CHECK_TIMEOUT_MS2 = 2e4;
+var INSTALL_TIMEOUT_MS2 = 18e4;
+var BUILD_TIMEOUT_MS = 3e5;
+var STATUS_TIMEOUT_MS = 3e4;
+var UNINSTALL_TIMEOUT_MS2 = 12e4;
+var ACTION_TYPE_INSTALLED_BINARY = "installed-binary";
+var ACTION_TYPE_PREEXISTING_BINARY = "preexisting-binary";
+var ACTION_TYPE_GRAPH_BUILT = "graph-built";
+function getPluginActions2(ctx) {
+  return ctx.manifest.getActions().filter((action) => action.plugin === PLUGIN_ID2);
+}
+function hasManagedInstall(ctx) {
+  return getPluginActions2(ctx).some(
+    (action) => action.type === ACTION_TYPE_INSTALLED_BINARY && action.preExisting === false
+  );
+}
+function hasPreexistingRecord2(ctx) {
+  return getPluginActions2(ctx).some(
+    (action) => action.type === ACTION_TYPE_PREEXISTING_BINARY && action.preExisting === true
+  );
+}
+async function detectCrgPresence(ctx) {
+  const versionCheck = await ctx.run("code-review-graph", ["--version"], {
+    timeoutMs: VERSION_CHECK_TIMEOUT_MS2
+  });
+  const commandIsAvailable = versionCheck.code === 0;
+  if (!commandIsAvailable) {
+    return { present: false, preExisting: false };
+  }
+  if (hasManagedInstall(ctx)) {
+    return { present: true, preExisting: false };
+  }
+  if (!hasPreexistingRecord2(ctx) && !ctx.dryRun) {
+    await ctx.manifest.recordAction({
+      plugin: PLUGIN_ID2,
+      type: ACTION_TYPE_PREEXISTING_BINARY,
+      target: PACKAGE_NAME,
+      preExisting: true
+    });
+  }
+  return { present: true, preExisting: true };
+}
+async function installCrg(ctx) {
+  if (ctx.dryRun) {
+    ctx.ui.info(`Would install ${PACKAGE_NAME} via pipx`);
+    ctx.ui.info("Would build graph for current repository");
+    return;
+  }
+  const installResult = await ctx.run("pipx", ["install", PACKAGE_NAME], {
+    timeoutMs: INSTALL_TIMEOUT_MS2
+  });
+  if (installResult.code !== 0) {
+    throw new Error(
+      installResult.stderr || `pipx install failed for ${PACKAGE_NAME}`
+    );
+  }
+  await ctx.manifest.recordAction({
+    plugin: PLUGIN_ID2,
+    type: ACTION_TYPE_INSTALLED_BINARY,
+    target: `${PACKAGE_NAME} (pipx)`,
+    preExisting: false
+  });
+  const buildResult = await ctx.run("pipx", [...PIPX_RUN_PREFIX, "build"], {
+    timeoutMs: BUILD_TIMEOUT_MS
+  });
+  if (buildResult.code !== 0) {
+    throw new Error(buildResult.stderr || "code-review-graph build failed");
+  }
+  await ctx.manifest.recordAction({
+    plugin: PLUGIN_ID2,
+    type: ACTION_TYPE_GRAPH_BUILT,
+    target: ".code-review-graph",
+    preExisting: false
+  });
+}
+async function verifyCrg(ctx) {
+  if (ctx.dryRun) {
+    return { ok: true, detail: "dry-run" };
+  }
+  const statusResult = await ctx.run("pipx", [...PIPX_RUN_PREFIX, "status"], {
+    timeoutMs: STATUS_TIMEOUT_MS
+  });
+  if (statusResult.code !== 0) {
+    return {
+      ok: false,
+      detail: statusResult.stderr || "code-review-graph status failed"
+    };
+  }
+  return { ok: true, detail: "status command passed" };
+}
+async function uninstallCrg(ctx) {
+  const managedInstall = hasManagedInstall(ctx);
+  if (ctx.dryRun) {
+    if (managedInstall) {
+      ctx.ui.info(`Would uninstall ${PACKAGE_NAME} from pipx`);
+    } else {
+      ctx.ui.info(`Would keep pre-existing ${PACKAGE_NAME} install`);
+    }
+    return;
+  }
+  if (managedInstall) {
+    const uninstallResult = await ctx.run("pipx", ["uninstall", PACKAGE_NAME], {
+      timeoutMs: UNINSTALL_TIMEOUT_MS2
+    });
+    if (uninstallResult.code !== 0) {
+      throw new Error(
+        uninstallResult.stderr || `pipx uninstall failed for ${PACKAGE_NAME}`
+      );
+    }
+  }
+  await ctx.manifest.removeActionsForPlugin(PLUGIN_ID2);
+}
+var crgPlugin = {
+  id: PLUGIN_ID2,
+  detect: detectCrgPresence,
+  install: installCrg,
+  verify: verifyCrg,
+  uninstall: uninstallCrg
+};
+
+// src/plugins/daemon/index.ts
+var PLUGIN_ID3 = "daemon";
+var UNIT_NAME = "agemon-crg-daemon.service";
+var ACTION_TYPE_REGISTERED_SERVICE = "registered-service";
+var ACTION_TYPE_PREEXISTING_SERVICE = "preexisting-service";
+var ACTION_TYPE_ENABLED_LINGER = "enabled-linger";
+function readHardeningProfileFromEnv() {
+  return process.env.AGEMON_DAEMON_HARDENING === "compat" ? "compat" : "strict";
+}
+function getHardeningDirectives(profile) {
+  if (profile === "compat") {
+    return ["NoNewPrivileges=yes", "RestrictSUIDSGID=yes"];
+  }
+  return [
+    "NoNewPrivileges=yes",
+    "RestrictSUIDSGID=yes",
+    "ProtectSystem=full",
+    "ProtectHome=read-only",
+    "PrivateTmp=yes"
+  ];
+}
+function buildUnitContents(cwd, profile) {
+  return [
+    "[Unit]",
+    "Description=agemon code-review-graph daemon",
+    "After=network-online.target",
+    "",
+    "[Service]",
+    "Type=simple",
+    `WorkingDirectory=${cwd}`,
+    "ExecStart=crg-daemon start",
+    ...getHardeningDirectives(profile),
+    "Restart=always",
+    "RestartSec=3",
+    "",
+    "[Install]",
+    "WantedBy=default.target",
+    ""
+  ].join("\n");
+}
+function getPluginActions3(ctx) {
+  return ctx.manifest.getActions().filter((action) => action.plugin === PLUGIN_ID3);
+}
+function hasManagedServiceRegistration(ctx) {
+  return getPluginActions3(ctx).some(
+    (action) => action.type === ACTION_TYPE_REGISTERED_SERVICE && action.preExisting === false
+  );
+}
+function hasPreexistingServiceRecord(ctx) {
+  return getPluginActions3(ctx).some(
+    (action) => action.type === ACTION_TYPE_PREEXISTING_SERVICE && action.preExisting === true
+  );
+}
+function enabledLingerByAgemon(ctx) {
+  return getPluginActions3(ctx).some(
+    (action) => action.type === ACTION_TYPE_ENABLED_LINGER && action.preExisting === false
+  );
+}
+async function detectDaemon(ctx) {
+  const status = await ctx.serviceManager.isActive(UNIT_NAME);
+  if (!status.active) {
+    return { present: false, preExisting: false };
+  }
+  if (hasManagedServiceRegistration(ctx)) {
+    return { present: true, preExisting: false };
+  }
+  if (!hasPreexistingServiceRecord(ctx) && !ctx.dryRun) {
+    await ctx.manifest.recordAction({
+      plugin: PLUGIN_ID3,
+      type: ACTION_TYPE_PREEXISTING_SERVICE,
+      target: UNIT_NAME,
+      preExisting: true
+    });
+  }
+  return { present: true, preExisting: true };
+}
+async function installDaemon(ctx) {
+  if (ctx.dryRun) {
+    ctx.ui.info(`Would register user service ${UNIT_NAME}`);
+    ctx.ui.info("Would enable user linger when not already enabled");
+    return;
+  }
+  const configuredProfile = readHardeningProfileFromEnv();
+  const registration = await (async () => {
+    try {
+      return await ctx.serviceManager.registerAutostart({
+        unitName: UNIT_NAME,
+        unitContents: buildUnitContents(ctx.cwd, configuredProfile)
+      });
+    } catch (error) {
+      if (configuredProfile !== "strict") {
+        throw error;
+      }
+      ctx.ui.info(
+        "Strict daemon hardening failed; retrying with compatibility hardening."
+      );
+      return await ctx.serviceManager.registerAutostart({
+        unitName: UNIT_NAME,
+        unitContents: buildUnitContents(ctx.cwd, "compat")
+      });
+    }
+  })();
+  await ctx.manifest.recordAction({
+    plugin: PLUGIN_ID3,
+    type: ACTION_TYPE_REGISTERED_SERVICE,
+    target: registration.unitPath,
+    preExisting: false
+  });
+  if (registration.lingerEnabledByAgemon) {
+    await ctx.manifest.recordAction({
+      plugin: PLUGIN_ID3,
+      type: ACTION_TYPE_ENABLED_LINGER,
+      target: process.env.USER ?? "current-user",
+      preExisting: false
+    });
+  }
+}
+async function verifyDaemon(ctx) {
+  if (ctx.dryRun) {
+    return { ok: true, detail: "dry-run" };
+  }
+  const status = await ctx.serviceManager.isActive(UNIT_NAME);
+  if (!status.active) {
+    return { ok: false, detail: "user service is not active" };
+  }
+  return { ok: true, detail: "service active" };
+}
+async function uninstallDaemon(ctx) {
+  const managedService = hasManagedServiceRegistration(ctx);
+  if (ctx.dryRun) {
+    if (managedService) {
+      ctx.ui.info(`Would unregister user service ${UNIT_NAME}`);
+      if (enabledLingerByAgemon(ctx)) {
+        ctx.ui.info("Would disable user linger because agemon enabled it");
+      }
+    } else {
+      ctx.ui.info(`Would keep pre-existing user service ${UNIT_NAME}`);
+    }
+    return;
+  }
+  if (managedService) {
+    await ctx.serviceManager.unregisterAutostart({
+      unitName: UNIT_NAME,
+      disableLinger: enabledLingerByAgemon(ctx)
+    });
+  }
+  await ctx.manifest.removeActionsForPlugin(PLUGIN_ID3);
+}
+var daemonPlugin = {
+  id: PLUGIN_ID3,
+  dependsOn: ["crg"],
+  detect: detectDaemon,
+  install: installDaemon,
+  verify: verifyDaemon,
+  uninstall: uninstallDaemon
+};
+
+// src/plugins/master-prompt/index.ts
+import { existsSync } from "fs";
+import { mkdir as mkdir4, readFile as readFile4, rm as rm4, writeFile as writeFile4 } from "fs/promises";
+import { dirname as dirname3, join as join5 } from "path";
+var PLUGIN_ID4 = "master-prompt";
+var ACTION_TYPE_MANAGED_RULE_FILE = "managed-rule-file";
+var ACTION_TYPE_PREEXISTING_RULE_FILE = "preexisting-rule-file";
+var BACKUP_DIRECTORY = ".agemon/backups/master-prompt";
+function buildPointerFileContents(toolName, targetFileName) {
+  return [
+    "<!-- AI agent rules pointer -->",
+    "# AI Agent Rules",
+    "",
+    "The canonical rules for this repo live in AGENTS.md \u2014 read that file in full before",
+    `making any changes here. This file exists only because ${toolName} looks for \`${targetFileName}\` specifically; it intentionally does not restate the rules.`,
+    ""
+  ].join("\n");
+}
+function buildAgentsFileContents() {
+  return [
+    "# AI Agent Rules",
+    "",
+    "This is the canonical, repo-wide rule set for every AI coding agent in this repository.",
+    "`CLAUDE.md`, `.cursorrules`, `.windsurfrules`, and `GEMINI.md` are pointer files that",
+    "exist only because their tools look for those exact filenames.",
+    "",
+    "## Standard Task Lifecycle",
+    "",
+    "1. Discover existing tools, skills, and patterns before writing new code.",
+    "2. Plan the smallest complete change before implementation.",
+    "3. Verify assumptions with tests or reproducible checks.",
+    "4. Implement with clear naming, modular boundaries, and zero dead code.",
+    "5. Re-verify after changes and record out-of-scope findings in improvements.md.",
+    "",
+    "## Core Directives",
+    "",
+    "- Keep code simple and task-scoped: no speculative abstractions.",
+    "- Reuse existing project utilities instead of duplicating logic.",
+    "- Preserve user-authored content outside agemon-managed files.",
+    "- Prioritize safe and reversible changes.",
+    ""
+  ].join("\n");
+}
+function getRuleFileDefinitions() {
+  return [
+    {
+      target: "AGENTS.md",
+      contents: buildAgentsFileContents()
+    },
+    {
+      target: "CLAUDE.md",
+      contents: buildPointerFileContents("Claude Code", "CLAUDE.md")
+    },
+    {
+      target: "GEMINI.md",
+      contents: buildPointerFileContents("Gemini CLI", "GEMINI.md")
+    },
+    {
+      target: ".cursorrules",
+      contents: buildPointerFileContents("Cursor", ".cursorrules")
+    },
+    {
+      target: ".windsurfrules",
+      contents: buildPointerFileContents("Windsurf", ".windsurfrules")
+    }
+  ];
+}
+function getPluginActions4(ctx) {
+  return ctx.manifest.getActions().filter((action) => action.plugin === PLUGIN_ID4);
+}
+function hasActionForTarget(ctx, target) {
+  return getPluginActions4(ctx).some((action) => action.target === target);
+}
+function getManagedActions(ctx) {
+  return getPluginActions4(ctx).filter(
+    (action) => action.type === ACTION_TYPE_MANAGED_RULE_FILE
+  );
+}
+function encodeTargetAsBackupFileName(target) {
+  return target.replace(/[^a-zA-Z0-9._-]/gu, "_");
+}
+function buildBackupPath(cwd, target) {
+  return join5(
+    cwd,
+    BACKUP_DIRECTORY,
+    `${encodeTargetAsBackupFileName(target)}.bak`
+  );
+}
+async function readFileIfExists(filePath) {
+  try {
+    return await readFile4(filePath, "utf8");
+  } catch {
+    return null;
+  }
+}
+function allRuleFilesMatch(ctx) {
+  return getRuleFileDefinitions().map(async (definition) => {
+    const targetPath = join5(ctx.cwd, definition.target);
+    const currentContents = await readFileIfExists(targetPath);
+    return currentContents === definition.contents;
+  });
+}
+async function detectMasterPrompt(ctx) {
+  const matchResults = await Promise.all(allRuleFilesMatch(ctx));
+  const allMatch = matchResults.every((matches) => matches);
+  if (!allMatch) {
+    return { present: false, preExisting: false };
+  }
+  if (!ctx.dryRun) {
+    for (const definition of getRuleFileDefinitions()) {
+      if (hasActionForTarget(ctx, definition.target)) {
+        continue;
+      }
+      await ctx.manifest.recordAction({
+        plugin: PLUGIN_ID4,
+        type: ACTION_TYPE_PREEXISTING_RULE_FILE,
+        target: definition.target,
+        preExisting: true
+      });
+    }
+  }
+  const allManaged = getRuleFileDefinitions().every(
+    (definition) => getManagedActions(ctx).some(
+      (action) => action.target === definition.target
+    )
+  );
+  return { present: true, preExisting: !allManaged };
+}
+async function backupOriginalFileIfNeeded(cwd, target, existingContents) {
+  const backupPath = buildBackupPath(cwd, target);
+  await mkdir4(dirname3(backupPath), { recursive: true });
+  await writeFile4(backupPath, existingContents, "utf8");
+}
+async function installMasterPrompt(ctx) {
+  if (ctx.dryRun) {
+    for (const definition of getRuleFileDefinitions()) {
+      ctx.ui.info(`Would consolidate rule file ${definition.target}`);
+    }
+    return;
+  }
+  for (const definition of getRuleFileDefinitions()) {
+    const targetPath = join5(ctx.cwd, definition.target);
+    const existingContents = await readFileIfExists(targetPath);
+    if (existingContents === definition.contents) {
+      if (!hasActionForTarget(ctx, definition.target)) {
+        await ctx.manifest.recordAction({
+          plugin: PLUGIN_ID4,
+          type: ACTION_TYPE_PREEXISTING_RULE_FILE,
+          target: definition.target,
+          preExisting: true
+        });
+      }
+      continue;
+    }
+    if (existingContents !== null) {
+      await backupOriginalFileIfNeeded(
+        ctx.cwd,
+        definition.target,
+        existingContents
+      );
+    }
+    await mkdir4(dirname3(targetPath), { recursive: true });
+    await writeFile4(targetPath, definition.contents, "utf8");
+    if (!hasActionForTarget(ctx, definition.target)) {
+      await ctx.manifest.recordAction({
+        plugin: PLUGIN_ID4,
+        type: ACTION_TYPE_MANAGED_RULE_FILE,
+        target: definition.target,
+        preExisting: existingContents !== null
+      });
+    }
+  }
+}
+async function verifyMasterPrompt(ctx) {
+  if (ctx.dryRun) {
+    return { ok: true, detail: "dry-run" };
+  }
+  const missingOrMismatchedTargets = [];
+  for (const definition of getRuleFileDefinitions()) {
+    const targetPath = join5(ctx.cwd, definition.target);
+    const currentContents = await readFileIfExists(targetPath);
+    if (currentContents !== definition.contents) {
+      missingOrMismatchedTargets.push(definition.target);
+    }
+  }
+  if (missingOrMismatchedTargets.length > 0) {
+    return {
+      ok: false,
+      detail: `Missing or mismatched rule file(s): ${missingOrMismatchedTargets.join(", ")}`
+    };
+  }
+  return {
+    ok: true,
+    detail: `${getRuleFileDefinitions().length} consolidated rule files present`
+  };
+}
+async function uninstallMasterPrompt(ctx) {
+  const managedActions = getManagedActions(ctx);
+  if (ctx.dryRun) {
+    if (managedActions.length === 0) {
+      ctx.ui.info("Would keep pre-existing rule files untouched");
+      return;
+    }
+    for (const action of managedActions) {
+      if (action.preExisting) {
+        ctx.ui.info(`Would restore original rule file ${action.target}`);
+      } else {
+        ctx.ui.info(`Would remove generated rule file ${action.target}`);
+      }
+    }
+    return;
+  }
+  for (const action of managedActions) {
+    const targetPath = join5(ctx.cwd, action.target);
+    const backupPath = buildBackupPath(ctx.cwd, action.target);
+    if (action.preExisting) {
+      if (!existsSync(backupPath)) {
+        throw new Error(
+          `Missing backup for pre-existing file ${action.target}`
+        );
+      }
+      const backupContents = await readFile4(backupPath, "utf8");
+      await writeFile4(targetPath, backupContents, "utf8");
+      await rm4(backupPath, { force: true });
+      continue;
+    }
+    await rm4(targetPath, { force: true });
+  }
+  await ctx.manifest.removeActionsForPlugin(PLUGIN_ID4);
+}
+var masterPromptPlugin = {
+  id: PLUGIN_ID4,
+  detect: detectMasterPrompt,
+  install: installMasterPrompt,
+  verify: verifyMasterPrompt,
+  uninstall: uninstallMasterPrompt
+};
+
+// src/plugins/patcher-checkpoint.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { join as join6 } from "path";
+
+// src/patchers/markdown-block.ts
+import { readFile as readFile5, writeFile as writeFile5 } from "fs/promises";
+function startMarker(blockId) {
+  return `<!-- agemon:start:${blockId} -->`;
+}
+function endMarker(blockId) {
+  return `<!-- agemon:end:${blockId} -->`;
+}
+function normalizeBlockBody(blockBody) {
+  return blockBody.replace(/\s+$/u, "");
+}
+function buildManagedBlock(blockId, blockBody) {
+  const body = normalizeBlockBody(blockBody);
+  if (body.length === 0) {
+    return `${startMarker(blockId)}
+${endMarker(blockId)}`;
+  }
+  return `${startMarker(blockId)}
+${body}
+${endMarker(blockId)}`;
+}
+function findManagedBlockRange(content, blockId) {
+  const start = content.indexOf(startMarker(blockId));
+  if (start < 0) {
+    return null;
+  }
+  const endTag = endMarker(blockId);
+  const endTagIndex = content.indexOf(endTag, start);
+  if (endTagIndex < 0) {
+    throw new Error(
+      `Found start marker without matching end marker for '${blockId}'.`
+    );
+  }
+  return { start, end: endTagIndex + endTag.length };
+}
+function upsertManagedMarkdownBlock(content, blockId, blockBody) {
+  const managedBlock = buildManagedBlock(blockId, blockBody);
+  const range = findManagedBlockRange(content, blockId);
+  if (range) {
+    const current = content.slice(range.start, range.end);
+    if (current === managedBlock) {
+      return { nextContent: content, changed: false };
+    }
+    const next = content.slice(0, range.start) + managedBlock + content.slice(range.end);
+    return { nextContent: next, changed: true };
+  }
+  if (content.length === 0) {
+    return { nextContent: `${managedBlock}
+`, changed: true };
+  }
+  const separator = content.endsWith("\n\n") ? "" : content.endsWith("\n") ? "\n" : "\n\n";
+  return {
+    nextContent: `${content}${separator}${managedBlock}
+`,
+    changed: true
+  };
+}
+function removeManagedMarkdownBlock(content, blockId) {
+  const range = findManagedBlockRange(content, blockId);
+  if (!range) {
+    return { nextContent: content, changed: false };
+  }
+  const before = content.slice(0, range.start);
+  const after = content.slice(range.end);
+  let next = `${before}${after}`;
+  next = next.replace(/\n{3,}/gu, "\n\n");
+  if (next === "\n") {
+    next = "";
+  }
+  return { nextContent: next, changed: true };
+}
+async function readFileOrEmpty(filePath) {
+  try {
+    return await readFile5(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+async function upsertManagedMarkdownBlockFile(filePath, blockId, blockBody) {
+  const content = await readFileOrEmpty(filePath);
+  const updated = upsertManagedMarkdownBlock(content, blockId, blockBody);
+  if (!updated.changed) {
+    return false;
+  }
+  await writeFile5(filePath, updated.nextContent, "utf8");
+  return true;
+}
+async function removeManagedMarkdownBlockFile(filePath, blockId) {
+  const content = await readFileOrEmpty(filePath);
+  const updated = removeManagedMarkdownBlock(content, blockId);
+  if (!updated.changed) {
+    return false;
+  }
+  await writeFile5(filePath, updated.nextContent, "utf8");
+  return true;
+}
+
+// src/plugins/patcher-checkpoint.ts
+var PLUGIN_ID5 = "patcher-checkpoint";
+var BLOCK_ID = "phase-5-checkpoint";
+var TARGET_FILE = "CLAUDE.md";
+function getTargetPath(cwd) {
+  return join6(cwd, TARGET_FILE);
+}
+function hasManagedBlock(cwd) {
+  const filePath = getTargetPath(cwd);
+  if (!existsSync2(filePath)) {
+    return false;
+  }
+  const content = readFileSync(filePath, "utf8");
+  return content.includes(`<!-- agemon:start:${BLOCK_ID} -->`);
+}
+var patcherCheckpointPlugin = {
+  id: PLUGIN_ID5,
+  async detect(ctx) {
+    return {
+      present: hasManagedBlock(ctx.cwd),
+      preExisting: false
+    };
+  },
+  async install(ctx) {
+    if (ctx.dryRun) {
+      ctx.ui.info(`Would patch ${TARGET_FILE} with one managed markdown block`);
+      return;
+    }
+    const targetPath = getTargetPath(ctx.cwd);
+    const filePreviouslyExisted = existsSync2(targetPath);
+    const changed = await upsertManagedMarkdownBlockFile(
+      targetPath,
+      BLOCK_ID,
+      "This block is owned by agemon and safe to remove during nuke."
+    );
+    if (!changed) {
+      return;
+    }
+    await ctx.manifest.recordAction({
+      plugin: PLUGIN_ID5,
+      type: "patched-block",
+      target: TARGET_FILE,
+      preExisting: filePreviouslyExisted
+    });
+  },
+  async verify(ctx) {
+    if (ctx.dryRun) {
+      return { ok: true, detail: "dry-run" };
+    }
+    return {
+      ok: hasManagedBlock(ctx.cwd),
+      detail: `managed block present in ${TARGET_FILE}`
+    };
+  },
+  async uninstall(ctx) {
+    if (ctx.dryRun) {
+      ctx.ui.info(`Would remove managed markdown block from ${TARGET_FILE}`);
+      return;
+    }
+    const targetPath = getTargetPath(ctx.cwd);
+    await removeManagedMarkdownBlockFile(targetPath, BLOCK_ID);
+    await ctx.manifest.removeActionsForPlugin(PLUGIN_ID5);
+  }
+};
+
+// src/plugins/skills/index.ts
+import { existsSync as existsSync3 } from "fs";
+import { rm as rm5 } from "fs/promises";
+import { join as join7 } from "path";
+
+// src/plugins/skills/catalog.ts
+var SKILL_BUNDLE = [
+  {
+    id: "web-design-guidelines",
+    source: "vercel-labs/agent-skills",
+    skillName: "web-design-guidelines",
+    agent: "claude-code"
+  },
+  {
+    id: "writing-guidelines",
+    source: "vercel-labs/agent-skills",
+    skillName: "writing-guidelines",
+    agent: "claude-code"
+  }
+];
+
+// src/plugins/skills/index.ts
+var PLUGIN_ID6 = "skills";
+var ACTION_TYPE_INSTALLED_SKILL = "installed-skill";
+var ACTION_TYPE_PREEXISTING_SKILL = "preexisting-skill";
+var ACTION_TYPE_GENERATED_SKILLS_LOCK = "generated-skills-lock";
+var SKILLS_LOCK_FILE = "skills-lock.json";
+var SKILLS_LIST_TIMEOUT_MS = 3e4;
+var SKILLS_ADD_TIMEOUT_MS = 18e4;
+var SKILLS_REMOVE_TIMEOUT_MS = 12e4;
+function getPluginActions5(ctx) {
+  return ctx.manifest.getActions().filter((action) => action.plugin === PLUGIN_ID6);
+}
+function hasManagedInstallRecord2(ctx, skillName) {
+  return getPluginActions5(ctx).some(
+    (action) => action.type === ACTION_TYPE_INSTALLED_SKILL && action.target === skillName && action.preExisting === false
+  );
+}
+function hasPreexistingRecord3(ctx, skillName) {
+  return getPluginActions5(ctx).some(
+    (action) => action.type === ACTION_TYPE_PREEXISTING_SKILL && action.target === skillName && action.preExisting === true
+  );
+}
+function hasAnyRecordForSkill(ctx, skillName) {
+  return hasManagedInstallRecord2(ctx, skillName) || hasPreexistingRecord3(ctx, skillName);
+}
+function getSkillsLockPath(cwd) {
+  return join7(cwd, SKILLS_LOCK_FILE);
+}
+function hasManagedSkillsLockRecord(ctx) {
+  return getPluginActions5(ctx).some(
+    (action) => action.type === ACTION_TYPE_GENERATED_SKILLS_LOCK && action.target === SKILLS_LOCK_FILE && action.preExisting === false
+  );
+}
+async function listInstalledSkillNames(ctx) {
+  const listResult = await ctx.run("npx", ["skills", "list", "--json"], {
+    timeoutMs: SKILLS_LIST_TIMEOUT_MS
+  });
+  if (listResult.code !== 0) {
+    throw new Error(listResult.stderr || "npx skills list failed");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(listResult.stdout || "[]");
+  } catch {
+    const stderr = listResult.stderr.trim();
+    const stdoutPreview = listResult.stdout.trim().slice(0, 200);
+    const detail = stderr || stdoutPreview || "no command output";
+    throw new Error(`npx skills list returned invalid JSON: ${detail}`);
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error("npx skills list returned non-array JSON");
+  }
+  const installedSkillNames = /* @__PURE__ */ new Set();
+  for (const item of parsed) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const typedItem = item;
+    if (typeof typedItem.name === "string" && typedItem.name.length > 0) {
+      installedSkillNames.add(typedItem.name);
+    }
+  }
+  return installedSkillNames;
+}
+function allBundleSkillsPresent(installedSkillNames) {
+  return SKILL_BUNDLE.every(
+    (entry) => installedSkillNames.has(entry.skillName)
+  );
+}
+async function detectSkills(ctx) {
+  const installedSkillNames = await listInstalledSkillNames(ctx);
+  if (!allBundleSkillsPresent(installedSkillNames)) {
+    return { present: false, preExisting: false };
+  }
+  const allManaged = SKILL_BUNDLE.every(
+    (entry) => hasManagedInstallRecord2(ctx, entry.skillName)
+  );
+  if (allManaged) {
+    return { present: true, preExisting: false };
+  }
+  if (!ctx.dryRun) {
+    for (const entry of SKILL_BUNDLE) {
+      if (hasAnyRecordForSkill(ctx, entry.skillName)) {
+        continue;
+      }
+      await ctx.manifest.recordAction({
+        plugin: PLUGIN_ID6,
+        type: ACTION_TYPE_PREEXISTING_SKILL,
+        target: entry.skillName,
+        preExisting: true
+      });
+    }
+  }
+  return { present: true, preExisting: true };
+}
+async function installSkills(ctx) {
+  if (ctx.dryRun) {
+    for (const entry of SKILL_BUNDLE) {
+      ctx.ui.info(`Would add skill ${entry.skillName} from ${entry.source}`);
+    }
+    return;
+  }
+  const skillsLockPreviouslyExisted = existsSync3(getSkillsLockPath(ctx.cwd));
+  const installedSkillNames = await listInstalledSkillNames(ctx);
+  for (const entry of SKILL_BUNDLE) {
+    if (installedSkillNames.has(entry.skillName)) {
+      if (!hasAnyRecordForSkill(ctx, entry.skillName)) {
+        await ctx.manifest.recordAction({
+          plugin: PLUGIN_ID6,
+          type: ACTION_TYPE_PREEXISTING_SKILL,
+          target: entry.skillName,
+          preExisting: true
+        });
+      }
+      continue;
+    }
+    const addResult = await ctx.run(
+      "npx",
+      [
+        "skills",
+        "add",
+        entry.source,
+        "--skill",
+        entry.skillName,
+        "--agent",
+        entry.agent,
+        "--yes"
+      ],
+      {
+        timeoutMs: SKILLS_ADD_TIMEOUT_MS
+      }
+    );
+    if (addResult.code !== 0) {
+      throw new Error(
+        addResult.stderr || `npx skills add failed for ${entry.skillName}`
+      );
+    }
+    await ctx.manifest.recordAction({
+      plugin: PLUGIN_ID6,
+      type: ACTION_TYPE_INSTALLED_SKILL,
+      target: entry.skillName,
+      preExisting: false
+    });
+  }
+  const skillsLockExistsAfterInstall = existsSync3(getSkillsLockPath(ctx.cwd));
+  if (!skillsLockPreviouslyExisted && skillsLockExistsAfterInstall && !hasManagedSkillsLockRecord(ctx)) {
+    await ctx.manifest.recordAction({
+      plugin: PLUGIN_ID6,
+      type: ACTION_TYPE_GENERATED_SKILLS_LOCK,
+      target: SKILLS_LOCK_FILE,
+      preExisting: false
+    });
+  }
+}
+async function verifySkills(ctx) {
+  if (ctx.dryRun) {
+    return { ok: true, detail: "dry-run" };
+  }
+  const installedSkillNames = await listInstalledSkillNames(ctx);
+  const missingSkillNames = SKILL_BUNDLE.map((entry) => entry.skillName).filter(
+    (skillName) => !installedSkillNames.has(skillName)
+  );
+  if (missingSkillNames.length > 0) {
+    return {
+      ok: false,
+      detail: `Missing skill(s): ${missingSkillNames.join(", ")}`
+    };
+  }
+  return {
+    ok: true,
+    detail: `${SKILL_BUNDLE.length} skill bundle entries present`
+  };
+}
+async function uninstallSkills(ctx) {
+  const managedActions = getPluginActions5(ctx).filter(
+    (action) => action.type === ACTION_TYPE_INSTALLED_SKILL && action.preExisting === false
+  );
+  const shouldRemoveManagedSkillsLock = hasManagedSkillsLockRecord(ctx);
+  if (ctx.dryRun) {
+    if (managedActions.length === 0) {
+      if (shouldRemoveManagedSkillsLock) {
+        ctx.ui.info(`Would remove ${SKILLS_LOCK_FILE}`);
+      } else {
+        ctx.ui.info("Would keep pre-existing skills untouched");
+      }
+      return;
+    }
+    for (const action of managedActions) {
+      ctx.ui.info(`Would remove skill ${action.target}`);
+    }
+    if (shouldRemoveManagedSkillsLock) {
+      ctx.ui.info(`Would remove ${SKILLS_LOCK_FILE}`);
+    }
+    return;
+  }
+  const installedSkillNames = await listInstalledSkillNames(ctx);
+  for (const action of managedActions) {
+    if (!installedSkillNames.has(action.target)) {
+      continue;
+    }
+    const removeResult = await ctx.run(
+      "npx",
+      ["skills", "remove", action.target, "--yes"],
+      {
+        timeoutMs: SKILLS_REMOVE_TIMEOUT_MS
+      }
+    );
+    if (removeResult.code !== 0) {
+      throw new Error(
+        removeResult.stderr || `npx skills remove failed for ${action.target}`
+      );
+    }
+  }
+  if (shouldRemoveManagedSkillsLock) {
+    await rm5(getSkillsLockPath(ctx.cwd), { force: true });
+  }
+  await ctx.manifest.removeActionsForPlugin(PLUGIN_ID6);
+}
+var skillsPlugin = {
+  id: PLUGIN_ID6,
+  detect: detectSkills,
+  install: installSkills,
+  verify: verifySkills,
+  uninstall: uninstallSkills
+};
+
+// src/plugins/test-plugin.ts
+var testPlugin = {
+  id: "test-plugin",
+  async detect(ctx) {
+    return {
+      present: ctx.manifest.hasActionForPlugin("test-plugin"),
+      preExisting: false
+    };
+  },
+  async install(ctx) {
+    if (ctx.dryRun) {
+      return;
+    }
+    await ctx.manifest.recordAction({
+      plugin: "test-plugin",
+      type: "simulated-install",
+      target: "phase-1 orchestrator checkpoint",
+      preExisting: false
+    });
+  },
+  async verify(ctx) {
+    if (ctx.dryRun) {
+      return { ok: true, detail: "dry-run" };
+    }
+    return {
+      ok: ctx.manifest.hasActionForPlugin("test-plugin"),
+      detail: "action logged in manifest"
+    };
+  },
+  async uninstall(ctx) {
+    if (ctx.dryRun) {
+      return;
+    }
+    await ctx.manifest.removeActionsForPlugin("test-plugin");
+  }
+};
+
+// src/plugins/workflow-scaffolder/index.ts
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir5, rm as rm6, writeFile as writeFile6 } from "fs/promises";
+import { join as join8 } from "path";
+
+// src/plugins/workflow-scaffolder/catalog.ts
+var WORKFLOW_BUNDLE = [
+  {
+    id: "claude-code-security-review",
+    filename: "claude-code-security-review.yml",
+    contents: [
+      "name: Claude Code Security Review",
+      "",
+      "on:",
+      "  pull_request:",
+      "",
+      "permissions:",
+      "  contents: read",
+      "  security-events: write",
+      "",
+      "jobs:",
+      "  security-review:",
+      "    runs-on: ubuntu-latest",
+      "    steps:",
+      "      - name: Checkout repository",
+      "        uses: actions/checkout@v4",
+      "",
+      "      - name: Run Claude Code Security Review",
+      "        uses: anthropics/claude-code-security-review@main",
+      ""
+    ].join("\n")
+  },
+  {
+    id: "code-review-graph-action",
+    filename: "code-review-graph-action.yml",
+    contents: [
+      "name: Code Review Graph Action",
+      "",
+      "on:",
+      "  pull_request:",
+      "",
+      "permissions:",
+      "  contents: read",
+      "",
+      "jobs:",
+      "  code-review-graph:",
+      "    runs-on: ubuntu-latest",
+      "    steps:",
+      "      - name: Checkout repository",
+      "        uses: actions/checkout@v4",
+      "",
+      "      - name: Run Code Review Graph",
+      "        uses: tirth8205/code-review-graph@main",
+      ""
+    ].join("\n")
+  }
+];
+
+// src/plugins/workflow-scaffolder/index.ts
+var PLUGIN_ID7 = "workflow-scaffolder";
+var WORKFLOW_DIRECTORY = ".github/workflows";
+var ACTION_TYPE_SCAFFOLDED_WORKFLOW = "scaffolded-workflow";
+function getPluginActions6(ctx) {
+  return ctx.manifest.getActions().filter((action) => action.plugin === PLUGIN_ID7);
+}
+function buildWorkflowPath(cwd, entry) {
+  return join8(cwd, WORKFLOW_DIRECTORY, entry.filename);
+}
+function buildWorkflowTarget(entry) {
+  return `${WORKFLOW_DIRECTORY}/${entry.filename}`;
+}
+function hasManagedWorkflowRecord(ctx, workflowTarget) {
+  return getPluginActions6(ctx).some(
+    (action) => action.type === ACTION_TYPE_SCAFFOLDED_WORKFLOW && action.target === workflowTarget && action.preExisting === false
+  );
+}
+function getUnmanagedCollisions(ctx) {
+  const collisions = [];
+  for (const entry of WORKFLOW_BUNDLE) {
+    const workflowPath = buildWorkflowPath(ctx.cwd, entry);
+    const workflowTarget = buildWorkflowTarget(entry);
+    if (!existsSync4(workflowPath)) {
+      continue;
+    }
+    if (hasManagedWorkflowRecord(ctx, workflowTarget)) {
+      continue;
+    }
+    collisions.push(workflowTarget);
+  }
+  return collisions;
+}
+function assertNoUnmanagedCollisions(ctx) {
+  const collisions = getUnmanagedCollisions(ctx);
+  if (collisions.length === 0) {
+    return;
+  }
+  throw new Error(
+    `Refusing to overwrite pre-existing workflow file(s): ${collisions.join(", ")}`
+  );
+}
+function allBundleWorkflowsExist(ctx) {
+  return WORKFLOW_BUNDLE.every(
+    (entry) => existsSync4(buildWorkflowPath(ctx.cwd, entry))
+  );
+}
+async function detectWorkflows(ctx) {
+  assertNoUnmanagedCollisions(ctx);
+  if (!allBundleWorkflowsExist(ctx)) {
+    return { present: false, preExisting: false };
+  }
+  return { present: true, preExisting: false };
+}
+async function installWorkflows(ctx) {
+  assertNoUnmanagedCollisions(ctx);
+  if (ctx.dryRun) {
+    for (const entry of WORKFLOW_BUNDLE) {
+      ctx.ui.info(`Would scaffold workflow ${buildWorkflowTarget(entry)}`);
+    }
+    return;
+  }
+  const workflowDirectoryPath = join8(ctx.cwd, WORKFLOW_DIRECTORY);
+  await mkdir5(workflowDirectoryPath, { recursive: true });
+  for (const entry of WORKFLOW_BUNDLE) {
+    const workflowPath = buildWorkflowPath(ctx.cwd, entry);
+    const workflowTarget = buildWorkflowTarget(entry);
+    await writeFile6(workflowPath, entry.contents, "utf8");
+    if (!hasManagedWorkflowRecord(ctx, workflowTarget)) {
+      await ctx.manifest.recordAction({
+        plugin: PLUGIN_ID7,
+        type: ACTION_TYPE_SCAFFOLDED_WORKFLOW,
+        target: workflowTarget,
+        preExisting: false
+      });
+    }
+  }
+}
+async function verifyWorkflows(ctx) {
+  if (ctx.dryRun) {
+    return { ok: true, detail: "dry-run" };
+  }
+  const missingWorkflows = WORKFLOW_BUNDLE.map(
+    (entry) => buildWorkflowTarget(entry)
+  ).filter((workflowTarget) => !existsSync4(join8(ctx.cwd, workflowTarget)));
+  if (missingWorkflows.length > 0) {
+    return {
+      ok: false,
+      detail: `Missing workflow file(s): ${missingWorkflows.join(", ")}`
+    };
+  }
+  return {
+    ok: true,
+    detail: `${WORKFLOW_BUNDLE.length} workflow bundle entries present`
+  };
+}
+async function uninstallWorkflows(ctx) {
+  const managedActions = getPluginActions6(ctx).filter(
+    (action) => action.type === ACTION_TYPE_SCAFFOLDED_WORKFLOW && action.preExisting === false
+  );
+  if (ctx.dryRun) {
+    if (managedActions.length === 0) {
+      ctx.ui.info("Would keep pre-existing workflow files untouched");
+      return;
+    }
+    for (const action of managedActions) {
+      ctx.ui.info(`Would remove workflow ${action.target}`);
+    }
+    return;
+  }
+  for (const action of managedActions) {
+    await rm6(join8(ctx.cwd, action.target), { force: true });
+  }
+  await ctx.manifest.removeActionsForPlugin(PLUGIN_ID7);
+}
+var workflowScaffolderPlugin = {
+  id: PLUGIN_ID7,
+  detect: detectWorkflows,
+  install: installWorkflows,
+  verify: verifyWorkflows,
+  uninstall: uninstallWorkflows
+};
+
+// src/plugins/index.ts
+var corePluginOrder = [
+  crgPlugin,
+  daemonPlugin,
+  skillsPlugin,
+  workflowScaffolderPlugin,
+  cliToolPlugin,
+  masterPromptPlugin
+];
+function getRegisteredPlugins() {
+  const devOnlyPlugins = process.env.AGEMON_DEV === "1" ? [testPlugin, patcherCheckpointPlugin] : [];
+  return [...corePluginOrder, ...devOnlyPlugins];
+}
+
+// src/ui/banner.ts
+import boxen from "boxen";
+
+// src/ui/theme.ts
+import pc from "picocolors";
+function colorsEnabled() {
+  if (process.env.NO_COLOR) return false;
+  return Boolean(process.stdout.isTTY);
+}
+function colors() {
+  return pc.createColors(colorsEnabled());
+}
+var theme = {
+  success: (text) => colors().green(text),
+  warn: (text) => colors().yellow(text),
+  error: (text) => colors().red(text),
+  info: (text) => colors().cyan(text),
+  muted: (text) => colors().gray(text),
+  bold: (text) => colors().bold(text)
+};
+
+// src/ui/banner.ts
+function renderBanner(title, message) {
+  return boxen(`${theme.bold(title)}
+
+${message}`, {
+    padding: 1,
+    borderColor: "cyan",
+    borderStyle: "round"
+  });
+}
+
+// src/ui/spinner.ts
+import ora from "ora";
+function isInteractive() {
+  return Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+}
+function createStepSpinner() {
+  let step = 0;
+  let current;
+  return {
+    start(label) {
+      step += 1;
+      const prefixed = `[${step}] ${label}`;
+      if (isInteractive()) {
+        current = ora(prefixed).start();
+      } else {
+        console.log(prefixed);
+      }
+    },
+    succeed(label) {
+      const text = label ?? current?.text ?? "";
+      if (isInteractive() && current) {
+        current.succeed(text);
+      } else {
+        console.log(theme.success(`\u2714 ${text}`));
+      }
+    },
+    fail(label) {
+      const text = label ?? current?.text ?? "";
+      if (isInteractive() && current) {
+        current.fail(text);
+      } else {
+        console.log(theme.error(`\u2718 ${text}`));
+      }
+    },
+    info(label) {
+      if (isInteractive() && current) {
+        current.info(label);
+      } else {
+        console.log(theme.info(label));
+      }
+    }
+  };
+}
+
+// src/cli/index.ts
+var VERSION = "0.1.0";
+var DESCRIPTION = "Bootstraps and reverses an AI coding agent's working environment in a repo.";
+async function runInstall(options) {
+  const spinner = createStepSpinner();
+  const plugins = getRegisteredPlugins().filter(
+    (plugin) => !(options.skipDaemon && plugin.id === "daemon")
+  );
+  const context = await createContext({
+    dryRun: Boolean(options.dryRun),
+    yes: Boolean(options.yes),
+    ui: spinner
+  });
+  await installPlugins(context, plugins, { only: options.only });
+}
+async function runNuke(options) {
+  const spinner = createStepSpinner();
+  const plugins = getRegisteredPlugins();
+  const context = await createContext({
+    dryRun: Boolean(options.dryRun),
+    yes: Boolean(options.yes),
+    ui: spinner
+  });
+  await uninstallPlugins(context, plugins, { only: options.only });
+}
+function createProgram() {
+  const program = new Command();
+  program.name("agemon").description(DESCRIPTION).version(VERSION).option("--dry-run", "narrate actions without making changes").option("--yes", "skip confirmation prompts").option("--skip-daemon", "skip daemon registration").option("--only <plugins>", "comma-separated list of plugin ids to run").option("--no-color", "disable colored output").option("-v, --verbose", "show raw subprocess output beneath each step").option("-q, --quiet", "print only the final summary").addHelpText("beforeAll", () => `${renderBanner("agemon", DESCRIPTION)}
+`).hook("preAction", (thisCommand) => {
+    if (thisCommand.opts().color === false) {
+      process.env.NO_COLOR = "1";
+    }
+  }).action((options) => runInstall(options));
+  program.command("nuke").description("Reverse agemon-managed changes").option("--dry-run", "narrate actions without making changes").option("--yes", "skip confirmation prompts").option("--only <plugins>", "comma-separated list of plugin ids to run").action((options) => runNuke(options));
+  program.exitOverride();
+  return program;
+}
+async function runCli(argv) {
+  const program = createProgram();
+  try {
+    assertFakeBackendsAreDevOnly();
+    await program.parseAsync(argv, { from: "user" });
+    return 0;
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      return error.exitCode;
+    }
+    console.error(
+      theme.error(error instanceof Error ? error.message : String(error))
+    );
+    return 1;
+  }
+}
+var isDirectlyExecuted = process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1];
+if (isDirectlyExecuted) {
+  process.exitCode = await runCli(process.argv.slice(2));
+}
+export {
+  runCli
+};
+//# sourceMappingURL=index.js.map