@clearlydev/nx-archweave 0.0.0-stage → 0.1.1

package/dist/generators/install-integration/generator.js

@@ -0,0 +1,1233 @@
+// ../integrations/dist/registry/integration-registry.js
+function createIntegrationRegistry(integrations) {
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const integration of integrations) {
+    if (seenIds.has(integration.id)) {
+      throw new Error(`Duplicate integration id: "${integration.id}"`);
+    }
+    seenIds.add(integration.id);
+  }
+  return integrations;
+}
+function listIntegrations(registry) {
+  return registry;
+}
+function getIntegration(registry, id) {
+  return registry.find((integration) => integration.id === id);
+}
+
+// ../integrations/dist/manifest/manifest.js
+import { existsSync, lstatSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+var MANIFEST_FILENAME = "archweave-integrations.json";
+function createEmptyManifest() {
+  return { integrations: {} };
+}
+function loadManifest(root) {
+  const manifestPath = join(root, MANIFEST_FILENAME);
+  if (!existsSync(manifestPath)) {
+    return createEmptyManifest();
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+    if (parsed && typeof parsed === "object" && typeof parsed.integrations === "object") {
+      return { integrations: parsed.integrations ?? {} };
+    }
+    return createEmptyManifest();
+  } catch {
+    return createEmptyManifest();
+  }
+}
+function serializeManifest(manifest) {
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+function writeManifestAtomic(root, manifest) {
+  const finalPath = join(root, MANIFEST_FILENAME);
+  if (existsSync(finalPath) && lstatSync(finalPath).isSymbolicLink()) {
+    throw new Error(`Refusing to write ${MANIFEST_FILENAME}: the path is a symlink. Remove or replace it with a regular file first.`);
+  }
+  const suffix = randomBytes(6).toString("hex");
+  const tempPath = join(root, `.${MANIFEST_FILENAME}.tmp-${suffix}`);
+  try {
+    writeFileSync(tempPath, serializeManifest(manifest));
+    renameSync(tempPath, finalPath);
+  } catch (error) {
+    if (existsSync(tempPath)) {
+      unlinkSync(tempPath);
+    }
+    throw error;
+  }
+}
+
+// ../integrations/dist/manifest/record-plan.js
+function entriesEqual(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function buildRecordPlan(input) {
+  const isRecordable = input.verification.verified && input.verificationSource === "claude-cli";
+  const proposedEntry = isRecordable ? {
+    source: input.metadata.source,
+    repository: input.metadata.repository,
+    version: input.verification.resolvedVersion,
+    method: input.metadata.method,
+    managedBy: "nx-archweave",
+    verification: "passed",
+    target: input.target,
+    evidenceKind: "claude-cli"
+  } : void 0;
+  const hasConflict = input.existingEntry !== void 0 && proposedEntry !== void 0 && !entriesEqual(input.existingEntry, proposedEntry);
+  return {
+    id: input.id,
+    target: input.target,
+    verificationSource: input.verificationSource,
+    currentVerification: input.verification,
+    existingEntry: input.existingEntry,
+    proposedEntry,
+    hasConflict
+  };
+}
+
+// ../shared/dist/lib/spawnable-command.js
+import { statSync } from "node:fs";
+import { win32 } from "node:path";
+function isFile(path) {
+  try {
+    return statSync(path).isFile();
+  } catch {
+    return false;
+  }
+}
+var DEFAULT_ENV = { platform: process.platform, env: process.env, isFile };
+function envValue(env, name) {
+  const key = Object.keys(env).find((candidate) => candidate.toUpperCase() === name);
+  return key === void 0 ? void 0 : env[key];
+}
+function resolveWindowsCommand(command, environment) {
+  const exts = (envValue(environment.env, "PATHEXT") ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+  const candidates = (base) => win32.extname(base) !== "" ? [base] : exts.map((ext) => base + ext);
+  if (win32.isAbsolute(command) || /[\\/]/.test(command)) {
+    return candidates(command).find(environment.isFile);
+  }
+  const dirs = (envValue(environment.env, "PATH") ?? "").split(";").filter(Boolean);
+  for (const dir of dirs) {
+    const found = candidates(win32.join(dir, command)).find(environment.isFile);
+    if (found !== void 0)
+      return found;
+  }
+  return void 0;
+}
+var META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
+var BIN_SHIM = /node_modules[\\/]\.bin[\\/][^\\/]+\.cmd$/i;
+function escapeCmdArgument(arg, doubleEscape = false) {
+  let quoted = arg.replace(/(\\*)"/g, '$1$1\\"');
+  quoted = quoted.replace(/(\\*)$/, "$1$1");
+  const escaped = `"${quoted}"`.replace(META_CHARS, "^$1");
+  return doubleEscape ? escaped.replace(META_CHARS, "^$1") : escaped;
+}
+function spawnableCommand(command, args, environment = DEFAULT_ENV) {
+  if (environment.platform !== "win32")
+    return { command, args: [...args] };
+  const resolved = resolveWindowsCommand(command, environment);
+  if (resolved === void 0 || !/\.(cmd|bat)$/i.test(resolved))
+    return { command, args: [...args] };
+  const doubleEscape = BIN_SHIM.test(resolved);
+  const line = [resolved.replace(META_CHARS, "^$1"), ...args.map((arg) => escapeCmdArgument(arg, doubleEscape))].join(" ");
+  return {
+    command: envValue(environment.env, "COMSPEC") ?? "cmd.exe",
+    args: ["/d", "/s", "/c", `"${line}"`],
+    windowsVerbatimArguments: true
+  };
+}
+
+// ../integrations/dist/config/declare-enabled-integration.js
+import { existsSync as existsSync2, lstatSync as lstatSync2, readFileSync as readFileSync2, renameSync as renameSync2, statSync as statSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { join as join2 } from "node:path";
+var CONFIG_FILENAME = "toolkit.config.json";
+function detectIndent(raw) {
+  if (!raw.includes("\n"))
+    return void 0;
+  for (const line of raw.split(/\r?\n/)) {
+    const match = /^(\t+| +)/.exec(line);
+    if (match)
+      return match[1];
+  }
+  return "  ";
+}
+function declareEnabledIntegration(root, id, options) {
+  const configPath = join2(root, CONFIG_FILENAME);
+  if (!existsSync2(configPath))
+    return { action: "no-config" };
+  if (lstatSync2(configPath).isSymbolicLink())
+    return { action: "unrecognized" };
+  const raw = readFileSync2(configPath, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { action: "unrecognized" };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+    return { action: "unrecognized" };
+  const existing = parsed;
+  const integrationsField = existing["integrations"];
+  if (integrationsField !== void 0 && (typeof integrationsField !== "object" || integrationsField === null || Array.isArray(integrationsField))) {
+    return { action: "unrecognized" };
+  }
+  const integrations = integrationsField ?? {};
+  const enabledField = integrations["enabled"];
+  if (enabledField !== void 0 && (!Array.isArray(enabledField) || !enabledField.every((e) => typeof e === "string"))) {
+    return { action: "unrecognized" };
+  }
+  const enabled = enabledField ?? [];
+  if (enabled.includes(id))
+    return { action: "unchanged" };
+  if (options.write) {
+    const next = { ...existing, integrations: { ...integrations, enabled: [...enabled, id] } };
+    let body = JSON.stringify(next, null, detectIndent(raw));
+    if (raw.endsWith("\n"))
+      body += "\n";
+    if (raw.includes("\r\n"))
+      body = body.replace(/\n/g, "\r\n");
+    const tempPath = join2(root, `.${CONFIG_FILENAME}.tmp-${randomBytes2(6).toString("hex")}`);
+    try {
+      writeFileSync2(tempPath, body, { mode: statSync2(configPath).mode & 511 });
+      renameSync2(tempPath, configPath);
+    } catch (error) {
+      if (existsSync2(tempPath))
+        unlinkSync2(tempPath);
+      throw error;
+    }
+  }
+  return { action: "updated" };
+}
+
+// ../integrations/dist/process/read-only-command-runner.js
+var CLAUDE_CLI_TIMEOUT_MS = 5e3;
+var CLAUDE_CLI_STDOUT_LIMIT_BYTES = 1048576;
+var CLAUDE_CLI_STDERR_LIMIT_BYTES = 65536;
+
+// ../integrations/dist/catalog/plugin-catalog.js
+var PLUGIN_HOSTS = ["claude-code"];
+var PLUGIN_CATALOG = [
+  {
+    // Researched 2026-07-15. The claude-code values are the ones the manifest and verifier
+    // were measured with. ponytail documents official installs for ~20 hosts; only claude-code
+    // has an adapter.
+    id: "ponytail",
+    displayName: "ponytail",
+    // The project's own tagline.
+    description: 'over-engineering review rules and skills \u2014 "makes your AI agent think like the laziest senior dev in the room"',
+    homepage: "https://ponytail.dev",
+    repository: "https://github.com/DietrichGebert/ponytail",
+    license: "MIT",
+    npmPackage: "@dietrichgebert/ponytail",
+    installDocs: "https://github.com/DietrichGebert/ponytail#install",
+    uninstallSteps: [
+      "Run this from a clone of https://github.com/DietrichGebert/ponytail (or before removing the plugin below \u2014 the script is itself a plugin file, so removing the plugin first deletes it): node scripts/uninstall.js",
+      "Then remove the plugin via your host's own command, e.g. in Claude Code: /plugin uninstall ponytail@ponytail (or use the Claude Code Desktop app: Customize > manage marketplaces > remove plugin).",
+      "See https://github.com/DietrichGebert/ponytail#uninstall for the full, current official instructions."
+    ],
+    hosts: {
+      "claude-code": { name: "ponytail", marketplace: "DietrichGebert/ponytail", pluginId: "ponytail@ponytail" }
+    }
+  }
+];
+var PLUGIN_IDS = PLUGIN_CATALOG.map((entry) => entry.id);
+function getCatalogEntry(id) {
+  return PLUGIN_CATALOG.find((entry) => entry.id === id);
+}
+var CLAUDE_MARKETPLACE_METHOD = "claude-code-plugin-marketplace";
+function recordMetadataFor(entry) {
+  const claude = entry.hosts["claude-code"];
+  if (!claude)
+    return void 0;
+  return { source: claude.marketplace, repository: entry.repository, method: CLAUDE_MARKETPLACE_METHOD };
+}
+
+// ../integrations/dist/hosts/claude-code/detect.js
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+async function detectWorkspacePackage(entry, context) {
+  const npmPackage = entry.npmPackage;
+  if (npmPackage === void 0) {
+    return { installed: false, managedBy: "unknown", evidence: [] };
+  }
+  const packageJsonPath = join3(context.workspaceRoot, "package.json");
+  if (!existsSync3(packageJsonPath)) {
+    return { installed: false, managedBy: "unknown", evidence: [] };
+  }
+  let pkg;
+  try {
+    pkg = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
+  } catch {
+    return { installed: false, managedBy: "unknown", evidence: [] };
+  }
+  const deps = pkg["dependencies"] ?? {};
+  const devDeps = pkg["devDependencies"] ?? {};
+  const version = deps[npmPackage] ?? devDeps[npmPackage];
+  if (!version) {
+    return { installed: false, managedBy: "unknown", evidence: [] };
+  }
+  return {
+    installed: true,
+    installedVersion: version,
+    managedBy: "external-tool",
+    evidence: [`package.json: ${npmPackage}@${version}`]
+  };
+}
+
+// ../integrations/dist/hosts/claude-code/plan.js
+var VERSION_DECIDED_BY_MARKETPLACE = "latest (decided by the marketplace)";
+var WORKSPACE_FILES_BY_SCOPE = {
+  user: [],
+  project: [".claude/settings.json"],
+  local: [".claude/settings.local.json"]
+};
+var DEFAULT_PLUGIN_SCOPE = "project";
+function createClaudeMarketplacePlan(entry) {
+  return async (options) => {
+    const distribution = entry.hosts["claude-code"];
+    if (options.targetEnvironment !== "claude-code" || distribution === void 0) {
+      const supported = Object.entries(entry.hosts).filter(([, value]) => value !== void 0).map(([host]) => host).join(", ");
+      throw new Error(`Target environment "${options.targetEnvironment}" is not supported by this integration. Supported: ${supported}.`);
+    }
+    const resolvedVersion = options.versionRange ?? VERSION_DECIDED_BY_MARKETPLACE;
+    const scope = options.scope ?? DEFAULT_PLUGIN_SCOPE;
+    return {
+      officialCommand: {
+        executable: "claude",
+        args: [
+          "plugin",
+          "install",
+          distribution.name,
+          "--marketplace",
+          distribution.marketplace,
+          "--scope",
+          scope,
+          "--json"
+        ]
+      },
+      resolvedVersion,
+      filesCreated: [],
+      // project/local scope: Claude Code records the plugin in the workspace's own
+      // .claude settings — shown before approval as the files that will change.
+      filesModified: [...WORKSPACE_FILES_BY_SCOPE[scope]],
+      conflicts: [],
+      sourceRepository: entry.repository,
+      officialHomepage: entry.homepage,
+      license: entry.license,
+      requiresManualExecution: false
+    };
+  };
+}
+
+// ../integrations/dist/hosts/claude-code/install.js
+import { homedir } from "node:os";
+function manualInstallSteps(entry) {
+  const distribution = entry.hosts["claude-code"];
+  if (distribution === void 0)
+    return [`See ${entry.installDocs} for the official instructions.`];
+  return [
+    `In Claude Code, send this as its own prompt: /plugin marketplace add ${distribution.marketplace}`,
+    `Then, as a second separate prompt: /plugin install ${distribution.pluginId}`,
+    `See ${entry.installDocs} for the official instructions.`
+  ];
+}
+var CLAUDE_CLI_INSTALL_TIMEOUT_MS = 12e4;
+var CLAUDE_CLI_INSTALL_STDOUT_LIMIT_BYTES = 1048576;
+var CLAUDE_CLI_INSTALL_STDERR_LIMIT_BYTES = 262144;
+function defaultRerunCommand(entry, runNx = "pnpm nx") {
+  return `${runNx} g @clearlydev/nx-archweave:install-integration --tool=${entry.id} --apply`;
+}
+function chatAlternative(entry) {
+  return ["Alternatively, inside a Claude Code session (the chat path):", ...manualInstallSteps(entry)];
+}
+var MARKETPLACE_NOTE = "If the marketplace was registered before the failure, it stays in your user settings \u2014 see `claude plugin marketplace list`.";
+function claudeCliNotFoundSteps(entry, rerunCommand) {
+  return [
+    "The claude CLI was not found on PATH. Install the Claude Code CLI from your terminal: npm install -g @anthropic-ai/claude-code (setup guide: https://code.claude.com/docs/en/setup)",
+    `Then rerun: ${rerunCommand}`,
+    ...chatAlternative(entry)
+  ];
+}
+function claudeCliUnsupportedSteps(entry, rerunCommand, cliSaid) {
+  return [
+    `Your claude CLI does not know this command (it said: ${cliSaid}). Scriptable plugin install needs Claude Code 2.1.285 or newer: run \`claude update\`, or reinstall it with npm install -g @anthropic-ai/claude-code@latest`,
+    `Then rerun: ${rerunCommand}`,
+    ...chatAlternative(entry)
+  ];
+}
+var TAIL_CHARS = 500;
+var UNSUPPORTED_CLI_PATTERN = /error: unknown (command|option) '(plugin|install|marketplace|--json|--marketplace|--scope)'/;
+function tail(text) {
+  const trimmed = text.trim();
+  return trimmed.length > TAIL_CHARS ? trimmed.slice(-TAIL_CHARS) : trimmed;
+}
+var ESCAPED_HOME = homedir().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var HOME_PATTERN = new RegExp(`${ESCAPED_HOME}(?=[/\\\\\\s'"\`]|$)`, "g");
+function redactHomePaths(text) {
+  let out = ESCAPED_HOME.length > 1 ? text.replace(HOME_PATTERN, "~") : text;
+  out = out.replace(/\/(?:Users|home)\/[^/\s'"`]+/g, "~");
+  out = out.replace(/[A-Za-z]:\\Users\\[^\\\s'"`]+/g, "~");
+  out = out.replace(/\/root(?=[/\s'"`]|$)/g, "~");
+  return out;
+}
+function parseLastJsonObject(stdout) {
+  const lines = stdout.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i].trim();
+    if (!line.startsWith("{"))
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed))
+        return parsed;
+    } catch {
+    }
+  }
+  return null;
+}
+function renderUserCommand(command) {
+  return [command.executable, ...command.args.filter((arg) => arg !== "--json")].join(" ");
+}
+async function classifyRun(runner, command, cwd) {
+  let raw;
+  try {
+    raw = await runner.run({
+      executable: command.executable,
+      argv: command.args,
+      ...cwd === void 0 ? {} : { cwd },
+      timeoutMs: CLAUDE_CLI_INSTALL_TIMEOUT_MS,
+      stdoutLimitBytes: CLAUDE_CLI_INSTALL_STDOUT_LIMIT_BYTES,
+      stderrLimitBytes: CLAUDE_CLI_INSTALL_STDERR_LIMIT_BYTES
+    });
+  } catch (error) {
+    const code = typeof error?.code === "string" ? error.code : "unknown";
+    return code === "ENOENT" ? { kind: "cli-not-found" } : { kind: "failed-to-start", code };
+  }
+  if (raw.timedOut)
+    return { kind: "timeout" };
+  if (raw.outputExceeded)
+    return { kind: "output-too-large" };
+  const json = parseLastJsonObject(raw.stdout);
+  const jsonSaysFailed = json !== null && json["outcome"] === "failed";
+  if (raw.exitCode === 0 && !jsonSaysFailed)
+    return { kind: "executed" };
+  if (json !== null) {
+    const message = redactHomePaths(typeof json["message"] === "string" ? json["message"] : `the claude CLI exited with code ${raw.exitCode}`);
+    const failureCode = typeof json["failureCode"] === "string" ? json["failureCode"] : void 0;
+    const shown = json["shownCommand"];
+    if (typeof shown === "object" && shown !== null)
+      return { kind: "confirmation-required", message };
+    return failureCode === void 0 ? { kind: "failed", message } : { kind: "failed", failureCode, message };
+  }
+  if (UNSUPPORTED_CLI_PATTERN.test(raw.stderr)) {
+    const line = raw.stderr.split("\n").find((l) => UNSUPPORTED_CLI_PATTERN.test(l)) ?? "";
+    return { kind: "cli-unsupported", stderrTail: redactHomePaths(line.trim()) };
+  }
+  const said = redactHomePaths(tail(raw.stderr.length > 0 ? raw.stderr : raw.stdout));
+  return { kind: "failed", message: said.length > 0 ? said : `the claude CLI exited with code ${raw.exitCode}` };
+}
+function manualStepsFor(entry, detail, command, rerunCommand) {
+  const chat = chatAlternative(entry);
+  const userCommand = command === null ? "" : renderUserCommand(command);
+  const rerun = `Once resolved, rerun to install, verify and record it: ${rerunCommand}`;
+  switch (detail.kind) {
+    case "executed":
+      return [];
+    case "manual-only":
+      return manualInstallSteps(entry);
+    case "cli-not-found":
+      return claudeCliNotFoundSteps(entry, rerunCommand);
+    case "failed-to-start":
+      return [
+        `The claude CLI was found but could not be started (${detail.code}) \u2014 check its permissions and your system limits.`,
+        rerun,
+        ...chat
+      ];
+    case "cli-unsupported":
+      return claudeCliUnsupportedSteps(entry, rerunCommand, detail.stderrTail);
+    case "confirmation-required":
+      return [
+        `The marketplace declares a command that must be confirmed by a person; nx-archweave never accepts it for you (${detail.message})`,
+        `Review it and run the install yourself: ${userCommand}`,
+        rerun,
+        ...chat
+      ];
+    case "failed":
+      return [`The install command did not succeed: ${detail.message}`, MARKETPLACE_NOTE, rerun, ...chat];
+    case "timeout":
+      return [
+        `The install command did not finish within ${CLAUDE_CLI_INSTALL_TIMEOUT_MS / 1e3} s and was stopped.`,
+        MARKETPLACE_NOTE,
+        rerun,
+        ...chat
+      ];
+    case "output-too-large":
+      return [
+        "The install command produced more output than nx-archweave is willing to buffer and was stopped.",
+        `Run it yourself to see the full output: ${userCommand}`,
+        rerun,
+        ...chat
+      ];
+  }
+}
+async function installClaudeMarketplacePlugin(entry, deps, plan, options = {}) {
+  const rerunCommand = options.rerunCommand ?? defaultRerunCommand(entry);
+  const detail = plan.officialCommand === null ? { kind: "manual-only" } : await classifyRun(deps.runner, plan.officialCommand, options.cwd);
+  const executed = detail.kind === "executed";
+  const result = {
+    executed,
+    // One command: it either reached exit 0 or it did not. What a failed run may
+    // have left behind is re-checked live by install-integration, not guessed here.
+    partialFailure: false,
+    filesCreated: [],
+    // The workspace files the plan said the host would change (project/local scope);
+    // Claude's own plugin store is outside the workspace and never listed.
+    filesModified: executed ? [...plan.filesModified] : [],
+    manualStepsRemaining: manualStepsFor(entry, detail, plan.officialCommand, rerunCommand)
+  };
+  return { result, detail };
+}
+function projectMarketplaceCommand(entry) {
+  const distribution = entry.hosts["claude-code"];
+  if (distribution === void 0)
+    return null;
+  return {
+    executable: "claude",
+    args: ["plugin", "marketplace", "add", distribution.marketplace, "--scope", "project", "--json"]
+  };
+}
+async function declareProjectMarketplace(entry, deps, options = {}) {
+  const command = projectMarketplaceCommand(entry);
+  return command === null ? { kind: "manual-only" } : classifyRun(deps.runner, command, options.cwd);
+}
+function createClaudeMarketplaceInstall(entry, deps) {
+  return async (plan) => (await installClaudeMarketplacePlugin(entry, deps, plan)).result;
+}
+
+// ../integrations/dist/hosts/claude-code/verify-via-claude-cli.js
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+
+// ../integrations/dist/hosts/claude-code/parse-claude-plugin-list.js
+var KNOWN_SCOPES = /* @__PURE__ */ new Set(["user", "project", "local", "managed"]);
+function isKnownScope(scope) {
+  return KNOWN_SCOPES.has(scope);
+}
+function isValidEntry(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const record = value;
+  if (typeof record["id"] !== "string") {
+    return false;
+  }
+  if (typeof record["enabled"] !== "boolean") {
+    return false;
+  }
+  if (typeof record["scope"] !== "string" || record["scope"].length === 0) {
+    return false;
+  }
+  if (record["version"] !== void 0 && typeof record["version"] !== "string") {
+    return false;
+  }
+  return true;
+}
+function parseClaudePluginList(rawStdout, options = {}) {
+  let parsed;
+  try {
+    parsed = JSON.parse(rawStdout);
+  } catch {
+    return { ok: false, reason: "invalid-json" };
+  }
+  if (!Array.isArray(parsed)) {
+    return { ok: false, reason: "non-array" };
+  }
+  const entries = [];
+  const otherScopeIds = [];
+  for (const item of parsed) {
+    if (!isValidEntry(item)) {
+      return { ok: false, reason: "missing-fields" };
+    }
+    if (typeof item.projectPath === "string" && options.isThisWorkspace && !options.isThisWorkspace(item.projectPath)) {
+      continue;
+    }
+    const scope = item.scope;
+    if (!isKnownScope(scope)) {
+      otherScopeIds.push(item.id);
+      continue;
+    }
+    entries.push({
+      id: item.id,
+      version: item.version,
+      scope,
+      enabled: item.enabled
+    });
+  }
+  return { ok: true, entries, otherScopeIds };
+}
+
+// ../integrations/dist/hosts/claude-code/match-claude-plugin.js
+function matchClaudePlugin(entries, pluginId) {
+  const matches = entries.filter((candidate) => candidate.id === pluginId);
+  if (matches.length === 0) {
+    return { kind: "absent" };
+  }
+  if (matches.length > 1) {
+    return { kind: "ambiguous", entries: matches };
+  }
+  return { kind: "matched", entry: matches[0] };
+}
+
+// ../integrations/dist/hosts/claude-code/claude-cli-verification-result.js
+function evaluateClaudeCliMatch(match) {
+  switch (match.kind) {
+    case "matched":
+      return match.entry.enabled ? { status: "verified", version: match.entry.version, scope: match.entry.scope } : { status: "installed-but-disabled", scope: match.entry.scope };
+    case "absent":
+      return { status: "absent" };
+    case "ambiguous":
+      return { status: "ambiguous" };
+  }
+}
+
+// ../integrations/dist/hosts/claude-code/verify-via-claude-cli.js
+async function verifyViaClaudeCli(runner, pluginId, cwd) {
+  let raw;
+  try {
+    raw = await runner.run({
+      executable: "claude",
+      argv: ["plugin", "list", "--json"],
+      ...cwd === void 0 ? {} : { cwd },
+      timeoutMs: CLAUDE_CLI_TIMEOUT_MS,
+      stdoutLimitBytes: CLAUDE_CLI_STDOUT_LIMIT_BYTES,
+      stderrLimitBytes: CLAUDE_CLI_STDERR_LIMIT_BYTES
+    });
+  } catch {
+    return { source: "claude-cli-unavailable", reason: "not-found" };
+  }
+  if (raw.timedOut) {
+    return { source: "claude-cli-unavailable", reason: "timeout" };
+  }
+  if (raw.outputExceeded) {
+    return { source: "claude-cli-unavailable", reason: "output-too-large" };
+  }
+  if (raw.exitCode !== 0) {
+    return { source: "claude-cli-unavailable", reason: "non-zero-exit" };
+  }
+  const parsed = parseClaudePluginList(raw.stdout, cwd === void 0 ? {} : { isThisWorkspace: samePathAs(cwd) });
+  if (!parsed.ok) {
+    return {
+      source: "claude-cli-unavailable",
+      reason: parsed.reason === "invalid-json" ? "invalid-json" : "unexpected-schema"
+    };
+  }
+  const match = matchClaudePlugin(parsed.entries, pluginId);
+  if (parsed.otherScopeIds.includes(pluginId)) {
+    return match.kind === "absent" ? { source: "claude-cli-unavailable", reason: "unexpected-schema" } : { source: "claude-cli", outcome: { status: "ambiguous" } };
+  }
+  return { source: "claude-cli", outcome: evaluateClaudeCliMatch(match) };
+}
+function canonical(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+function samePathAs(workspaceRoot) {
+  const root = canonical(workspaceRoot);
+  return (projectPath) => canonical(projectPath) === root;
+}
+
+// ../integrations/dist/hosts/claude-code/verify.js
+async function verifyClaudeMarketplacePlugin(entry, deps, context) {
+  const detect = deps.detect ?? detectWorkspacePackage;
+  const pluginId = entry.hosts["claude-code"]?.pluginId;
+  if (pluginId === void 0) {
+    throw new Error(`${entry.displayName} has no Claude Code distribution \u2014 it cannot be verified through the claude CLI.`);
+  }
+  const cliResult = await verifyViaClaudeCli(deps.runner, pluginId, context.workspaceRoot);
+  if (cliResult.source === "claude-cli") {
+    switch (cliResult.outcome.status) {
+      case "verified":
+        return {
+          source: "claude-cli",
+          result: { verified: true, resolvedVersion: cliResult.outcome.version, problems: [] }
+        };
+      case "installed-but-disabled":
+        return {
+          source: "claude-cli",
+          result: {
+            verified: false,
+            problems: [
+              `${entry.displayName} is installed (scope: ${cliResult.outcome.scope}) but currently disabled in Claude Code.`,
+              "Enable it before recording this integration \u2014 a disabled plugin is never recorded as verified."
+            ]
+          }
+        };
+      case "absent":
+        return {
+          source: "claude-cli",
+          result: {
+            verified: false,
+            problems: [
+              `${pluginId} was not found in the installed Claude Code plugin list.`,
+              `Install it (${defaultRerunCommand(entry)}) or complete the manual Claude Code steps, then try again.`
+            ]
+          }
+        };
+      case "ambiguous":
+        return {
+          source: "claude-cli",
+          result: {
+            verified: false,
+            problems: [
+              `Verification error: more than one installed plugin matches ${pluginId} exactly. This is ambiguous and cannot be safely resolved automatically.`
+            ]
+          }
+        };
+    }
+  }
+  if (cliResult.reason === "not-found") {
+    const detected = await detect(entry, context);
+    if (detected.installed) {
+      return {
+        source: "package-json",
+        result: { verified: true, resolvedVersion: detected.installedVersion, problems: [] }
+      };
+    }
+    return {
+      source: "package-json",
+      result: {
+        verified: false,
+        problems: [
+          `The claude CLI was not found, and ${entry.displayName} was not found as a workspace dependency either.`,
+          `Install the Claude Code CLI to use the authoritative verification signal, or add ${entry.displayName} as a workspace dependency for the weaker fallback signal.`
+        ]
+      }
+    };
+  }
+  return {
+    source: "claude-cli",
+    result: {
+      verified: false,
+      problems: [`Verification error: the claude CLI returned an unexpected result (${cliResult.reason}).`]
+    }
+  };
+}
+function createClaudeMarketplaceVerifier(entry, deps) {
+  return async (context) => (await verifyClaudeMarketplacePlugin(entry, deps, context)).result;
+}
+
+// ../integrations/dist/catalog/create-catalog-integration.js
+function createCatalogIntegration(entry, deps) {
+  return {
+    id: entry.id,
+    displayName: entry.displayName,
+    homepage: entry.homepage,
+    repository: entry.repository,
+    license: entry.license,
+    supportedEnvironments: PLUGIN_HOSTS.filter((host) => entry.hosts[host] !== void 0),
+    detect: (context) => detectWorkspacePackage(entry, context),
+    plan: createClaudeMarketplacePlan(entry),
+    install: createClaudeMarketplaceInstall(entry, { runner: deps.runner }),
+    verify: createClaudeMarketplaceVerifier(entry, { runner: deps.runner }),
+    uninstallInstructions: async () => [...entry.uninstallSteps]
+  };
+}
+function createCatalogIntegrations(deps) {
+  return PLUGIN_CATALOG.map((entry) => createCatalogIntegration(entry, deps));
+}
+
+// src/generators/install-integration/render.ts
+function describeState(state) {
+  switch (state.kind) {
+    case "absent":
+      return "not installed";
+    case "already-installed":
+      return `already installed and enabled at ${state.scope} scope${state.version ? ` (version ${state.version})` : ""}`;
+    case "installed-other-scope":
+      return `installed and enabled, but at ${state.installedScope} scope`;
+    case "disabled":
+      return "installed but disabled";
+    case "ambiguous":
+      return "more than one installed plugin matches exactly";
+    case "cli-not-found":
+      return "unknown \u2014 the claude CLI was not found";
+    case "cli-error":
+      return `unknown \u2014 the claude CLI could not list plugins (${state.reason})`;
+  }
+}
+function describeInstall(detail) {
+  switch (detail.kind) {
+    case "executed":
+      return "the official command exited successfully";
+    case "manual-only":
+      return "no scriptable command exists for this target \u2014 nothing was executed";
+    case "cli-not-found":
+      return "not executed \u2014 the claude CLI was not found";
+    case "failed-to-start":
+      return `not executed \u2014 the claude CLI could not be started (${detail.code})`;
+    case "cli-unsupported":
+      return "not executed \u2014 this claude CLI does not support scriptable plugin install";
+    case "confirmation-required":
+      return "stopped \u2014 the marketplace declares a command that a person must confirm";
+    case "failed":
+      return `failed${detail.failureCode ? ` (${detail.failureCode})` : ""}`;
+    case "timeout":
+      return "stopped \u2014 the command timed out";
+    case "output-too-large":
+      return "stopped \u2014 the command produced too much output";
+  }
+}
+function describeDeclaration(declaration, tool, preview) {
+  switch (declaration.action) {
+    case "updated":
+      return `toolkit.config.json: "${tool}" ${preview ? "would be added" : "added"} to integrations.enabled`;
+    case "unchanged":
+      return `toolkit.config.json: "${tool}" is already declared in integrations.enabled (unchanged)`;
+    case "no-config":
+      return `toolkit.config.json: not declared \u2014 this workspace has no toolkit.config.json (it was not set up with init). Add "${tool}" to integrations.enabled there if you want doctor to track the declaration.`;
+    case "unrecognized":
+      return `toolkit.config.json: not updated \u2014 the file is not in a shape nx-archweave recognizes, so it was left alone. Add "${tool}" to integrations.enabled by hand.`;
+    case "write-failed":
+      return `toolkit.config.json: not updated \u2014 writing it failed (${declaration.message}). Add "${tool}" to integrations.enabled by hand.`;
+  }
+}
+function renderInstallIntegrationView(view) {
+  const lines = [
+    `Integration: ${view.tool} (a separate project \u2014 nx-archweave only runs its official installer)`,
+    `Source repository: ${view.sourceRepository}`,
+    `Official homepage: ${view.officialHomepage}`,
+    `License: ${view.license}`,
+    view.requestedVersion === null ? "Version: latest (decided by the marketplace) \u2014 the version actually installed is the one recorded" : `Requested version: ${view.requestedVersion} (not enforced \u2014 the marketplace decides; the version actually installed is the one recorded)`,
+    `Target: ${view.target}`,
+    `Scope: ${view.scope}`,
+    `Official command: ${view.command}`,
+    ...view.teamMarketplace ? [`For teammates (project scope), the marketplace is declared in .claude/settings.json first: ${view.teamMarketplace.command}`] : [],
+    ...view.workspaceFiles.length > 0 ? [`Claude Code will update in this workspace: ${view.workspaceFiles.join(", ")}`] : [],
+    `Current state: ${describeState(view.currentState)}`
+  ];
+  if (view.applyIgnoredForNxDryRun) {
+    lines.push("Note: --apply was ignored because Nx's --dry-run is set.");
+  }
+  if (view.preview && view.currentState.kind === "absent") {
+    lines.push("", ...view.teamMarketplace ? [`Would run: ${view.teamMarketplace.command}`] : [], `Would run: ${view.command}`, `To run it: ${view.rerunCommand}`);
+  } else if (view.preview && view.teamMarketplace) {
+    lines.push("", `Would run: ${view.teamMarketplace.command}`, `To run it: ${view.rerunCommand}`);
+  }
+  if (view.teamMarketplace?.detail) {
+    const { detail } = view.teamMarketplace;
+    lines.push(
+      "",
+      detail.kind === "executed" ? "Marketplace: declared in .claude/settings.json (extraKnownMarketplaces) \u2014 teammates get its source from the committed file" : `Marketplace declaration: ${describeInstall(detail)}${detail.kind === "failed" ? ` \u2014 ${detail.message}` : ""}`
+    );
+  }
+  if (view.install) {
+    lines.push("", `Install: ${describeInstall(view.install.detail)}`);
+  }
+  if (view.record) {
+    const { record } = view;
+    lines.push(
+      "",
+      `Verification: ${record.verification.verified ? "passed" : "not verified"}`,
+      ...record.verification.problems.map((problem) => `  ! ${problem}`)
+    );
+    if (record.hasConflict && record.existingEntry) {
+      lines.push(
+        "Conflict: an existing manifest entry differs from what was verified now \u2014 the fresh result replaces it.",
+        `  Existing: ${JSON.stringify(record.existingEntry)}`,
+        `  Verified: ${JSON.stringify(record.proposedEntry)}`
+      );
+    }
+    const installKind = view.install?.detail.kind;
+    if (record.proposedEntry) {
+      if (installKind !== void 0 && installKind !== "executed") {
+        lines.push(
+          `The install command reported ${installKind}, but a fresh check shows the plugin installed and enabled.`
+        );
+      }
+      lines.push(
+        record.wasWritten ? "Recorded \u2014 the following manifest entry was written to archweave-integrations.json:" : "archweave-integrations.json would get this entry:",
+        `  ${JSON.stringify(record.proposedEntry)}`
+      );
+    } else if (installKind === "executed") {
+      lines.push("The install command exited 0, but the fresh verification did not confirm the plugin \u2014 nothing was written.");
+    } else {
+      lines.push("Nothing was written \u2014 verification did not succeed via the authoritative claude-cli signal.");
+    }
+  }
+  if (view.declaration) {
+    lines.push(describeDeclaration(view.declaration, view.tool, view.preview));
+  }
+  if (view.guidance.length > 0) {
+    lines.push("", "Next steps:", ...view.guidance.map((step) => `  - ${step}`));
+  }
+  lines.push(
+    "",
+    view.preview ? "(preview \u2014 only read-only checks ran; nothing was installed and no file was written)" : "(applied \u2014 the lines above state exactly what was executed and written)"
+  );
+  return lines.join("\n");
+}
+
+// src/generators/shared/record-pipeline.ts
+async function runRecordPipeline(input) {
+  const entry = getCatalogEntry(input.id);
+  const metadata = entry === void 0 ? void 0 : recordMetadataFor(entry);
+  if (!entry || !metadata) {
+    throw new Error(`No manifest metadata is defined for "${input.id}".`);
+  }
+  const { result: verification, source: verificationSource } = await verifyClaudeMarketplacePlugin(
+    entry,
+    { runner: input.runner },
+    { workspaceRoot: input.workspaceRoot, targetEnvironment: input.target }
+  );
+  const manifest = loadManifest(input.workspaceRoot);
+  const existingEntry = manifest.integrations[input.id];
+  const plan = buildRecordPlan({ id: input.id, target: input.target, verificationSource, verification, existingEntry, metadata });
+  let wasWritten = false;
+  if (input.write && plan.proposedEntry) {
+    writeManifestAtomic(input.workspaceRoot, {
+      integrations: { ...manifest.integrations, [input.id]: plan.proposedEntry }
+    });
+    wasWritten = true;
+  }
+  return {
+    verificationSource,
+    verification,
+    existingEntry,
+    proposedEntry: plan.proposedEntry,
+    hasConflict: plan.hasConflict,
+    wasWritten
+  };
+}
+
+// src/generators/shared/run-nx.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
+import { join as join4 } from "node:path";
+
+// ../template-engine/dist/environment/package-manager.js
+var LOCKFILES = [
+  ["yarn", ["yarn.lock"]],
+  ["bun", ["bun.lock", "bun.lockb"]],
+  ["npm", ["package-lock.json"]]
+];
+function detectWorkspacePackageManager(exists, read = () => void 0) {
+  if (exists("pnpm-lock.yaml") || exists("pnpm-workspace.yaml"))
+    return "pnpm";
+  const found = LOCKFILES.filter(([, files]) => files.some((file) => exists(file))).map(([pm]) => pm);
+  if (found.length <= 1)
+    return found[0] ?? null;
+  const declared = /"packageManager"\s*:\s*"(npm|yarn|bun)@/.exec(read("package.json") ?? "")?.[1];
+  const named = found.find((pm) => pm === declared);
+  if (named)
+    return named;
+  return found.includes("npm") ? "npm" : found[0];
+}
+function packageManagerCommands(pm, flavor = "classic") {
+  switch (pm) {
+    case "pnpm":
+      return { addDevAtRoot: (spec) => `pnpm add -D -w ${spec}`, addAtRoot: (spec) => `pnpm add -w ${spec}`, runNx: "pnpm nx", install: "pnpm install", workspaceRegistration: "pnpm-workspace.yaml" };
+    case "yarn":
+      return {
+        addDevAtRoot: (spec) => flavor === "berry" ? `yarn add -D ${spec}` : `yarn add -D -W ${spec}`,
+        addAtRoot: (spec) => flavor === "berry" ? `yarn add ${spec}` : `yarn add -W ${spec}`,
+        runNx: "yarn nx",
+        install: "yarn install",
+        workspaceRegistration: "package.json workspaces"
+      };
+    case "bun":
+      return { addDevAtRoot: (spec) => `bun add -d ${spec}`, addAtRoot: (spec) => `bun add ${spec}`, runNx: "bun nx", install: "bun install", workspaceRegistration: "package.json workspaces" };
+    case "npm":
+      return { addDevAtRoot: (spec) => `npm install -D ${spec}`, addAtRoot: (spec) => `npm install ${spec}`, runNx: "npm exec nx --", install: "npm install", workspaceRegistration: "package.json workspaces" };
+  }
+}
+
+// src/generators/shared/toolkit-config-file.ts
+var TOOLKIT_CONFIG_PATH = "toolkit.config.json";
+function recordedChoice(config, key, allowed) {
+  const value = config?.[key];
+  return typeof value === "string" && allowed.includes(value) ? value : void 0;
+}
+var RECORDED_PACKAGE_MANAGERS = ["pnpm", "npm", "yarn", "bun"];
+function workspacePackageManager(exists, read, config) {
+  return detectWorkspacePackageManager(exists, read) ?? recordedChoice(config, "packageManager", RECORDED_PACKAGE_MANAGERS) ?? null;
+}
+
+// src/generators/shared/run-nx.ts
+function runNxFor(exists, read) {
+  let config = null;
+  try {
+    const parsed = JSON.parse(read(TOOLKIT_CONFIG_PATH) ?? "null");
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) config = parsed;
+  } catch {
+  }
+  return packageManagerCommands(workspacePackageManager(exists, read, config) ?? "pnpm").runNx;
+}
+function diskRunNx(root) {
+  return runNxFor(
+    (path) => existsSync4(join4(root, path)),
+    (path) => existsSync4(join4(root, path)) ? readFileSync4(join4(root, path), "utf-8") : void 0
+  );
+}
+
+// src/runtime/node-command-runner.ts
+import { spawn } from "node:child_process";
+var KILL_GRACE_MS = 500;
+var NodeCommandRunner = class {
+  run(input) {
+    return new Promise((resolve2, reject) => {
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+      let outputExceeded = false;
+      let settled = false;
+      let killTimer;
+      const spawnable = spawnableCommand(input.executable, input.argv);
+      const child = spawn(spawnable.command, spawnable.args, {
+        cwd: input.cwd,
+        shell: false,
+        windowsVerbatimArguments: spawnable.windowsVerbatimArguments,
+        windowsHide: true,
+        // No stdin: nothing here ever answers a prompt (a command that wants
+        // confirmation must fail fast instead of waiting on an open pipe).
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const terminate = () => {
+        child.kill("SIGTERM");
+        killTimer = setTimeout(() => {
+          child.kill("SIGKILL");
+        }, KILL_GRACE_MS);
+      };
+      const timer = setTimeout(() => {
+        timedOut = true;
+        terminate();
+      }, input.timeoutMs);
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString("utf8");
+        if (Buffer.byteLength(stdout, "utf8") > input.stdoutLimitBytes) {
+          outputExceeded = true;
+          terminate();
+        }
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf8");
+        if (Buffer.byteLength(stderr, "utf8") > input.stderrLimitBytes) {
+          outputExceeded = true;
+          terminate();
+        }
+      });
+      child.on("error", (error) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        clearTimeout(killTimer);
+        reject(error);
+      });
+      child.on("close", (code) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        clearTimeout(killTimer);
+        resolve2({ stdout, stderr, exitCode: code, timedOut, outputExceeded });
+      });
+    });
+  }
+};
+
+// src/runtime/integrations-composition-root.ts
+function createIntegrationsCompositionRoot(deps = {}) {
+  const runner = deps.runner ?? new NodeCommandRunner();
+  const registry = createIntegrationRegistry(createCatalogIntegrations({ runner }));
+  return {
+    registry,
+    runner,
+    getIntegration: (id) => getIntegration(registry, id),
+    listIntegrations: () => listIntegrations(registry)
+  };
+}
+
+// src/generators/install-integration/generator.ts
+var RECHECK_AFTER = /* @__PURE__ */ new Set([
+  "executed",
+  "failed",
+  "timeout",
+  "output-too-large",
+  "confirmation-required"
+]);
+async function runInstallIntegration(tree, options, deps = {}) {
+  const root = deps.integrationsRoot ?? createIntegrationsCompositionRoot();
+  const declare = deps.declare ?? declareEnabledIntegration;
+  const target = options.target ?? "claude-code";
+  const scope = options.scope ?? DEFAULT_PLUGIN_SCOPE;
+  const nxDryRun = process.env["NX_DRY_RUN"] === "true";
+  const apply = (options.apply ?? false) && !nxDryRun;
+  const nxG = `${diskRunNx(tree.root)} g`;
+  const rerunCommand = `${nxG} @clearlydev/nx-archweave:install-integration --tool=${options.tool} --apply` + (options.scope === void 0 ? "" : ` --scope=${options.scope}`);
+  const integration = root.getIntegration(options.tool);
+  const entry = getCatalogEntry(options.tool);
+  const pluginId = entry?.hosts["claude-code"]?.pluginId;
+  if (!integration || !entry || pluginId === void 0) {
+    throw new Error(`Unsupported integration "${options.tool}". Supported: ${PLUGIN_IDS.join(", ")}.`);
+  }
+  const name = entry.displayName;
+  const plan = await integration.plan({
+    targetEnvironment: target,
+    versionRange: options.versionRange,
+    scope
+  });
+  const pre = await verifyViaClaudeCli(root.runner, pluginId, tree.root);
+  let currentState;
+  if (pre.source === "claude-cli") {
+    const outcome = pre.outcome;
+    switch (outcome.status) {
+      case "verified":
+        currentState = options.scope !== void 0 && outcome.scope !== options.scope ? { kind: "installed-other-scope", installedScope: outcome.scope } : { kind: "already-installed", version: outcome.version, scope: outcome.scope };
+        break;
+      case "installed-but-disabled":
+        currentState = { kind: "disabled" };
+        break;
+      case "absent":
+        currentState = { kind: "absent" };
+        break;
+      case "ambiguous":
+        currentState = { kind: "ambiguous" };
+        break;
+    }
+  } else {
+    currentState = pre.reason === "not-found" ? { kind: "cli-not-found" } : { kind: "cli-error", reason: pre.reason };
+  }
+  const view = {
+    tool: options.tool,
+    target,
+    scope,
+    preview: !apply,
+    applyIgnoredForNxDryRun: (options.apply ?? false) && nxDryRun,
+    sourceRepository: plan.sourceRepository,
+    officialHomepage: plan.officialHomepage,
+    license: plan.license,
+    requestedVersion: options.versionRange ?? null,
+    workspaceFiles: plan.filesModified,
+    command: plan.officialCommand === null ? "(none \u2014 manual install only)" : renderUserCommand(plan.officialCommand),
+    rerunCommand,
+    currentState,
+    install: null,
+    record: null,
+    declaration: null,
+    teamMarketplace: null,
+    guidance: []
+  };
+  const teamCommand = projectMarketplaceCommand(entry);
+  const planTeamDeclaration = () => {
+    if (teamCommand === null) return false;
+    view.teamMarketplace = { command: renderUserCommand(teamCommand), detail: null };
+    return true;
+  };
+  const declareForTeam = async () => {
+    if (!apply || view.teamMarketplace === null) return true;
+    const detail = await declareProjectMarketplace(entry, { runner: root.runner }, { cwd: tree.root });
+    view.teamMarketplace.detail = detail;
+    return detail.kind === "executed";
+  };
+  const teamFailureStep = () => `Declaring the marketplace for teammates did not succeed \u2014 run it yourself to see why: ${view.teamMarketplace?.command}`;
+  const recordAndDeclare = async () => {
+    const outcome = await runRecordPipeline({
+      id: integration.id,
+      runner: root.runner,
+      workspaceRoot: tree.root,
+      target,
+      write: apply
+    });
+    view.record = {
+      verification: outcome.verification,
+      existingEntry: outcome.existingEntry,
+      proposedEntry: outcome.proposedEntry,
+      hasConflict: outcome.hasConflict,
+      wasWritten: outcome.wasWritten
+    };
+    if (outcome.proposedEntry) {
+      try {
+        view.declaration = declare(tree.root, integration.id, { write: apply });
+      } catch (error) {
+        view.declaration = {
+          action: "write-failed",
+          message: redactHomePaths(error instanceof Error ? error.message : String(error))
+        };
+      }
+    }
+  };
+  switch (currentState.kind) {
+    case "already-installed":
+      if (currentState.scope === "project" && planTeamDeclaration() && !await declareForTeam()) {
+        view.guidance = [teamFailureStep()];
+      }
+      await recordAndDeclare();
+      break;
+    case "installed-other-scope":
+      view.guidance = currentState.installedScope === "managed" ? [
+        `${name} is provided at managed scope by your organization and cannot be installed again at another scope.`,
+        `Record the managed install instead (nothing is installed again): ${nxG} @clearlydev/nx-archweave:install-integration --tool=${options.tool} --apply`
+      ] : [
+        `${name} is already installed at ${currentState.installedScope} scope. Installing it again at ${scope} scope would leave two entries that verification cannot tell apart, so nothing was done.`,
+        `To record the existing install (nothing is installed again): ${nxG} @clearlydev/nx-archweave:install-integration --tool=${options.tool} --apply --scope=${currentState.installedScope}`,
+        `To move it instead: claude plugin uninstall ${pluginId} --scope ${currentState.installedScope}, then rerun: ${rerunCommand}`
+      ];
+      break;
+    case "disabled":
+      view.guidance = [
+        `${name} is installed but disabled. Enable it yourself (nx-archweave never enables or disables plugins): claude plugin enable ${pluginId}`,
+        `Then rerun to record and declare it: ${rerunCommand}`
+      ];
+      break;
+    case "ambiguous":
+      view.guidance = [
+        `More than one installed plugin matches ${pluginId} exactly (for example at user and project scope), so nothing was done.`,
+        `Remove the extra one (claude plugin uninstall ${pluginId} --scope <scope>), then rerun: ${rerunCommand}`
+      ];
+      break;
+    case "cli-not-found":
+      view.guidance = claudeCliNotFoundSteps(entry, rerunCommand);
+      break;
+    case "cli-error":
+      view.guidance = [
+        "The claude CLI is present but could not list its plugins, so no install was attempted.",
+        `Run \`claude plugin list\` yourself to see the error, fix it, and rerun: ${rerunCommand}`
+      ];
+      break;
+    case "absent": {
+      if (scope === "project") planTeamDeclaration();
+      if (!apply) break;
+      if (!await declareForTeam()) {
+        view.guidance = [teamFailureStep(), `Nothing was installed. Once resolved, rerun: ${rerunCommand}`];
+        break;
+      }
+      const approved = { ...plan, approvedBy: "user" };
+      const { result, detail } = await installClaudeMarketplacePlugin(entry, { runner: root.runner }, approved, {
+        cwd: tree.root,
+        rerunCommand
+      });
+      view.install = { detail, manualStepsRemaining: result.manualStepsRemaining };
+      if (RECHECK_AFTER.has(detail.kind)) await recordAndDeclare();
+      if (view.record?.proposedEntry) break;
+      view.guidance = detail.kind === "executed" ? [
+        `Run \`claude plugin list\` to see what was installed; once it shows ${pluginId} enabled, rerun: ${rerunCommand}`
+      ] : result.manualStepsRemaining;
+      break;
+    }
+  }
+  return view;
+}
+async function installIntegrationGenerator(tree, options, deps = {}) {
+  console.log(renderInstallIntegrationView(await runInstallIntegration(tree, options, deps)));
+}
+var generator_default = installIntegrationGenerator;
+export {
+  generator_default as default,
+  installIntegrationGenerator,
+  runInstallIntegration
+};