agents-united 0.12.0 → 0.13.0

package/dist/cli.js

@@ -3,9 +3,9 @@
 // src/cli.ts
 import { cac } from "cac";
 import pc from "picocolors";
-import { intro, outro, spinner, note, select, multiselect, confirm, text } from "@clack/prompts";
-import fs12 from "fs-extra";
-import path14 from "path";
+import { intro, outro, spinner, note, log, select, multiselect, confirm, text } from "@clack/prompts";
+import fs15 from "fs-extra";
+import path17 from "path";
 
 // src/core/registry.ts
 import path from "path";
@@ -309,6 +309,19 @@ var RegistryResolver = class _RegistryResolver {
           `Registry validation error: bundle "${name}" has unknown planningLoop.mode "${mode}". Valid modes: ${validModes.join(", ")}`
         );
       }
+      if (pl.budget) {
+        if (bundle.tier !== "organization") {
+          throw new Error(
+            `Registry validation error: bundle "${name}" declares a Consultation Budget but is not an organization-tier bundle. Iteration caps (planningLoop.budget.maxIterations) are Tier-2-only.`
+          );
+        }
+        const cap = pl.budget.maxIterations;
+        if (!Number.isInteger(cap) || cap < 1) {
+          throw new Error(
+            `Registry validation error: bundle "${name}" has planningLoop.budget.maxIterations ${String(cap)}; expected a positive integer.`
+          );
+        }
+      }
       if (mode === "planner-orchestrator") {
         if (pl.budget) {
           throw new Error(
@@ -326,9 +339,9 @@ var RegistryResolver = class _RegistryResolver {
 };
 
 // src/core/installer.ts
-import path5 from "path";
+import path6 from "path";
 import crypto from "crypto";
-import fs3 from "fs-extra";
+import fs4 from "fs-extra";
 
 // src/core/adapter.ts
 import path3 from "path";
@@ -345,7 +358,8 @@ var HOST_REGISTRY = {
     agentsSubdir: "agents",
     detectionMarkers: [".agents"],
     profile: "antigravity",
-    projectionCapable: false
+    projectionCapable: false,
+    status: "supported"
   },
   gemini: {
     id: "gemini",
@@ -355,7 +369,8 @@ var HOST_REGISTRY = {
     agentsSubdir: "agents",
     detectionMarkers: [".gemini"],
     profile: "antigravity",
-    projectionCapable: false
+    projectionCapable: false,
+    status: "supported"
   },
   claude: {
     id: "claude",
@@ -365,7 +380,8 @@ var HOST_REGISTRY = {
     agentsSubdir: "agents",
     detectionMarkers: [".claude"],
     profile: "claude-code",
-    projectionCapable: true
+    projectionCapable: true,
+    status: "supported"
   },
   cursor: {
     id: "cursor",
@@ -375,7 +391,8 @@ var HOST_REGISTRY = {
     agentsSubdir: "agents",
     detectionMarkers: [".cursor"],
     profile: "cursor",
-    projectionCapable: true
+    projectionCapable: true,
+    status: "under-development"
   },
   cline: {
     id: "cline",
@@ -385,7 +402,8 @@ var HOST_REGISTRY = {
     agentsSubdir: "agents",
     detectionMarkers: [".cline", ".clinerules"],
     profile: "cline",
-    projectionCapable: true
+    projectionCapable: true,
+    status: "supported"
   },
   opencode: {
     id: "opencode",
@@ -395,7 +413,8 @@ var HOST_REGISTRY = {
     agentsSubdir: "agent",
     detectionMarkers: [".opencode", "opencode.json"],
     profile: "opencode",
-    projectionCapable: true
+    projectionCapable: true,
+    status: "under-development"
   },
   codex: {
     id: "codex",
@@ -405,13 +424,29 @@ var HOST_REGISTRY = {
     agentsSubdir: void 0,
     detectionMarkers: ["AGENTS.md", ".codex"],
     profile: "agentsmd",
-    projectionCapable: true
+    projectionCapable: true,
+    status: "under-development"
   }
 };
 var KNOWN_HOST_IDS = Object.keys(HOST_REGISTRY);
 function isKnownHost(id) {
   return Object.prototype.hasOwnProperty.call(HOST_REGISTRY, id);
 }
+var SUPPORTED_HOST_IDS = Object.values(HOST_REGISTRY).filter((h) => h.status === "supported").map((h) => h.id);
+var UNDER_DEVELOPMENT_HOST_IDS = Object.values(HOST_REGISTRY).filter((h) => h.status === "under-development").map((h) => h.id);
+var PLANNED_HOSTS = [
+  { id: "kimi", label: "Kimi / Moonshot" }
+];
+function hostAvailabilityNotice() {
+  const supported = SUPPORTED_HOST_IDS.map((id) => HOST_REGISTRY[id].label).join(" \xB7 ");
+  const underDev = UNDER_DEVELOPMENT_HOST_IDS.map((id) => HOST_REGISTRY[id].label).join(" \xB7 ");
+  const planned = PLANNED_HOSTS.map((h) => h.label).join(" \xB7 ");
+  return [
+    `\u2705 Supported: ${supported}`,
+    `\u{1F6A7} Under Development (unavailable): ${underDev}`,
+    `\u{1F5D3} Planned: ${planned} (projector on the planning list)`
+  ].join("\n");
+}
 function resolveHostProjectDir(host, cwd) {
   return path2.resolve(cwd, HOST_REGISTRY[host].projectDir);
 }
@@ -682,7 +717,8 @@ ${bodyStr}
     const coordinatorCanonical = `agents/${coordinatorFile}`;
     const specialistLines = (bundle.agents || []).map((agentFile) => {
       const name = agentFile.replace(/\.md$/, "");
-      return `- **${name}**: \`.agents/agents/${agentFile}\``;
+      const projected = this.stripSubagentPrefix(name);
+      return `- **${name}**: \`.cline/agents/${projected}.yml\` | \`.agents/agents/${agentFile}\``;
     });
     const rawWorkflows = [
       ...(bundle.workflows || []).map((w) => w.replace(/\.md$/i, "")),
@@ -1065,21 +1101,779 @@ ${normalizedBody}`;
   }
 };
 
+// src/core/claude-projector.ts
+import yaml3 from "yaml";
+
+// src/core/guard.ts
+var GUARD_SCRIPT = String.raw`let s="";process.stdin.on("data",c=>s+=c).on("end",()=>{let i={};try{i=JSON.parse(s)}catch(e){}const t=i.tool_input||{},c=String(t.command||""),f=String(t.file_path||"").replace(/\\/g,"/");let r="";if(/\bgit\b[^;&|]*\bpush\b[^;&|]*(--force(?!-with-lease)\b|(^|\s)-f\b)/.test(c))r="git push --force";else if(/\bvercel\b[^;&|]*--prod\b/.test(c))r="vercel --prod";else if(/(^|\/)\.env(\.(?!example$)[^\/]+)?$/.test(f)||/>\s*(\S*\/)?\.env(\.(?!example\b)\S+)?(\s|$)/.test(c))r="a .env write";if(r){process.stderr.write("Blocked by agents-united guard: "+r+" requires explicit human approval outside the agent session.\n");process.exit(2)}})`;
+function guardHandler() {
+  return { type: "command", command: "node", args: ["-e", GUARD_SCRIPT] };
+}
+function managedGuardHooks() {
+  return {
+    PreToolUse: [
+      { matcher: "Bash", hooks: [guardHandler()] },
+      { matcher: "Write|Edit|NotebookEdit", hooks: [guardHandler()] }
+    ]
+  };
+}
+
+// src/core/claude-projector.ts
+import path5 from "path";
+import fs3 from "fs-extra";
+
+// src/core/residue-patterns.ts
+var RESIDUE_PATTERNS_BY_HOST = {
+  claude: [/Nested Subagent Delegation/, /Host Routing/, /language_server/, /Cline & CLI/]
+};
+
+// src/core/overlays.ts
+var OVERLAY_FIELD_VOCAB = {
+  permissionMode: ["default", "acceptEdits", "bypassPermissions", "plan", "delegate"],
+  model: ["opus", "sonnet", "haiku", "inherit"],
+  effort: ["low", "medium", "high", "inherit"]
+};
+var CLAUDE_FIELD_POLICY = {
+  name: "keep",
+  description: "keep",
+  model: "map",
+  tools: "map",
+  permissionMode: "map",
+  effort: "map",
+  skills: "map",
+  projections: "map",
+  version: "drop",
+  type: "drop",
+  commandExecutionPolicy: "drop",
+  mainAgent: "drop",
+  subagent: "drop",
+  hooks: "drop",
+  mcpServers: "drop",
+  rules: "drop",
+  inheritCustomizations: "drop"
+};
+function validateProjectionOverlays(projections, spec) {
+  if (projections === void 0 || projections === null) return;
+  if (typeof projections !== "object" || Array.isArray(projections)) {
+    throw new Error("Projection overlay validation failed: projections must be an object.");
+  }
+  for (const [host, overlay] of Object.entries(projections)) {
+    if (host !== spec.id) {
+      throw new Error(`Projection overlay validation failed: unknown overlay host "${host}".`);
+    }
+    if (overlay === null || typeof overlay !== "object" || Array.isArray(overlay)) {
+      throw new Error(`Projection overlay validation failed: overlay for "${host}" must be an object.`);
+    }
+    for (const [field, value] of Object.entries(overlay)) {
+      const policy = spec.fields[field];
+      if (policy === void 0) {
+        throw new Error(`Projection overlay validation failed: unknown overlay field "${field}".`);
+      }
+      if (policy === "drop") {
+        throw new Error(
+          `Projection overlay validation failed: "${field}" is unsupported on host "${host}" and must never be introduced by an overlay.`
+        );
+      }
+      const vocab = OVERLAY_FIELD_VOCAB[field];
+      if (vocab && (typeof value !== "string" || !vocab.includes(value))) {
+        throw new Error(
+          `Projection overlay validation failed: invalid value "${String(value)}" for "${field}" (allowed: ${vocab.join(", ")}).`
+        );
+      }
+    }
+  }
+}
+
+// src/core/claude-projector.ts
+var INLINE_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "description",
+  "model",
+  "permissionMode",
+  "effort",
+  "tools",
+  "maxIterations",
+  "projections"
+]);
+var FEATURE_LEDGER = {
+  version: { disposition: "mapped", rationale: "Authoring metadata for the canonical store; no Claude field needed." },
+  type: { disposition: "mapped", rationale: "Canonical role discriminator; Claude distinguishes roles by file location." },
+  mainAgent: { disposition: "mapped", rationale: "Canonical masthead flag; Claude decides main-thread status at launch (--agent)." },
+  subagent: { disposition: "mapped", rationale: "Canonical masthead flag; every file under .claude/agents/ is a subagent." },
+  inheritCustomizations: { disposition: "mapped", rationale: "Claude loads CLAUDE.md and project memory unless omitClaudeMd is set (flag-gated)." },
+  commandExecutionPolicy: { disposition: "unsupported", rationale: "Antigravity shell policy has no Claude frontmatter equivalent; Bash permissions cover it." },
+  hooks: { disposition: "unsupported", rationale: "Antigravity hook schema (PreInvocation/PostInvocation matchers) differs from Claude hook events; canonical prose hooks are not translated and stay advisory. The one enforced hook is the managed PreToolUse guard every role carries (Plan 022 H5)." },
+  rules: { disposition: "mapped", rationale: "Agent-referenced rules project into the lean .claude/rules/ lane." },
+  effort: { disposition: "mapped", rationale: "Reasoning effort passes through to the Claude effort field." },
+  invoke_subagent: { disposition: "mapped", rationale: "Delegation maps to the Claude Agent tool (allowlist on coordinators)." },
+  send_message: { disposition: "approximated", rationale: "Maps to the Claude SendMessage tool; cross-session reach differs from Antigravity messaging." },
+  manage_task: { disposition: "approximated", rationale: 'Maps to the Claude task tools (TaskCreate/TaskUpdate), but the live tools reference says they are "provided by default only on the models listed under Task tool availability, and on other models when you opt in" \u2014 so the grant can resolve to nothing depending on the model.' },
+  schedule: { disposition: "approximated", rationale: "Maps to Cron tools, but Antigravity reactive liveness timers are event-driven rather than cron-scheduled." },
+  define_subagent: { disposition: "approximated", rationale: "Claude agents are pre-defined: runtime subagent definition is unavailable, so the prompt delegates via the Agent tool." },
+  manage_subagents: { disposition: "approximated", rationale: "Claude manages subagent lifecycle itself; the roster is static and the prompt delegates via the Agent tool." },
+  ask_question: { disposition: "approximated", rationale: "Claude exposes AskUserQuestion only in the main conversation (excluded from subagents by default)." },
+  generate_image: { disposition: "unsupported", rationale: "Claude Code exposes no image-generation tool; asset creation must happen outside the agent run." },
+  skills: { disposition: "degraded", rationale: "Claude subagents discover project skills and can invoke them; the canonical preload list is not injected to avoid paying its token cost on every spawn." },
+  mcpServers: { disposition: "degraded", rationale: "Claude supports per-subagent mcpServers, but the canonical descriptor dialect differs; MCP wiring stays host-configured via the MCP location registry (translation deferred)." }
+};
+var MARKER_PROFILE = "claude";
+var MARKER_PREFIX = "managed-by: agents-united";
+var HOST = "claude";
+var ENTRYPOINT_RULES = /* @__PURE__ */ new Set(["CLAUDE.md", "CLAUDE.local.md", "GEMINI.md", "AGENTS.md", "CURSOR.md"]);
+var COORDINATOR_BASELINE_TOOLS = ["Read", "Write", "Edit", "Bash", "Grep", "Glob"];
+var READ_ONLY_EXCLUDED_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "NotebookEdit", "Bash"]);
+var FRONTMATTER_REGEX2 = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+var RUNTIME_NOTE = `## Claude runtime note
+
+Delegation runs through the Agent tool: the coordinator spawns the specialists named in its own tools
+allowlist; specialists hold no Agent tool and never spawn peers (the coordinator relays and wakes them). Canonical tool names in this prompt were rewritten to their
+Claude equivalents; a fenced code block may still show the original spelling because code is preserved
+byte-for-byte. A subagent does not hand results to a peer: its final report is returned to the
+conversation that spawned it, and on Claude Code v2.1.271+ in auto mode the runtime delivers it through the
+SubagentHandback tool.
+
+Enforced guard: a PreToolUse hook in this file's frontmatter blocks \`git push --force\`, \`.env\` writes and
+\`vercel --prod\` (exit 2, with the reason); ask the user to run those steps themselves.
+All other lifecycle hooks described in this prompt are advisory: this host does not fire them.`;
+var MANAGED_HOOKS = managedGuardHooks();
+var ClaudeProjector = class _ClaudeProjector {
+  /** Pure data (Plan 017 lifts this object into a shared HostDialectSpec). */
+  static CLAUDE_DIALECT = {
+    id: "claude",
+    nameRegex: /^[a-z0-9]+(-[a-z0-9]+)*$/,
+    toolVocabulary: {
+      view_file: "Read",
+      read_file: "Read",
+      replace_file_content: "Edit",
+      apply_diff: "Edit",
+      multi_replace_file_content: "Edit",
+      write_to_file: "Write",
+      run_command: "Bash",
+      grep_search: "Grep",
+      search_file_content: "Grep",
+      list_dir: "Glob",
+      find_by_name: "Glob",
+      web_search: "WebSearch",
+      search_web: "WebSearch",
+      read_url_content: "WebFetch",
+      invoke_subagent: "Agent",
+      define_subagent: "Agent",
+      manage_subagents: "Agent",
+      send_message: "SendMessage",
+      manage_task: "TaskCreate",
+      schedule: "CronCreate",
+      ask_question: "AskUserQuestion",
+      // The runtime's own hand-off channel for subagents (Claude Code v2.1.271+, auto mode): it delivers
+      // a subagent's final report to whichever conversation receives that subagent's result. It has no
+      // Antigravity-dialect equivalent, so the lane grants it to specialists directly (see renderRole);
+      // the token exists so a canonical agent could also name it explicitly.
+      subagent_handback: "SubagentHandback"
+    },
+    bodyToolVocabulary: {
+      view_file: "Read",
+      read_file: "Read",
+      write_to_file: "Write",
+      replace_file_content: "Edit",
+      apply_diff: "Edit",
+      multi_replace_file_content: "Edit",
+      run_command: "Bash",
+      grep_search: "Grep",
+      find_by_name: "Glob",
+      list_dir: "Glob",
+      search_web: "WebSearch",
+      read_url_content: "WebFetch",
+      invoke_subagent: "Agent",
+      define_subagent: "the Agent tool",
+      manage_subagents: "the Agent tool",
+      // ADR 0018 decision 8 requires canonical tool names in prose to be rewritten, not just the
+      // frontmatter vocabulary: a specialist reading "reach a peer with `send_message`" would otherwise
+      // look for a tool that does not exist on this host. Whole-word and code-fence-aware like the rest.
+      send_message: "SendMessage",
+      manage_task: "TaskCreate",
+      ask_question: "AskUserQuestion",
+      generate_image: "image generation (unsupported on this host)"
+      // `schedule` is deliberately absent: it is an ordinary English word, so rewriting it in prose
+      // would corrupt sentences. Its loss is recorded once at frontmatter level instead.
+    },
+    commandVocabulary: {
+      team_command: "Agent Teams (opt-in: agents start --host claude --teams)",
+      deep_planning_command: "/workflow-grill",
+      interview_command: "/grill-me"
+    },
+    permissionModeMap: {
+      acceptEdits: "acceptEdits",
+      readOnly: "plan",
+      requestReview: "default",
+      strict: "default"
+    },
+    modelMap: { pro: "sonnet", flash: "haiku" },
+    // ADR 0018 decision 7, amended 2026-09-22 by the product owner. The canonical catalog declares
+    // `model: inherit` on all 59 agents, which made `inherit` the de-facto value and left every
+    // projection inheriting the *session* model instead of a chosen posture. The intended posture is
+    // explicit — coordinators reason on Opus at high effort, specialists run on Sonnet at medium
+    // effort — so `inherit` now resolves to a role default rather than being omitted. Both fields are
+    // documented subagent frontmatter: `model` accepts sonnet|opus|haiku|fable|<full id>|inherit, and
+    // `effort` (low|medium|high|xhigh|max) overrides the session effort level. Caveats recorded rather
+    // than coded around: Opus is unavailable on some plans, so a workspace may need a different anchor;
+    // and `xhigh`/`max` exist only on newer models. Both are one-constant changes here.
+    roleModelDefaults: { coordinator: "opus", specialist: "sonnet" },
+    roleEffortDefaults: { coordinator: "high", specialist: "medium" },
+    bodySectionOverrides: [
+      {
+        // Plan 019 escape hatch (2026-09-25): the old anchor — "Subagent Delegation & Host
+        // Routing" — was residue (it described OTHER runtimes: Antigravity's language_server.exe
+        // limitation and Cline's subagent_* tools) and the G1 purge deleted it. Its Claude-side
+        // rendering survives as this per-host overlay, keyed on the neutral "Delegation
+        // Mechanics" stub in canonical; hosts without an overlay render the stub itself.
+        heading: /^#{2,3}\s*.*Delegation Mechanics/m,
+        replacement: [
+          "### \u26A1 Subagent Delegation & Agent Routing (Claude Code)",
+          "",
+          "- **Delegation tool**: spawn specialists with the `Agent` tool. Your `tools` allowlist names exactly the specialist types you may call (the projected definitions in `.claude/agents/`, with the `subagent-` prefix stripped); calling any other type fails, so send work only to those names. There are no `TypeName`/`Role`/`Prompt` fields \u2014 `Agent` takes the specialist type and one self-contained prompt, so put the role, the scope boundaries and the acceptance criteria inside that prompt.",
+          "- **Parallel work**: spawn independent specialists in one turn \u2014 each runs in its own context window and returns its result to you (delivered by `SubagentHandback` on Claude Code v2.1.271+ in auto mode). You are the single synthesis and relay point: name who reported what, and never let one specialist wait on another.",
+          "- **Your allowlist is the whole domain team, not only what is installed.** A listed type whose definition is not in this workspace yet will fail to spawn: say so, recommend installing it (`agents add <addon>`), and handle that slice yourself if the user declines. Never delegate to a type outside your allowlist.",
+          "- **Agent Teams (opt-in, `--teams`)**: the lead can spawn *teammates* instead of subagents and message them directly with `SendMessage`. The scaffold is experimental \u2014 one team per session, a fixed lead, no nested teams \u2014 so never make it load-bearing."
+        ].join("\n")
+      }
+    ],
+    budgets: { skillDescriptionChars: 1536, agentDescriptionTokens: 15e3 },
+    maxRuleLines: 200
+  };
+  /** `subagent-backend-architect` -> `backend-architect` (Step 0 proved zero collisions). */
+  static stripSubagentPrefix(name) {
+    return name.trim().replace(/^subagent-/, "");
+  }
+  /** Uniform managed-projection marker; always the first line of the projected body. */
+  static marker(canonicalRelPath) {
+    const norm = canonicalRelPath.replace(/\\/g, "/");
+    return `<!-- managed-by: agents-united | profile: ${MARKER_PROFILE} | canonical: ${norm} | do not edit -->`;
+  }
+  /** `generative_ui` -> `generative-ui`: every dialect requires lowercase-hyphen names. */
+  static normalizeSkillName(name) {
+    return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  }
+  static parse(canonicalContent, canonicalRelPath) {
+    const match = canonicalContent.match(FRONTMATTER_REGEX2);
+    if (!match) {
+      throw new Error(`Cannot project ${canonicalRelPath}: no YAML frontmatter found.`);
+    }
+    let parsed;
+    try {
+      parsed = yaml3.parse(match[1]);
+    } catch (cause) {
+      const err = cause instanceof Error ? cause : new Error(String(cause));
+      throw new Error(`Cannot project ${canonicalRelPath}: invalid YAML frontmatter (${err.message}).`);
+    }
+    const meta = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    return { meta, body: match[2].replace(/^\r?\n/, "") };
+  }
+  static ledgerEntry(feature) {
+    const known = FEATURE_LEDGER[feature];
+    if (!known) return void 0;
+    return { feature, host: HOST, disposition: known.disposition, rationale: known.rationale };
+  }
+  /** Guard: an unmapped feature must never be dropped without a recorded disposition. */
+  static requireDisposition(feature, canonicalRelPath) {
+    const entry = _ClaudeProjector.ledgerEntry(feature);
+    if (!entry) {
+      throw new Error(
+        `No translation-ledger disposition recorded for feature "${feature}" in ${canonicalRelPath}. Add it to FEATURE_LEDGER so translation loss is never silent (ADR 0018 decision 9).`
+      );
+    }
+    return entry;
+  }
+  /**
+   * Replace one canonical body section, matched by its heading, with a host-native rendering.
+   *
+   * Deterministic: the section runs from the matched heading to the next heading of the same or a higher
+   * level (an `h3` stops at the next `h1`/`h2`), and trailing blank lines and the `---` separator are left
+   * with the following section so the document structure is unchanged. A heading that is absent is a no-op.
+   */
+  static replaceSection(body, heading, replacement) {
+    const lines = body.split("\n");
+    const start = lines.findIndex((line) => heading.test(line));
+    if (start < 0) return body;
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i += 1) {
+      if (/^#{1,2}\s/.test(lines[i])) {
+        end = i;
+        break;
+      }
+    }
+    while (end > start + 1 && (lines[end - 1].trim() === "" || lines[end - 1].trim() === "---")) end -= 1;
+    return [...lines.slice(0, start), ...replacement.split("\n"), ...lines.slice(end)].join("\n");
+  }
+  /**
+   * Deterministically rewrite canonical tool names in prompt prose (whole-word, case-sensitive,
+   * fenced code blocks byte-preserved) and report a disposition for every rewrite that loses fidelity.
+   */
+  /** Command tokens are ledger citizens (Plan 020 note 7) — rewritten and dispositioned. */
+  static COMMAND_LEDGER = {
+    team_command: { disposition: "mapped", rationale: "Rewritten to the host team entrypoint (Agent Teams opt-in)." },
+    deep_planning_command: { disposition: "mapped", rationale: "Rewritten to the host deep-planning command." },
+    interview_command: { disposition: "mapped", rationale: "Rewritten to the host interview command." }
+  };
+  /** Plan 019 safety net: residue-headed sections never survive into a projection body. */
+  static dropResidueSections(body) {
+    let out = body;
+    for (const pattern of RESIDUE_PATTERNS_BY_HOST.claude) {
+      out = out.replace(
+        new RegExp(`(^|\\n)#{1,6}[^\\n]*${pattern.source}[^\\n]*\\n[\\s\\S]*?(?=\\n#{1,6} |$)`, "g"),
+        "$1"
+      );
+    }
+    return out;
+  }
+  /** Plan 019 safety net: residual residue phrases in prose are neutralized deterministically. */
+  static scrubResiduePhrases(body) {
+    return body.replace(/Cline & CLI/g, "other hosts").replace(/language_server(\.exe)?/g, "the runtime").replace(/Nested Subagent Delegation/g, "peer delegation").replace(/Host Routing/g, "host delegation");
+  }
+  /** Whole-word canonical tokens surviving OUTSIDE code fences after the rewrite pass. */
+  static survivingBodyTokens(body) {
+    const vocab = {
+      ..._ClaudeProjector.CLAUDE_DIALECT.toolVocabulary,
+      ..._ClaudeProjector.CLAUDE_DIALECT.commandVocabulary
+    };
+    const prose = body.split(/(```[\s\S]*?```)/g).filter((_, index) => index % 2 === 0).join("\n");
+    return Object.keys(vocab).filter(
+      (token) => new RegExp(`(^|[^A-Za-z0-9_])${token}(?=[^A-Za-z0-9_]|$)`).test(prose)
+    );
+  }
+  static rewriteBody(body) {
+    const ledger = /* @__PURE__ */ new Map();
+    body = _ClaudeProjector.dropResidueSections(body);
+    body = _ClaudeProjector.scrubResiduePhrases(body);
+    for (const override of _ClaudeProjector.CLAUDE_DIALECT.bodySectionOverrides) {
+      body = _ClaudeProjector.replaceSection(body, override.heading, override.replacement);
+    }
+    const vocab = {
+      ..._ClaudeProjector.CLAUDE_DIALECT.bodyToolVocabulary,
+      ..._ClaudeProjector.CLAUDE_DIALECT.commandVocabulary
+    };
+    const tokens = Object.keys(vocab).sort((a, b) => b.length - a.length);
+    const parts = body.split(/(```[\s\S]*?```)/g);
+    const rewritten = parts.map((part, index) => {
+      if (index % 2 === 1) return part;
+      let text2 = part;
+      for (const token of tokens) {
+        const re = new RegExp(`(^|[^A-Za-z0-9_])${token}(?=[^A-Za-z0-9_]|$)`, "g");
+        if (!text2.match(re)) continue;
+        const command = _ClaudeProjector.COMMAND_LEDGER[token];
+        const entry = command ? { feature: token, host: HOST, disposition: command.disposition, rationale: command.rationale } : _ClaudeProjector.ledgerEntry(token);
+        if (entry) ledger.set(token, entry);
+        text2 = text2.replace(re, `$1${vocab[token]}`);
+      }
+      return text2;
+    });
+    return { body: rewritten.join(""), ledger: [...ledger.values()] };
+  }
+  /** Render `.claude/agents/<role>.md` from a canonical agent definition. */
+  static renderRole(canonicalContent, canonicalRelPath, opts = {}) {
+    const { meta, body } = _ClaudeProjector.parse(canonicalContent, canonicalRelPath);
+    const ledger = /* @__PURE__ */ new Map();
+    for (const key of Object.keys(meta)) {
+      if (INLINE_KEYS.has(key)) continue;
+      const entry = _ClaudeProjector.requireDisposition(key, canonicalRelPath);
+      ledger.set(entry.feature, entry);
+    }
+    const rawName = typeof meta.name === "string" && meta.name.trim().length > 0 ? meta.name.trim() : path5.basename(canonicalRelPath).replace(/\.md$/i, "");
+    const out = { name: _ClaudeProjector.stripSubagentPrefix(rawName) };
+    if (typeof meta.description === "string" && meta.description.trim().length > 0) {
+      out.description = meta.description.trim();
+    }
+    const isCoordinator = !!(opts.allowlist && opts.allowlist.length > 0) || meta.type === "orchestrator" || meta.mainAgent === true;
+    const tools = [];
+    if (isCoordinator) {
+      tools.push(opts.allowlist && opts.allowlist.length > 0 ? `Agent(${opts.allowlist.join(", ")})` : "Agent");
+    }
+    for (const raw of Array.isArray(meta.tools) ? meta.tools : []) {
+      if (typeof raw !== "string") continue;
+      const entry = _ClaudeProjector.ledgerEntry(raw);
+      if (entry) ledger.set(entry.feature, entry);
+      const mapped = _ClaudeProjector.CLAUDE_DIALECT.toolVocabulary[raw];
+      if (!mapped) {
+        _ClaudeProjector.requireDisposition(raw, canonicalRelPath);
+        continue;
+      }
+      if (!tools.includes(mapped)) tools.push(mapped);
+    }
+    if (opts.allowlist && opts.allowlist.length > 0) {
+      const withoutBareAgent = tools.filter((t) => t !== "Agent");
+      tools.length = 0;
+      tools.push(...withoutBareAgent);
+    }
+    if (!isCoordinator) {
+      const withoutAgent = tools.filter((t) => t !== "Agent" && !t.startsWith("Agent("));
+      tools.length = 0;
+      tools.push(...withoutAgent);
+    }
+    if (isCoordinator) {
+      for (const base of COORDINATOR_BASELINE_TOOLS) {
+        if (!tools.includes(base)) tools.push(base);
+      }
+    } else if (!tools.includes("SubagentHandback")) {
+      tools.push("SubagentHandback");
+    }
+    const permission = typeof meta.permissionMode === "string" ? _ClaudeProjector.CLAUDE_DIALECT.permissionModeMap[meta.permissionMode] ?? "default" : void 0;
+    if (permission === "plan") {
+      const restricted = tools.filter((t) => !READ_ONLY_EXCLUDED_TOOLS.has(t));
+      tools.length = 0;
+      tools.push(...restricted);
+    }
+    out.tools = tools;
+    if (permission) out.permissionMode = permission;
+    const declaredModel = typeof meta.model === "string" ? meta.model : void 0;
+    const mappedModel = declaredModel && declaredModel !== "inherit" ? _ClaudeProjector.CLAUDE_DIALECT.modelMap[declaredModel] ?? declaredModel : void 0;
+    out.model = mappedModel ?? (isCoordinator ? _ClaudeProjector.CLAUDE_DIALECT.roleModelDefaults.coordinator : _ClaudeProjector.CLAUDE_DIALECT.roleModelDefaults.specialist);
+    const declaredEffort = typeof meta.effort === "string" ? meta.effort : void 0;
+    out.effort = declaredEffort ?? (isCoordinator ? _ClaudeProjector.CLAUDE_DIALECT.roleEffortDefaults.coordinator : _ClaudeProjector.CLAUDE_DIALECT.roleEffortDefaults.specialist);
+    if (typeof opts.maxTurns === "number") out.maxTurns = opts.maxTurns;
+    out.hooks = MANAGED_HOOKS;
+    const rewritten = _ClaudeProjector.rewriteBody(body);
+    for (const entry of rewritten.ledger) ledger.set(entry.feature, entry);
+    for (const token of _ClaudeProjector.survivingBodyTokens(rewritten.body)) {
+      _ClaudeProjector.requireDisposition(token, canonicalRelPath);
+    }
+    if (meta.projections !== void 0 && meta.projections !== null) {
+      validateProjectionOverlays(meta.projections, { id: HOST, fields: CLAUDE_FIELD_POLICY });
+      const overlay = meta.projections[HOST];
+      if (overlay) Object.assign(out, overlay);
+    }
+    const yamlStr = yaml3.stringify(out).replace(/\r\n/g, "\n").trimEnd();
+    const content = `---
+${yamlStr}
+---
+${_ClaudeProjector.marker(canonicalRelPath)}
+
+${RUNTIME_NOTE}
+
+${rewritten.body.trim()}
+`;
+    return { content, ledger: [...ledger.values()] };
+  }
+  /** Render `.claude/skills/<name>/SKILL.md` from a canonical skill. */
+  static renderSkill(canonicalContent, canonicalRelPath) {
+    const { meta, body } = _ClaudeProjector.parse(canonicalContent, canonicalRelPath);
+    const ledger = /* @__PURE__ */ new Map();
+    const rawName = typeof meta.name === "string" && meta.name.trim().length > 0 ? meta.name.trim() : path5.basename(path5.dirname(canonicalRelPath));
+    const normalized = _ClaudeProjector.normalizeSkillName(rawName);
+    if (normalized !== rawName) {
+      ledger.set(`skill-name:${rawName}`, {
+        feature: `skill-name:${rawName}`,
+        host: HOST,
+        disposition: "mapped",
+        rationale: `Skill name normalized to the dialect rule (${rawName} -> ${normalized}); body references follow the artifact name.`
+      });
+    }
+    const out = { name: normalized };
+    if (typeof meta.description === "string" && meta.description.trim().length > 0) {
+      out.description = meta.description.trim();
+    }
+    if (meta["disable-slash-command"] === true || meta.disableSlashCommand === true) {
+      out["user-invocable"] = false;
+      ledger.set("disable-slash-command", {
+        feature: "disable-slash-command",
+        host: HOST,
+        disposition: "mapped",
+        rationale: "Hidden from the / palette while staying model-invocable (Claude polarity: user-invocable, never disable-model-invocation)."
+      });
+    }
+    const metadata = meta.metadata;
+    if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) {
+      const allowed = ["author", "version", "icon", "source", "license"];
+      const kept = {};
+      for (const key of allowed) {
+        const value = metadata[key];
+        if (value !== void 0) kept[key] = value;
+      }
+      for (const key of Object.keys(metadata)) {
+        if (allowed.includes(key)) continue;
+        ledger.set(`metadata:${key}`, {
+          feature: `metadata:${key}`,
+          host: HOST,
+          disposition: "mapped",
+          rationale: "Non-standard skill metadata; stripped because the projection carries only the Agent Skills contract."
+        });
+      }
+      if (Object.keys(kept).length > 0) out.metadata = kept;
+    }
+    if (typeof meta.license === "string") out.license = meta.license;
+    const HANDLED_SKILL_KEYS = /* @__PURE__ */ new Set([
+      "name",
+      "description",
+      "metadata",
+      "license",
+      "disable-slash-command",
+      "disableSlashCommand"
+    ]);
+    for (const key of Object.keys(meta)) {
+      if (HANDLED_SKILL_KEYS.has(key)) continue;
+      const entry = _ClaudeProjector.requireDisposition(key, canonicalRelPath);
+      ledger.set(entry.feature, entry);
+    }
+    let rewrittenBody = body;
+    if (normalized !== rawName) {
+      const re = new RegExp(`(^|[^A-Za-z0-9_-])${rawName}(?![A-Za-z0-9_-])`, "gi");
+      rewrittenBody = rewrittenBody.replace(re, `$1${normalized}`);
+    }
+    const rewritten = _ClaudeProjector.rewriteBody(rewrittenBody);
+    for (const entry of rewritten.ledger) ledger.set(entry.feature, entry);
+    const yamlStr = yaml3.stringify(out).replace(/\r\n/g, "\n").trimEnd();
+    const content = `---
+${yamlStr}
+---
+${_ClaudeProjector.marker(canonicalRelPath)}
+
+${rewritten.body.trim()}
+`;
+    return { content, ledger: [...ledger.values()] };
+  }
+  /**
+   * Render `.claude/rules/<rule>.md`. Rules load unconditionally in every Claude session, so this
+   * lane is deliberately lean: optional `paths:` scoping plus a hard adherence budget (ADR 0018).
+   *
+   * The `paths:` block is the ONLY frontmatter field this lane emits, so it is emitted only when a
+   * rule is actually scoped. The live doc is explicit — "Rules without a `paths` field are loaded
+   * unconditionally and apply to all files" — which makes frontmatter optional; an unscoped rule is
+   * therefore rendered marker-first with no frontmatter block at all, matching the Cline lane's shape
+   * instead of emitting a stray empty `--- {} ---`.
+   */
+  static renderRule(canonicalContent, canonicalRelPath, opts = {}) {
+    const lineCount = canonicalContent.split(/\r?\n/).length;
+    if (lineCount > _ClaudeProjector.CLAUDE_DIALECT.maxRuleLines) {
+      throw new Error(
+        `Rule ${canonicalRelPath} has ${lineCount} lines, exceeding the ${_ClaudeProjector.CLAUDE_DIALECT.maxRuleLines}-line adherence budget (ADR 0018 decision 5).`
+      );
+    }
+    const frontmatter = {};
+    if (opts.paths && opts.paths.length > 0) frontmatter.paths = opts.paths;
+    const head = Object.keys(frontmatter).length > 0 ? `---
+${yaml3.stringify(frontmatter).replace(/\r\n/g, "\n").trimEnd()}
+---
+` : "";
+    const rewritten = _ClaudeProjector.rewriteBody(canonicalContent.trim());
+    const content = `${head}${_ClaudeProjector.marker(canonicalRelPath)}
+
+${rewritten.body}
+`;
+    return { content, ledger: rewritten.ledger };
+  }
+  /**
+   * The specialist roster a coordinator may delegate to: the whole **domain** team, not only the slice
+   * this bundle declares or what happens to be installed.
+   *
+   * `software-engineering` declares 4 specialists, but the `engineering` domain has 15 — so an essentials
+   * install used to leave the domain lead able to call 4 of its 15 people, with the list growing only when
+   * the operator happened to install more *and* re-project. `bundles.json` already groups every bundle under
+   * a `domain`, so the roster is the union of that domain's declared agents minus the coordinator itself.
+   * The allowlist is then stable (independent of install state) and complete (it never silently hides a
+   * teammate). The cost is that a listed type may not be installed yet — the delegation section turns that
+   * into an install recommendation rather than a dead end.
+   *
+   * Sorted for determinism: repeated projections must be byte-identical, because `agents doctor` diffs them.
+   */
+  static resolveDomainRoster(bundle, coordinatorFile, registryDir) {
+    const names = /* @__PURE__ */ new Set();
+    try {
+      const raw = fs3.readFileSync(path5.join(registryDir, "bundles.json"), "utf8");
+      const bundles = JSON.parse(raw).bundles ?? {};
+      for (const candidate of Object.values(bundles)) {
+        if (!bundle.domain || candidate.domain !== bundle.domain) continue;
+        for (const agentFile of candidate.agents || []) {
+          if (agentFile === coordinatorFile) continue;
+          names.add(_ClaudeProjector.stripSubagentPrefix(agentFile.replace(/\.md$/i, "")));
+        }
+      }
+    } catch {
+    }
+    return [...names].sort();
+  }
+  /**
+   * Plan the full Claude compound projection for one bundle: roles (with a coordinator allowlist of
+   * its whole domain team), skills (normalized names plus auxiliary files copied byte-for-byte), and
+   * the lean deduplicated rule set. It emits **no** team-manifest duplicate and **no** workflows lane,
+   * because Claude workflows are JavaScript orchestration scripts rather than markdown (ADR 0018 d14).
+   */
+  static async planCompoundProjection(bundle, scope, resolved, registryDir, _excludeAddons) {
+    void scope;
+    const artifacts = [];
+    const coordinatorFile = bundle.orchestrator || `${bundle.name}.md`;
+    const domainRoster = _ClaudeProjector.resolveDomainRoster(bundle, coordinatorFile, registryDir);
+    const specialistNames = domainRoster.length > 0 ? domainRoster : (bundle.agents || []).map((f) => _ClaudeProjector.stripSubagentPrefix(f.replace(/\.md$/i, "")));
+    const maxTurns = bundle.planningLoop?.budget?.maxIterations;
+    for (const agentFile of resolved.agents || []) {
+      const canonicalRel = `agents/${agentFile}`;
+      const src = path5.join(registryDir, "agents", agentFile);
+      if (!await fs3.pathExists(src)) continue;
+      const content = await fs3.readFile(src, "utf8");
+      const isCoordinator = coordinatorFile === agentFile;
+      const roleName = _ClaudeProjector.stripSubagentPrefix(agentFile.replace(/\.md$/i, ""));
+      const rendered = _ClaudeProjector.renderRole(content, canonicalRel, {
+        allowlist: isCoordinator ? specialistNames : void 0,
+        maxTurns: isCoordinator ? maxTurns : void 0
+      });
+      artifacts.push({
+        kind: "role",
+        canonical: canonicalRel,
+        relPath: `.claude/agents/${roleName}.md`,
+        content: rendered.content,
+        managedMarker: true
+      });
+    }
+    for (const skillName of resolved.skills || []) {
+      const skillDir = path5.join(registryDir, "skills", skillName);
+      const skillFile = path5.join(skillDir, "SKILL.md");
+      if (!await fs3.pathExists(skillFile)) continue;
+      const canonicalRel = `skills/${skillName}/SKILL.md`;
+      const normalized = _ClaudeProjector.normalizeSkillName(skillName);
+      artifacts.push({
+        kind: "skill",
+        canonical: canonicalRel,
+        relPath: `.claude/skills/${normalized}/SKILL.md`,
+        content: _ClaudeProjector.renderSkill(await fs3.readFile(skillFile, "utf8"), canonicalRel).content,
+        managedMarker: true
+      });
+      const entries = (await fs3.readdir(skillDir, { withFileTypes: true })).filter((entry) => entry.name !== "SKILL.md").sort((a, b) => a.name.localeCompare(b.name));
+      for (const entry of entries) {
+        if (!entry.isFile()) continue;
+        artifacts.push({
+          kind: "skill",
+          canonical: `skills/${skillName}/${entry.name}`,
+          relPath: `.claude/skills/${normalized}/${entry.name}`,
+          sourceFilePath: path5.join(skillDir, entry.name),
+          managedMarker: false
+        });
+      }
+    }
+    for (const ruleFile of [...new Set(resolved.rules || [])].sort()) {
+      if (ENTRYPOINT_RULES.has(ruleFile)) continue;
+      const src = path5.join(registryDir, "rules", ruleFile);
+      if (!await fs3.pathExists(src)) continue;
+      const canonicalRel = `rules/${ruleFile}`;
+      const content = await fs3.readFile(src, "utf8");
+      if (content.split(/\r?\n/).length > _ClaudeProjector.CLAUDE_DIALECT.maxRuleLines) continue;
+      artifacts.push({
+        kind: "rule",
+        canonical: canonicalRel,
+        relPath: `.claude/rules/${ruleFile}`,
+        content: _ClaudeProjector.renderRule(content, canonicalRel).content,
+        managedMarker: true
+      });
+    }
+    return artifacts;
+  }
+  /** Claude plugin package name rule; every bundle in `registry/bundles.json` satisfies it today. */
+  static PLUGIN_NAME_REGEX = /^[a-z0-9][a-z0-9-]*$/;
+  /**
+   * Render the Claude plugin manifest (`.claude-plugin/plugin.json`).
+   *
+   * Deterministic: fixed field order, two-space indent, trailing newline, and no data read
+   * from the environment (a `package.json` lookup would make the bytes differ between a
+   * project and a global install and would trip doctor's recorded-hash drift check).
+   */
+  static renderPluginManifest(bundle, canonicalRelPath) {
+    if (!_ClaudeProjector.PLUGIN_NAME_REGEX.test(bundle.name)) {
+      throw new Error(
+        `Cannot project ${canonicalRelPath}: bundle name "${bundle.name}" is not a valid Claude plugin name (must match ^[a-z0-9][a-z0-9-]*$).`
+      );
+    }
+    const markerText = `${MARKER_PREFIX} | profile: ${MARKER_PROFILE} | do not edit`;
+    const description = bundle.description ? `${bundle.description} [${markerText}]` : markerText;
+    const manifest = {
+      author: "",
+      description,
+      homepage: "",
+      license: "",
+      name: bundle.name,
+      repository: "",
+      version: bundle.version || "1.0.0"
+    };
+    return JSON.stringify(manifest, null, 2) + "\n";
+  }
+  /**
+   * ADR 0018 decision 12 / Plan 016 decision 13 — the opt-in Claude **plugin lane**.
+   *
+   * Plans the `claude --plugin-dir` consumable package *inside* the organization package:
+   * `.agents/plugins/<bundle>/.claude-plugin/plugin.json` plus an `agents/` subdirectory that
+   * mirrors the `.claude/agents/` projection name-for-name and byte-for-byte (same `renderRole`
+   * call, same coordinator allowlist, same `maxTurns`).
+   *
+   * **Distribution-only, never the behavioural source.** Claude has no project-local plugin
+   * auto-discovery, plugin agents are namespaced (`plugin:agent`) and a plugin
+   * `permissionMode` is ignored — so the `.claude/agents/` projection produced by
+   * `planCompoundProjection` stays the single behavioural source. This package exists purely
+   * so the same folder can be zipped and consumed elsewhere via `--plugin-dir`.
+   *
+   * Additive and caller-gated (`InstallOptions.pluginLane`): when the flag is off this method
+   * is never called and the install plan is byte-identical to before.
+   */
+  static async planPluginLane(bundle, resolved, registryDir) {
+    const artifacts = [];
+    const baseDir = `.agents/plugins/${bundle.name}`;
+    artifacts.push({
+      kind: "plugin-manifest",
+      relPath: `${baseDir}/.claude-plugin/plugin.json`,
+      content: _ClaudeProjector.renderPluginManifest(bundle, `${baseDir}/.claude-plugin/plugin.json`),
+      managedMarker: true,
+      distributionOnly: true
+    });
+    const coordinatorFile = bundle.orchestrator || `${bundle.name}.md`;
+    const domainRoster = _ClaudeProjector.resolveDomainRoster(bundle, coordinatorFile, registryDir);
+    const specialistNames = domainRoster.length > 0 ? domainRoster : (bundle.agents || []).map((f) => _ClaudeProjector.stripSubagentPrefix(f.replace(/\.md$/i, "")));
+    const maxTurns = bundle.planningLoop?.budget?.maxIterations;
+    for (const agentFile of resolved.agents || []) {
+      const canonicalRel = `agents/${agentFile}`;
+      const src = path5.join(registryDir, "agents", agentFile);
+      if (!await fs3.pathExists(src)) continue;
+      const isCoordinator = coordinatorFile === agentFile;
+      const roleName = _ClaudeProjector.stripSubagentPrefix(agentFile.replace(/\.md$/i, ""));
+      const rendered = _ClaudeProjector.renderRole(await fs3.readFile(src, "utf8"), canonicalRel, {
+        allowlist: isCoordinator ? specialistNames : void 0,
+        maxTurns: isCoordinator ? maxTurns : void 0
+      });
+      artifacts.push({
+        kind: "role",
+        canonical: canonicalRel,
+        relPath: `${baseDir}/agents/${roleName}.md`,
+        content: rendered.content,
+        managedMarker: true,
+        distributionOnly: true
+      });
+    }
+    return artifacts;
+  }
+};
+
 // src/core/installer.ts
 import YAML2 from "yaml";
+
+// src/core/types.ts
+function assetOwners(rec) {
+  if (!rec) return [];
+  const declared = rec.owners ?? [];
+  if (declared.length > 0) return declared;
+  return rec.bundle ? [rec.bundle] : [];
+}
+function mergeAssetOwners(rec, owner) {
+  const owners = assetOwners(rec);
+  if (!owner) return owners;
+  return owners.includes(owner) ? owners : [...owners, owner];
+}
+
+// src/core/installer.ts
 var InstallEngine = class _InstallEngine {
   registry;
   constructor(registry2) {
     this.registry = registry2 || new RegistryResolver();
   }
   async calculateHash(filePath) {
-    const buffer = await fs3.readFile(filePath);
+    const buffer = await fs4.readFile(filePath);
     return "sha256:" + crypto.createHash("sha256").update(buffer).digest("hex");
   }
   async readLockfile(lockfilePath) {
-    if (await fs3.pathExists(lockfilePath)) {
+    if (await fs4.pathExists(lockfilePath)) {
       try {
-        return await fs3.readJson(lockfilePath);
+        return await fs4.readJson(lockfilePath);
       } catch {
       }
     }
@@ -1122,24 +1916,24 @@ var InstallEngine = class _InstallEngine {
     return options.scope || "project";
   }
   async deployFile(src, dest, method, force) {
-    await fs3.ensureDir(path5.dirname(dest));
-    if (await fs3.pathExists(dest) || await fs3.pathExists(dest).catch(() => false)) {
+    await fs4.ensureDir(path6.dirname(dest));
+    if (await fs4.pathExists(dest) || await fs4.pathExists(dest).catch(() => false)) {
       if (force) {
-        await fs3.remove(dest);
+        await fs4.remove(dest);
       }
     }
     if (method === "symlink") {
       try {
-        const stat = await fs3.stat(src);
+        const stat = await fs4.stat(src);
         const type = stat.isDirectory() ? process.platform === "win32" ? "junction" : "dir" : "file";
-        await fs3.ensureSymlink(src, dest, type);
+        await fs4.ensureSymlink(src, dest, type);
         return "symlink";
       } catch {
-        await fs3.copy(src, dest, { overwrite: true });
+        await fs4.copy(src, dest, { overwrite: true });
         return "copy";
       }
     }
-    await fs3.copy(src, dest, { overwrite: true });
+    await fs4.copy(src, dest, { overwrite: true });
     return "copy";
   }
   /**
@@ -1147,8 +1941,8 @@ var InstallEngine = class _InstallEngine {
      * copies of canonical assets, so their bytes differ from the source.
      */
   async deployProjection(dest, content) {
-    await fs3.ensureDir(path5.dirname(dest));
-    await fs3.writeFile(dest, content, "utf8");
+    await fs4.ensureDir(path6.dirname(dest));
+    await fs4.writeFile(dest, content, "utf8");
   }
   /**
    * Computes the canonical `.agents/` target dir and the workspace root that contains
@@ -1156,27 +1950,27 @@ var InstallEngine = class _InstallEngine {
    */
   static projectionRoot(scope, targetDir) {
     const agentsTarget = AgentHostAdapter.resolveHostDir(scope, "agents", targetDir);
-    return { agentsTarget, root: path5.resolve(path5.dirname(agentsTarget)) };
+    return { agentsTarget, root: path6.resolve(path6.dirname(agentsTarget)) };
   }
   toPosix(p) {
-    return p.split(path5.sep).join("/");
+    return p.split(path6.sep).join("/");
   }
   canonicalRelAgent(agentFile) {
     return `.agents/agents/${agentFile}`;
   }
   lockRel(subdir, file) {
-    return path5.join(subdir, file);
+    return path6.join(subdir, file);
   }
   destForProjection(host, root, file) {
     const def = HOST_REGISTRY[host];
     const base = resolveHostProjectDir(host, root);
-    if (def.agentsSubdir) return path5.join(base, def.agentsSubdir, file);
+    if (def.agentsSubdir) return path6.join(base, def.agentsSubdir, file);
     return base;
   }
   recordProjectedTo(lockfile, relKey, projPath) {
     const normProj = this.toPosix(projPath);
     const posixKey = relKey.replace(/\\/g, "/");
-    const sysKey = relKey.replace(/\//g, path5.sep);
+    const sysKey = relKey.replace(/\//g, path6.sep);
     const targetKey = lockfile.files[posixKey] ? posixKey : lockfile.files[sysKey] ? sysKey : relKey;
     if (!lockfile.files[targetKey]) {
       lockfile.files[targetKey] = { hash: "", installedAt: (/* @__PURE__ */ new Date()).toISOString() };
@@ -1190,7 +1984,7 @@ var InstallEngine = class _InstallEngine {
   removeProjectedTo(lockfile, canonicalRelPath, projectedRelPath) {
     const normProj = this.toPosix(projectedRelPath);
     const posixKey = canonicalRelPath.replace(/\\/g, "/");
-    const sysKey = canonicalRelPath.replace(/\//g, path5.sep);
+    const sysKey = canonicalRelPath.replace(/\//g, path6.sep);
     const targetKey = lockfile.files[posixKey] ? posixKey : lockfile.files[sysKey] ? sysKey : canonicalRelPath;
     const asset = lockfile.files[targetKey];
     if (asset && asset.projectedTo) {
@@ -1247,7 +2041,7 @@ var InstallEngine = class _InstallEngine {
     if (prefixes.length === 0 || producedByCanonical.size === 0) return;
     for (const [canonical, producedPaths] of producedByCanonical) {
       const posixKey = canonical.replace(/\\/g, "/");
-      const sysKey = canonical.replace(/\//g, path5.sep);
+      const sysKey = canonical.replace(/\//g, path6.sep);
       const targetKey = lockfile.files[posixKey] ? posixKey : lockfile.files[sysKey] ? sysKey : null;
       if (!targetKey) continue;
       const asset = lockfile.files[targetKey];
@@ -1264,17 +2058,142 @@ var InstallEngine = class _InstallEngine {
       }
     }
   }
+  /**
+   * ADR 0018 — the shared compound-lane body used by every host that owns a
+   * dedicated projector (Cline per ADR 0013, Claude per ADR 0018).
+   *
+   * Parameterising by `host` instead of forking the body is deliberate: the two
+   * lanes must stay behaviourally identical in pruning, refcounting and
+   * reconcile semantics, and the Cline path is provably unchanged because it
+   * passes the exact same literal `'cline'` (and the same `declared` set, plan
+   * artifacts and force flag) it previously used inline.
+   *
+   * The host-specific plan (the projector call) stays at the call site; this body
+   * is purely mechanical: prune superseded projections, deploy artifacts, record
+   * refcounted projection entries, reconcile `projectedTo`, surface `projections`.
+   */
+  async applyCompoundLane(host, bundleName, artifacts, context) {
+    const { root, lockfile, declared, projections, now, force } = context;
+    const newPaths = new Set(artifacts.map((a) => a.relPath));
+    if (lockfile.projections) {
+      for (const [projRelPath, proj] of Object.entries(lockfile.projections)) {
+        if (proj.host === host && !newPaths.has(projRelPath) && proj.owners.includes(bundleName)) {
+          proj.owners = proj.owners.filter((o) => o !== bundleName);
+          if (proj.owners.length === 0) {
+            const absProjection = path6.join(root, projRelPath);
+            if (await fs4.pathExists(absProjection)) {
+              await fs4.remove(absProjection);
+              await this.removeEmptyProjectionDirs(root, projRelPath);
+            }
+            delete lockfile.projections[projRelPath];
+          }
+          if (proj.canonical) {
+            this.removeProjectedTo(lockfile, proj.canonical, projRelPath);
+          }
+        }
+      }
+    }
+    for (const artifact of artifacts) {
+      const dest = path6.join(root, artifact.relPath);
+      if (await fs4.pathExists(dest) && !force) {
+        const existing = await fs4.readFile(dest, "utf8").catch(() => null);
+        if (existing !== null) {
+          if (artifact.managedMarker && !HostProjector.hasManagedMarker(existing)) {
+            throw new Error(
+              `Projection target ${artifact.relPath} already exists and is not managed by agents-united. Use --force to overwrite.`
+            );
+          } else if (!artifact.managedMarker) {
+            const registeredProj = lockfile.projections?.[artifact.relPath];
+            if (!registeredProj) {
+              throw new Error(
+                `Projection target ${artifact.relPath} already exists and is not managed by agents-united. Use --force to overwrite.`
+              );
+            }
+          }
+        }
+      }
+      if (artifact.content !== void 0) {
+        await this.deployProjection(dest, artifact.content);
+      } else if (artifact.sourceFilePath) {
+        await fs4.ensureDir(path6.dirname(dest));
+        await fs4.copy(artifact.sourceFilePath, dest, { overwrite: true });
+      }
+      const deployedHash = await this.calculateHash(dest);
+      lockfile.projections = lockfile.projections || {};
+      const existingProj = lockfile.projections[artifact.relPath];
+      const declares = artifact.kind === "rule" || artifact.kind === "team-manifest" || artifact.kind === "plugin-manifest" || (artifact.canonical ? declared.has(artifact.canonical) : false);
+      const bundleScoped = artifact.relPath.startsWith(".agents/plugins/");
+      const canonicalOwners = !bundleScoped && artifact.canonical ? lockfile.files[artifact.canonical]?.owners ?? [] : [];
+      const priorOwners = existingProj?.owners ?? [];
+      const owners = Array.from(/* @__PURE__ */ new Set([
+        ...priorOwners,
+        ...canonicalOwners,
+        ...declares ? [bundleName] : []
+      ]));
+      lockfile.projections[artifact.relPath] = {
+        host,
+        kind: artifact.kind,
+        canonical: artifact.canonical,
+        owners,
+        hash: deployedHash,
+        installedAt: existingProj?.installedAt ?? now,
+        managedMarker: artifact.managedMarker
+      };
+      projections.push({ host, path: artifact.relPath, kind: artifact.kind, warnings: [] });
+      if (artifact.canonical && !artifact.distributionOnly) {
+        this.recordProjectedTo(lockfile, artifact.canonical, artifact.relPath);
+      }
+    }
+    const producedByCanonical = /* @__PURE__ */ new Map();
+    for (const artifact of artifacts) {
+      if (!artifact.canonical || artifact.distributionOnly) continue;
+      const producedPaths = producedByCanonical.get(artifact.canonical);
+      if (producedPaths) {
+        producedPaths.push(artifact.relPath);
+      } else {
+        producedByCanonical.set(artifact.canonical, [artifact.relPath]);
+      }
+    }
+    this.reconcileProjectedTo(lockfile, host, bundleName, producedByCanonical);
+  }
+  /**
+   * Plan 016 / ADR 0018 decision 12 — resolve the effective plugin-lane opt-in.
+   *
+   * An explicit `InstallOptions.pluginLane` always wins (the CLI passes `true` for `--plugin` and
+   * `false` for `--no-plugin`); an unset flag inherits the recorded choice so that `agents update`
+   * — which re-runs the installer without the flag — cannot silently prune an opted-in package.
+   */
+  static effectivePluginLane(options, lockfile) {
+    if (typeof options.pluginLane === "boolean") return options.pluginLane;
+    return lockfile?.pluginLane === true;
+  }
+  /**
+   * ADR 0018 — the host-specific projection plan, the single input that differs per host once
+   * `applyCompoundLane` shared the mechanics. `pluginLane` (Plan 016 decision 13) is honoured for
+   * the **Claude lane only**: the Cline package must stay byte-identical with the flag on and off,
+   * so the flag is inert for `cline`.
+   */
+  static async planCompoundArtifacts(host, bundleDef, scope, resolved, registryDir, pluginLane) {
+    if (host === "cline") {
+      return ClineProjector.planCompoundProjection(bundleDef, scope, resolved, registryDir);
+    }
+    const artifacts = await ClaudeProjector.planCompoundProjection(bundleDef, scope, resolved, registryDir);
+    if (pluginLane) {
+      artifacts.push(...await ClaudeProjector.planPluginLane(bundleDef, resolved, registryDir));
+    }
+    return artifacts;
+  }
   async removeEmptyProjectionDirs(workspaceRoot, projPath) {
-    let dir = path5.dirname(path5.join(workspaceRoot, projPath));
+    let dir = path6.dirname(path6.join(workspaceRoot, projPath));
     while (dir !== workspaceRoot && dir.startsWith(workspaceRoot)) {
       try {
-        const entries = await fs3.readdir(dir);
+        const entries = await fs4.readdir(dir);
         if (entries.length > 0) break;
-        await fs3.rmdir(dir);
+        await fs4.rmdir(dir);
       } catch {
         break;
       }
-      dir = path5.dirname(dir);
+      dir = path6.dirname(dir);
     }
   }
   // ADR 0016: Silent auto-migration of legacy .agents/workflows/*.md into
@@ -1284,27 +2203,27 @@ var InstallEngine = class _InstallEngine {
     let migratedCount = 0;
     let targetLockfile = lockfile;
     let lockfileLoadedFromDisk = false;
-    if (!targetLockfile && await fs3.pathExists(subPaths.lockfile)) {
+    if (!targetLockfile && await fs4.pathExists(subPaths.lockfile)) {
       try {
-        targetLockfile = await fs3.readJson(subPaths.lockfile);
+        targetLockfile = await fs4.readJson(subPaths.lockfile);
         lockfileLoadedFromDisk = true;
       } catch {
       }
     }
-    if (await fs3.pathExists(subPaths.workflowsDir)) {
-      const entries = await fs3.readdir(subPaths.workflowsDir).catch(() => []);
+    if (await fs4.pathExists(subPaths.workflowsDir)) {
+      const entries = await fs4.readdir(subPaths.workflowsDir).catch(() => []);
       for (const entry of entries) {
         if (entry.endsWith(".md")) {
-          const legacyPath = path5.join(subPaths.workflowsDir, entry);
+          const legacyPath = path6.join(subPaths.workflowsDir, entry);
           let skillName = entry.replace(/\.md$/, "").replace(/--/g, "-");
           if (!skillName.startsWith("workflow-")) {
             skillName = `workflow-${skillName}`;
           }
-          const targetSkillDir = path5.join(subPaths.skillsDir, skillName);
-          const targetSkillFile = path5.join(targetSkillDir, "SKILL.md");
-          if (!await fs3.pathExists(targetSkillFile)) {
-            await fs3.ensureDir(targetSkillDir);
-            const legacyContent = await fs3.readFile(legacyPath, "utf8");
+          const targetSkillDir = path6.join(subPaths.skillsDir, skillName);
+          const targetSkillFile = path6.join(targetSkillDir, "SKILL.md");
+          if (!await fs4.pathExists(targetSkillFile)) {
+            await fs4.ensureDir(targetSkillDir);
+            const legacyContent = await fs4.readFile(legacyPath, "utf8");
             let skillContent = legacyContent;
             const fmMatch = legacyContent.match(/^---\r?\n([\s\S]+?)\r?\n---/);
             if (fmMatch) {
@@ -1325,14 +2244,14 @@ ${YAML2.stringify(meta).trim()}
               } catch {
               }
             }
-            await fs3.writeFile(targetSkillFile, skillContent, "utf8");
+            await fs4.writeFile(targetSkillFile, skillContent, "utf8");
           }
-          await fs3.remove(legacyPath).catch(() => {
+          await fs4.remove(legacyPath).catch(() => {
           });
           migratedCount++;
           if (targetLockfile) {
-            const legacyRel = this.toPosix(path5.relative(targetDir, legacyPath));
-            const newRel = this.toPosix(path5.relative(targetDir, targetSkillFile));
+            const legacyRel = this.toPosix(path6.relative(targetDir, legacyPath));
+            const newRel = this.toPosix(path6.relative(targetDir, targetSkillFile));
             if (targetLockfile.files && targetLockfile.files[legacyRel]) {
               targetLockfile.files[newRel] = targetLockfile.files[legacyRel];
               delete targetLockfile.files[legacyRel];
@@ -1345,9 +2264,9 @@ ${YAML2.stringify(meta).trim()}
           }
         }
       }
-      const remaining = await fs3.readdir(subPaths.workflowsDir).catch(() => []);
+      const remaining = await fs4.readdir(subPaths.workflowsDir).catch(() => []);
       if (remaining.length === 0) {
-        await fs3.remove(subPaths.workflowsDir).catch(() => {
+        await fs4.remove(subPaths.workflowsDir).catch(() => {
         });
       }
     }
@@ -1363,15 +2282,15 @@ ${YAML2.stringify(meta).trim()}
       }
       targetLockfile.installed.workflows = [];
     }
-    if (targetLockfile && (lockfileLoadedFromDisk || await fs3.pathExists(subPaths.lockfile))) {
-      await fs3.writeJson(subPaths.lockfile, targetLockfile, { spaces: 2 });
+    if (targetLockfile && (lockfileLoadedFromDisk || await fs4.pathExists(subPaths.lockfile))) {
+      await fs4.writeJson(subPaths.lockfile, targetLockfile, { spaces: 2 });
     }
     return migratedCount;
   }
   /**
    * Dry-run: compute the projection plan (paths + warnings) without writing anything.
    */
-  async buildProjections(fanoutHosts, resolved, registryDir, scope, targetDir) {
+  async buildProjections(fanoutHosts, resolved, registryDir, scope, targetDir, pluginLane = false) {
     const infos = [];
     if (fanoutHosts.length === 0) return infos;
     const { root } = _InstallEngine.projectionRoot(scope, targetDir);
@@ -1380,10 +2299,17 @@ ${YAML2.stringify(meta).trim()}
         infos.push({ host, path: "AGENTS.md", kind: "bridge", warnings: [] });
         continue;
       }
-      if (host === "cline") {
+      if (host === "cline" || host === "claude") {
         const bundleDef = resolved.targetBundle ? await this.registry.getBundle(resolved.targetBundle) : void 0;
         if (bundleDef) {
-          const artifacts = await ClineProjector.planCompoundProjection(bundleDef, scope, resolved, registryDir);
+          const artifacts = await _InstallEngine.planCompoundArtifacts(
+            host,
+            bundleDef,
+            scope,
+            resolved,
+            registryDir,
+            pluginLane
+          );
           for (const artifact of artifacts) {
             infos.push({ host, path: artifact.relPath, kind: artifact.kind, warnings: [] });
           }
@@ -1393,10 +2319,10 @@ ${YAML2.stringify(meta).trim()}
       const base = resolveHostProjectDir(host, root);
       const subdir = HOST_REGISTRY[host].agentsSubdir ?? "agents";
       for (const agentFile of resolved.agents) {
-        const content = await fs3.readFile(path5.join(registryDir, "agents", agentFile), "utf8");
+        const content = await fs4.readFile(path6.join(registryDir, "agents", agentFile), "utf8");
         const res = HostProjector.projectAgent(content, HOST_REGISTRY[host].profile, this.canonicalRelAgent(agentFile));
-        const dest = path5.join(base, subdir, agentFile);
-        infos.push({ host, path: this.toPosix(path5.relative(root, dest)), kind: "role", warnings: res.warnings });
+        const dest = path6.join(base, subdir, agentFile);
+        infos.push({ host, path: this.toPosix(path6.relative(root, dest)), kind: "role", warnings: res.warnings });
       }
     }
     return infos;
@@ -1410,6 +2336,14 @@ ${YAML2.stringify(meta).trim()}
     if (fanoutHosts.length === 0) return;
     const { root } = _InstallEngine.projectionRoot(scope, options.targetDir);
     const now = (/* @__PURE__ */ new Date()).toISOString();
+    const pluginLane = _InstallEngine.effectivePluginLane(options, lockfile);
+    if (fanoutHosts.includes("claude")) {
+      if (pluginLane) {
+        lockfile.pluginLane = true;
+      } else if (options.pluginLane === false) {
+        delete lockfile.pluginLane;
+      }
+    }
     for (const host of fanoutHosts) {
       if (host === "codex") {
         const assets = [];
@@ -1417,9 +2351,9 @@ ${YAML2.stringify(meta).trim()}
         resolved.workflows.forEach((f) => assets.push({ name: f.replace(/\.md$/, ""), type: "workflow", relPath: `.agents/workflows/${f}` }));
         resolved.skills.forEach((s) => assets.push({ name: s, type: "skill", relPath: `.agents/skills/${s}/SKILL.md` }));
         const bridge = HostProjector.buildAgentsMdIndex(assets);
-        const bridgeDest = path5.join(root, "AGENTS.md");
-        if (await fs3.pathExists(bridgeDest) && !options.force) {
-          const existing = await fs3.readFile(bridgeDest, "utf8");
+        const bridgeDest = path6.join(root, "AGENTS.md");
+        if (await fs4.pathExists(bridgeDest) && !options.force) {
+          const existing = await fs4.readFile(bridgeDest, "utf8");
           if (!HostProjector.hasManagedMarker(existing)) {
             throw new Error(
               "File AGENTS.md already exists at the workspace root and is not managed by agents-united. Use --force to overwrite."
@@ -1430,10 +2364,10 @@ ${YAML2.stringify(meta).trim()}
         projections.push({ host, path: "AGENTS.md", kind: "bridge", warnings: [] });
         resolved.agents.forEach((f) => this.recordProjectedTo(lockfile, this.lockRel("agents", f), "AGENTS.md"));
         resolved.workflows.forEach((f) => this.recordProjectedTo(lockfile, this.lockRel("workflows", f), "AGENTS.md"));
-        resolved.skills.forEach((s) => this.recordProjectedTo(lockfile, this.lockRel("skills", path5.join(s, "SKILL.md")), "AGENTS.md"));
+        resolved.skills.forEach((s) => this.recordProjectedTo(lockfile, this.lockRel("skills", path6.join(s, "SKILL.md")), "AGENTS.md"));
         continue;
       }
-      if (host === "cline") {
+      if (host === "cline" || host === "claude") {
         const bundleDef = resolved.targetBundle ? await this.registry.getBundle(resolved.targetBundle) : void 0;
         if (bundleDef) {
           const declared = /* @__PURE__ */ new Set();
@@ -1441,84 +2375,23 @@ ${YAML2.stringify(meta).trim()}
           (bundleDef.agents || []).forEach((a) => declared.add(`agents/${a}`));
           (bundleDef.skills || []).forEach((s) => declared.add(`skills/${s}/SKILL.md`));
           (bundleDef.workflows || []).forEach((w) => declared.add(`workflows/${w}`));
-          const artifacts = await ClineProjector.planCompoundProjection(bundleDef, scope, resolved, registryDir);
-          const newPaths = new Set(artifacts.map((a) => a.relPath));
-          if (lockfile.projections) {
-            for (const [projRelPath, proj] of Object.entries(lockfile.projections)) {
-              if (proj.host === "cline" && !newPaths.has(projRelPath) && proj.owners.includes(bundleDef.name)) {
-                proj.owners = proj.owners.filter((o) => o !== bundleDef.name);
-                if (proj.owners.length === 0) {
-                  const absProjection = path5.join(root, projRelPath);
-                  if (await fs3.pathExists(absProjection)) {
-                    await fs3.remove(absProjection);
-                    await this.removeEmptyProjectionDirs(root, projRelPath);
-                  }
-                  delete lockfile.projections[projRelPath];
-                }
-                if (proj.canonical) {
-                  this.removeProjectedTo(lockfile, proj.canonical, projRelPath);
-                }
-              }
-            }
-          }
-          for (const artifact of artifacts) {
-            const dest = path5.join(root, artifact.relPath);
-            if (await fs3.pathExists(dest) && !options.force) {
-              const existing = await fs3.readFile(dest, "utf8").catch(() => null);
-              if (existing !== null) {
-                if (artifact.managedMarker && !HostProjector.hasManagedMarker(existing)) {
-                  throw new Error(
-                    `Projection target ${artifact.relPath} already exists and is not managed by agents-united. Use --force to overwrite.`
-                  );
-                } else if (!artifact.managedMarker) {
-                  const registeredProj = lockfile.projections?.[artifact.relPath];
-                  if (!registeredProj) {
-                    throw new Error(
-                      `Projection target ${artifact.relPath} already exists and is not managed by agents-united. Use --force to overwrite.`
-                    );
-                  }
-                }
-              }
-            }
-            if (artifact.content !== void 0) {
-              await this.deployProjection(dest, artifact.content);
-            } else if (artifact.sourceFilePath) {
-              await fs3.ensureDir(path5.dirname(dest));
-              await fs3.copy(artifact.sourceFilePath, dest, { overwrite: true });
-            }
-            const deployedHash = await this.calculateHash(dest);
-            lockfile.projections = lockfile.projections || {};
-            const existingProj = lockfile.projections[artifact.relPath];
-            const bundleName = bundleDef.name;
-            const declares = artifact.kind === "rule" || artifact.kind === "team-manifest" || artifact.kind === "plugin-manifest" || (artifact.canonical ? declared.has(artifact.canonical) : false);
-            const priorOwners = existingProj?.owners ?? [];
-            const owners = declares ? Array.from(/* @__PURE__ */ new Set([...priorOwners, bundleName])) : priorOwners;
-            lockfile.projections[artifact.relPath] = {
-              host: "cline",
-              kind: artifact.kind,
-              canonical: artifact.canonical,
-              owners,
-              hash: deployedHash,
-              installedAt: existingProj?.installedAt ?? now,
-              managedMarker: artifact.managedMarker
-            };
-            projections.push({ host, path: artifact.relPath, kind: artifact.kind, warnings: [] });
-            if (artifact.canonical) {
-              this.recordProjectedTo(lockfile, artifact.canonical, artifact.relPath);
-            }
-          }
-          const producedByCanonical = /* @__PURE__ */ new Map();
-          for (const artifact of artifacts) {
-            if (!artifact.canonical) continue;
-            const producedPaths = producedByCanonical.get(artifact.canonical);
-            if (producedPaths) {
-              producedPaths.push(artifact.relPath);
-            } else {
-              producedByCanonical.set(artifact.canonical, [artifact.relPath]);
-            }
-          }
-          this.reconcileProjectedTo(lockfile, "cline", bundleDef.name, producedByCanonical);
-          if (bundleDef.parentBundle) {
+          const artifacts = await _InstallEngine.planCompoundArtifacts(
+            host,
+            bundleDef,
+            scope,
+            resolved,
+            registryDir,
+            pluginLane
+          );
+          await this.applyCompoundLane(host, bundleDef.name, artifacts, {
+            root,
+            lockfile,
+            declared,
+            projections,
+            now,
+            force: options.force
+          });
+          if (host === "cline" && bundleDef.parentBundle) {
             const parentDef = await this.registry.getBundle(bundleDef.parentBundle);
             if (parentDef) {
               const parentProjection = await ClineProjector.planCompoundProjection(
@@ -1531,8 +2404,8 @@ ${YAML2.stringify(meta).trim()}
               for (const artifact of parentProjection) {
                 if (artifact.kind !== "rule" && artifact.kind !== "team-manifest") continue;
                 if (artifact.content === void 0) continue;
-                const dest = path5.join(root, artifact.relPath);
-                if (!await fs3.pathExists(dest)) continue;
+                const dest = path6.join(root, artifact.relPath);
+                if (!await fs4.pathExists(dest)) continue;
                 await this.deployProjection(dest, artifact.content);
                 const deployedHash = await this.calculateHash(dest);
                 lockfile.projections = lockfile.projections || {};
@@ -1556,35 +2429,51 @@ ${YAML2.stringify(meta).trim()}
       const base = resolveHostProjectDir(host, root);
       const subdir = HOST_REGISTRY[host].agentsSubdir ?? "agents";
       for (const agentFile of resolved.agents) {
-        const content = await fs3.readFile(path5.join(registryDir, "agents", agentFile), "utf8");
+        const content = await fs4.readFile(path6.join(registryDir, "agents", agentFile), "utf8");
         const canonicalRel = this.canonicalRelAgent(agentFile);
-        const res = HostProjector.projectAgent(content, HOST_REGISTRY[host].profile, canonicalRel);
-        const projName = host === "cline" ? `${agentFile.replace(/\.md$/i, "").replace(/^subagent-/, "")}.yml` : agentFile;
-        const dest = path5.join(base, subdir, projName);
-        const projPath = this.toPosix(path5.relative(root, dest));
-        if (host === "cline" && lockfile.projections?.[projPath]?.kind === "role") {
-          continue;
+        const isCoordinatorRole = /^\s*type:\s*orchestrator\s*$/m.test(content) || /^\s*mainAgent:\s*true\s*$/m.test(content);
+        const peerRoles = resolved.agents.filter((f) => f !== agentFile).map((f) => ClaudeProjector.stripSubagentPrefix(f.replace(/\.md$/i, "")));
+        const res = host === "claude" ? ClaudeProjector.renderRole(content, canonicalRel, {
+          allowlist: isCoordinatorRole ? peerRoles : void 0
+        }) : HostProjector.projectAgent(content, HOST_REGISTRY[host].profile, canonicalRel);
+        const strippedRoleName = agentFile.replace(/\.md$/i, "").replace(/^subagent-/, "");
+        const projName = host === "cline" ? `${strippedRoleName}.yml` : host === "claude" ? `${strippedRoleName}.md` : agentFile;
+        const dest = path6.join(base, subdir, projName);
+        const projPath = this.toPosix(path6.relative(root, dest));
+        const existingRoleProj = lockfile.projections?.[projPath];
+        if (existingRoleProj?.kind === "role") {
+          const compoundOwned = !(existingRoleProj.canonical ?? "").startsWith(".agents/");
+          if (host === "cline" || host === "claude" && compoundOwned) {
+            continue;
+          }
         }
-        if (await fs3.pathExists(dest) && !options.force) {
-          const existing = await fs3.readFile(dest, "utf8");
+        if (await fs4.pathExists(dest) && !options.force) {
+          const existing = await fs4.readFile(dest, "utf8");
           if (!HostProjector.hasManagedMarker(existing)) {
             throw new Error(
-              `Projection target ${this.toPosix(path5.relative(root, dest))} already exists and is not managed by agents-united. Use --force to overwrite.`
+              `Projection target ${this.toPosix(path6.relative(root, dest))} already exists and is not managed by agents-united. Use --force to overwrite.`
             );
           }
         }
         await this.deployProjection(dest, res.content);
-        projections.push({ host, path: projPath, kind: "role", warnings: res.warnings });
+        projections.push({
+          host,
+          path: projPath,
+          kind: "role",
+          warnings: "warnings" in res ? res.warnings : []
+        });
         this.recordProjectedTo(lockfile, this.lockRel("agents", agentFile), projPath);
-        if (host === "cline") {
+        if (host === "cline" || host === "claude") {
           lockfile.projections = lockfile.projections || {};
+          const existingProj = lockfile.projections[projPath];
+          const canonicalRecord = lockfile.files[canonicalRel] ?? lockfile.files[canonicalRel.replace(/^\.agents\//, "")];
           lockfile.projections[projPath] = {
             host,
             kind: "role",
             canonical: canonicalRel,
-            owners: resolved.targetBundle ? [resolved.targetBundle] : [],
+            owners: mergeAssetOwners(existingProj, resolved.targetBundle ?? void 0).concat(canonicalRecord?.owners ?? []).filter((o, i, arr) => arr.indexOf(o) === i),
             hash: await this.calculateHash(dest),
-            installedAt: lockfile.projections[projPath]?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+            installedAt: existingProj?.installedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
             managedMarker: true
           };
         }
@@ -1602,17 +2491,19 @@ ${YAML2.stringify(meta).trim()}
     const fanoutHosts = (options.fanout || []).map((h) => typeof h === "string" ? h.trim().toLowerCase() : h).filter((h) => isKnownHost(h) && HOST_REGISTRY[h]?.projectionCapable);
     if (options.dryRun) {
       let effectiveDryFanout = fanoutHosts;
-      if (options.fanout === void 0 && hasCanonicalAgents) {
-        const agentsTarget2 = AgentHostAdapter.resolveHostDir(scope, "agents", options.targetDir);
-        const lockfilePath = path5.join(agentsTarget2, "agents-united.json");
-        if (await fs3.pathExists(lockfilePath)) {
-          const lockfile = await fs3.readJson(lockfilePath).catch(() => null);
-          if (lockfile?.fanout) {
-            effectiveDryFanout = lockfile.fanout.filter((h) => isKnownHost(h) && HOST_REGISTRY[h]?.projectionCapable);
-          }
+      let effectiveDryPluginLane = options.pluginLane === true;
+      const agentsTarget2 = AgentHostAdapter.resolveHostDir(scope, "agents", options.targetDir);
+      const lockfilePath = path6.join(agentsTarget2, "agents-united.json");
+      if (await fs4.pathExists(lockfilePath)) {
+        const lockfile = await fs4.readJson(lockfilePath).catch(() => null);
+        if (options.fanout === void 0 && hasCanonicalAgents && lockfile?.fanout) {
+          effectiveDryFanout = lockfile.fanout.filter((h) => isKnownHost(h) && HOST_REGISTRY[h]?.projectionCapable);
+        }
+        if (options.pluginLane === void 0 && lockfile?.pluginLane === true) {
+          effectiveDryPluginLane = true;
         }
       }
-      const projections2 = hasCanonicalAgents ? await this.buildProjections(effectiveDryFanout, resolved, registryDir, scope, options.targetDir) : [];
+      const projections2 = hasCanonicalAgents ? await this.buildProjections(effectiveDryFanout, resolved, registryDir, scope, options.targetDir, effectiveDryPluginLane) : [];
       return { installed: resolved, targetDirs, dryRun: true, method, projections: projections2 };
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1620,12 +2511,12 @@ ${YAML2.stringify(meta).trim()}
     const agentsTarget = AgentHostAdapter.resolveHostDir(scope, "agents", options.targetDir);
     for (const targetDir of targetDirs) {
       const subPaths = AgentHostAdapter.getSubPaths(targetDir);
-      await fs3.ensureDir(subPaths.agentsDir);
-      await fs3.ensureDir(subPaths.skillsDir);
+      await fs4.ensureDir(subPaths.agentsDir);
+      await fs4.ensureDir(subPaths.skillsDir);
       if (resolved.workflows && resolved.workflows.length > 0) {
-        await fs3.ensureDir(subPaths.workflowsDir);
+        await fs4.ensureDir(subPaths.workflowsDir);
       }
-      await fs3.ensureDir(subPaths.rulesDir);
+      await fs4.ensureDir(subPaths.rulesDir);
       const lockfile = await this.readLockfile(subPaths.lockfile);
       await this.migrateLegacyWorkspaceWorkflows(targetDir, lockfile);
       lockfile.scope = scope;
@@ -1636,32 +2527,34 @@ ${YAML2.stringify(meta).trim()}
         lockfile.fanout = effectiveFanout;
       }
       const declared = /* @__PURE__ */ new Set();
+      let hasDeclaredRoster = false;
       if (resolved.targetBundle) {
         const bundleDef = await this.registry.getBundle(resolved.targetBundle);
         if (bundleDef) {
+          hasDeclaredRoster = true;
           if (bundleDef.orchestrator) declared.add(`agents/${bundleDef.orchestrator}`);
           (bundleDef.agents || []).forEach((a) => declared.add(`agents/${a}`));
           (bundleDef.skills || []).forEach((s) => declared.add(`skills/${s}/SKILL.md`));
           (bundleDef.workflows || []).forEach((w) => declared.add(`workflows/${w}`));
         }
       }
+      const declaresAsset = (assetKey) => !hasDeclaredRoster || declared.has(assetKey);
       for (const agentFile of resolved.agents) {
-        const src = path5.join(registryDir, "agents", agentFile);
-        const dest = path5.join(subPaths.agentsDir, agentFile);
-        if (await fs3.pathExists(dest) && !options.force && method !== "symlink") {
+        const src = path6.join(registryDir, "agents", agentFile);
+        const dest = path6.join(subPaths.agentsDir, agentFile);
+        if (await fs4.pathExists(dest) && !options.force && method !== "symlink") {
           const existingHash = await this.calculateHash(dest).catch(() => null);
-          const relPath2 = path5.relative(targetDir, dest);
+          const relPath2 = path6.relative(targetDir, dest);
           if (existingHash && lockfile.files[relPath2] && lockfile.files[relPath2].hash !== existingHash) {
             throw new Error(`File ${relPath2} has user modifications. Use --force to overwrite.`);
           }
         }
         const actualMethod = await this.deployFile(src, dest, method, options.force);
         const hash = await this.calculateHash(src);
-        const relPath = this.toPosix(path5.relative(targetDir, dest));
+        const relPath = this.toPosix(path6.relative(targetDir, dest));
         const existing = lockfile.files[relPath];
-        const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
-        const declaresAsset = declared.has(`agents/${agentFile}`);
-        const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
+        const existingOwners = existing?.owners ?? [];
+        const owners = resolved.targetBundle && declaresAsset(`agents/${agentFile}`) ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
         lockfile.files[relPath] = {
           hash,
           bundle: existing?.bundle ?? resolved.targetBundle,
@@ -1675,17 +2568,16 @@ ${YAML2.stringify(meta).trim()}
         }
       }
       for (const skillName of resolved.skills) {
-        const src = path5.join(registryDir, "skills", skillName);
-        const dest = path5.join(subPaths.skillsDir, skillName);
+        const src = path6.join(registryDir, "skills", skillName);
+        const dest = path6.join(subPaths.skillsDir, skillName);
         const actualMethod = await this.deployFile(src, dest, method, options.force);
-        const skillFile = path5.join(src, "SKILL.md");
-        if (await fs3.pathExists(skillFile)) {
+        const skillFile = path6.join(src, "SKILL.md");
+        if (await fs4.pathExists(skillFile)) {
           const hash = await this.calculateHash(skillFile);
-          const relPath = this.toPosix(path5.relative(targetDir, path5.join(subPaths.skillsDir, skillName, "SKILL.md")));
+          const relPath = this.toPosix(path6.relative(targetDir, path6.join(subPaths.skillsDir, skillName, "SKILL.md")));
           const existing = lockfile.files[relPath];
-          const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
-          const declaresAsset = declared.has(`skills/${skillName}/SKILL.md`);
-          const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
+          const existingOwners = existing?.owners ?? [];
+          const owners = resolved.targetBundle && declaresAsset(`skills/${skillName}/SKILL.md`) ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
           lockfile.files[relPath] = {
             hash,
             bundle: existing?.bundle ?? resolved.targetBundle,
@@ -1695,20 +2587,43 @@ ${YAML2.stringify(meta).trim()}
             ...existing?.projectedTo ? { projectedTo: existing.projectedTo } : {}
           };
         }
+        const sidecarStack = [dest];
+        while (sidecarStack.length > 0) {
+          const dir = sidecarStack.pop();
+          for (const entry of await fs4.readdir(dir, { withFileTypes: true })) {
+            const abs = path6.join(dir, entry.name);
+            if (entry.isDirectory()) {
+              sidecarStack.push(abs);
+              continue;
+            }
+            const sideRel = this.toPosix(path6.relative(targetDir, abs));
+            if (abs === path6.join(dest, "SKILL.md")) continue;
+            const existingSide = lockfile.files[sideRel];
+            const existingSideOwners = existingSide?.owners ?? [];
+            const sideOwners = resolved.targetBundle && declaresAsset(`skills/${skillName}/SKILL.md`) ? Array.from(/* @__PURE__ */ new Set([...existingSideOwners, resolved.targetBundle])) : existingSideOwners;
+            lockfile.files[sideRel] = {
+              hash: await this.calculateHash(abs),
+              bundle: existingSide?.bundle ?? resolved.targetBundle,
+              owners: sideOwners,
+              method: actualMethod,
+              installedAt: existingSide?.installedAt ?? now,
+              ...existingSide?.projectedTo ? { projectedTo: existingSide.projectedTo } : {}
+            };
+          }
+        }
         if (!lockfile.installed.skills.includes(skillName)) {
           lockfile.installed.skills.push(skillName);
         }
       }
       for (const workflowFile of resolved.workflows) {
-        const src = path5.join(registryDir, "workflows", workflowFile);
-        const dest = path5.join(subPaths.workflowsDir, workflowFile);
+        const src = path6.join(registryDir, "workflows", workflowFile);
+        const dest = path6.join(subPaths.workflowsDir, workflowFile);
         const actualMethod = await this.deployFile(src, dest, method, options.force);
         const hash = await this.calculateHash(src);
-        const relPath = this.toPosix(path5.relative(targetDir, dest));
+        const relPath = this.toPosix(path6.relative(targetDir, dest));
         const existing = lockfile.files[relPath];
-        const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
-        const declaresAsset = declared.has(`workflows/${workflowFile}`);
-        const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
+        const existingOwners = existing?.owners ?? [];
+        const owners = resolved.targetBundle && declaresAsset(`workflows/${workflowFile}`) ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
         lockfile.files[relPath] = {
           hash,
           bundle: existing?.bundle ?? resolved.targetBundle,
@@ -1723,16 +2638,15 @@ ${YAML2.stringify(meta).trim()}
         }
       }
       for (const ruleFile of resolved.rules) {
-        const src = path5.join(registryDir, "rules", ruleFile);
-        const dest = path5.join(subPaths.rulesDir, ruleFile);
-        if (await fs3.pathExists(src)) {
+        const src = path6.join(registryDir, "rules", ruleFile);
+        const dest = path6.join(subPaths.rulesDir, ruleFile);
+        if (await fs4.pathExists(src)) {
           const actualMethod = await this.deployFile(src, dest, method, options.force);
           const hash = await this.calculateHash(src);
-          const relPath = this.toPosix(path5.relative(targetDir, dest));
+          const relPath = this.toPosix(path6.relative(targetDir, dest));
           const existing = lockfile.files[relPath];
-          const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
-          const declaresAsset = true;
-          const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
+          const existingOwners = existing?.owners ?? [];
+          const owners = resolved.targetBundle ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
           lockfile.files[relPath] = {
             hash,
             bundle: existing?.bundle ?? resolved.targetBundle,
@@ -1755,26 +2669,26 @@ ${YAML2.stringify(meta).trim()}
           lockfile.bundleModes[resolved.targetBundle] = options.mode;
         }
       }
-      if (hasCanonicalAgents && effectiveFanout.length > 0 && path5.resolve(targetDir) === path5.resolve(agentsTarget)) {
+      if (hasCanonicalAgents && effectiveFanout.length > 0 && path6.resolve(targetDir) === path6.resolve(agentsTarget)) {
         await this.applyFanout(effectiveFanout, resolved, registryDir, scope, targetDir, lockfile, options, projections);
       }
-      await fs3.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
+      await fs4.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
     }
     return { installed: resolved, targetDirs, dryRun: false, method, projections };
   }
 };
 
 // src/core/uninstaller.ts
-import path6 from "path";
+import path7 from "path";
 import crypto2 from "crypto";
-import fs4 from "fs-extra";
+import fs5 from "fs-extra";
 var UninstallEngine = class {
   registry;
   constructor(registry2) {
     this.registry = registry2 || new RegistryResolver();
   }
   async calculateHash(filePath) {
-    const buffer = await fs4.readFile(filePath);
+    const buffer = await fs5.readFile(filePath);
     return "sha256:" + crypto2.createHash("sha256").update(buffer).digest("hex");
   }
   /**
@@ -1783,42 +2697,47 @@ var UninstallEngine = class {
    * AGENTS.md bridge (agentsmd profile) is a plain markdown index with no
    * frontmatter, so the marker is checked against the whole content.
    */
-  async isManagedProjection(absPath, isAgentsMd) {
-    const content = await fs4.readFile(absPath, "utf8");
+  async isManagedProjection(absPath, isAgentsMd, recordedHash) {
+    const content = await fs5.readFile(absPath, "utf8");
     if (isAgentsMd) {
       return content.includes("managed-by: agents-united");
     }
-    return HostProjector.hasManagedMarker(content);
+    if (HostProjector.hasManagedMarker(content)) return true;
+    if (recordedHash) {
+      const bytes = await fs5.readFile(absPath);
+      return `sha256:${crypto2.createHash("sha256").update(bytes).digest("hex")}` === recordedHash;
+    }
+    return false;
   }
   /**
    * Removes empty projection dirs left behind after deleting a projected file
    * (e.g. `.claude/agents/` and then `.claude/`). Only ever removes empty dirs.
    */
   async removeEmptyProjectionDirs(workspaceRoot, projPath) {
-    let dir = path6.dirname(path6.join(workspaceRoot, projPath));
+    let dir = path7.dirname(path7.join(workspaceRoot, projPath));
     while (dir !== workspaceRoot && dir.startsWith(workspaceRoot)) {
       try {
-        const entries = await fs4.readdir(dir);
+        const entries = await fs5.readdir(dir);
         if (entries.length > 0) break;
-        await fs4.rmdir(dir);
+        await fs5.rmdir(dir);
       } catch {
         break;
       }
-      dir = path6.dirname(dir);
+      dir = path7.dirname(dir);
     }
   }
   /**
    * Removes every recorded projection for a canonical asset, guarding against
    * clobbering user-modified files. Mirrors the hash-conflict error pattern.
    */
-  async removeProjections(workspaceRoot, projectedTo, force) {
+  async removeProjections(workspaceRoot, projectedTo, force, projectionHashes) {
     for (const projPath of projectedTo) {
-      const absProjection = path6.join(workspaceRoot, projPath);
-      if (!await fs4.pathExists(absProjection)) {
+      const absProjection = path7.join(workspaceRoot, projPath);
+      if (!await fs5.pathExists(absProjection)) {
         continue;
       }
       const isAgentsMd = projPath === "AGENTS.md";
-      const managed = await this.isManagedProjection(absProjection, isAgentsMd);
+      const managed = await this.isManagedProjection(absProjection, isAgentsMd, projectionHashes?.[projPath]?.hash);
       if (!managed && !force) {
         throw new Error(
           `Projection ${projPath} has user modifications. Use --force to remove.`
@@ -1830,14 +2749,14 @@ var UninstallEngine = class {
   }
   async safeRemoveProjection(absPath) {
     try {
-      const lstat = await fs4.lstat(absPath);
+      const lstat = await fs5.lstat(absPath);
       if (lstat.isSymbolicLink()) {
-        await fs4.unlink(absPath);
+        await fs5.unlink(absPath);
         return;
       }
     } catch {
     }
-    await fs4.remove(absPath);
+    await fs5.remove(absPath);
   }
   /**
    * Installed-addon freshness (plan 003): after a child bundle (one with a
@@ -1866,9 +2785,9 @@ var UninstallEngine = class {
     for (const artifact of projection) {
       if (artifact.kind !== "rule" && artifact.kind !== "team-manifest") continue;
       if (artifact.content === void 0) continue;
-      const dest = path6.join(workspaceRoot, artifact.relPath);
-      if (!await fs4.pathExists(dest)) continue;
-      await fs4.writeFile(dest, artifact.content, "utf8");
+      const dest = path7.join(workspaceRoot, artifact.relPath);
+      if (!await fs5.pathExists(dest)) continue;
+      await fs5.writeFile(dest, artifact.content, "utf8");
       const hash = await this.calculateHash(dest);
       if (lockfile.projections?.[artifact.relPath]) {
         lockfile.projections[artifact.relPath].hash = hash;
@@ -1890,15 +2809,15 @@ var UninstallEngine = class {
     return options.scope || "project";
   }
   async safeRemove(targetDir, relPath) {
-    const fullPath = path6.join(targetDir, relPath);
-    if (relPath.startsWith("skills" + path6.sep) || relPath.startsWith("skills/")) {
+    const fullPath = path7.join(targetDir, relPath);
+    if (relPath.startsWith("skills" + path7.sep) || relPath.startsWith("skills/")) {
       const parts = relPath.split(/[/\\]/);
       if (parts.length >= 2) {
-        const skillDir = path6.join(targetDir, parts[0], parts[1]);
+        const skillDir = path7.join(targetDir, parts[0], parts[1]);
         try {
-          const lstat = await fs4.lstat(skillDir);
+          const lstat = await fs5.lstat(skillDir);
           if (lstat.isSymbolicLink()) {
-            await fs4.unlink(skillDir);
+            await fs5.unlink(skillDir);
             return;
           }
         } catch {
@@ -1906,14 +2825,14 @@ var UninstallEngine = class {
       }
     }
     try {
-      const lstat = await fs4.lstat(fullPath);
+      const lstat = await fs5.lstat(fullPath);
       if (lstat.isSymbolicLink()) {
-        await fs4.unlink(fullPath);
+        await fs5.unlink(fullPath);
         return;
       }
     } catch {
     }
-    await fs4.remove(fullPath);
+    await fs5.remove(fullPath);
   }
   async uninstall(identifier, options = {}) {
     const scope = this.parseScope(options);
@@ -1921,30 +2840,92 @@ var UninstallEngine = class {
     const targetDirs = hosts.map((h) => AgentHostAdapter.resolveHostDir(scope, h, options.targetDir));
     const resolved = await this.registry.resolve(identifier).catch(() => null);
     const totalRemoved = [];
+    const totalKept = [];
+    const totalStale = [];
+    const retainedOwners = /* @__PURE__ */ new Set();
     for (const targetDir of targetDirs) {
       const subPaths = AgentHostAdapter.getSubPaths(targetDir);
-      if (!await fs4.pathExists(subPaths.lockfile)) {
+      if (!await fs5.pathExists(subPaths.lockfile)) {
         continue;
       }
-      const lockfile = await fs4.readJson(subPaths.lockfile);
+      const lockfile = await fs5.readJson(subPaths.lockfile);
       const removedFiles = [];
+      const keptFiles = [];
+      const staleRecords = [];
+      const projectionOwners = (projRelPath, proj) => {
+        const own = proj.owners ?? [];
+        if (projRelPath.startsWith(".agents/plugins/")) return own;
+        const canonical = proj.canonical ?? "";
+        const rec = lockfile.files[canonical] ?? lockfile.files[canonical.replace(/^\.agents\//, "")];
+        return Array.from(/* @__PURE__ */ new Set([...own, ...assetOwners(rec)]));
+      };
+      const survivingCoverage = async (source, removedId) => {
+        const survivors = lockfile.installed.bundles.filter((b) => b !== removedId);
+        const covering = [];
+        for (const id of survivors) {
+          try {
+            const def = await this.registry.getBundle(id);
+            const have = /* @__PURE__ */ new Set([]);
+            if (def) {
+              if (def.orchestrator) have.add(`agents/${def.orchestrator}`);
+              (def.agents || []).forEach((a) => have.add(`agents/${a}`));
+              (def.skills || []).forEach((s) => have.add(`skills/${s}/SKILL.md`));
+              (def.workflows || []).forEach((w) => have.add(`workflows/${w}`));
+              (def.rules || []).forEach((rl) => have.add(`rules/${rl}`));
+            } else {
+              const r = await this.registry.resolve(id);
+              r.agents.forEach((f) => have.add(`agents/${f}`));
+              r.skills.forEach((s) => have.add(`skills/${s}/SKILL.md`));
+              (r.workflows || []).forEach((w) => have.add(`workflows/${w}`));
+              (r.rules || []).forEach((rl) => have.add(`rules/${rl}`));
+            }
+            if (source.asset) {
+              if (have.has(source.asset)) covering.push(id);
+            } else if (source.declaringBundle) {
+              const def2 = await this.registry.getBundle(source.declaringBundle);
+              if (!def2) continue;
+              const want = /* @__PURE__ */ new Set([]);
+              if (def2.orchestrator) want.add(`agents/${def2.orchestrator}`);
+              (def2.agents || []).forEach((a) => want.add(`agents/${a}`));
+              (def2.skills || []).forEach((s) => want.add(`skills/${s}/SKILL.md`));
+              (def2.workflows || []).forEach((w) => want.add(`workflows/${w}`));
+              (def2.rules || []).forEach((rl) => want.add(`rules/${rl}`));
+              if (want.size > 0 && [...want].every((k) => have.has(k))) covering.push(id);
+            }
+          } catch {
+          }
+        }
+        return covering;
+      };
       if (resolved && resolved.targetBundle) {
         const bundleName = resolved.targetBundle;
-        if (lockfile.installed.bundles.includes(bundleName)) {
+        const ownsSomething = Object.values(lockfile.files).some((m) => assetOwners(m).includes(bundleName)) || Object.values(lockfile.projections || {}).some((p) => (p.owners ?? []).includes(bundleName));
+        if (lockfile.installed.bundles.includes(bundleName) || ownsSomething) {
           if (!options.dryRun) {
-            const workspaceRoot = path6.resolve(path6.dirname(targetDir));
-            const ownedFiles = Object.entries(lockfile.files).filter(([, m]) => (m.owners ?? (m.bundle ? [m.bundle] : [])).includes(bundleName));
-            const ownedProjections = lockfile.projections ? Object.values(lockfile.projections).filter((p) => p.owners.includes(bundleName)).length : 0;
+            const workspaceRoot = path7.resolve(path7.dirname(targetDir));
+            const ownedFiles = Object.entries(lockfile.files).filter(([, m]) => assetOwners(m).includes(bundleName));
+            const ownedProjections = lockfile.projections ? Object.entries(lockfile.projections).filter(([p, v]) => projectionOwners(p, v).includes(bundleName)).length : 0;
             if (ownedFiles.length === 0 && ownedProjections === 0) {
               throw new Error(`No installed assets found matching "${bundleName}".`);
             }
             if (lockfile.projections) {
               for (const [projRelPath, proj] of Object.entries(lockfile.projections)) {
-                if (proj.owners.includes(bundleName)) {
-                  proj.owners = proj.owners.filter((o) => o !== bundleName);
+                const owners = projectionOwners(projRelPath, proj);
+                if (owners.includes(bundleName)) {
+                  proj.owners = owners.filter((o) => o !== bundleName);
                   if (proj.owners.length === 0) {
-                    const absProjection = path6.join(workspaceRoot, projRelPath);
-                    if (await fs4.pathExists(absProjection)) {
+                    const declaringMatch = /^\.agents\/plugins\/([^/]+)\//.exec(projRelPath);
+                    const derivedCoordination = Boolean(declaringMatch) || proj.kind === "rule" || proj.kind === "team-manifest" || proj.kind === "plugin-manifest";
+                    const covering = derivedCoordination ? await survivingCoverage({ declaringBundle: declaringMatch ? declaringMatch[1] : bundleName }, bundleName) : [];
+                    if (covering.length > 0) {
+                      proj.owners = covering;
+                      keptFiles.push(projRelPath);
+                      covering.forEach((o) => retainedOwners.add(o));
+                      continue;
+                    }
+                    const absProjection = path7.join(workspaceRoot, projRelPath);
+                    const existedOnDisk = await fs5.pathExists(absProjection);
+                    if (existedOnDisk) {
                       if (proj.managedMarker) {
                         const managed = await this.isManagedProjection(absProjection, projRelPath === "AGENTS.md");
                         if (!managed && !options.force) {
@@ -1960,20 +2941,36 @@ var UninstallEngine = class {
                       await this.removeEmptyProjectionDirs(workspaceRoot, projRelPath);
                     }
                     delete lockfile.projections[projRelPath];
+                    if (existedOnDisk) {
+                      removedFiles.push(projRelPath);
+                    } else {
+                      staleRecords.push(projRelPath);
+                    }
+                    const canonicalKey = (proj.canonical ?? "").replace(/^\.agents\//, "");
+                    for (const key of /* @__PURE__ */ new Set([proj.canonical ?? "", canonicalKey])) {
+                      const rec = key ? lockfile.files[key] : void 0;
+                      if (rec?.projectedTo) {
+                        rec.projectedTo = rec.projectedTo.filter((p) => p !== projRelPath);
+                        if (rec.projectedTo.length === 0) delete rec.projectedTo;
+                      }
+                    }
+                  } else {
+                    keptFiles.push(projRelPath);
+                    proj.owners.forEach((o) => retainedOwners.add(o));
                   }
                 }
               }
             }
             for (const [relPath, assetMeta] of Object.entries(lockfile.files)) {
-              const assetOwners = assetMeta.owners ?? (assetMeta.bundle ? [assetMeta.bundle] : []);
-              if (!assetOwners.includes(bundleName)) continue;
-              const newOwners = assetOwners.filter((o) => o !== bundleName);
+              const recordOwners = assetOwners(assetMeta);
+              if (!recordOwners.includes(bundleName)) continue;
+              const newOwners = recordOwners.filter((o) => o !== bundleName);
               if (newOwners.length === 0) {
                 if (assetMeta.projectedTo && assetMeta.projectedTo.length > 0) {
-                  await this.removeProjections(workspaceRoot, assetMeta.projectedTo, options.force);
+                  await this.removeProjections(workspaceRoot, assetMeta.projectedTo, options.force, lockfile.projections);
                 }
-                const fullPath = path6.join(targetDir, relPath);
-                if (await fs4.pathExists(fullPath) || await fs4.pathExists(fullPath).catch(() => false)) {
+                const fullPath = path7.join(targetDir, relPath);
+                if (await fs5.pathExists(fullPath) || await fs5.pathExists(fullPath).catch(() => false)) {
                   if (!options.force && assetMeta.method !== "symlink") {
                     const currentHash = await this.calculateHash(fullPath).catch(() => null);
                     if (currentHash && currentHash !== assetMeta.hash) {
@@ -1986,6 +2983,16 @@ var UninstallEngine = class {
                 delete lockfile.files[relPath];
               } else {
                 lockfile.files[relPath] = { ...assetMeta, owners: newOwners };
+                keptFiles.push(relPath);
+                newOwners.forEach((o) => retainedOwners.add(o));
+              }
+            }
+            for (const dir of [subPaths.agentsDir, subPaths.skillsDir, subPaths.workflowsDir, subPaths.rulesDir]) {
+              if (await fs5.pathExists(dir)) {
+                const entries = await fs5.readdir(dir).catch(() => []);
+                if (entries.length === 0) {
+                  await fs5.remove(dir);
+                }
               }
             }
             lockfile.installed.bundles = lockfile.installed.bundles.filter((b) => b !== bundleName);
@@ -1996,7 +3003,12 @@ var UninstallEngine = class {
             const survival = /* @__PURE__ */ new Set();
             for (const b of surviving) {
               const bdef = await this.registry.getBundle(b);
-              if (!bdef) continue;
+              if (!bdef) {
+                for (const [relPath, meta] of Object.entries(lockfile.files)) {
+                  if (assetOwners(meta).includes(b)) survival.add(relPath);
+                }
+                continue;
+              }
               if (bdef.orchestrator) survival.add(`agents/${bdef.orchestrator}`);
               (bdef.agents || []).forEach((a) => survival.add(`agents/${a}`));
               (bdef.skills || []).forEach((s) => survival.add(`skills/${s}/SKILL.md`));
@@ -2008,17 +3020,30 @@ var UninstallEngine = class {
               lockfile.installed.workflows = lockfile.installed.workflows.filter((w) => survival.has(`workflows/${w}`));
             }
             await this.refreshParentCoordination(bundleName, workspaceRoot, lockfile, scope);
-            await fs4.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
+            await fs5.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
           } else {
-            removedFiles.push(...resolved.agents, ...resolved.skills, ...resolved.workflows);
+            for (const [relPath, m] of Object.entries(lockfile.files)) {
+              const owners = assetOwners(m);
+              if (!owners.includes(bundleName)) continue;
+              const remaining = owners.filter((o) => o !== bundleName);
+              (remaining.length === 0 ? removedFiles : keptFiles).push(relPath);
+              remaining.forEach((o) => retainedOwners.add(o));
+            }
+            for (const [projRelPath, proj] of Object.entries(lockfile.projections || {})) {
+              const owners = projectionOwners(projRelPath, proj);
+              if (!owners.includes(bundleName)) continue;
+              const remaining = owners.filter((o) => o !== bundleName);
+              (remaining.length === 0 ? removedFiles : keptFiles).push(projRelPath);
+              remaining.forEach((o) => retainedOwners.add(o));
+            }
           }
         }
       } else {
         const itemTargetRelPaths = Object.keys(lockfile.files).filter((p) => p.includes(identifier));
         if (!options.dryRun) {
           for (const relPath of itemTargetRelPaths) {
-            const fullPath = path6.join(targetDir, relPath);
-            if (await fs4.pathExists(fullPath) || await fs4.pathExists(fullPath).catch(() => false)) {
+            const fullPath = path7.join(targetDir, relPath);
+            if (await fs5.pathExists(fullPath) || await fs5.pathExists(fullPath).catch(() => false)) {
               if (!options.force && lockfile.files[relPath]?.method !== "symlink") {
                 const currentHash = await this.calculateHash(fullPath).catch(() => null);
                 const assetMeta = lockfile.files[relPath];
@@ -2031,24 +3056,33 @@ var UninstallEngine = class {
             }
             delete lockfile.files[relPath];
           }
-          await fs4.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
+          await fs5.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
         } else {
           removedFiles.push(...itemTargetRelPaths);
         }
       }
       totalRemoved.push(...removedFiles);
+      totalKept.push(...keptFiles);
+      totalStale.push(...staleRecords);
     }
-    if (totalRemoved.length === 0 && !options.dryRun) {
+    if (totalRemoved.length === 0 && totalKept.length === 0 && totalStale.length === 0 && !options.dryRun) {
       throw new Error(`No installed assets found matching "${identifier}".`);
     }
-    return { removed: totalRemoved, targetDirs, dryRun: options.dryRun || false };
+    return {
+      removed: totalRemoved,
+      kept: totalKept,
+      staleRecords: totalStale,
+      retainedOwners: [...retainedOwners].sort(),
+      targetDirs,
+      dryRun: options.dryRun || false
+    };
   }
 };
 
 // src/core/inventory.ts
-import path7 from "path";
+import path8 from "path";
 import os2 from "os";
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 var InventoryScanner = class _InventoryScanner {
   registry;
   constructor(registry2) {
@@ -2059,10 +3093,10 @@ var InventoryScanner = class _InventoryScanner {
     const cwd = process.cwd();
     let prettyPath = targetDir;
     if (targetDir.startsWith(cwd)) {
-      const rel = path7.relative(cwd, targetDir);
+      const rel = path8.relative(cwd, targetDir);
       prettyPath = rel ? `./${rel.replace(/\\/g, "/")}` : ".";
     } else if (targetDir.startsWith(home)) {
-      const rel = path7.relative(home, targetDir);
+      const rel = path8.relative(home, targetDir);
       prettyPath = `~/${rel.replace(/\\/g, "/")}`;
     }
     const fanoutSuffix = fanout && fanout.length > 0 ? ` + ${fanout.join(", ")}` : "";
@@ -2092,7 +3126,7 @@ var InventoryScanner = class _InventoryScanner {
     const candidateDirs = [];
     if (options.targetDir) {
       candidateDirs.push({
-        dir: path7.resolve(options.targetDir),
+        dir: path8.resolve(options.targetDir),
         scope: options.scope || "project",
         host: hosts[0] || "agents"
       });
@@ -2114,10 +3148,10 @@ var InventoryScanner = class _InventoryScanner {
       const canonicalDir = AgentHostAdapter.resolveHostDir(scope, "agents", options.targetDir);
       let displayLoc = canonicalDir;
       if (canonicalDir.startsWith(cwd)) {
-        const rel = path7.relative(cwd, canonicalDir);
+        const rel = path8.relative(cwd, canonicalDir);
         displayLoc = rel ? `./${rel.replace(/\\/g, "/")}` : ".";
       } else if (canonicalDir.startsWith(home)) {
-        const rel = path7.relative(home, canonicalDir);
+        const rel = path8.relative(home, canonicalDir);
         displayLoc = `~/${rel.replace(/\\/g, "/")}`;
       }
       scannedLocationsMap.set(`${scope}:${canonicalDir}`, {
@@ -2129,14 +3163,14 @@ var InventoryScanner = class _InventoryScanner {
       });
     }
     for (const item of candidateDirs) {
-      const lockfilePath = path7.join(item.dir, "agents-united.json");
-      if (!await fs5.pathExists(lockfilePath)) {
+      const lockfilePath = path8.join(item.dir, "agents-united.json");
+      if (!await fs6.pathExists(lockfilePath)) {
         continue;
       }
       scannedTargetDirs.add(item.dir);
       let lockfile;
       try {
-        lockfile = await fs5.readJson(lockfilePath);
+        lockfile = await fs6.readJson(lockfilePath);
       } catch {
         continue;
       }
@@ -2285,10 +3319,10 @@ var InventoryScanner = class _InventoryScanner {
 };
 
 // src/core/updater.ts
-import path8 from "path";
+import path9 from "path";
 import crypto3 from "crypto";
-import fs6 from "fs-extra";
-var UpdateEngine = class {
+import fs7 from "fs-extra";
+var UpdateEngine = class _UpdateEngine {
   registry;
   scanner;
   installer;
@@ -2310,7 +3344,7 @@ var UpdateEngine = class {
     return deduplicated;
   }
   async calculateHash(filePath) {
-    const buffer = await fs6.readFile(filePath);
+    const buffer = await fs7.readFile(filePath);
     return "sha256:" + crypto3.createHash("sha256").update(buffer).digest("hex");
   }
   /**
@@ -2318,26 +3352,31 @@ var UpdateEngine = class {
    * M5). Agent projections place the marker as the first body line after frontmatter;
    * the AGENTS.md bridge has no frontmatter so it is checked over the whole content.
    */
-  async isManagedProjection(absPath, isAgentsMd) {
-    const content = await fs6.readFile(absPath, "utf8");
+  async isManagedProjection(absPath, isAgentsMd, recordedHash) {
+    const content = await fs7.readFile(absPath, "utf8");
     if (isAgentsMd) {
       return content.includes("managed-by: agents-united");
     }
-    return HostProjector.hasManagedMarker(content);
+    if (HostProjector.hasManagedMarker(content)) return true;
+    if (recordedHash) {
+      const bytes = await fs7.readFile(absPath);
+      return `sha256:${crypto3.createHash("sha256").update(bytes).digest("hex")}` === recordedHash;
+    }
+    return false;
   }
   /**
    * Returns the first user-modified projection path belonging to a record, or '' when
    * every recorded projection still carries the managed marker.
    */
   async staleProjection(record, lockfile) {
-    let workspaceRoot = path8.dirname(record.targetDir);
+    let workspaceRoot = path9.dirname(record.targetDir);
     for (const assetMeta of Object.values(lockfile.files)) {
       if (assetMeta.bundle !== record.name) continue;
       if (!assetMeta.projectedTo || assetMeta.projectedTo.length === 0) continue;
       for (const projPath of assetMeta.projectedTo) {
-        const absProjection = path8.join(workspaceRoot, projPath);
-        if (await fs6.pathExists(absProjection)) {
-          const managed = await this.isManagedProjection(absProjection, projPath === "AGENTS.md");
+        const absProjection = path9.join(workspaceRoot, projPath);
+        if (await fs7.pathExists(absProjection)) {
+          const managed = await this.isManagedProjection(absProjection, projPath === "AGENTS.md", lockfile.projections?.[projPath]?.hash);
           if (!managed) {
             return projPath;
           }
@@ -2346,6 +3385,79 @@ var UpdateEngine = class {
     }
     return "";
   }
+  /** Plan 016 Step 4 — the canonical asset whose dialect name changed (ADR 0016 pattern). */
+  static LEGACY_GENERATIVE_UI_CANONICAL = "skills/generative_ui/SKILL.md";
+  static LEGACY_GENERATIVE_UI_PATH = /(^|\/)generative_ui\/SKILL\.md$/;
+  /** Removes empty projection dirs left behind by the migration (never a non-empty one). */
+  async removeEmptyProjectionDirs(workspaceRoot, projPath) {
+    let dir = path9.dirname(path9.join(workspaceRoot, projPath));
+    while (dir !== workspaceRoot && dir.startsWith(workspaceRoot)) {
+      try {
+        const entries = await fs7.readdir(dir);
+        if (entries.length > 0) break;
+        await fs7.rmdir(dir);
+      } catch {
+        break;
+      }
+      dir = path9.dirname(dir);
+    }
+  }
+  /** Drops one projected path from every canonical file record (host-agnostic). */
+  dropProjectedTo(lockfile, projectedRelPath) {
+    const normProj = projectedRelPath.replace(/\\/g, "/");
+    for (const asset of Object.values(lockfile.files)) {
+      if (!asset.projectedTo || asset.projectedTo.length === 0) continue;
+      const kept = asset.projectedTo.filter((p) => p !== normProj);
+      if (kept.length === asset.projectedTo.length) continue;
+      if (kept.length === 0) {
+        delete asset.projectedTo;
+      } else {
+        asset.projectedTo = kept;
+      }
+    }
+  }
+  /**
+   * Plan 016 Step 4 — silent, bounded, idempotent migration of the `generative_ui`
+   * projection rename (ADR 0016 pattern).
+   *
+   * `registry/skills/generative_ui/` is deliberately NOT renamed: the underscore is
+   * invalid in every host dialect, so the projectors normalize the name at projection
+   * time (`generative_ui` -> `generative-ui`; ADR 0018 decision 2 — normalization is
+   * projection-level). Projections recorded before that change therefore still point at
+   * `.claude/skills/generative_ui/SKILL.md` and/or the Cline plugin copy
+   * `.agents/plugins/<bundle>/skills/generative_ui/SKILL.md`, which the current renderers
+   * no longer produce.
+   *
+   * Runs before each record's re-install so the freshly rendered normalized path is
+   * registered by the normal install path. Guarantees: (a) a file that lacks the managed
+   * marker is never deleted (its lockfile entries are left untouched too, so the
+   * migration never lies about a file it did not remove); (b) a second run is a no-op
+   * because the entries are gone; (c) it is host-agnostic, so it covers `.claude/**` and
+   * the Cline plugin lane alike, and it never touches the canonical registry store.
+   */
+  async migrateLegacyGenerativeUiProjections(workspaceRoot, lockfile) {
+    const projections = lockfile.projections;
+    if (!projections) return [];
+    const normalized = ClaudeProjector.normalizeSkillName("generative_ui");
+    const removed = [];
+    for (const [projRelPath, proj] of Object.entries(projections)) {
+      const posixPath = projRelPath.replace(/\\/g, "/");
+      const isLegacy = proj.canonical === _UpdateEngine.LEGACY_GENERATIVE_UI_CANONICAL || _UpdateEngine.LEGACY_GENERATIVE_UI_PATH.test(posixPath);
+      if (!isLegacy) continue;
+      if (posixPath.includes(`/${normalized}/`)) continue;
+      const absProjection = path9.join(workspaceRoot, projRelPath);
+      if (await fs7.pathExists(absProjection)) {
+        const managed = await this.isManagedProjection(absProjection, posixPath === "AGENTS.md");
+        if (!managed) continue;
+        await fs7.remove(absProjection);
+        await this.removeEmptyProjectionDirs(workspaceRoot, projRelPath);
+      }
+      delete projections[projRelPath];
+      this.dropProjectedTo(lockfile, projRelPath);
+      removed.push(projRelPath);
+    }
+    return removed;
+  }
   async checkUpdates(options = {}) {
     const inventory = await this.scanner.scan(options);
     const items = [];
@@ -2397,8 +3509,8 @@ var UpdateEngine = class {
     if (options.dryRun) {
       const dryProjections = [];
       for (const record of recordsToUpdate) {
-        const lockfilePath = path8.join(record.targetDir, "agents-united.json");
-        if (await fs6.pathExists(lockfilePath)) {
+        const lockfilePath = path9.join(record.targetDir, "agents-united.json");
+        if (await fs7.pathExists(lockfilePath)) {
           const dryResult = await this.installer.install(record.name, {
             scope: record.scope,
             method: record.method,
@@ -2424,18 +3536,18 @@ var UpdateEngine = class {
     const skipped = [];
     const collectedProjections = [];
     for (const record of recordsToUpdate) {
-      const lockfilePath = path8.join(record.targetDir, "agents-united.json");
-      if (!await fs6.pathExists(lockfilePath)) {
+      const lockfilePath = path9.join(record.targetDir, "agents-united.json");
+      if (!await fs7.pathExists(lockfilePath)) {
         continue;
       }
-      const lockfile = await fs6.readJson(lockfilePath);
+      const lockfile = await fs7.readJson(lockfilePath);
       if (record.method === "copy" && !options.force && lockfile.files) {
         let hasConflict = false;
         let conflictRelPath = "";
         for (const [relPath, assetMeta] of Object.entries(lockfile.files)) {
           if (assetMeta.bundle === record.name || relPath.includes(record.name)) {
-            const fullPath = path8.join(record.targetDir, relPath);
-            if (await fs6.pathExists(fullPath)) {
+            const fullPath = path9.join(record.targetDir, relPath);
+            if (await fs7.pathExists(fullPath)) {
               const currentHash = await this.calculateHash(fullPath).catch(() => null);
               if (currentHash && currentHash !== assetMeta.hash) {
                 hasConflict = true;
@@ -2463,6 +3575,13 @@ var UpdateEngine = class {
           continue;
         }
       }
+      const migratedGenerativeUi = await this.migrateLegacyGenerativeUiProjections(
+        path9.dirname(record.targetDir),
+        lockfile
+      );
+      if (migratedGenerativeUi.length > 0) {
+        await fs7.writeJson(lockfilePath, lockfile, { spaces: 2 });
+      }
       const installResult = await this.installer.install(record.name, {
         scope: record.scope,
         method: record.method,
@@ -2475,11 +3594,11 @@ var UpdateEngine = class {
       if (installResult.projections) {
         collectedProjections.push(...installResult.projections);
       }
-      if (await fs6.pathExists(lockfilePath)) {
-        const updatedLockfile = await fs6.readJson(lockfilePath);
+      if (await fs7.pathExists(lockfilePath)) {
+        const updatedLockfile = await fs7.readJson(lockfilePath);
         updatedLockfile.bundleVersions = updatedLockfile.bundleVersions || {};
         updatedLockfile.bundleVersions[record.name] = record.upstreamVersion;
-        await fs6.writeJson(lockfilePath, updatedLockfile, { spaces: 2 });
+        await fs7.writeJson(lockfilePath, updatedLockfile, { spaces: 2 });
         if (updatedLockfile.fanout) {
           record.fanout = updatedLockfile.fanout;
           record.projections = updatedLockfile.fanout;
@@ -2506,14 +3625,18 @@ var UpdateEngine = class {
 };
 
 // src/core/doctor.ts
-import path10 from "path";
-import fs8 from "fs-extra";
+import path12 from "path";
+import fs10 from "fs-extra";
 import crypto4 from "crypto";
 import YAML3 from "yaml";
 
+// src/core/claude-capabilities.ts
+import path11 from "path";
+import fs9 from "fs-extra";
+
 // src/core/cline-capabilities.ts
-import path9 from "path";
-import fs7 from "fs-extra";
+import path10 from "path";
+import fs8 from "fs-extra";
 import { execFile } from "child_process";
 var defaultProcessRunner = (executable, args, options) => {
   return new Promise((resolve) => {
@@ -2555,7 +3678,165 @@ var defaultProcessRunner = (executable, args, options) => {
     }
   });
 };
-var ClineCapabilityProbe = class {
+var ClineCapabilityProbe = class {
+  runner;
+  customResolver;
+  constructor(runner, options) {
+    this.runner = runner || defaultProcessRunner;
+    this.customResolver = options?.resolveExecutable;
+  }
+  /**
+   * Safe executable resolution across POSIX and Windows layouts.
+   */
+  resolveExecutable() {
+    if (this.customResolver) {
+      return this.customResolver();
+    }
+    const envBin = process.env.CLINE_BIN_PATH;
+    if (envBin && path10.isAbsolute(envBin) && fs8.existsSync(envBin)) {
+      return {
+        executable: envBin,
+        prefixArgs: [],
+        source: "env-binary"
+      };
+    }
+    const pathEnv = process.env.PATH || "";
+    const pathSeparator = process.platform === "win32" ? ";" : ":";
+    const dirs = pathEnv.split(pathSeparator).filter(Boolean);
+    if (process.platform === "win32") {
+      const exeNames = ["cline.cmd", "cline.bat", "cline.exe", "cline"];
+      for (const dir of dirs) {
+        for (const exeName of exeNames) {
+          const fullPath = path10.join(dir, exeName);
+          if (fs8.existsSync(fullPath)) {
+            const adjacentWrapper1 = path10.join(dir, "node_modules", "cline", "bin", "cline");
+            const adjacentWrapper2 = path10.join(dir, "node_modules", "@cline", "cline", "bin", "cline");
+            if (fs8.existsSync(adjacentWrapper1)) {
+              return {
+                executable: process.execPath,
+                prefixArgs: [adjacentWrapper1],
+                source: "node-wrapper"
+              };
+            }
+            if (fs8.existsSync(adjacentWrapper2)) {
+              return {
+                executable: process.execPath,
+                prefixArgs: [adjacentWrapper2],
+                source: "node-wrapper"
+              };
+            }
+            const ext = path10.extname(fullPath).toLowerCase();
+            if (ext === ".cmd" || ext === ".bat") {
+              return {
+                executable: "cmd.exe",
+                prefixArgs: ["/c", fullPath],
+                source: "path-executable"
+              };
+            }
+            return {
+              executable: fullPath,
+              prefixArgs: [],
+              source: "path-executable"
+            };
+          }
+        }
+      }
+    } else {
+      for (const dir of dirs) {
+        const fullPath = path10.join(dir, "cline");
+        if (fs8.existsSync(fullPath)) {
+          return {
+            executable: fullPath,
+            prefixArgs: [],
+            source: "path-executable"
+          };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Run read-only capability probe against local Cline.
+   */
+  async probe() {
+    const cmd = this.resolveExecutable();
+    const diagnostics = [];
+    if (!cmd) {
+      diagnostics.push("Cline executable not found on PATH or via CLINE_BIN_PATH.");
+      return {
+        installed: false,
+        namedTeams: false,
+        rolePresetConsumer: "unknown",
+        diagnostics
+      };
+    }
+    let version;
+    try {
+      const verRes = await this.runner(cmd.executable, [...cmd.prefixArgs, "version"], {
+        timeoutMs: 5e3
+      });
+      if (verRes.exitCode === 0) {
+        version = verRes.stdout.trim().split("\n")[0]?.trim();
+      } else {
+        diagnostics.push(`Cline version check failed (exit code ${verRes.exitCode}): ${verRes.stderr.trim()}`);
+        return {
+          installed: false,
+          command: cmd,
+          namedTeams: false,
+          rolePresetConsumer: "unknown",
+          diagnostics
+        };
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      diagnostics.push(`Error executing Cline version check: ${msg}`);
+      return {
+        installed: false,
+        command: cmd,
+        namedTeams: false,
+        rolePresetConsumer: "unknown",
+        diagnostics
+      };
+    }
+    let namedTeams = false;
+    try {
+      const probeRes = await this.runner(
+        cmd.executable,
+        [...cmd.prefixArgs, "--team-name", "agents-united-capability-probe", "version"],
+        { timeoutMs: 5e3 }
+      );
+      if (probeRes.exitCode === 0) {
+        namedTeams = true;
+      } else {
+        diagnostics.push(`Named teams probe returned non-zero (exit code ${probeRes.exitCode}). Falling back to adaptive session.`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      diagnostics.push(`Named teams probe failed: ${msg}`);
+    }
+    return {
+      installed: true,
+      version,
+      command: cmd,
+      namedTeams,
+      rolePresetConsumer: "unknown",
+      diagnostics
+    };
+  }
+};
+
+// src/core/claude-capabilities.ts
+var SUBAGENT_HANDBACK_MIN = { major: 2, minor: 1, patch: 271 };
+function supportsSubagentHandback(version) {
+  if (!version) return false;
+  const match = version.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return false;
+  const [major, minor, patch] = [Number(match[1]), Number(match[2]), Number(match[3])];
+  if (major !== SUBAGENT_HANDBACK_MIN.major) return major > SUBAGENT_HANDBACK_MIN.major;
+  if (minor !== SUBAGENT_HANDBACK_MIN.minor) return minor > SUBAGENT_HANDBACK_MIN.minor;
+  return patch >= SUBAGENT_HANDBACK_MIN.patch;
+}
+var ClaudeCapabilityProbe = class {
   runner;
   customResolver;
   constructor(runner, options) {
@@ -2569,8 +3850,8 @@ var ClineCapabilityProbe = class {
     if (this.customResolver) {
       return this.customResolver();
     }
-    const envBin = process.env.CLINE_BIN_PATH;
-    if (envBin && path9.isAbsolute(envBin) && fs7.existsSync(envBin)) {
+    const envBin = process.env.CLAUDE_BIN_PATH;
+    if (envBin && path11.isAbsolute(envBin) && fs9.existsSync(envBin)) {
       return {
         executable: envBin,
         prefixArgs: [],
@@ -2581,28 +3862,28 @@ var ClineCapabilityProbe = class {
     const pathSeparator = process.platform === "win32" ? ";" : ":";
     const dirs = pathEnv.split(pathSeparator).filter(Boolean);
     if (process.platform === "win32") {
-      const exeNames = ["cline.cmd", "cline.bat", "cline.exe", "cline"];
+      const exeNames = ["claude.cmd", "claude.bat", "claude.exe", "claude"];
       for (const dir of dirs) {
         for (const exeName of exeNames) {
-          const fullPath = path9.join(dir, exeName);
-          if (fs7.existsSync(fullPath)) {
-            const adjacentWrapper1 = path9.join(dir, "node_modules", "cline", "bin", "cline");
-            const adjacentWrapper2 = path9.join(dir, "node_modules", "@cline", "cline", "bin", "cline");
-            if (fs7.existsSync(adjacentWrapper1)) {
+          const fullPath = path11.join(dir, exeName);
+          if (fs9.existsSync(fullPath)) {
+            const adjacentWrapper1 = path11.join(dir, "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+            const adjacentWrapper2 = path11.join(dir, "node_modules", "claude", "bin", "claude");
+            if (fs9.existsSync(adjacentWrapper1)) {
               return {
                 executable: process.execPath,
                 prefixArgs: [adjacentWrapper1],
                 source: "node-wrapper"
               };
             }
-            if (fs7.existsSync(adjacentWrapper2)) {
+            if (fs9.existsSync(adjacentWrapper2)) {
               return {
                 executable: process.execPath,
                 prefixArgs: [adjacentWrapper2],
                 source: "node-wrapper"
               };
             }
-            const ext = path9.extname(fullPath).toLowerCase();
+            const ext = path11.extname(fullPath).toLowerCase();
             if (ext === ".cmd" || ext === ".bat") {
               return {
                 executable: "cmd.exe",
@@ -2620,8 +3901,8 @@ var ClineCapabilityProbe = class {
       }
     } else {
       for (const dir of dirs) {
-        const fullPath = path9.join(dir, "cline");
-        if (fs7.existsSync(fullPath)) {
+        const fullPath = path11.join(dir, "claude");
+        if (fs9.existsSync(fullPath)) {
           return {
             executable: fullPath,
             prefixArgs: [],
@@ -2633,90 +3914,134 @@ var ClineCapabilityProbe = class {
     return null;
   }
   /**
-   * Run read-only capability probe against local Cline.
+   * Run the read-only capability probe against local Claude Code. Never throws: an absent
+   * executable, a non-zero exit and a runner error are all reported as data.
    */
   async probe() {
     const cmd = this.resolveExecutable();
     const diagnostics = [];
     if (!cmd) {
-      diagnostics.push("Cline executable not found on PATH or via CLINE_BIN_PATH.");
+      diagnostics.push("Claude Code executable not found on PATH or via CLAUDE_BIN_PATH.");
       return {
         installed: false,
-        namedTeams: false,
-        rolePresetConsumer: "unknown",
+        pluginSupport: false,
+        agentTeamsExperimental: false,
+        subagentHandback: false,
         diagnostics
       };
     }
     let version;
+    let subagentHandback = false;
     try {
-      const verRes = await this.runner(cmd.executable, [...cmd.prefixArgs, "version"], {
+      const verRes = await this.runner(cmd.executable, [...cmd.prefixArgs, "--version"], {
         timeoutMs: 5e3
       });
       if (verRes.exitCode === 0) {
         version = verRes.stdout.trim().split("\n")[0]?.trim();
+        subagentHandback = supportsSubagentHandback(version);
       } else {
-        diagnostics.push(`Cline version check failed (exit code ${verRes.exitCode}): ${verRes.stderr.trim()}`);
+        diagnostics.push(`Claude Code version check failed (exit code ${verRes.exitCode}): ${verRes.stderr.trim()}`);
         return {
           installed: false,
           command: cmd,
-          namedTeams: false,
-          rolePresetConsumer: "unknown",
+          pluginSupport: false,
+          agentTeamsExperimental: false,
+          subagentHandback: false,
           diagnostics
         };
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      diagnostics.push(`Error executing Cline version check: ${msg}`);
+      diagnostics.push(`Error executing Claude Code version check: ${msg}`);
       return {
         installed: false,
         command: cmd,
-        namedTeams: false,
-        rolePresetConsumer: "unknown",
+        pluginSupport: false,
+        agentTeamsExperimental: false,
+        subagentHandback: false,
         diagnostics
       };
     }
-    let namedTeams = false;
+    let pluginSupport = false;
+    let agentTeamsExperimental = false;
     try {
-      const probeRes = await this.runner(
-        cmd.executable,
-        [...cmd.prefixArgs, "--team-name", "agents-united-capability-probe", "version"],
-        { timeoutMs: 5e3 }
-      );
-      if (probeRes.exitCode === 0) {
-        namedTeams = true;
+      const helpRes = await this.runner(cmd.executable, [...cmd.prefixArgs, "--help"], {
+        timeoutMs: 5e3
+      });
+      if (helpRes.exitCode === 0) {
+        const help = helpRes.stdout;
+        pluginSupport = help.includes("--plugin-dir");
+        agentTeamsExperimental = /agent teams/i.test(help) || help.includes("CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS");
       } else {
-        diagnostics.push(`Named teams probe returned non-zero (exit code ${probeRes.exitCode}). Falling back to adaptive session.`);
+        diagnostics.push(
+          `Claude Code help probe returned non-zero (exit code ${helpRes.exitCode}); plugin and agent-team support could not be verified.`
+        );
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      diagnostics.push(`Named teams probe failed: ${msg}`);
+      diagnostics.push(`Claude Code help probe failed: ${msg}`);
     }
     return {
       installed: true,
       version,
       command: cmd,
-      namedTeams,
-      rolePresetConsumer: "unknown",
+      pluginSupport,
+      agentTeamsExperimental,
+      subagentHandback,
       diagnostics
     };
   }
 };
 
 // src/core/doctor.ts
-var DoctorEngine = class {
-  static async isManagedProjection(absPath, isAgentsMd) {
-    const content = await fs8.readFile(absPath, "utf8");
+var DoctorEngine = class _DoctorEngine {
+  static async isManagedProjection(absPath, isAgentsMd, recordedHash) {
+    const content = await fs10.readFile(absPath, "utf8");
     if (isAgentsMd) {
       return content.includes("managed-by: agents-united");
     }
-    return HostProjector.hasManagedMarker(content);
+    if (HostProjector.hasManagedMarker(content)) return true;
+    if (recordedHash) {
+      const bytes = await fs10.readFile(absPath);
+      return `sha256:${crypto4.createHash("sha256").update(bytes).digest("hex")}` === recordedHash;
+    }
+    return false;
+  }
+  static isCompoundLaneHost(host) {
+    return host === "cline" || host === "claude";
+  }
+  /**
+   * Plan 015 §5.9 item 3 / ADR 0018 decision 2 — find the projection that now serves
+   * `canonical` at a *different* path and actually exists on disk. A hit turns an absent
+   * recorded path into self-healing staleness (`Stale projection … (superseded by …)`)
+   * instead of a user-deletion report.
+   *
+   * Covers every rename the lockfile can still carry: the ADR 0016 workflow slug rename
+   * (`.cline/workflows/implement-feature-or-fix.md` → `…/workflow-implement.md`) and the
+   * ADR 0018 prefix strip (`.claude/agents/subagent-<role>.md` → `.claude/agents/<role>.md`).
+   */
+  static async findSupersedingProjection(projPath, canonical, manifest, workspaceRoot) {
+    if (!canonical) return null;
+    for (const [projRelPath, proj] of Object.entries(manifest.projections ?? {})) {
+      if (projRelPath === projPath) continue;
+      if (proj.canonical !== canonical) continue;
+      if (!await fs10.pathExists(path12.join(workspaceRoot, projRelPath))) continue;
+      return { relPath: projRelPath, host: proj.host, owners: proj.owners ?? [] };
+    }
+    return null;
   }
   /**
    * ADR 0017 — re-render the compound projections owned by the installed bundles so
    * doctor can compare what is on disk with what the current renderer produces.
    *
-   * Returns projection path -> acceptable content variants, or `null` when the registry
-   * is unavailable (the freshness check is then skipped rather than guessed).
+   * Returns projection path -> acceptable content variants **for `host` only**, or `null`
+   * when the registry is unavailable (the freshness check is then skipped rather than
+   * guessed).
+   *
+   * ADR 0018 decision 11 — the renderer is dispatched by the *recorded projection's* host.
+   * Cline entries are diffed against `ClineProjector` output and Claude entries against
+   * `ClaudeProjector` output; nothing else is comparable, and the Cline path is unchanged
+   * because it renders exactly what it rendered before.
    *
    * Two variants are produced per path on purpose: the coordinator rule and team manifest
    * legitimately render either with or without the installed-bundle addon exclusions
@@ -2724,7 +4049,7 @@ var DoctorEngine = class {
    * projection is fresh, which keeps the check false-positive free while still catching
    * content that matches neither.
    */
-  static async renderProjectionVariants(owners, installedBundles) {
+  static async renderProjectionVariants(owners, installedBundles, host) {
     if (owners.size === 0) return null;
     let resolver;
     try {
@@ -2741,7 +4066,13 @@ var DoctorEngine = class {
         if (!bundleDef) continue;
         const resolved = await resolver.resolve(bundleDef.name);
         for (const excludeAddons of [void 0, installedBundles]) {
-          const artifacts = await ClineProjector.planCompoundProjection(
+          const artifacts = host === "cline" ? await ClineProjector.planCompoundProjection(
+            bundleDef,
+            "project",
+            resolved,
+            registryDir,
+            excludeAddons
+          ) : await ClaudeProjector.planCompoundProjection(
             bundleDef,
             "project",
             resolved,
@@ -2771,12 +4102,13 @@ var DoctorEngine = class {
     let workflowsCount = 0;
     let manifest;
     let clineCapability;
+    let claudeCapability;
     let isInitialized = false;
-    const lockfileExists = await fs8.pathExists(subPaths.lockfile);
-    const agentsDirExists = await fs8.pathExists(subPaths.agentsDir);
+    const lockfileExists = await fs10.pathExists(subPaths.lockfile);
+    const agentsDirExists = await fs10.pathExists(subPaths.agentsDir);
     if (lockfileExists) {
       try {
-        const parsed = await fs8.readJson(subPaths.lockfile);
+        const parsed = await fs10.readJson(subPaths.lockfile);
         manifest = parsed;
         agentsCount = parsed.installed?.agents?.length || 0;
         skillsCount = parsed.installed?.skills?.length || 0;
@@ -2790,11 +4122,11 @@ var DoctorEngine = class {
     } else if (agentsDirExists) {
       warnings.push(`No lockfile found at ${subPaths.lockfile}, but agent files were detected in ${subPaths.agentsDir}. Run 'agents update' to sync.`);
     }
-    if (await fs8.pathExists(subPaths.agentsDir)) {
-      const agentFiles = await fs8.readdir(subPaths.agentsDir);
+    if (await fs10.pathExists(subPaths.agentsDir)) {
+      const agentFiles = await fs10.readdir(subPaths.agentsDir);
       for (const file of agentFiles) {
         if (file.endsWith(".md")) {
-          const content = await fs8.readFile(path10.join(subPaths.agentsDir, file), "utf8");
+          const content = await fs10.readFile(path12.join(subPaths.agentsDir, file), "utf8");
           const frontmatterMatch = content.match(/^---\r?\n([\s\S]+?)\r?\n---/);
           if (!frontmatterMatch) {
             warnings.push(`Agent ${file} is missing YAML frontmatter.`);
@@ -2811,79 +4143,104 @@ var DoctorEngine = class {
         }
       }
     }
-    if (await fs8.pathExists(subPaths.workflowsDir)) {
-      const remainingWorkflowFiles = (await fs8.readdir(subPaths.workflowsDir)).filter((f) => f.endsWith(".md"));
+    if (await fs10.pathExists(subPaths.workflowsDir)) {
+      const remainingWorkflowFiles = (await fs10.readdir(subPaths.workflowsDir)).filter((f) => f.endsWith(".md"));
       if (remainingWorkflowFiles.length > 0) {
         warnings.push(`Detected ${remainingWorkflowFiles.length} legacy workflows in ${subPaths.workflowsDir}. Run 'agents update' to automatically migrate them to modern skills.`);
       }
     }
     if (manifest) {
-      const workspaceRoot = path10.resolve(path10.dirname(root));
+      const workspaceRoot = path12.resolve(path12.dirname(root));
+      const warnedProjectionPaths = /* @__PURE__ */ new Set();
+      const pushProjectionWarning = (projPath, message) => {
+        if (warnedProjectionPaths.has(projPath)) return;
+        warnedProjectionPaths.add(projPath);
+        warnings.push(message);
+      };
       for (const [relPath, assetMeta] of Object.entries(manifest.files)) {
         const projectedTo = assetMeta.projectedTo;
         if (!projectedTo || projectedTo.length === 0) continue;
         for (const projPath of projectedTo) {
-          const absProjection = path10.join(workspaceRoot, projPath);
-          if (!await fs8.pathExists(absProjection)) {
-            let superseding = null;
-            for (const [projRelPath, proj] of Object.entries(manifest.projections ?? {})) {
-              if (projRelPath === projPath) continue;
-              if (proj.canonical !== relPath) continue;
-              if (!await fs8.pathExists(path10.join(workspaceRoot, projRelPath))) continue;
-              superseding = { relPath: projRelPath, host: proj.host, owners: proj.owners ?? [] };
-              break;
-            }
+          const absProjection = path12.join(workspaceRoot, projPath);
+          if (!await fs10.pathExists(absProjection)) {
+            const superseding = await this.findSupersedingProjection(projPath, relPath, manifest, workspaceRoot);
             if (superseding) {
               const owner = superseding.owners[0];
-              warnings.push(
+              pushProjectionWarning(
+                projPath,
                 `Stale projection ${projPath} for canonical ${relPath} (superseded by ${superseding.relPath}).` + (owner ? ` Run: agents update ${owner} --fanout ${superseding.host} to reconcile.` : "")
               );
             } else {
-              warnings.push(
+              pushProjectionWarning(
+                projPath,
                 `Missing projection ${projPath} for canonical ${relPath}. Re-run: agents add ... --fanout`
               );
             }
             continue;
           }
-          const managed = await this.isManagedProjection(absProjection, projPath === "AGENTS.md");
+          const managed = await this.isManagedProjection(absProjection, projPath === "AGENTS.md", manifest.projections?.[projPath]?.hash);
           if (!managed) {
-            warnings.push(`user-modified projection ${projPath}`);
+            pushProjectionWarning(projPath, `user-modified projection ${projPath}`);
           }
         }
       }
       if (manifest.projections) {
         for (const [projRelPath, proj] of Object.entries(manifest.projections)) {
-          const absPath = path10.join(workspaceRoot, projRelPath);
-          if (!await fs8.pathExists(absPath)) {
-            warnings.push(`Missing Cline projection ${projRelPath} (owners: ${proj.owners.join(", ")}).`);
+          const absPath = path12.join(workspaceRoot, projRelPath);
+          if (!await fs10.pathExists(absPath)) {
+            const superseding = await this.findSupersedingProjection(projRelPath, proj.canonical, manifest, workspaceRoot);
+            if (superseding) {
+              const owner = superseding.owners[0];
+              pushProjectionWarning(
+                projRelPath,
+                `Stale projection ${projRelPath} for canonical ${proj.canonical} (superseded by ${superseding.relPath}).` + (owner ? ` Run: agents update ${owner} --fanout ${superseding.host} to reconcile.` : "")
+              );
+            } else {
+              pushProjectionWarning(
+                projRelPath,
+                `Missing ${proj.host} projection ${projRelPath} (owners: ${proj.owners.join(", ")}).`
+              );
+            }
             continue;
           }
           if (proj.managedMarker) {
-            const managed = await this.isManagedProjection(absPath, projRelPath === "AGENTS.md");
+            const managed = await this.isManagedProjection(absPath, projRelPath === "AGENTS.md", proj.hash);
             if (!managed) {
-              warnings.push(`user-modified projection ${projRelPath}`);
+              pushProjectionWarning(projRelPath, `user-modified projection ${projRelPath}`);
             }
           }
         }
       }
       if (manifest.projections && manifest.installed) {
-        const ownerNames = /* @__PURE__ */ new Set();
+        const ownersByHost = /* @__PURE__ */ new Map();
         for (const proj of Object.values(manifest.projections)) {
-          for (const owner of proj.owners) ownerNames.add(owner);
+          if (!_DoctorEngine.isCompoundLaneHost(proj.host)) continue;
+          const owners = ownersByHost.get(proj.host) ?? /* @__PURE__ */ new Set();
+          for (const owner of proj.owners) owners.add(owner);
+          ownersByHost.set(proj.host, owners);
         }
-        const expectedVariants = await this.renderProjectionVariants(ownerNames, manifest.installed.bundles ?? []);
-        if (expectedVariants) {
+        const variantsByHost = /* @__PURE__ */ new Map();
+        for (const [projHost, owners] of ownersByHost) {
+          const variants = await this.renderProjectionVariants(owners, manifest.installed.bundles ?? [], projHost);
+          if (variants) variantsByHost.set(projHost, variants);
+        }
+        if (variantsByHost.size > 0) {
           for (const [projRelPath, proj] of Object.entries(manifest.projections)) {
-            const absPath = path10.join(workspaceRoot, projRelPath);
-            if (!await fs8.pathExists(absPath)) continue;
+            const projHost = proj.host;
+            if (!_DoctorEngine.isCompoundLaneHost(projHost)) continue;
+            const expectedVariants = variantsByHost.get(projHost);
+            if (!expectedVariants) continue;
+            const absPath = path12.join(workspaceRoot, projRelPath);
+            if (!await fs10.pathExists(absPath)) continue;
             if (!proj.managedMarker) continue;
-            const content = await fs8.readFile(absPath, "utf8");
+            const content = await fs10.readFile(absPath, "utf8");
             if (!HostProjector.hasManagedMarker(content)) continue;
             if (proj.hash) {
-              const diskHash = `sha256:${crypto4.createHash("sha256").update(await fs8.readFile(absPath)).digest("hex")}`;
+              const diskHash = `sha256:${crypto4.createHash("sha256").update(await fs10.readFile(absPath)).digest("hex")}`;
               if (diskHash !== proj.hash) {
                 const owner = proj.owners[0];
-                warnings.push(
+                pushProjectionWarning(
+                  projRelPath,
                   `Content drift ${projRelPath} \u2014 edited after installation (recorded ${proj.hash.slice(0, 16)}\u2026, on disk ${diskHash.slice(0, 16)}\u2026).` + (owner ? ` Run: agents update ${owner} --fanout ${proj.host} to restore it.` : "")
                 );
                 continue;
@@ -2894,7 +4251,8 @@ var DoctorEngine = class {
             const onDisk = content.replace(/\r\n/g, "\n");
             if (!variants.some((variant) => variant.replace(/\r\n/g, "\n") === onDisk)) {
               const owner = proj.owners[0];
-              warnings.push(
+              pushProjectionWarning(
+                projRelPath,
                 `Outdated projection ${projRelPath} (content differs from the current render).` + (owner ? ` Run: agents update ${owner} --fanout ${proj.host} to refresh it.` : "")
               );
             }
@@ -2902,7 +4260,7 @@ var DoctorEngine = class {
         }
       }
       const installedBundles = manifest.installed?.bundles ?? [];
-      const fileOwnersOf = (rec) => rec.owners ?? (rec.bundle ? [rec.bundle] : []);
+      const fileOwnersOf = (rec) => assetOwners(rec);
       if (manifest.projections) {
         for (const [projRelPath, proj] of Object.entries(manifest.projections)) {
           for (const owner of proj.owners) {
@@ -2932,6 +4290,12 @@ var DoctorEngine = class {
       if (!clineCapability.installed) {
         warnings.push("Cline executable was not detected on PATH or via CLINE_BIN_PATH.");
       }
+    } else if (host === "claude") {
+      const probe = new ClaudeCapabilityProbe();
+      claudeCapability = await probe.probe();
+      if (!claudeCapability.installed) {
+        warnings.push("Claude Code executable was not detected on PATH or via CLAUDE_BIN_PATH.");
+      }
     }
     return {
       valid: issues.length === 0,
@@ -2942,16 +4306,17 @@ var DoctorEngine = class {
       agentsCount,
       skillsCount,
       workflowsCount,
-      clineCapability
+      clineCapability,
+      claudeCapability
     };
   }
 };
 
 // src/core/cline-launcher.ts
-import path11 from "path";
+import path13 from "path";
 import os3 from "os";
 import crypto5 from "crypto";
-import fs9 from "fs-extra";
+import fs11 from "fs-extra";
 var ClineLauncher = class _ClineLauncher {
   probe;
   runner;
@@ -2964,7 +4329,7 @@ var ClineLauncher = class _ClineLauncher {
    */
   static generateTeamName(bundleName, workspace) {
     const sanitizedBundle = bundleName.replace(/[^A-Za-z0-9_-]/g, "-");
-    const hash = crypto5.createHash("sha256").update(path11.resolve(workspace)).digest("hex").slice(0, 8);
+    const hash = crypto5.createHash("sha256").update(path13.resolve(workspace)).digest("hex").slice(0, 8);
     const prefix = `au-${sanitizedBundle}`;
     const maxPrefixLen = 64 - 9;
     const truncatedPrefix = prefix.slice(0, maxPrefixLen);
@@ -2991,16 +4356,16 @@ var ClineLauncher = class _ClineLauncher {
       workspace = os3.homedir();
     } else {
       workspace = cwd;
-      targetDir = path11.join(cwd, ".agents");
+      targetDir = path13.join(cwd, ".agents");
       scope = "project";
     }
-    const lockfilePath = path11.join(targetDir, "agents-united.json");
-    if (!await fs9.pathExists(lockfilePath)) {
+    const lockfilePath = path13.join(targetDir, "agents-united.json");
+    if (!await fs11.pathExists(lockfilePath)) {
       if (!isGlobal) {
         const globalTarget = AgentHostAdapter.resolveHostDir("global", "agents");
-        const globalLockfile = path11.join(globalTarget, "agents-united.json");
-        if (await fs9.pathExists(globalLockfile)) {
-          const gLock = await fs9.readJson(globalLockfile);
+        const globalLockfile = path13.join(globalTarget, "agents-united.json");
+        if (await fs11.pathExists(globalLockfile)) {
+          const gLock = await fs11.readJson(globalLockfile);
           if (gLock.installed?.bundles?.includes(bundleName)) {
             return this.resolveInstallation(bundleName, { ...options, global: true });
           }
@@ -3008,14 +4373,14 @@ var ClineLauncher = class _ClineLauncher {
       }
       throw new Error(`Bundle '${bundleName}' is not installed in ${scope} scope.`);
     }
-    const lockfile = await fs9.readJson(lockfilePath);
+    const lockfile = await fs11.readJson(lockfilePath);
     if (!lockfile.installed?.bundles?.includes(bundleName)) {
       throw new Error(`Bundle '${bundleName}' is not installed in ${scope} scope.`);
     }
     const hasClineFanout = (lockfile.fanout || []).includes("cline");
     const manifestRel = `.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml`;
-    const manifestPath = path11.join(workspace, manifestRel);
-    if (!hasClineFanout || !await fs9.pathExists(manifestPath)) {
+    const manifestPath = path13.join(workspace, manifestRel);
+    if (!hasClineFanout || !await fs11.pathExists(manifestPath)) {
       throw new Error(
         `Bundle '${bundleName}' is not projected to Cline. Run 'agents update ${bundleName} --fanout cline' first.`
       );
@@ -3114,15 +4479,190 @@ var ClineLauncher = class _ClineLauncher {
   }
 };
 
+// src/core/claude-launcher.ts
+import path14 from "path";
+import os4 from "os";
+import fs12 from "fs-extra";
+var DEFAULT_COORDINATOR = "orchestrator-engineering.md";
+var ClaudeLauncher = class _ClaudeLauncher {
+  probe;
+  runner;
+  constructor(probe, runner) {
+    this.probe = probe || new ClaudeCapabilityProbe();
+    this.runner = runner || defaultProcessRunner;
+  }
+  /**
+   * The `--agent` value must equal the projected coordinator definition's basename without `.md`.
+   *
+   * A projected coordinator keeps its full `orchestrator-<x>` name in `.claude/agents/`: coordinators are
+   * never `subagent-<x>` files, so the prefix stripping that applies to every specialist role is a no-op
+   * here. We still route through the projector's own helper so the launcher and the renderer can never
+   * diverge if a bundle ever declares a differently-prefixed orchestrator.
+   */
+  static resolveCoordinatorName(orchestrator) {
+    const file = (orchestrator && orchestrator.trim().length > 0 ? orchestrator.trim() : DEFAULT_COORDINATOR).replace(/\.md$/i, "");
+    return ClaudeProjector.stripSubagentPrefix(path14.basename(file));
+  }
+  /**
+   * Resolve an installed bundle for Claude Code activation. Mirrors `ClineLauncher.resolveInstallation`:
+   * same global→project fallback, same `.agents/agents-united.json` lockfile path, same error text.
+   */
+  async resolveInstallation(bundleName, options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const isGlobal = !!options.global;
+    let targetDir;
+    let scope;
+    let workspace;
+    if (isGlobal) {
+      targetDir = AgentHostAdapter.resolveHostDir("global", "agents");
+      scope = "global";
+      workspace = os4.homedir();
+    } else {
+      workspace = cwd;
+      targetDir = path14.join(cwd, ".agents");
+      scope = "project";
+    }
+    const lockfilePath = path14.join(targetDir, "agents-united.json");
+    if (!await fs12.pathExists(lockfilePath)) {
+      if (!isGlobal) {
+        const globalTarget = AgentHostAdapter.resolveHostDir("global", "agents");
+        const globalLockfile = path14.join(globalTarget, "agents-united.json");
+        if (await fs12.pathExists(globalLockfile)) {
+          const gLock = await fs12.readJson(globalLockfile);
+          if (gLock.installed?.bundles?.includes(bundleName)) {
+            return this.resolveInstallation(bundleName, { ...options, global: true });
+          }
+        }
+      }
+      throw new Error(`Bundle '${bundleName}' is not installed in ${scope} scope.`);
+    }
+    const lockfile = await fs12.readJson(lockfilePath);
+    if (!lockfile.installed?.bundles?.includes(bundleName)) {
+      throw new Error(`Bundle '${bundleName}' is not installed in ${scope} scope.`);
+    }
+    const hasClaudeFanout = (lockfile.fanout || []).includes("claude");
+    const manifestRel = `.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml`;
+    const manifestPath = path14.join(workspace, manifestRel);
+    if (!hasClaudeFanout && !await fs12.pathExists(manifestPath)) {
+      throw new Error(
+        `Bundle '${bundleName}' is not projected to Claude. Run 'agents update ${bundleName} --fanout claude' first.`
+      );
+    }
+    return {
+      scope,
+      workspace,
+      lockfile,
+      manifestPath
+    };
+  }
+  /**
+   * Plan the argv, bootstrap prompt and ephemeral environment for a Claude Code session. Pure: no process
+   * is spawned and nothing is written to disk, so `--dry-run` can call it safely.
+   */
+  planActivation(options) {
+    const {
+      bundleName,
+      workspace,
+      scope,
+      report,
+      prompt,
+      orchestrator,
+      allowAddons,
+      background,
+      teams,
+      pluginDir,
+      manifestAvailable
+    } = options;
+    const command = report.command || {
+      executable: "claude",
+      prefixArgs: [],
+      source: "path-executable"
+    };
+    const coordinatorName = _ClaudeLauncher.resolveCoordinatorName(orchestrator);
+    const homePrefix = scope === "global" ? "~/" : "";
+    const manifestRel = `${homePrefix}.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml`;
+    const coordinatorRel = `${homePrefix}.claude/agents/${coordinatorName}.md`;
+    const addonPolicyText = allowAddons ? "Addon auto-installation is pre-authorized for this session." : `Before installing any recommended addon, explain the requirement to the user and request explicit confirmation to run: agents add <addon> -t claude ${scope === "global" ? "-g " : ""}-y.`;
+    const deploymentNoteText = `Deployment note: this bundle is already projected natively for this workspace - roles in "${homePrefix}.claude/agents/", skills in "${homePrefix}.claude/skills/" and rules in "${homePrefix}.claude/rules/". The single source of truth stays the canonical store under "${homePrefix}.agents/" (ADR 0018): read the projections, edit the canonical files, never the copies.`;
+    const delegationNoteText = `Delegation on this host works by description: in an ordinary Claude Code session you name a specialist and Claude picks the matching definition from "${homePrefix}.claude/agents/". This session was started with \`claude --agent ${coordinatorName}\`, so your own projected coordinator definition runs on the main thread and the real \`Agent(...)\` allowlist in its frontmatter is what bounds the specialists you may delegate to - send work only to those exact agent type names.`;
+    const taskText = prompt && prompt.trim().length > 0 ? `User task: ${prompt.trim()}` : "Please introduce your coordinator role to the user and ask for their first task.";
+    const manifestInstruction = manifestAvailable === false ? `Read your coordinator role definition at "${coordinatorRel}" before acting. Specialist roles are discoverable by name and description from the projected definitions in "${homePrefix}.claude/agents/" (the host-neutral team manifest is not present in this workspace yet - it is written by a \`--fanout cline\` install).` : `Read the Team Manifest at "${manifestRel}" and your coordinator role definition at "${coordinatorRel}" before acting.`;
+    const bootstrapLines = [
+      `You are coordinating the "${bundleName}" team in Agents United.`,
+      manifestInstruction,
+      delegationNoteText,
+      "Use specialist roles only when necessary.",
+      addonPolicyText,
+      deploymentNoteText,
+      taskText
+    ];
+    if (teams === true) {
+      bootstrapLines.push(
+        `Agent teams are enabled for this session as an EXPERIMENTAL scaffold: spawn teammates from the projected agent types by name - the names you see in "${homePrefix}.claude/agents/" (specialists are projected with their "subagent-" prefix stripped, e.g. \`backend-architect\`). The scaffold is deliberately minimal: exactly one team per session, you are the fixed lead, there is no nested teams and no session resumption, and nothing about it is persisted to disk. Never make it load-bearing - if a teammate cannot be spawned, continue with ordinary delegated subagents using the Agent tool.`
+      );
+    }
+    const bootstrapPrompt = bootstrapLines.join("\n\n");
+    const env = {};
+    if (teams === true) {
+      env.CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS = "1";
+    }
+    const argv = [...command.prefixArgs];
+    argv.push("--agent");
+    argv.push(coordinatorName);
+    argv.push("--add-dir");
+    argv.push(workspace);
+    if (background === true) {
+      argv.push("--bg");
+    }
+    if (pluginDir) {
+      argv.push("--plugin-dir");
+      argv.push(pluginDir);
+    }
+    argv.push(bootstrapPrompt);
+    return {
+      bundleName,
+      scope,
+      workspace,
+      executable: command.executable,
+      argv,
+      bootstrapPrompt,
+      env
+    };
+  }
+  /**
+   * Launch the Claude Code session from the argv array. Mirrors `ClineLauncher.launch`: `shell: false`
+   * (never `shell: true`), `stdio: 'inherit'`, and the plan's ephemeral env merged over `process.env`.
+   */
+  async launch(plan) {
+    const { spawn } = await import("child_process");
+    const child = spawn(plan.executable, plan.argv, {
+      cwd: plan.workspace,
+      stdio: "inherit",
+      shell: false,
+      env: { ...process.env, ...plan.env }
+    });
+    await new Promise((resolve, reject) => {
+      child.on("error", reject);
+      child.on("exit", (code) => {
+        if (code === 0 || code === null) {
+          resolve();
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+};
+
 // src/core/prerequisites.ts
-import path13 from "path";
-import os5 from "os";
-import fs11 from "fs-extra";
+import path16 from "path";
+import os6 from "os";
+import fs14 from "fs-extra";
 
 // src/core/mcp-locations.ts
-import path12 from "path";
-import os4 from "os";
-import fs10 from "fs-extra";
+import path15 from "path";
+import os5 from "os";
+import fs13 from "fs-extra";
 var McpLocationRegistry = class _McpLocationRegistry {
   /**
    * Declarative catalog of known MCP configuration files across AI tools, CLIs, extensions, and workspaces.
@@ -3134,7 +4674,7 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "gemini",
       category: "cli",
       label: "Google Antigravity & Gemini Global Config",
-      resolvePath: (_, home) => path12.join(home, ".gemini", "config", "mcp_config.json"),
+      resolvePath: (_, home) => path15.join(home, ".gemini", "config", "mcp_config.json"),
       isPrimary: true
     },
     {
@@ -3142,21 +4682,21 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "gemini",
       category: "desktop",
       label: "Google Antigravity System Config",
-      resolvePath: (_, home) => path12.join(home, ".gemini", "antigravity", "mcp_config.json")
+      resolvePath: (_, home) => path15.join(home, ".gemini", "antigravity", "mcp_config.json")
     },
     {
       id: "antigravity-workspace",
       host: "gemini",
       category: "workspace",
       label: "Google Antigravity Local Workspace Config",
-      resolvePath: (cwd) => path12.join(cwd, ".gemini", "config", "mcp_config.json")
+      resolvePath: (cwd) => path15.join(cwd, ".gemini", "config", "mcp_config.json")
     },
     {
       id: "gemini-appdata",
       host: "gemini",
       category: "cli",
       label: "Google Gemini AppData Config",
-      resolvePath: (_, __, appData) => path12.join(appData, "gemini", "config", "mcp_config.json")
+      resolvePath: (_, __, appData) => path15.join(appData, "gemini", "config", "mcp_config.json")
     },
     // --- Cline CLI & VS Code Extension ---
     {
@@ -3164,7 +4704,7 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "cline",
       category: "cli",
       label: "Cline CLI MCP Settings",
-      resolvePath: (_, home) => path12.join(home, ".cline", "data", "settings", "cline_mcp_settings.json"),
+      resolvePath: (_, home) => path15.join(home, ".cline", "data", "settings", "cline_mcp_settings.json"),
       isPrimary: true
     },
     {
@@ -3172,42 +4712,42 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "cline",
       category: "extension",
       label: "Cline VS Code Extension Global Settings",
-      resolvePath: (_, __, appData) => path12.join(appData, "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+      resolvePath: (_, __, appData) => path15.join(appData, "Code", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
     },
     {
       id: "cline-insiders-extension-settings",
       host: "cline",
       category: "extension",
       label: "Cline VS Code Insiders Extension Settings",
-      resolvePath: (_, __, appData) => path12.join(appData, "Code - Insiders", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
+      resolvePath: (_, __, appData) => path15.join(appData, "Code - Insiders", "User", "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json")
     },
     {
       id: "cline-legacy-settings",
       host: "cline",
       category: "cli",
       label: "Cline Home Legacy Settings",
-      resolvePath: (_, home) => path12.join(home, ".cline", "settings", "cline_mcp_settings.json")
+      resolvePath: (_, home) => path15.join(home, ".cline", "settings", "cline_mcp_settings.json")
     },
     {
       id: "cline-home-flat",
       host: "cline",
       category: "cli",
       label: "Cline Home Flat Settings",
-      resolvePath: (_, home) => path12.join(home, "cline_mcp_settings.json")
+      resolvePath: (_, home) => path15.join(home, "cline_mcp_settings.json")
     },
     {
       id: "cline-workspace-flat",
       host: "cline",
       category: "workspace",
       label: "Cline Workspace Settings",
-      resolvePath: (cwd) => path12.join(cwd, "cline_mcp_settings.json")
+      resolvePath: (cwd) => path15.join(cwd, "cline_mcp_settings.json")
     },
     {
       id: "cline-workspace-dot",
       host: "cline",
       category: "workspace",
       label: "Cline Workspace .cline/mcp.json",
-      resolvePath: (cwd) => path12.join(cwd, ".cline", "mcp.json")
+      resolvePath: (cwd) => path15.join(cwd, ".cline", "mcp.json")
     },
     // --- Roo Code Extension ---
     {
@@ -3215,7 +4755,7 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "cline",
       category: "extension",
       label: "Roo Code VS Code Extension Settings",
-      resolvePath: (_, __, appData) => path12.join(appData, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json")
+      resolvePath: (_, __, appData) => path15.join(appData, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json")
     },
     // --- Cursor IDE / CLI ---
     {
@@ -3223,7 +4763,7 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "cursor",
       category: "workspace",
       label: "Cursor Workspace Config",
-      resolvePath: (cwd) => path12.join(cwd, ".cursor", "mcp.json"),
+      resolvePath: (cwd) => path15.join(cwd, ".cursor", "mcp.json"),
       isPrimary: true
     },
     {
@@ -3231,7 +4771,7 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "cursor",
       category: "desktop",
       label: "Cursor Global User Config",
-      resolvePath: (_, home) => path12.join(home, ".cursor", "mcp.json")
+      resolvePath: (_, home) => path15.join(home, ".cursor", "mcp.json")
     },
     // --- Claude Code CLI & Claude Desktop ---
     {
@@ -3239,7 +4779,7 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "claude",
       category: "workspace",
       label: "Claude Code Workspace Config",
-      resolvePath: (cwd) => path12.join(cwd, ".claude", "mcp.json"),
+      resolvePath: (cwd) => path15.join(cwd, ".claude", "mcp.json"),
       isPrimary: true
     },
     {
@@ -3247,28 +4787,28 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "claude",
       category: "workspace",
       label: "Claude Workspace claude.json",
-      resolvePath: (cwd) => path12.join(cwd, "claude.json")
+      resolvePath: (cwd) => path15.join(cwd, "claude.json")
     },
     {
       id: "claude-global-dot",
       host: "claude",
       category: "cli",
       label: "Claude Code Global Config",
-      resolvePath: (_, home) => path12.join(home, ".claude", "mcp.json")
+      resolvePath: (_, home) => path15.join(home, ".claude", "mcp.json")
     },
     {
       id: "claude-global-flat",
       host: "claude",
       category: "cli",
       label: "Claude Code Global claude.json",
-      resolvePath: (_, home) => path12.join(home, "claude.json")
+      resolvePath: (_, home) => path15.join(home, "claude.json")
     },
     {
       id: "claude-desktop-global",
       host: "claude",
       category: "desktop",
       label: "Claude Desktop Global Config",
-      resolvePath: (_, __, appData) => path12.join(appData, "Claude", "claude_desktop_config.json")
+      resolvePath: (_, __, appData) => path15.join(appData, "Claude", "claude_desktop_config.json")
     },
     // --- Windsurf IDE ---
     {
@@ -3276,7 +4816,7 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "windsurf",
       category: "desktop",
       label: "Windsurf Global Config",
-      resolvePath: (_, home) => path12.join(home, ".codeium", "windsurf", "mcp_config.json"),
+      resolvePath: (_, home) => path15.join(home, ".codeium", "windsurf", "mcp_config.json"),
       isPrimary: true
     },
     {
@@ -3284,7 +4824,7 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "windsurf",
       category: "desktop",
       label: "Windsurf AppData Config",
-      resolvePath: (_, __, appData) => path12.join(appData, "Windsurf", "mcp_config.json")
+      resolvePath: (_, __, appData) => path15.join(appData, "Windsurf", "mcp_config.json")
     },
     // --- OpenCode & Codex ---
     {
@@ -3292,7 +4832,7 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "opencode",
       category: "workspace",
       label: "OpenCode Workspace Config",
-      resolvePath: (cwd) => path12.join(cwd, ".opencode", "mcp.json"),
+      resolvePath: (cwd) => path15.join(cwd, ".opencode", "mcp.json"),
       isPrimary: true
     },
     {
@@ -3300,28 +4840,28 @@ var McpLocationRegistry = class _McpLocationRegistry {
       host: "opencode",
       category: "cli",
       label: "OpenCode Global Config",
-      resolvePath: (_, home) => path12.join(home, ".config", "opencode", "mcp.json")
+      resolvePath: (_, home) => path15.join(home, ".config", "opencode", "mcp.json")
     }
   ];
   /**
    * Discovers all MCP configuration files across the filesystem, inspecting existence and parsing server definitions.
    */
   static async discoverAll(cwd = process.cwd()) {
-    const homeDir = os4.homedir();
-    const appData = process.env.APPDATA || (process.platform === "darwin" ? path12.join(homeDir, "Library", "Application Support") : path12.join(homeDir, ".config"));
+    const homeDir = os5.homedir();
+    const appData = process.env.APPDATA || (process.platform === "darwin" ? path15.join(homeDir, "Library", "Application Support") : path15.join(homeDir, ".config"));
     const results = [];
     const seenPaths = /* @__PURE__ */ new Set();
     for (const desc of _McpLocationRegistry.LOCATIONS) {
-      const resolved = path12.normalize(desc.resolvePath(cwd, homeDir, appData));
+      const resolved = path15.normalize(desc.resolvePath(cwd, homeDir, appData));
       const key = resolved.toLowerCase();
       if (seenPaths.has(key)) continue;
       seenPaths.add(key);
-      const exists = await fs10.pathExists(resolved);
+      const exists = await fs13.pathExists(resolved);
       let serverCount = 0;
       let servers;
       if (exists) {
         try {
-          const config = await fs10.readJson(resolved);
+          const config = await fs13.readJson(resolved);
           const rawServers = config?.mcpServers || config?.servers || config;
           if (rawServers && typeof rawServers === "object") {
             servers = rawServers;
@@ -3356,14 +4896,14 @@ var McpLocationRegistry = class _McpLocationRegistry {
    * Resolves the primary target write path for a given host runtime.
    */
   static getPrimaryWritePath(host, cwd = process.cwd()) {
-    const homeDir = os4.homedir();
-    const appData = process.env.APPDATA || (process.platform === "darwin" ? path12.join(homeDir, "Library", "Application Support") : path12.join(homeDir, ".config"));
+    const homeDir = os5.homedir();
+    const appData = process.env.APPDATA || (process.platform === "darwin" ? path15.join(homeDir, "Library", "Application Support") : path15.join(homeDir, ".config"));
     const targetHost = host === "agents" ? "gemini" : host;
     const desc = _McpLocationRegistry.LOCATIONS.find((l) => l.host === targetHost && l.isPrimary);
     if (desc) {
-      return path12.normalize(desc.resolvePath(cwd, homeDir, appData));
+      return path15.normalize(desc.resolvePath(cwd, homeDir, appData));
     }
-    return path12.normalize(path12.join(cwd, ".cursor", "mcp.json"));
+    return path15.normalize(path15.join(cwd, ".cursor", "mcp.json"));
   }
 };
 
@@ -3478,21 +5018,21 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
         });
       }
     }
-    const homeDir = os5.homedir();
+    const homeDir = os6.homedir();
     const dirCandidates = [
-      path13.join(cwd, ".gemini", "antigravity", "mcp"),
-      path13.join(homeDir, ".gemini", "antigravity", "mcp")
+      path16.join(cwd, ".gemini", "antigravity", "mcp"),
+      path16.join(homeDir, ".gemini", "antigravity", "mcp")
     ];
     for (const dir of dirCandidates) {
-      if (await fs11.pathExists(dir)) {
-        const entries = await fs11.readdir(dir).catch(() => []);
+      if (await fs14.pathExists(dir)) {
+        const entries = await fs14.readdir(dir).catch(() => []);
         for (const entry of entries) {
           if (_PrerequisiteChecker.matchesMcpServer(mcpName, entry, {})) {
             foundInConfigs.push({
               id: "antigravity-dir",
               host: "gemini",
               label: "Google Antigravity MCP Directory",
-              path: path13.join(dir, entry),
+              path: path16.join(dir, entry),
               disabled: false,
               serverKey: entry
             });
@@ -3517,14 +5057,14 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
    * Checks if an npm package is installed in node_modules or declared in package.json
    */
   static async isPackageInstalled(pkgName, cwd = process.cwd()) {
-    const modulePath = path13.join(cwd, "node_modules", ...pkgName.split("/"));
-    if (await fs11.pathExists(modulePath)) {
+    const modulePath = path16.join(cwd, "node_modules", ...pkgName.split("/"));
+    if (await fs14.pathExists(modulePath)) {
       return { installed: true, location: modulePath };
     }
-    const pkgJsonPath = path13.join(cwd, "package.json");
-    if (await fs11.pathExists(pkgJsonPath)) {
+    const pkgJsonPath = path16.join(cwd, "package.json");
+    if (await fs14.pathExists(pkgJsonPath)) {
       try {
-        const pkg = await fs11.readJson(pkgJsonPath);
+        const pkg = await fs14.readJson(pkgJsonPath);
         const deps = {
           ...pkg.dependencies,
           ...pkg.devDependencies,
@@ -3547,20 +5087,20 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
       return { set: true, source: "process.env" };
     }
     const envFiles = [
-      path13.join(cwd, ".env.local"),
-      path13.join(cwd, ".env")
+      path16.join(cwd, ".env.local"),
+      path16.join(cwd, ".env")
     ];
     for (const envFile of envFiles) {
-      if (await fs11.pathExists(envFile)) {
+      if (await fs14.pathExists(envFile)) {
         try {
-          const content = await fs11.readFile(envFile, "utf8");
+          const content = await fs14.readFile(envFile, "utf8");
           const lines = content.split("\n");
           for (const line of lines) {
             const trimmed = line.trim();
             if (trimmed.startsWith("#") || !trimmed.includes("=")) continue;
             const [k, ...v] = trimmed.split("=");
             if (k.trim() === varName && v.join("=").trim() !== "") {
-              return { set: true, source: path13.basename(envFile) };
+              return { set: true, source: path16.basename(envFile) };
             }
           }
         } catch {
@@ -3766,11 +5306,11 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
    * activating disabled servers and appending missing definitions.
    */
   static async autoConfigureConfigFile(targetFilePath, mcpNames, mode = "operational", envVars = {}) {
-    await fs11.ensureDir(path13.dirname(targetFilePath));
+    await fs14.ensureDir(path16.dirname(targetFilePath));
     let existingConfig = {};
-    if (await fs11.pathExists(targetFilePath)) {
+    if (await fs14.pathExists(targetFilePath)) {
       try {
-        existingConfig = await fs11.readJson(targetFilePath);
+        existingConfig = await fs14.readJson(targetFilePath);
       } catch {
         existingConfig = {};
       }
@@ -3802,7 +5342,7 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
     } else {
       existingConfig.mcpServers = existingServers;
     }
-    await fs11.writeJson(targetFilePath, existingConfig, { spaces: 2 });
+    await fs14.writeJson(targetFilePath, existingConfig, { spaces: 2 });
     return {
       success: true,
       targetFile: targetFilePath,
@@ -3847,7 +5387,7 @@ var updater = new UpdateEngine(registry, scanner, installer);
 function detectWorkspaceHosts(cwd = process.cwd()) {
   const detected = [];
   for (const host of Object.values(HOST_REGISTRY)) {
-    const found = host.detectionMarkers.some((marker) => fs12.pathExistsSync(path14.join(cwd, marker)));
+    const found = host.detectionMarkers.some((marker) => fs15.pathExistsSync(path17.join(cwd, marker)));
     if (found) detected.push(host.id);
   }
   return detected;
@@ -4078,7 +5618,7 @@ var BUNDLE_DISPLAY_NAMES = {
     summary: "Complete suite with all 7 team leads, 38 agents, and all 160 modular skills & workflows"
   }
 };
-cli.command("add [identifier]", "Add a bundle, agent, skill, or workflow to project or global configuration").option("-g, --global", "Install globally into home directory (~/.agents/)").option("-s, --symlink", "Create symbolic links to central registry cache (default / recommended)").option("--copy", "Create independent standalone copies of asset files").option("-t, --target <hosts>", "Which assistants to set up (agents = main library; claude, cursor, cline, opencode, codex get translated copies)", { default: "agents" }).option("--fanout <hosts>", "Also make translated copies for these assistants: claude, cursor, cline, opencode, codex").option("--mode <mode>", "Execution mode for organization bundles (operational | brainstorming)", { default: "operational" }).option("--allow-missing-prereqs", "Proceed with installation even if some prerequisites are missing").option("--allow-under-construction", "Allow installation of bundles marked as under construction").option("-y, --yes", "Skip confirmation prompts").option("-f, --force", "Force overwrite user modified files").option("--start", "Start the installed team in Cline immediately after setup").option("--dry-run", "Simulate installation without writing files").action(async (targetIdentifier, options = {}) => {
+cli.command("add [identifier]", "Add a bundle, agent, skill, or workflow to project or global configuration").option("-g, --global", "Install globally into home directory (~/.agents/)").option("-s, --symlink", "Create symbolic links to central registry cache (default / recommended)").option("--copy", "Create independent standalone copies of asset files").option("-t, --target <hosts>", "Which assistants to set up (agents = main library; claude, cursor, cline, opencode, codex get translated copies)", { default: "agents" }).option("--fanout <hosts>", "Also make translated copies for these assistants: claude, cline. Under Development hosts (cursor, opencode, codex) are refused").option("--plugin", "Claude lane only: also emit the distribution-only plugin package (.agents/plugins/<bundle>/.claude-plugin/plugin.json + agents/) for `claude --plugin-dir`. Adds nothing when --fanout claude is absent; never the behavioural source. Sticky: the opt-in is recorded in the lockfile, so `agents update` keeps it. Use --no-plugin to turn it back off.").option("--mode <mode>", "Execution mode for organization bundles (operational | brainstorming)", { default: "operational" }).option("--allow-missing-prereqs", "Proceed with installation even if some prerequisites are missing").option("--allow-under-construction", "Allow installation of bundles marked as under construction").option("-y, --yes", "Skip confirmation prompts").option("-f, --force", "Force overwrite user modified files").option("--start", "Start the installed team in Cline immediately after setup").option("--dry-run", "Simulate installation without writing files").action(async (targetIdentifier, options = {}) => {
   intro(pc.cyan("Agents United \u2014 AI Agent Ecosystem"));
   let identifier = targetIdentifier;
   let scope = options.global ? "global" : "project";
@@ -4112,6 +5652,14 @@ cli.command("add [identifier]", "Add a bundle, agent, skill, or workflow to proj
       );
     }
     fanout = Array.from(/* @__PURE__ */ new Set([...fanout, ...parsedFanout.filter((h) => isKnownHost(h) && HOST_REGISTRY[h].projectionCapable)]));
+    const underDevFanout = Array.from(new Set(parsedFanout.filter((h) => isKnownHost(h) && HOST_REGISTRY[h].status === "under-development")));
+    if (underDevFanout.length > 0) {
+      note(
+        `Refusing --fanout host(s): ${underDevFanout.join(", ")} \u2014 they are listed as Under Development and unavailable. Supported --fanout ids: ${SUPPORTED_HOST_IDS.filter((h) => HOST_REGISTRY[h].projectionCapable).join(", ")}. Drop ${underDevFanout.join(", ")} from --fanout and run again.`,
+        "Host unavailable"
+      );
+      process.exit(1);
+    }
   }
   const isInteractive = process.stdout.isTTY && !options.yes;
   if (isInteractive && !options.global && !options.copy && !options.symlink && options.target === "agents") {
@@ -4122,6 +5670,7 @@ cli.command("add [identifier]", "Add a bundle, agent, skill, or workflow to proj
         "Workspace Environment Discovery"
       );
     }
+    note(hostAvailabilityNotice(), "Host availability");
     const hostSelection = await multiselect({
       message: "1. Which AI tools should we configure agent teams & personas for?",
       options: [
@@ -4135,33 +5684,18 @@ cli.command("add [identifier]", "Add a bundle, agent, skill, or workflow to proj
           label: HOST_REGISTRY.claude.label,
           hint: detectedHosts.includes("claude") ? "found in this project" : "orchestrator & subagent personas for Claude Code"
         },
-        {
-          value: "cursor",
-          label: HOST_REGISTRY.cursor.label,
-          hint: detectedHosts.includes("cursor") ? "found in this project" : "orchestrator & subagent personas for Cursor IDE"
-        },
         {
           value: "cline",
           label: HOST_REGISTRY.cline.label,
           hint: detectedHosts.includes("cline") ? "found in this project" : "configured agents, skills, rules, workflows & team manifests for Cline"
         },
-        {
-          value: "opencode",
-          label: HOST_REGISTRY.opencode.label,
-          hint: detectedHosts.includes("opencode") ? "found in this project" : "orchestrator & subagent personas for OpenCode"
-        },
-        {
-          value: "codex",
-          label: HOST_REGISTRY.codex.label,
-          hint: detectedHosts.includes("codex") ? "found in this project" : "root index linking orchestrators, subagents & skills for Codex, Copilot, Aider & Zed"
-        },
         {
           value: "gemini",
           label: HOST_REGISTRY.gemini.label,
           hint: detectedHosts.includes("gemini") ? "found in this project" : "older Antigravity 1.0 / Gemini folder"
         }
       ],
-      initialValues: detectedHosts.length > 0 ? detectedHosts : ["agents"],
+      initialValues: detectedHosts.length > 0 ? detectedHosts.filter((h) => HOST_REGISTRY[h]?.status === "supported") : ["agents"],
       required: true
     });
     if (Array.isArray(hostSelection) && hostSelection.length > 0) {
@@ -4466,6 +6000,10 @@ To bypass this gate and install draft assets anyway, pass: --allow-under-constru
       method,
       hosts,
       fanout,
+      // Plan 016 decision 13 — opt-in Claude plugin lane (distribution-only; ignored unless the
+      // claude lane runs). `--plugin` opts in, `--no-plugin` opts out explicitly, and an omitted
+      // flag inherits the recorded choice so `agents update` cannot prune the package.
+      pluginLane: typeof options.plugin === "boolean" ? options.plugin : void 0,
       mode: executionMode,
       allowMissingPrereqs: options.allowMissingPrereqs,
       yes: options.yes,
@@ -4589,6 +6127,14 @@ rules & workflows run: agents update ${identifier} --fanout cline
         "Adaptive Tooling"
       );
     }
+    if (!options.dryRun) {
+      note(
+        pc.yellow(
+          "New skills are discovered at session start. To pick them up now:\n  Claude Code ..... user types /reload-skills (#58733)\n  Antigravity CLI . user types /skills reload\n  Antigravity App . restart the app, or use @<skill_name>\n  Cline ........... agents read .cline/skills/ directly\nSlash commands only fire when YOU type them; agents can read the file."
+        ),
+        "Pick up new skills"
+      );
+    }
     outro(pc.green(`\u2714 Installed "${identifier}" successfully!`));
   } catch (err) {
     s.stop(pc.red("Failed resolution"));
@@ -4656,10 +6202,25 @@ cli.command("remove [identifier]", "Remove an installed bundle, agent, skill, or
     });
     s.stop(`Uninstall processed`);
     if (options.dryRun) {
-      outro(pc.yellow(`[DRY RUN] Would remove ${result.removed.length} assets from ${result.targetDirs.join(", ")}`));
+      outro(pc.yellow(
+        `[DRY RUN] Would delete ${result.removed.length} and keep ${result.kept.length}` + (result.kept.length > 0 ? ` (still owned by: ${result.retainedOwners.join(", ")})` : "") + ` \u2014 ${result.targetDirs.join(", ")}`
+      ));
       return;
     }
-    outro(pc.green(`\u2714 Successfully removed ${result.removed.length} files matching "${identifier}"`));
+    if (result.kept.length > 0) {
+      log.info(`${result.removed.length} deleted \xB7 ${result.kept.length} kept \u2014 still owned by: ${result.retainedOwners.join(", ")}`);
+    }
+    if (result.removed.length > 0) {
+      const sample = result.removed.slice(0, 3).join(", ");
+      const more = result.removed.length > 3 ? `, \u2026 +${result.removed.length - 3} more` : "";
+      log.info(`deleted: ${sample}${more}`);
+    }
+    if (result.staleRecords.length > 0) {
+      log.info(`${result.staleRecords.length} stale record(s) cleaned \u2014 bookkeeping only, those files were already gone`);
+    }
+    outro(pc.green(
+      result.removed.length === 0 && result.kept.length > 0 ? `\u2714 Removed "${identifier}" from this workspace \u2014 nothing was deleted, ${result.kept.length} co-owned assets kept` : `\u2714 Removed "${identifier}" from this workspace \u2014 ${result.removed.length} deleted, ${result.kept.length} kept`
+    ));
   } catch (err) {
     s.stop(pc.red("Uninstall failed"));
     outro(pc.red(`Error: ${err.message}`));
@@ -4681,6 +6242,16 @@ cli.command("update [identifier]", "Update installed packages to upstream regist
         "Invalid fanout"
       );
     }
+    const updateUnderDev = Array.from(new Set(parsedFanout.filter((h) => isKnownHost(h) && HOST_REGISTRY[h].status === "under-development")));
+    if (updateUnderDev.length > 0) {
+      note(
+        pc.yellow(
+          `Refusing --fanout host(s): ${updateUnderDev.join(", ")} \u2014 they are listed as Under Development and unavailable. Supported --fanout ids: ${SUPPORTED_HOST_IDS.filter((h) => HOST_REGISTRY[h].projectionCapable).join(", ")}. Drop ${updateUnderDev.join(", ")} from --fanout and run again.`
+        ),
+        "Host unavailable"
+      );
+      process.exit(1);
+    }
     updateFanout = parsedFanout.filter((h) => isKnownHost(h) && HOST_REGISTRY[h].projectionCapable);
   }
   const s = spinner();
@@ -4803,7 +6374,7 @@ Updates Available: ${report.outdatedCount > 0 ? pc.yellow(pc.bold(`${report.outd
       const unprojected = [];
       for (const rec of result.updated) {
         try {
-          const lf = await fs12.readJson(path14.join(rec.targetDir, "agents-united.json"));
+          const lf = await fs15.readJson(path17.join(rec.targetDir, "agents-united.json"));
           if (!lf.fanout || lf.fanout.length === 0) unprojected.push(rec.name);
         } catch {
         }
@@ -5242,6 +6813,12 @@ Planned Capabilities:
         method: "symlink"
       });
       installSpinner.stop(pc.green(`\u2714 Successfully installed ${bundle.name}!`));
+      note(
+        pc.yellow(
+          "New skills are discovered at session start. To pick them up now:\n  Claude Code ..... user types /reload-skills (#58733)\n  Antigravity CLI . user types /skills reload\n  Antigravity App . restart the app, or use @<skill_name>\n  Cline ........... agents read .cline/skills/ directly\nSlash commands only fire when YOU type them; agents can read the file."
+        ),
+        "Pick up new skills"
+      );
       note(
         formatInstallationSummary({
           bundleName: result.installed.targetBundle || bundle.name,
@@ -5537,11 +7114,19 @@ cli.command("init", "Initialize project workspace directory and install recommen
     process.exit(1);
   }
 });
-cli.command("start <bundle> [prompt]", "Start an installed bundle team in its host runtime (e.g. Cline)").option("--host <host>", "Host runtime (default: auto-detect from lockfile fanout)").option("-g, --global", "Select global installation").option("--team <name>", "Override generated team name").option("--allow-addons", "Pre-authorize recommended addon installations for this session").option("--headless", "Run non-interactively without interactive TUI").option("--dry-run", "Print activation resolution and argv summary without launching").action(async (bundle, prompt, options = {}) => {
+cli.command("start <bundle> [prompt]", "Start an installed bundle team in its host runtime (e.g. Cline, Claude Code)").option("--host <host>", "Host runtime (default: auto-detect from lockfile fanout)").option("-g, --global", "Select global installation").option("--team <name>", "Override generated team name").option("--allow-addons", "Pre-authorize recommended addon installations for this session").option("--headless", "Run non-interactively without interactive TUI").option("--bg", "Run the Claude Code session in the background (claude host only)").option("--teams", "Force the experimental agent-teams scaffold on (claude host only). Default: ON for organization-tier (Tier 2) bundles, OFF for domain-tier (Tier 1) bundles \u2014 pass --no-teams to opt out. Ephemeral env only, nothing persisted").option("--plugin", "Pass --plugin-dir with the bundle plugin root (claude host only)").option("--dry-run", "Print activation resolution and argv summary without launching").action(async (bundle, prompt, options = {}) => {
   intro(pc.cyan("Agents United \u2014 Runtime Activation"));
   const launcher = new ClineLauncher();
   const probe = new ClineCapabilityProbe();
   try {
+    const effectiveHost = await resolveStartHost(bundle, options);
+    if (effectiveHost === "claude") {
+      await runClaudeStart(bundle, prompt, options);
+      return;
+    }
+    if (effectiveHost === "unsupported") {
+      note(pc.yellow(`Host '${options.host}' has no activation launcher yet; falling back to the Cline lane.`), "Host Runtime");
+    }
     const resolution = await launcher.resolveInstallation(bundle, {
       global: options.global,
       cwd: process.cwd()
@@ -5552,6 +7137,7 @@ cli.command("start <bundle> [prompt]", "Start an installed bundle team in its ho
       process.exit(1);
     }
     const bundleDef = await registry.getBundle(bundle);
+    const organizationTier = bundleDef?.tier === "organization";
     const plan = launcher.planActivation({
       bundleName: bundle,
       workspace: resolution.workspace,
@@ -5566,6 +7152,8 @@ cli.command("start <bundle> [prompt]", "Start an installed bundle team in its ho
     if (options.dryRun) {
       note(
         `Bundle: ${plan.bundleName}
+Tier: ${bundleDef?.tier ?? "not declared (Tier-1 domain default)"}
+Agent teams: ${organizationTier ? "not available on this host (claude-only runtime feature)" : "no"}
 Scope: ${plan.scope}
 Workspace: ${plan.workspace}
 Team Name: ${plan.teamName}
@@ -5577,6 +7165,16 @@ Argv: ${plan.argv.map((a) => a.includes(" ") || a.includes("\n") ? `"${a.replace
       outro(pc.yellow("Dry run complete. No processes launched."));
       return;
     }
+    if (organizationTier) {
+      note(
+        pc.yellow(
+          `"${bundle}" is an organization-tier (Tier 2) bundle. Agent Teams is a Claude Code runtime
+feature and is not available on this host, so '--teams' is claude-only. This session runs
+Cline's ${plan.strategy} strategy with the projected specialist tools under .cline/agents/.`
+        ),
+        "Tier 2 (organization)"
+      );
+    }
     note(
       `Team: ${pc.bold(plan.teamName)}
 Strategy: ${pc.cyan(plan.strategy)}
@@ -5590,7 +7188,7 @@ Workspace: ${plan.workspace}`,
     process.exit(1);
   }
 });
-cli.command("doctor", "Verify health of installed agents, frontmatter schemas, and hooks").option("--host <host>", "Audit specific host runtime (e.g. cline)").action(async (options = {}) => {
+cli.command("doctor", "Verify health of installed agents, frontmatter schemas, and hooks").option("--host <host>", "Audit specific host runtime (e.g. cline, claude)").action(async (options = {}) => {
   intro(pc.cyan("\u{1FA7A} Agents United \u2014 Health Doctor"));
   const report = await DoctorEngine.runDoctor(void 0, options.host);
   if (!report.isInitialized || report.agentsCount === 0 && report.skillsCount === 0 && report.workflowsCount === 0 && report.issues.length === 0) {
@@ -5612,6 +7210,13 @@ cli.command("doctor", "Verify health of installed agents, frontmatter schemas, a
       console.log(`  Named Teams: ${report.clineCapability.namedTeams ? pc.green("\u2714 Supported") : pc.yellow("\u2716 Unsupported (Adaptive fallback)")}
 `);
     }
+    if (report.claudeCapability) {
+      renderClaudeCapabilityBlock(report.claudeCapability);
+      for (const diagnostic of report.claudeCapability.diagnostics) {
+        console.log(`  ${pc.dim(diagnostic)}`);
+      }
+      console.log();
+    }
     if (report.warnings.length > 0) {
       console.log(pc.yellow(pc.bold("\u26A0\uFE0F  Warnings:")));
       report.warnings.forEach((w) => console.log(`  \u26A0 ${w}`));
@@ -5632,6 +7237,11 @@ cli.command("doctor", "Verify health of installed agents, frontmatter schemas, a
     }
     console.log(`  Named Teams: ${report.clineCapability.namedTeams ? pc.green("\u2714 Supported") : pc.yellow("\u2716 Unsupported (Adaptive fallback)")}`);
     console.log(`  Configured Agents: ${report.agentsCount} active natively in any Cline session ("agents start" = optional team-session launcher)
+`);
+  }
+  if (report.claudeCapability) {
+    renderClaudeCapabilityBlock(report.claudeCapability);
+    console.log(`  Configured Agents: ${report.agentsCount} projected into .claude/agents/ ("agents start --host claude" = optional launcher)
 `);
   }
   if (report.issues.length > 0) {
@@ -5651,15 +7261,176 @@ cli.command("doctor", "Verify health of installed agents, frontmatter schemas, a
     process.exit(1);
   }
 });
+async function resolveStartHost(bundle, options) {
+  const explicitHost = typeof options.host === "string" ? options.host.trim().toLowerCase() : "";
+  if (explicitHost === "claude") {
+    return "claude";
+  }
+  if (explicitHost === "cline") {
+    return "cline";
+  }
+  if (explicitHost.length > 0) {
+    return "unsupported";
+  }
+  let recordedFanout = [];
+  try {
+    const detection = await new ClaudeLauncher().resolveInstallation(bundle, {
+      global: options.global,
+      cwd: process.cwd()
+    });
+    recordedFanout = detection.lockfile.fanout || [];
+  } catch {
+    recordedFanout = [];
+  }
+  return recordedFanout.includes("claude") ? "claude" : "cline";
+}
+function resolveClaudeTeamsPosture(teamsOption, tier) {
+  if (teamsOption === true) return { active: true, reason: "explicit", tier };
+  if (teamsOption === false) return { active: false, reason: "opt-out", tier };
+  if (tier === "organization") return { active: true, reason: "tier-default", tier };
+  if (tier === "domain") return { active: false, reason: "domain-tier", tier };
+  return { active: false, reason: "unresolved-tier" };
+}
+function describeClaudeTeamsPosture(posture) {
+  switch (posture.reason) {
+    case "explicit":
+      return "explicit --teams";
+    case "tier-default":
+      return "default for tier 'organization'";
+    case "opt-out":
+      return "--no-teams opt-out";
+    case "domain-tier":
+      return "tier 'domain' \u2014 pass --teams to enable";
+    case "unresolved-tier":
+      return "no declared tier (Tier-1 domain default) \u2014 pass --teams to enable";
+  }
+}
+async function runClaudeStart(bundle, prompt, options) {
+  const launcher = new ClaudeLauncher();
+  const probe = new ClaudeCapabilityProbe();
+  const resolution = await launcher.resolveInstallation(bundle, {
+    global: options.global,
+    cwd: process.cwd()
+  });
+  const probeReport = await probe.probe();
+  if (!probeReport.installed && !options.dryRun) {
+    outro(pc.red(`Claude Code executable was not found on PATH or via CLAUDE_BIN_PATH. Please install Claude Code or ensure it is accessible.`));
+    process.exit(1);
+  }
+  const bundleDef = await registry.getBundle(bundle);
+  const teamsPosture = resolveClaudeTeamsPosture(options.teams, bundleDef?.tier);
+  const teamsActive = teamsPosture.active;
+  const manifestAvailable = await fs15.pathExists(resolution.manifestPath);
+  const pluginDir = options.plugin ? path17.join(".agents", "plugins", bundle).split(path17.sep).join("/") : void 0;
+  const plan = launcher.planActivation({
+    bundleName: bundle,
+    workspace: resolution.workspace,
+    scope: resolution.scope,
+    report: probeReport,
+    prompt,
+    orchestrator: bundleDef?.orchestrator,
+    allowAddons: options.allowAddons,
+    background: options.bg,
+    teams: teamsActive,
+    pluginDir,
+    manifestAvailable
+  });
+  const recordedFanout = resolution.lockfile.fanout || [];
+  if (options.dryRun) {
+    note(renderClaudeActivationPlan(plan, probeReport, recordedFanout, teamsPosture), "Claude Activation Plan (dry run)");
+    outro(pc.yellow("Dry run complete. No processes launched."));
+    return;
+  }
+  if (!recordedFanout.includes("claude")) {
+    note(
+      pc.yellow(
+        `This workspace records fanout [${recordedFanout.join(", ") || "none"}]. Run
+'agents update ${bundle} --fanout claude' to project .claude/agents/ before the session needs it.`
+      ),
+      "Claude Projection"
+    );
+  }
+  if (teamsActive && teamsPosture.reason === "tier-default") {
+    note(
+      pc.yellow(
+        `Agent Teams is ON by default for this organization-tier bundle (tier 'organization').
+--no-teams falls back to ordinary parallel subagents.`
+      ),
+      "Agent Teams"
+    );
+  } else if (teamsActive) {
+    note(pc.cyan("Agent Teams explicitly requested with --teams; the scaffold stays experimental."), "Agent Teams");
+  }
+  if (teamsActive && !probeReport.agentTeamsExperimental) {
+    note(pc.yellow("The capability probe could not confirm agent-team support from --help; the scaffold stays experimental and unverified."), "Agent Teams");
+  }
+  if (pluginDir && !probeReport.pluginSupport) {
+    note(pc.yellow("The capability probe could not confirm --plugin-dir support from --help."), "Plugin Dir");
+  }
+  note(
+    `Host: ${pc.cyan("claude")}
+Executable: ${plan.executable}
+Workspace: ${plan.workspace}
+Background: ${options.bg ? "yes (--bg)" : "no"}
+Teams scaffold: ${teamsActive ? `yes (${describeClaudeTeamsPosture(teamsPosture)}; experimental, ephemeral env only)` : `no (${describeClaudeTeamsPosture(teamsPosture)})`}
+Plugin dir: ${pluginDir || "(none)"}`,
+    "Starting Claude Code Session"
+  );
+  const coordinatorRel = `.claude/agents/${ClaudeLauncher.resolveCoordinatorName(bundleDef?.orchestrator)}.md`;
+  if (!await fs15.pathExists(path17.join(resolution.workspace, coordinatorRel))) {
+    outro(
+      pc.red(
+        `Claude projection "${coordinatorRel}" was not found in ${resolution.workspace}.
+Run 'agents update ${bundle} --fanout claude' before starting an --agent session.`
+      )
+    );
+    process.exit(1);
+  }
+  await launcher.launch(plan);
+  outro(pc.green(`\u2714 Claude Code session finished.`));
+}
+function renderClaudeCapabilityBlock(capability) {
+  console.log(pc.bold(pc.cyan("Claude Code Runtime & Native Discovery Audit:")));
+  console.log(`  Installed: ${capability.installed ? pc.green("\u2714 Detected") : pc.yellow("\u2716 Not Found")}`);
+  if (capability.version) {
+    console.log(`  Version: ${capability.version}`);
+  }
+  console.log(`  Plugin Support (--plugin-dir): ${capability.pluginSupport ? pc.green("\u2714 Supported") : pc.yellow("\u2716 Unsupported")}`);
+  console.log(`  Agent Teams (experimental): ${capability.agentTeamsExperimental ? pc.green("\u2714 Supported") : pc.yellow("\u2716 Unsupported")}`);
+  console.log(`  Subagent hand-off (SubagentHandback): ${capability.subagentHandback ? pc.green("\u2714 Supported") : pc.yellow("\u2716 Needs v2.1.271+ (auto mode)")}`);
+}
+function renderClaudeActivationPlan(plan, report, recordedFanout, posture) {
+  const envEntries = Object.keys(plan.env);
+  const pluginFlagIndex = plan.argv.indexOf("--plugin-dir");
+  const teamsActive = envEntries.includes("CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS");
+  return [
+    `Bundle: ${plan.bundleName}`,
+    `Host: claude`,
+    `Bundle tier: ${posture.tier ?? "not declared (Tier-1 'domain' default)"}`,
+    `Scope: ${plan.scope}`,
+    `Workspace: ${plan.workspace}`,
+    `Executable: ${plan.executable}`,
+    `Background (--bg): ${plan.argv.includes("--bg") ? "yes" : "no"}`,
+    teamsActive ? `Agent teams (--teams): yes (${describeClaudeTeamsPosture(posture)} \u2014 experimental; ephemeral env only, nothing persisted)` : `Agent teams (--teams): no (${describeClaudeTeamsPosture(posture)})`,
+    `Plugin (--plugin-dir): ${pluginFlagIndex >= 0 ? plan.argv[pluginFlagIndex + 1] : "(none)"}`,
+    `Env injected (merged over process.env): ${envEntries.length > 0 ? envEntries.map((k) => `${k}=${plan.env[k]}`).join(", ") : "(none)"}`,
+    `Capability probe: installed=${report.installed ? `yes${report.version ? ` (${report.version})` : ""}` : "no"}, --plugin-dir=${report.pluginSupport ? "yes" : "no"}, agent teams=${report.agentTeamsExperimental ? "yes" : "no"}, subagent handback=${report.subagentHandback ? "yes" : "no"}`,
+    `Recorded fanout: [${recordedFanout.join(", ")}]`,
+    `Argv (${plan.argv.length} elements, one element per line, spawned with shell: false):`,
+    ...plan.argv.map((arg, index) => `  [${index}] ${arg.replace(/\r?\n/g, "\\n")}`)
+  ].join("\n");
+}
 cli.help();
 cli.version("1.0.0");
 cli.parse();
 export {
+  describeClaudeTeamsPosture,
   detectWorkspaceHosts,
   formatInstallationSummary,
   formatWrappedList,
   getTerminalContentWidth,
   renderProjections,
+  resolveClaudeTeamsPosture,
   wrapText
 };
 //# sourceMappingURL=cli.js.map