agents-united 0.13.0 → 0.15.0

package/dist/cli.js

@@ -4,8 +4,8 @@
 import { cac } from "cac";
 import pc from "picocolors";
 import { intro, outro, spinner, note, log, select, multiselect, confirm, text } from "@clack/prompts";
-import fs15 from "fs-extra";
-import path17 from "path";
+import fs20 from "fs-extra";
+import path22 from "path";
 
 // src/core/registry.ts
 import path from "path";
@@ -337,11 +337,42 @@ var RegistryResolver = class _RegistryResolver {
     }
   }
 };
+function loadTranslationLedger(registryDir = "registry") {
+  const ledgerPath = path.join(registryDir, "translation-ledger.json");
+  const parsed = JSON.parse(fs.readFileSync(ledgerPath, "utf8"));
+  const entries = Array.isArray(parsed) ? parsed : parsed.entries;
+  if (!Array.isArray(entries)) {
+    throw new Error(`Declared-Delta Registry error: ${ledgerPath} must be a JSON array of entries or carry an "entries" array.`);
+  }
+  const validDispositions = /* @__PURE__ */ new Set(["mapped", "approximated", "degraded", "unsupported"]);
+  return entries.map((raw, index) => {
+    const entry = raw;
+    const feature = entry.feature;
+    const host = entry.host;
+    const disposition = entry.disposition;
+    const rationale = entry.rationale;
+    if (typeof feature !== "string" || feature.trim() === "") {
+      throw new Error(`Declared-Delta Registry error: entries[${index}] needs a non-empty feature.`);
+    }
+    if (typeof host !== "string" || host.trim() === "") {
+      throw new Error(`Declared-Delta Registry error: entries[${index}] ("${feature}") needs a non-empty host.`);
+    }
+    if (typeof disposition !== "string" || !validDispositions.has(disposition)) {
+      throw new Error(
+        `Declared-Delta Registry error: entries[${index}] ("${feature}") needs disposition mapped|approximated|degraded|unsupported.`
+      );
+    }
+    if (typeof rationale !== "string" || rationale.trim() === "") {
+      throw new Error(`Declared-Delta Registry error: entries[${index}] ("${feature}") needs a rationale.`);
+    }
+    return { feature, host, disposition, rationale };
+  });
+}
 
 // src/core/installer.ts
-import path6 from "path";
-import crypto from "crypto";
-import fs4 from "fs-extra";
+import path9 from "path";
+import crypto2 from "crypto";
+import fs7 from "fs-extra";
 
 // src/core/adapter.ts
 import path3 from "path";
@@ -432,6 +463,9 @@ var KNOWN_HOST_IDS = Object.keys(HOST_REGISTRY);
 function isKnownHost(id) {
   return Object.prototype.hasOwnProperty.call(HOST_REGISTRY, id);
 }
+function splitHostList(value) {
+  return value.split(/[,\s]+/).filter(Boolean);
+}
 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 = [
@@ -453,22 +487,23 @@ function resolveHostProjectDir(host, cwd) {
 function resolveHostGlobalDir(host, home) {
   return path2.join(home, ...HOST_REGISTRY[host].globalDirSegments);
 }
-function planInstallTargets(selected) {
+function planInstallTargets(selected, opts = {}) {
   const normalized = Array.from(
     new Set(selected.map((s) => typeof s === "string" ? s.trim().toLowerCase() : "").filter(Boolean))
   );
   const known = normalized.filter(isKnownHost);
   const fanout = known.filter((h) => HOST_REGISTRY[h].projectionCapable);
   const hosts = known.filter((h) => !HOST_REGISTRY[h].projectionCapable);
+  const storeShape = hosts.length === 0 && fanout.length === 1 && fanout[0] === "claude" && !opts.canonicalStore && !opts.pluginLane ? "sidecar" : "store";
   let addedCanonicalStore = false;
   if (fanout.length > 0 && !hosts.includes("agents")) {
     hosts.unshift("agents");
-    addedCanonicalStore = true;
+    addedCanonicalStore = storeShape === "store";
   }
   if (hosts.length === 0 && fanout.length === 0) {
     hosts.push("agents");
   }
-  return { hosts, fanout, addedCanonicalStore };
+  return { hosts, fanout, addedCanonicalStore, storeShape };
 }
 
 // src/core/adapter.ts
@@ -563,6 +598,12 @@ complete the role in the main session.`;
     } else if (typeof defaultMaxIterations === "number") {
       cleanFrontmatter.maxIterations = defaultMaxIterations;
     }
+    if (Array.isArray(parsed.skills)) {
+      const skills = parsed.skills.filter((s) => typeof s === "string" && s.trim().length > 0);
+      if (skills.length > 0) {
+        cleanFrontmatter.skills = skills;
+      }
+    }
     const frontmatterStr = yaml2.stringify(cleanFrontmatter).trim();
     const bodyStr = match[2].trim();
     return `---
@@ -737,7 +778,7 @@ When user tasks require capabilities from: ${addons.join(", ")}, explain the cap
     const mode = planning?.mode ?? "subagent-first";
     const budget = planning?.budget;
     const delegationStep = planning ? mode === "subagent-first" ? "2. **Subagent-First Delegation Policy (ADR 0014)**: execute specialist work through the configured `subagent_*` agent tools (projected under `.cline/agents/`), assigning non-overlapping scopes. Complete specialist work in the main session ONLY if the subagent tools are genuinely absent from this runtime or the task is trivial (single-file read, one-line answer, formatting) \u2014 never as a convenience or speed choice." : "2. **Planner-Orchestrator Delegation Policy (ADR 0015)**: execute specialist work through the configured `subagent_*` agent tools (projected under `.cline/agents/`), assigning non-overlapping scopes. Complete specialist work in the main session ONLY if the subagent tools are genuinely absent from this runtime or the task is trivial (single-file read, one-line answer, formatting) \u2014 never as a convenience or speed choice." : "2. Delegate specialist tasks using the configured `subagent_*` agent tools (projected under `.cline/agents/`) when available, assigning non-overlapping scopes; fall back to Agent Teams (`team_spawn_teammate`) or session subagents as needed.";
-    const planningSection = planning ? mode === "subagent-first" ? "\n\n## Subagent-First Planning Dialogue Loop (ADR 0014)Run this loop BEFORE any substantive execution on a non-trivial task. Delegation-first is mandatory, not advisory.\n\n### Phase 0 \u2014 User Alignment\nIf the user's brief is ambiguous, grill it Socratically with the user first: `/grill-me` (strategy / non-code) or `/grill-with-docs` (code & docs; writes ADRs and updates CONTEXT.md).\n\n### Phase 0.5 \u2014 Sidekick Clarification\nSpawn at most " + (planning.sidekicks?.max ?? 2) + " relevant specialists (spawnable `subagent_*` tools) INTO this planning conversation to resolve remaining ambiguity. Sidekicks advise you; you relay their questions to the user.\n\n### Phase 1 \u2014 Specialist Council\nHave every relevant specialist return a Scope-of-Work Statement (max " + (budget?.summaryWordCap ?? 150) + " words): (1) my scope, (2) inputs I need from peers, (3) my deliverable per my own workflows, (4) at most 2 open questions.\n\n### Phase 2 \u2014 Delegation Map\nSynthesize the council output into a task \u2192 specialist map and present it to the user BEFORE execution. Then delegate per the map.\n\n### Consultation Budget (hard caps)\n- Planning rounds (orchestrator \u2194 council): max " + (budget?.maxPlanningRounds ?? 2) + "\n- Peer exchanges per specialist pair: max " + (budget?.maxPeerExchangesPerPair ?? 2) + " directed questions\n- Scope-of-Work statement length: max " + (budget?.summaryWordCap ?? 150) + " words\n- Specialist per-invocation iteration cap: maxIterations: " + (budget?.maxIterations ?? 8) + " (rendered into .cline/agents/*.yml)" : "\n\n## Planner-Orchestrator Policy (ADR 0015)Plan solo, delegate execution. This mode replaces the Subagent-First Planning Dialogue Loop for single-discipline domain bundles.\n\n### Phase 0 \u2014 User Alignment (solo)\nIf the user's brief is ambiguous, grill it Socratically yourself: `/grill-me` (strategy / non-code) or `/grill-with-docs` (code & docs). Consult the bundle's skills directly whenever they help you plan \u2014 you have the same skill access as your specialists. Do NOT spawn specialists during planning.\n\n### Planning Aid Boundary\nWhile planning you may consult skills and reason to give the user PROVISIONAL answers and estimates. A concrete deliverable \u2014 data analysis, code, assets, documents \u2014 is specialist work: defer it to the delegation map, never produce it yourself during planning.\n\n### Phase 2 \u2014 Delegation Map (solo-composed)\nCompose the task \u2192 specialist map from your own domain expertise and the skill runbooks, and present it to the user BEFORE execution.\n\n### Execution\nDelegate every deliverable to the configured `subagent_*` agent tools (projected under `.cline/agents/`), assigning non-overlapping scopes. Complete specialist work in the main session ONLY if the subagent tools are genuinely absent from this runtime or the task is trivial (single-file read, one-line answer, formatting) \u2014 never as a convenience or speed choice." : "";
+    const planningSection = planning ? mode === "subagent-first" ? "\n\n## Subagent-First Planning Dialogue Loop (ADR 0014)Run this loop BEFORE any substantive execution on a non-trivial task. Delegation-first is mandatory, not advisory.\n\n### Phase 0 \u2014 User Alignment\nIf the user's brief is ambiguous, grill it Socratically with the user first: `/grill-me` (strategy / non-code) or `/grill-with-docs` (code & docs; writes ADRs and updates CONTEXT.md).\n\n### Phase 0.5 \u2014 Sidekick Clarification\nSpawn at most " + (planning.sidekicks?.max ?? 2) + " relevant specialists (spawnable `subagent_*` tools) INTO this planning conversation to resolve remaining ambiguity. Sidekicks advise you; you relay their questions to the user.\n\n### Phase 1 \u2014 Specialist Council\nHave every relevant specialist return a Scope-of-Work Statement (max " + (budget?.summaryWordCap ?? 150) + " words): (1) my scope, (2) inputs I need from peers, (3) my deliverable per my own workflows, (4) at most 2 open questions.\n\n### Phase 2 \u2014 Delegation Map\nSynthesize the council output into a task \u2192 specialist map and present it to the user BEFORE execution. Then delegate per the map.\n\n### Consultation Budget (hard caps)\n- Planning rounds (orchestrator \u2194 council): max " + (budget?.maxPlanningRounds ?? 2) + "\n- Peer exchanges per specialist pair: max " + (budget?.maxPeerExchangesPerPair ?? 2) + " directed questions\n- Scope-of-Work statement length: max " + (budget?.summaryWordCap ?? 150) + " words\n- Specialist per-invocation iteration cap: maxIterations: " + (budget?.maxIterations ?? 8) + " (rendered into .cline/agents/*.yml)" : "\n\n## Planner-Orchestrator Policy (ADR 0015)Plan solo, delegate execution. This mode replaces the Subagent-First Planning Dialogue Loop for single-discipline domain bundles.\n\n### Phase 0 \u2014 User Alignment (solo)\nIf the user's brief is ambiguous, grill it Socratically yourself: `/grill-me` (strategy / non-code) or `/grill-with-docs` (code & docs). Consult the bundle's skills directly whenever they help you plan \u2014 you have the same skill access as your specialists. During planning, specialists are consulted read-only only (the Planning Consultation Phase gate); do not spawn them to produce deliverables.\n\n### Planning Aid Boundary\nWhile planning you may consult skills and reason to give the user PROVISIONAL answers and estimates. A concrete deliverable \u2014 data analysis, code, assets, documents \u2014 is specialist work: defer it to the delegation map, never produce it yourself during planning.\n\n### Phase 2 \u2014 Delegation Map\nCompose the task \u2192 specialist map from your domain expertise, the skill runbooks and the read-only consultation output, and present it to the user BEFORE execution.\n\n### Execution\nDelegate every deliverable to the configured `subagent_*` agent tools (projected under `.cline/agents/`), assigning non-overlapping scopes. Complete specialist work in the main session ONLY if the subagent tools are genuinely absent from this runtime or the task is trivial (single-file read, one-line answer, formatting) \u2014 never as a convenience or speed choice." : "";
     const personaSection = planning && bundle.personaAliases && Object.keys(bundle.personaAliases).length > 0 ? `
 
 ### Persona \u2192 Spawnable Tool Map
@@ -1214,7 +1255,7 @@ var FEATURE_LEDGER = {
   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)." }
+  mcpServers: { disposition: "mapped", rationale: "Plan 029 A2 \u2014 a canonical `mcpServers:` entry projects into the Claude subagent `mcpServers:` field as a server NAME reference (`- name: <server>`), and the matching grant lands in `tools:` (`mcp__<server>`, or pinned read-only tool names for a read-only role). Credentials, `env` blocks and inline server definitions are never projected (Risk R4)." }
 };
 var MARKER_PROFILE = "claude";
 var MARKER_PREFIX = "managed-by: agents-united";
@@ -1222,11 +1263,28 @@ 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 MCP_SERVERS_KEY = "mcpServers";
+var READ_ONLY_MCP_TOOL_GRANTS = {
+  // Only GitHub tools whose names are read-only verbs (`search_*`, `get_*`, `list_*`, `*_read`).
+  github: [
+    "mcp__github__search_code",
+    "mcp__github__get_file_contents",
+    "mcp__github__list_pull_requests",
+    "mcp__github__pull_request_read"
+  ],
+  // Context7 is documentation lookup only, so its published tools are read-only by construction.
+  // Plan 029 Step 3 pin correction: `get-library-docs` is Context7's DEPRECATED tool name; the
+  // current surface is `resolve-library-id` + `query-docs` (verified against the live MCP server).
+  context7: ["mcp__context7__resolve-library-id", "mcp__context7__query-docs"]
+};
 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
+allowlist; specialists hold no Agent tool and never spawn peers (the coordinator relays and wakes them).
+Outside Agent Teams (\`--teams\`), specialists cannot message each other by name: only the coordinator holds
+their agent IDs, so relay mode is the default and team mode exists only when the brief says so.
+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
@@ -1367,6 +1425,47 @@ var ClaudeProjector = class _ClaudeProjector {
     const meta = parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
     return { meta, body: match[2].replace(/^\r?\n/, "") };
   }
+  /**
+   * Plan 029 A2 / Risk R4 — the servers a canonical role declares, by NAME only.
+   *
+   * The canonical dialect is a sequence of `- name: <server>` mapping objects (a projected-style
+   * plain string is accepted too). Anything else is a fail-fast error: an inline server definition
+   * (`command`, `args`, `env`, `headers`, `url`, …) would put a credential-shaped block into a
+   * projected artifact — exactly what Risk R4 forbids — so it never reaches the output and is
+   * never silently dropped either (ADR 0018 decision 9).
+   */
+  static declaredMcpServers(meta, canonicalRelPath) {
+    const raw = meta[MCP_SERVERS_KEY];
+    if (raw === void 0 || raw === null) return [];
+    if (!Array.isArray(raw)) {
+      throw new Error(
+        `Cannot project ${canonicalRelPath}: ${MCP_SERVERS_KEY} must be a sequence of "- name: <server>" entries (server names only; an inline server definition is never projected).`
+      );
+    }
+    const names = [];
+    raw.forEach((entry, index) => {
+      if (typeof entry === "string" && entry.trim().length > 0) {
+        if (!names.includes(entry.trim())) names.push(entry.trim());
+        return;
+      }
+      if (entry !== null && typeof entry === "object" && !Array.isArray(entry)) {
+        const record = entry;
+        const keys = Object.keys(record);
+        const name = record.name;
+        if (typeof name === "string" && name.trim().length > 0 && keys.every((key) => key === "name")) {
+          if (!names.includes(name.trim())) names.push(name.trim());
+          return;
+        }
+        throw new Error(
+          `Cannot project ${canonicalRelPath}: ${MCP_SERVERS_KEY} entry #${index + 1} carries [${keys.join(", ")}] \u2014 servers are referenced by NAME only, never by an inline server definition (Risk R4: no credential may reach a projected artifact).`
+        );
+      }
+      throw new Error(
+        `Cannot project ${canonicalRelPath}: ${MCP_SERVERS_KEY} entry #${index + 1} is not a server name reference (expected "- name: <server>").`
+      );
+    });
+    return names;
+  }
   static ledgerEntry(feature) {
     const known = FEATURE_LEDGER[feature];
     if (!known) return void 0;
@@ -1520,7 +1619,17 @@ var ClaudeProjector = class _ClaudeProjector {
       tools.length = 0;
       tools.push(...restricted);
     }
+    const declaredServers = _ClaudeProjector.declaredMcpServers(meta, canonicalRelPath);
+    for (const server of declaredServers) {
+      const grants = permission === "plan" ? READ_ONLY_MCP_TOOL_GRANTS[server] ?? [] : [`mcp__${server}`];
+      for (const grant of grants) {
+        if (!tools.includes(grant)) tools.push(grant);
+      }
+    }
     out.tools = tools;
+    if (declaredServers.length > 0) {
+      out.mcpServers = declaredServers.map((server) => ({ name: server }));
+    }
     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;
@@ -1733,14 +1842,13 @@ ${rewritten.body}
         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;
+      const resourceRels = (await _ClaudeProjector.listSkillResources(skillDir)).filter((rel) => rel !== "SKILL.md");
+      for (const rel of resourceRels) {
         artifacts.push({
           kind: "skill",
-          canonical: `skills/${skillName}/${entry.name}`,
-          relPath: `.claude/skills/${normalized}/${entry.name}`,
-          sourceFilePath: path5.join(skillDir, entry.name),
+          canonical: `skills/${skillName}/${rel}`,
+          relPath: `.claude/skills/${normalized}/${rel}`,
+          sourceFilePath: path5.join(skillDir, ...rel.split("/")),
           managedMarker: false
         });
       }
@@ -1762,6 +1870,19 @@ ${rewritten.body}
     }
     return artifacts;
   }
+  /**
+   * Every file under a skill folder, as sorted POSIX-style paths relative to it
+   * (deterministic across platforms, so projection plans and lockfile keys never differ).
+   */
+  static async listSkillResources(skillDir, prefix = "") {
+    const out = [];
+    for (const entry of await fs3.readdir(path5.join(skillDir, ...prefix.split("/").filter(Boolean)), { withFileTypes: true })) {
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) out.push(...await _ClaudeProjector.listSkillResources(skillDir, rel));
+      else if (entry.isFile()) out.push(rel);
+    }
+    return out.sort((a, b) => a.localeCompare(b));
+  }
   /** Claude plugin package name rule; every bundle in `registry/bundles.json` satisfies it today. */
   static PLUGIN_NAME_REGEX = /^[a-z0-9][a-z0-9-]*$/;
   /**
@@ -1844,6 +1965,245 @@ ${rewritten.body}
   }
 };
 
+// src/core/state-dir.ts
+import os2 from "os";
+import path6 from "path";
+import fs4 from "fs-extra";
+var SIDECAR_DIR = ".claude/.agents-united";
+var STORE_DIR = ".agents";
+var LOCKFILE = "agents-united.json";
+function isSidecarDir(stateDir) {
+  const resolved = path6.resolve(stateDir);
+  return path6.basename(resolved) === ".agents-united" && path6.basename(path6.dirname(resolved)) === ".claude";
+}
+function workspaceRootOf(stateDir) {
+  const resolved = path6.resolve(stateDir);
+  return isSidecarDir(resolved) ? path6.dirname(path6.dirname(resolved)) : path6.dirname(resolved);
+}
+function stateDirFor(root, shape) {
+  return shape === "sidecar" ? path6.join(root, ...SIDECAR_DIR.split("/")) : path6.join(root, STORE_DIR);
+}
+function resolveStateDir(scope = "project", overrideDir, opts = {}) {
+  if (overrideDir) return path6.resolve(overrideDir);
+  const root = scope === "global" ? opts.home ?? os2.homedir() : opts.cwd ?? process.cwd();
+  const store = stateDirFor(root, "store");
+  if (fs4.existsSync(path6.join(store, LOCKFILE))) return store;
+  const sidecar = stateDirFor(root, "sidecar");
+  if (fs4.existsSync(path6.join(sidecar, LOCKFILE))) return sidecar;
+  return opts.preferShape === "sidecar" ? sidecar : store;
+}
+
+// src/core/session-guard.ts
+import os3 from "os";
+import path7 from "path";
+import crypto from "crypto";
+import fs5 from "fs-extra";
+var GUARD_MARKER = "Blocked by agents-united guard";
+var SESSION_GUARD_FILES = {
+  project: ".claude/settings.json",
+  local: ".claude/settings.local.json",
+  user: ".claude/settings.json"
+};
+function resolveSessionGuardFile(variant, workspaceRoot) {
+  const base = variant === "user" ? os3.homedir() : workspaceRoot;
+  return path7.join(base, ...SESSION_GUARD_FILES[variant].split("/"));
+}
+function variantOfRecordedFile(file) {
+  if (path7.isAbsolute(file)) return "user";
+  return file.endsWith("settings.local.json") ? "local" : "project";
+}
+function guardHandlerHash() {
+  return crypto.createHash("sha256").update(JSON.stringify(guardHandler())).digest("hex").slice(0, 16);
+}
+function sessionGuardSnippet() {
+  return JSON.stringify({ hooks: managedGuardHooks() }, null, 2);
+}
+var isOursAnyVersion = (handler) => handler.command === "node" && Array.isArray(handler.args) && handler.args[0] === "-e" && typeof handler.args[1] === "string" && handler.args[1].includes(GUARD_MARKER);
+var isCurrentGuard = (handler) => JSON.stringify({ type: handler.type, command: handler.command, args: handler.args }) === JSON.stringify(guardHandler());
+var groupIsOurs = (group) => Array.isArray(group.hooks) && group.hooks.some(isOursAnyVersion);
+async function parse(file) {
+  if (!await fs5.pathExists(file)) return "absent";
+  const text2 = await fs5.readFile(file, "utf8");
+  let value;
+  try {
+    value = JSON.parse(text2.replace(/^/, ""));
+  } catch {
+    return "invalid";
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return "invalid";
+  const hooks = value.hooks;
+  if (hooks !== void 0 && (hooks === null || typeof hooks !== "object" || Array.isArray(hooks))) return "invalid";
+  if (hooks?.PreToolUse !== void 0 && !Array.isArray(hooks.PreToolUse)) return "invalid";
+  const indentMatch = text2.match(/\n([ \t]+)"/);
+  return {
+    settings: value,
+    indent: indentMatch ? indentMatch[1] : 2,
+    eol: text2.includes("\r\n") ? "\r\n" : "\n",
+    trailingNewline: /\r?\n$/.test(text2)
+  };
+}
+async function write(file, parsed, settings) {
+  let text2 = JSON.stringify(settings, null, parsed.indent);
+  if (parsed.eol === "\r\n") text2 = text2.replace(/\n/g, "\r\n");
+  if (parsed.trailingNewline) text2 += parsed.eol;
+  await fs5.ensureDir(path7.dirname(file));
+  await fs5.writeFile(file, text2, "utf8");
+}
+async function mergeSessionGuard(file, opts = {}) {
+  const handlerHash = guardHandlerHash();
+  const parsed = await parse(file);
+  if (parsed === "invalid") return { status: "skipped-invalid", handlerHash };
+  const created = parsed === "absent";
+  const base = created ? { indent: 2, eol: "\n", trailingNewline: true } : parsed;
+  const settings = created ? {} : parsed.settings;
+  const hooks = settings.hooks ??= {};
+  let pre = hooks.PreToolUse ??= [];
+  if (opts.replaceHash && opts.replaceHash !== handlerHash) {
+    pre = hooks.PreToolUse = pre.filter((group) => !(groupIsOurs(group) && !group.hooks.some(isCurrentGuard)));
+  }
+  let changed = false;
+  let modified = false;
+  for (const wanted of managedGuardHooks().PreToolUse) {
+    const sameMatcher = pre.filter((group) => group.matcher === wanted.matcher && groupIsOurs(group));
+    if (sameMatcher.some((group) => group.hooks.some(isCurrentGuard))) continue;
+    if (sameMatcher.length > 0) {
+      modified = true;
+      continue;
+    }
+    pre.push(JSON.parse(JSON.stringify(wanted)));
+    changed = true;
+  }
+  if (!changed) return { status: modified ? "modified" : "unchanged", handlerHash };
+  await write(file, base, settings);
+  return { status: created ? "created" : "merged", handlerHash };
+}
+async function removeSessionGuard(file, opts) {
+  const parsed = await parse(file);
+  if (parsed === "absent") return "absent";
+  if (parsed === "invalid") return "skipped-invalid";
+  const { settings } = parsed;
+  const pre = settings.hooks?.PreToolUse;
+  if (!pre || !pre.some(groupIsOurs)) return "absent";
+  const kept = pre.filter((group) => !groupIsOurs(group));
+  if (kept.length > 0) {
+    settings.hooks.PreToolUse = kept;
+  } else {
+    delete settings.hooks.PreToolUse;
+    if (Object.keys(settings.hooks).length === 0) delete settings.hooks;
+  }
+  if (opts.createdFile && Object.keys(settings).length === 0) {
+    await fs5.remove(file);
+    return "deleted-file";
+  }
+  await write(file, parsed, settings);
+  return "removed";
+}
+async function inspectSessionGuard(file) {
+  const parsed = await parse(file);
+  if (parsed === "absent" || parsed === "invalid") return parsed === "absent" ? "absent" : "skipped-invalid";
+  const pre = parsed.settings.hooks?.PreToolUse ?? [];
+  let allCurrent = true;
+  let anyOurs = false;
+  for (const wanted of managedGuardHooks().PreToolUse) {
+    const ours = pre.filter((group) => group.matcher === wanted.matcher && groupIsOurs(group));
+    if (ours.length > 0) anyOurs = true;
+    if (!ours.some((group) => group.hooks.some(isCurrentGuard))) allCurrent = false;
+  }
+  if (allCurrent) return "wired";
+  return anyOurs ? "modified" : "missing";
+}
+
+// src/core/permission-preset.ts
+import path8 from "path";
+import fs6 from "fs-extra";
+var VERIFY_COMMANDS = [
+  "git status",
+  "git diff",
+  "git log",
+  "npx tsc --noEmit",
+  "npx vitest run",
+  "npx eslint"
+];
+var BUILD_COMMANDS = [...VERIFY_COMMANDS, "npm install", "npm run", "npm test"];
+var PERMISSION_TIER_COMMANDS = {
+  verify: VERIFY_COMMANDS,
+  build: BUILD_COMMANDS
+};
+function claudeAllowEntries(tier) {
+  return PERMISSION_TIER_COMMANDS[tier].map((cmd) => `Bash(${cmd} *)`);
+}
+var SUPPORTED_PERMISSION_PRESET_HOSTS = ["claude"];
+async function parse2(file) {
+  if (!await fs6.pathExists(file)) return "absent";
+  const text2 = await fs6.readFile(file, "utf8");
+  let value;
+  try {
+    value = JSON.parse(text2.replace(/^/, ""));
+  } catch {
+    return "invalid";
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return "invalid";
+  const permissions = value.permissions;
+  if (permissions !== void 0 && (permissions === null || typeof permissions !== "object" || Array.isArray(permissions))) return "invalid";
+  if (permissions?.allow !== void 0 && !Array.isArray(permissions.allow)) return "invalid";
+  const indentMatch = text2.match(/\n([ \t]+)"/);
+  return {
+    settings: value,
+    indent: indentMatch ? indentMatch[1] : 2,
+    eol: text2.includes("\r\n") ? "\r\n" : "\n",
+    trailingNewline: /\r?\n$/.test(text2)
+  };
+}
+async function write2(file, parsed, settings) {
+  let text2 = JSON.stringify(settings, null, parsed.indent);
+  if (parsed.eol === "\r\n") text2 = text2.replace(/\n/g, "\r\n");
+  if (parsed.trailingNewline) text2 += parsed.eol;
+  await fs6.ensureDir(path8.dirname(file));
+  await fs6.writeFile(file, text2, "utf8");
+}
+async function mergePermissionPreset(file, tier) {
+  const wanted = claudeAllowEntries(tier);
+  const parsed = await parse2(file);
+  if (parsed === "invalid") return { status: "skipped-invalid", entries: [] };
+  const created = parsed === "absent";
+  const base = created ? { indent: 2, eol: "\n", trailingNewline: true } : parsed;
+  const settings = created ? {} : parsed.settings;
+  const permissions = settings.permissions ??= {};
+  const allow = permissions.allow ??= [];
+  const added = [];
+  for (const entry of wanted) {
+    if (!allow.includes(entry)) {
+      allow.push(entry);
+      added.push(entry);
+    }
+  }
+  if (added.length === 0) return { status: "unchanged", entries: wanted };
+  await write2(file, base, settings);
+  return { status: created ? "created" : "merged", entries: wanted };
+}
+async function removePermissionPreset(file, entries, opts) {
+  const parsed = await parse2(file);
+  if (parsed === "absent") return "absent";
+  if (parsed === "invalid") return "skipped-invalid";
+  const { settings } = parsed;
+  const allow = settings.permissions?.allow;
+  if (!Array.isArray(allow)) return "absent";
+  const owned = new Set(entries);
+  const kept = allow.filter((e) => !(typeof e === "string" && owned.has(e)));
+  if (kept.length > 0) {
+    settings.permissions.allow = kept;
+  } else {
+    delete settings.permissions.allow;
+    if (Object.keys(settings.permissions).length === 0) delete settings.permissions;
+  }
+  if (opts.createdFile && Object.keys(settings).length === 0) {
+    await fs6.remove(file);
+    return "deleted-file";
+  }
+  await write2(file, parsed, settings);
+  return "removed";
+}
+
 // src/core/installer.ts
 import YAML2 from "yaml";
 
@@ -1867,13 +2227,13 @@ var InstallEngine = class _InstallEngine {
     this.registry = registry2 || new RegistryResolver();
   }
   async calculateHash(filePath) {
-    const buffer = await fs4.readFile(filePath);
-    return "sha256:" + crypto.createHash("sha256").update(buffer).digest("hex");
+    const buffer = await fs7.readFile(filePath);
+    return "sha256:" + crypto2.createHash("sha256").update(buffer).digest("hex");
   }
   async readLockfile(lockfilePath) {
-    if (await fs4.pathExists(lockfilePath)) {
+    if (await fs7.pathExists(lockfilePath)) {
       try {
-        return await fs4.readJson(lockfilePath);
+        return await fs7.readJson(lockfilePath);
       } catch {
       }
     }
@@ -1916,24 +2276,24 @@ var InstallEngine = class _InstallEngine {
     return options.scope || "project";
   }
   async deployFile(src, dest, method, force) {
-    await fs4.ensureDir(path6.dirname(dest));
-    if (await fs4.pathExists(dest) || await fs4.pathExists(dest).catch(() => false)) {
+    await fs7.ensureDir(path9.dirname(dest));
+    if (await fs7.pathExists(dest) || await fs7.pathExists(dest).catch(() => false)) {
       if (force) {
-        await fs4.remove(dest);
+        await fs7.remove(dest);
       }
     }
     if (method === "symlink") {
       try {
-        const stat = await fs4.stat(src);
+        const stat = await fs7.stat(src);
         const type = stat.isDirectory() ? process.platform === "win32" ? "junction" : "dir" : "file";
-        await fs4.ensureSymlink(src, dest, type);
+        await fs7.ensureSymlink(src, dest, type);
         return "symlink";
       } catch {
-        await fs4.copy(src, dest, { overwrite: true });
+        await fs7.copy(src, dest, { overwrite: true });
         return "copy";
       }
     }
-    await fs4.copy(src, dest, { overwrite: true });
+    await fs7.copy(src, dest, { overwrite: true });
     return "copy";
   }
   /**
@@ -1941,8 +2301,8 @@ var InstallEngine = class _InstallEngine {
      * copies of canonical assets, so their bytes differ from the source.
      */
   async deployProjection(dest, content) {
-    await fs4.ensureDir(path6.dirname(dest));
-    await fs4.writeFile(dest, content, "utf8");
+    await fs7.ensureDir(path9.dirname(dest));
+    await fs7.writeFile(dest, content, "utf8");
   }
   /**
    * Computes the canonical `.agents/` target dir and the workspace root that contains
@@ -1950,27 +2310,27 @@ var InstallEngine = class _InstallEngine {
    */
   static projectionRoot(scope, targetDir) {
     const agentsTarget = AgentHostAdapter.resolveHostDir(scope, "agents", targetDir);
-    return { agentsTarget, root: path6.resolve(path6.dirname(agentsTarget)) };
+    return { agentsTarget, root: workspaceRootOf(agentsTarget) };
   }
   toPosix(p) {
-    return p.split(path6.sep).join("/");
+    return p.split(path9.sep).join("/");
   }
   canonicalRelAgent(agentFile) {
     return `.agents/agents/${agentFile}`;
   }
   lockRel(subdir, file) {
-    return path6.join(subdir, file);
+    return path9.join(subdir, file);
   }
   destForProjection(host, root, file) {
     const def = HOST_REGISTRY[host];
     const base = resolveHostProjectDir(host, root);
-    if (def.agentsSubdir) return path6.join(base, def.agentsSubdir, file);
+    if (def.agentsSubdir) return path9.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, path6.sep);
+    const sysKey = relKey.replace(/\//g, path9.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() };
@@ -1984,7 +2344,7 @@ var InstallEngine = class _InstallEngine {
   removeProjectedTo(lockfile, canonicalRelPath, projectedRelPath) {
     const normProj = this.toPosix(projectedRelPath);
     const posixKey = canonicalRelPath.replace(/\\/g, "/");
-    const sysKey = canonicalRelPath.replace(/\//g, path6.sep);
+    const sysKey = canonicalRelPath.replace(/\//g, path9.sep);
     const targetKey = lockfile.files[posixKey] ? posixKey : lockfile.files[sysKey] ? sysKey : canonicalRelPath;
     const asset = lockfile.files[targetKey];
     if (asset && asset.projectedTo) {
@@ -2041,7 +2401,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, path6.sep);
+      const sysKey = canonical.replace(/\//g, path9.sep);
       const targetKey = lockfile.files[posixKey] ? posixKey : lockfile.files[sysKey] ? sysKey : null;
       if (!targetKey) continue;
       const asset = lockfile.files[targetKey];
@@ -2080,9 +2440,9 @@ var InstallEngine = class _InstallEngine {
         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);
+            const absProjection = path9.join(root, projRelPath);
+            if (await fs7.pathExists(absProjection)) {
+              await fs7.remove(absProjection);
               await this.removeEmptyProjectionDirs(root, projRelPath);
             }
             delete lockfile.projections[projRelPath];
@@ -2094,9 +2454,9 @@ var InstallEngine = class _InstallEngine {
       }
     }
     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);
+      const dest = path9.join(root, artifact.relPath);
+      if (await fs7.pathExists(dest) && !force) {
+        const existing = await fs7.readFile(dest, "utf8").catch(() => null);
         if (existing !== null) {
           if (artifact.managedMarker && !HostProjector.hasManagedMarker(existing)) {
             throw new Error(
@@ -2115,8 +2475,8 @@ var InstallEngine = class _InstallEngine {
       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 });
+        await fs7.ensureDir(path9.dirname(dest));
+        await fs7.copy(artifact.sourceFilePath, dest, { overwrite: true });
       }
       const deployedHash = await this.calculateHash(dest);
       lockfile.projections = lockfile.projections || {};
@@ -2167,6 +2527,106 @@ var InstallEngine = class _InstallEngine {
     if (typeof options.pluginLane === "boolean") return options.pluginLane;
     return lockfile?.pluginLane === true;
   }
+  /**
+   * Plan 023 B (ADR 0022, D4) — resolve the state dir for this install. An explicit `targetDir`
+   * is a location hint; a requested (or implied) store shape always lands in `.agents/`, and a
+   * sidecar is used only when nothing needs the store: any non-Claude fan-out or the plugin lane
+   * (both write under `.agents/plugins/`) forces the store (strangler-safe, ADR 0022 decision 4).
+   */
+  static resolveInstallStateDir(scope, options, fanoutHosts) {
+    const discovered = resolveStateDir(scope, options.targetDir, { preferShape: options.storeShape ?? "store" });
+    const needsStore = options.storeShape === "store" || fanoutHosts.some((h) => h !== "claude") || options.pluginLane === true;
+    if (needsStore && isSidecarDir(discovered)) return stateDirFor(workspaceRootOf(discovered), "store");
+    return discovered;
+  }
+  /** Move an existing sidecar into the store dir (ADR 0022 upgrade path); a no-op otherwise. */
+  static async upgradeSidecarToStore(stateDir) {
+    if (isSidecarDir(stateDir)) return;
+    const sidecar = stateDirFor(workspaceRootOf(stateDir), "sidecar");
+    if (!await fs7.pathExists(path9.join(sidecar, "agents-united.json"))) return;
+    if (await fs7.pathExists(path9.join(stateDir, "agents-united.json"))) return;
+    await fs7.ensureDir(stateDir);
+    for (const entry of await fs7.readdir(sidecar)) {
+      await fs7.move(path9.join(sidecar, entry), path9.join(stateDir, entry), { overwrite: true });
+    }
+    await fs7.remove(sidecar);
+  }
+  /**
+   * Plan 023 A (owner D1–D2) — the plain-session guard. Runs only when the Claude lane runs.
+   * An explicit `options.sessionGuard` wins and is recorded; otherwise the recorded decision is
+   * re-applied (sticky yes re-merges idempotently, sticky no writes nothing); never decided ⇒
+   * nothing is written (the CLI asks). `project`/`local` are workspace files and are ignored for
+   * global installs; `user` (home settings) is honoured only when requested explicitly.
+   */
+  async applySessionGuard(scope, workspaceRoot, lockfile, options, projections) {
+    const recorded = lockfile.sessionGuard;
+    let variant = options.sessionGuard;
+    if (variant === void 0 && recorded) {
+      variant = "off" in recorded ? false : variantOfRecordedFile(recorded.file);
+    }
+    if (variant === void 0) return;
+    if (variant === false) {
+      lockfile.sessionGuard = { off: true };
+      return;
+    }
+    if (scope === "global" && variant !== "user") return;
+    const file = resolveSessionGuardFile(variant, workspaceRoot);
+    const recordedFile = variant === "user" ? file : this.toPosix(path9.relative(workspaceRoot, file));
+    const sameFileRecord = recorded && !("off" in recorded) && recorded.file === recordedFile ? recorded : void 0;
+    const existedBefore = await fs7.pathExists(file);
+    const result = await mergeSessionGuard(file, { replaceHash: sameFileRecord?.handlerHash });
+    lockfile.sessionGuard = {
+      file: recordedFile,
+      handlerHash: result.handlerHash,
+      createdFile: sameFileRecord ? sameFileRecord.createdFile : !existedBefore
+    };
+    const warnings = [];
+    if (result.status === "skipped-invalid") {
+      warnings.push(`Session guard not written: ${recordedFile} is not valid JSON (comments or trailing commas?). It was left untouched \u2014 paste this into it by hand:
+${sessionGuardSnippet()}`);
+    } else if (result.status === "modified") {
+      warnings.push(`Session guard in ${recordedFile} was edited by hand; left as-is (run with --force after removing it to restore).`);
+    }
+    projections.push({ host: "claude", path: recordedFile, warnings });
+  }
+  /**
+   * Plan 024 S4 (owner decisions E2/E4) — the opt-in command-permission preset. Written ONLY to
+   * `.claude/settings.local.json`, never the shared `.claude/settings.json`, regardless of what
+   * `sessionGuard` variant is also requested. Off by default, never implied by `-y`. Applies to
+   * every fan-out host that has a verified renderer (Claude only today); any other requested host
+   * gets an honest "not supported yet" warning instead of a guessed file.
+   */
+  async applyPermissionPreset(scope, workspaceRoot, lockfile, options, fanoutHosts, projections) {
+    const recorded = lockfile.permissionPreset;
+    const tier = options.permissionPreset ?? (recorded && !("off" in recorded) ? recorded.tier : void 0);
+    if (tier === void 0) return;
+    if (tier === false) {
+      lockfile.permissionPreset = { off: true };
+      return;
+    }
+    if (scope === "global") return;
+    const unsupported = fanoutHosts.filter((h) => h !== "claude" && !SUPPORTED_PERMISSION_PRESET_HOSTS.includes(h));
+    for (const host of unsupported) {
+      projections.push({ host, path: "", warnings: [`Permission preset not supported for ${host} yet \u2014 no file written for it. Claude still received it if selected.`] });
+    }
+    if (!fanoutHosts.includes("claude")) return;
+    const file = path9.join(workspaceRoot, ".claude", "settings.local.json");
+    const recordedFile = this.toPosix(path9.relative(workspaceRoot, file));
+    const existedBefore = await fs7.pathExists(file);
+    const result = await mergePermissionPreset(file, tier);
+    const warnings = [];
+    if (result.status === "skipped-invalid") {
+      warnings.push(`Permission preset not written: ${recordedFile} is not valid JSON (comments or trailing commas?). Left untouched.`);
+    } else {
+      lockfile.permissionPreset = {
+        tier,
+        file: recordedFile,
+        entries: result.entries,
+        createdFile: recorded && !("off" in recorded) ? recorded.createdFile : !existedBefore
+      };
+    }
+    projections.push({ host: "claude", path: recordedFile, warnings });
+  }
   /**
    * 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
@@ -2184,16 +2644,16 @@ var InstallEngine = class _InstallEngine {
     return artifacts;
   }
   async removeEmptyProjectionDirs(workspaceRoot, projPath) {
-    let dir = path6.dirname(path6.join(workspaceRoot, projPath));
+    let dir = path9.dirname(path9.join(workspaceRoot, projPath));
     while (dir !== workspaceRoot && dir.startsWith(workspaceRoot)) {
       try {
-        const entries = await fs4.readdir(dir);
+        const entries = await fs7.readdir(dir);
         if (entries.length > 0) break;
-        await fs4.rmdir(dir);
+        await fs7.rmdir(dir);
       } catch {
         break;
       }
-      dir = path6.dirname(dir);
+      dir = path9.dirname(dir);
     }
   }
   // ADR 0016: Silent auto-migration of legacy .agents/workflows/*.md into
@@ -2203,27 +2663,27 @@ var InstallEngine = class _InstallEngine {
     let migratedCount = 0;
     let targetLockfile = lockfile;
     let lockfileLoadedFromDisk = false;
-    if (!targetLockfile && await fs4.pathExists(subPaths.lockfile)) {
+    if (!targetLockfile && await fs7.pathExists(subPaths.lockfile)) {
       try {
-        targetLockfile = await fs4.readJson(subPaths.lockfile);
+        targetLockfile = await fs7.readJson(subPaths.lockfile);
         lockfileLoadedFromDisk = true;
       } catch {
       }
     }
-    if (await fs4.pathExists(subPaths.workflowsDir)) {
-      const entries = await fs4.readdir(subPaths.workflowsDir).catch(() => []);
+    if (await fs7.pathExists(subPaths.workflowsDir)) {
+      const entries = await fs7.readdir(subPaths.workflowsDir).catch(() => []);
       for (const entry of entries) {
         if (entry.endsWith(".md")) {
-          const legacyPath = path6.join(subPaths.workflowsDir, entry);
+          const legacyPath = path9.join(subPaths.workflowsDir, entry);
           let skillName = entry.replace(/\.md$/, "").replace(/--/g, "-");
           if (!skillName.startsWith("workflow-")) {
             skillName = `workflow-${skillName}`;
           }
-          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");
+          const targetSkillDir = path9.join(subPaths.skillsDir, skillName);
+          const targetSkillFile = path9.join(targetSkillDir, "SKILL.md");
+          if (!await fs7.pathExists(targetSkillFile)) {
+            await fs7.ensureDir(targetSkillDir);
+            const legacyContent = await fs7.readFile(legacyPath, "utf8");
             let skillContent = legacyContent;
             const fmMatch = legacyContent.match(/^---\r?\n([\s\S]+?)\r?\n---/);
             if (fmMatch) {
@@ -2244,14 +2704,14 @@ ${YAML2.stringify(meta).trim()}
               } catch {
               }
             }
-            await fs4.writeFile(targetSkillFile, skillContent, "utf8");
+            await fs7.writeFile(targetSkillFile, skillContent, "utf8");
           }
-          await fs4.remove(legacyPath).catch(() => {
+          await fs7.remove(legacyPath).catch(() => {
           });
           migratedCount++;
           if (targetLockfile) {
-            const legacyRel = this.toPosix(path6.relative(targetDir, legacyPath));
-            const newRel = this.toPosix(path6.relative(targetDir, targetSkillFile));
+            const legacyRel = this.toPosix(path9.relative(targetDir, legacyPath));
+            const newRel = this.toPosix(path9.relative(targetDir, targetSkillFile));
             if (targetLockfile.files && targetLockfile.files[legacyRel]) {
               targetLockfile.files[newRel] = targetLockfile.files[legacyRel];
               delete targetLockfile.files[legacyRel];
@@ -2264,9 +2724,9 @@ ${YAML2.stringify(meta).trim()}
           }
         }
       }
-      const remaining = await fs4.readdir(subPaths.workflowsDir).catch(() => []);
+      const remaining = await fs7.readdir(subPaths.workflowsDir).catch(() => []);
       if (remaining.length === 0) {
-        await fs4.remove(subPaths.workflowsDir).catch(() => {
+        await fs7.remove(subPaths.workflowsDir).catch(() => {
         });
       }
     }
@@ -2282,8 +2742,8 @@ ${YAML2.stringify(meta).trim()}
       }
       targetLockfile.installed.workflows = [];
     }
-    if (targetLockfile && (lockfileLoadedFromDisk || await fs4.pathExists(subPaths.lockfile))) {
-      await fs4.writeJson(subPaths.lockfile, targetLockfile, { spaces: 2 });
+    if (targetLockfile && (lockfileLoadedFromDisk || await fs7.pathExists(subPaths.lockfile))) {
+      await fs7.writeJson(subPaths.lockfile, targetLockfile, { spaces: 2 });
     }
     return migratedCount;
   }
@@ -2319,10 +2779,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 fs4.readFile(path6.join(registryDir, "agents", agentFile), "utf8");
+        const content = await fs7.readFile(path9.join(registryDir, "agents", agentFile), "utf8");
         const res = HostProjector.projectAgent(content, HOST_REGISTRY[host].profile, this.canonicalRelAgent(agentFile));
-        const dest = path6.join(base, subdir, agentFile);
-        infos.push({ host, path: this.toPosix(path6.relative(root, dest)), kind: "role", warnings: res.warnings });
+        const dest = path9.join(base, subdir, agentFile);
+        infos.push({ host, path: this.toPosix(path9.relative(root, dest)), kind: "role", warnings: res.warnings });
       }
     }
     return infos;
@@ -2351,9 +2811,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 = path6.join(root, "AGENTS.md");
-        if (await fs4.pathExists(bridgeDest) && !options.force) {
-          const existing = await fs4.readFile(bridgeDest, "utf8");
+        const bridgeDest = path9.join(root, "AGENTS.md");
+        if (await fs7.pathExists(bridgeDest) && !options.force) {
+          const existing = await fs7.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."
@@ -2364,7 +2824,7 @@ ${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", path6.join(s, "SKILL.md")), "AGENTS.md"));
+        resolved.skills.forEach((s) => this.recordProjectedTo(lockfile, this.lockRel("skills", path9.join(s, "SKILL.md")), "AGENTS.md"));
         continue;
       }
       if (host === "cline" || host === "claude") {
@@ -2404,8 +2864,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 = path6.join(root, artifact.relPath);
-                if (!await fs4.pathExists(dest)) continue;
+                const dest = path9.join(root, artifact.relPath);
+                if (!await fs7.pathExists(dest)) continue;
                 await this.deployProjection(dest, artifact.content);
                 const deployedHash = await this.calculateHash(dest);
                 lockfile.projections = lockfile.projections || {};
@@ -2429,7 +2889,7 @@ ${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 fs4.readFile(path6.join(registryDir, "agents", agentFile), "utf8");
+        const content = await fs7.readFile(path9.join(registryDir, "agents", agentFile), "utf8");
         const canonicalRel = this.canonicalRelAgent(agentFile);
         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, "")));
@@ -2438,8 +2898,8 @@ ${YAML2.stringify(meta).trim()}
         }) : 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 dest = path9.join(base, subdir, projName);
+        const projPath = this.toPosix(path9.relative(root, dest));
         const existingRoleProj = lockfile.projections?.[projPath];
         if (existingRoleProj?.kind === "role") {
           const compoundOwned = !(existingRoleProj.canonical ?? "").startsWith(".agents/");
@@ -2447,11 +2907,11 @@ ${YAML2.stringify(meta).trim()}
             continue;
           }
         }
-        if (await fs4.pathExists(dest) && !options.force) {
-          const existing = await fs4.readFile(dest, "utf8");
+        if (await fs7.pathExists(dest) && !options.force) {
+          const existing = await fs7.readFile(dest, "utf8");
           if (!HostProjector.hasManagedMarker(existing)) {
             throw new Error(
-              `Projection target ${this.toPosix(path6.relative(root, dest))} already exists and is not managed by agents-united. Use --force to overwrite.`
+              `Projection target ${this.toPosix(path9.relative(root, dest))} already exists and is not managed by agents-united. Use --force to overwrite.`
             );
           }
         }
@@ -2486,16 +2946,16 @@ ${YAML2.stringify(meta).trim()}
     const hosts = this.parseHosts(options);
     const resolved = await this.registry.resolve(identifier);
     const registryDir = this.registry.getRegistryDir();
-    const targetDirs = hosts.map((h) => AgentHostAdapter.resolveHostDir(scope, h, options.targetDir));
     const hasCanonicalAgents = hosts.includes("agents");
     const fanoutHosts = (options.fanout || []).map((h) => typeof h === "string" ? h.trim().toLowerCase() : h).filter((h) => isKnownHost(h) && HOST_REGISTRY[h]?.projectionCapable);
+    const stateDir = _InstallEngine.resolveInstallStateDir(scope, options, fanoutHosts);
+    const targetDirs = hosts.map((h) => options.targetDir && !(h === "agents") ? path9.resolve(options.targetDir) : h === "agents" ? stateDir : AgentHostAdapter.resolveHostDir(scope, h, options.targetDir));
     if (options.dryRun) {
       let effectiveDryFanout = fanoutHosts;
       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);
+      const lockfilePath = path9.join(stateDir, "agents-united.json");
+      if (await fs7.pathExists(lockfilePath)) {
+        const lockfile = await fs7.readJson(lockfilePath).catch(() => null);
         if (options.fanout === void 0 && hasCanonicalAgents && lockfile?.fanout) {
           effectiveDryFanout = lockfile.fanout.filter((h) => isKnownHost(h) && HOST_REGISTRY[h]?.projectionCapable);
         }
@@ -2503,24 +2963,28 @@ ${YAML2.stringify(meta).trim()}
           effectiveDryPluginLane = true;
         }
       }
-      const projections2 = hasCanonicalAgents ? await this.buildProjections(effectiveDryFanout, resolved, registryDir, scope, options.targetDir, effectiveDryPluginLane) : [];
+      const projections2 = hasCanonicalAgents ? await this.buildProjections(effectiveDryFanout, resolved, registryDir, scope, stateDir, effectiveDryPluginLane) : [];
       return { installed: resolved, targetDirs, dryRun: true, method, projections: projections2 };
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const projections = [];
-    const agentsTarget = AgentHostAdapter.resolveHostDir(scope, "agents", options.targetDir);
+    const agentsTarget = stateDir;
+    if (hasCanonicalAgents) await _InstallEngine.upgradeSidecarToStore(stateDir);
     for (const targetDir of targetDirs) {
       const subPaths = AgentHostAdapter.getSubPaths(targetDir);
-      await fs4.ensureDir(subPaths.agentsDir);
-      await fs4.ensureDir(subPaths.skillsDir);
+      const iterMethod = isSidecarDir(targetDir) ? "copy" : method;
+      await fs7.ensureDir(subPaths.agentsDir);
+      await fs7.ensureDir(subPaths.skillsDir);
       if (resolved.workflows && resolved.workflows.length > 0) {
-        await fs4.ensureDir(subPaths.workflowsDir);
+        await fs7.ensureDir(subPaths.workflowsDir);
       }
-      await fs4.ensureDir(subPaths.rulesDir);
+      await fs7.ensureDir(subPaths.rulesDir);
       const lockfile = await this.readLockfile(subPaths.lockfile);
       await this.migrateLegacyWorkspaceWorkflows(targetDir, lockfile);
       lockfile.scope = scope;
-      lockfile.method = method;
+      lockfile.method = iterMethod;
+      if (isSidecarDir(targetDir)) lockfile.storeShape = "sidecar";
+      else delete lockfile.storeShape;
       lockfile.hosts = hosts;
       const effectiveFanout = (options.fanout !== void 0 ? fanoutHosts : lockfile.fanout ?? []).filter((h) => isKnownHost(h) && HOST_REGISTRY[h]?.projectionCapable);
       if (options.fanout !== void 0) {
@@ -2540,18 +3004,18 @@ ${YAML2.stringify(meta).trim()}
       }
       const declaresAsset = (assetKey) => !hasDeclaredRoster || declared.has(assetKey);
       for (const agentFile of resolved.agents) {
-        const src = path6.join(registryDir, "agents", agentFile);
-        const dest = path6.join(subPaths.agentsDir, agentFile);
-        if (await fs4.pathExists(dest) && !options.force && method !== "symlink") {
+        const src = path9.join(registryDir, "agents", agentFile);
+        const dest = path9.join(subPaths.agentsDir, agentFile);
+        if (await fs7.pathExists(dest) && !options.force && method !== "symlink") {
           const existingHash = await this.calculateHash(dest).catch(() => null);
-          const relPath2 = path6.relative(targetDir, dest);
+          const relPath2 = path9.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 actualMethod = await this.deployFile(src, dest, iterMethod, options.force);
         const hash = await this.calculateHash(src);
-        const relPath = this.toPosix(path6.relative(targetDir, dest));
+        const relPath = this.toPosix(path9.relative(targetDir, dest));
         const existing = lockfile.files[relPath];
         const existingOwners = existing?.owners ?? [];
         const owners = resolved.targetBundle && declaresAsset(`agents/${agentFile}`) ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
@@ -2568,13 +3032,13 @@ ${YAML2.stringify(meta).trim()}
         }
       }
       for (const skillName of resolved.skills) {
-        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 = path6.join(src, "SKILL.md");
-        if (await fs4.pathExists(skillFile)) {
+        const src = path9.join(registryDir, "skills", skillName);
+        const dest = path9.join(subPaths.skillsDir, skillName);
+        const actualMethod = await this.deployFile(src, dest, iterMethod, options.force);
+        const skillFile = path9.join(src, "SKILL.md");
+        if (await fs7.pathExists(skillFile)) {
           const hash = await this.calculateHash(skillFile);
-          const relPath = this.toPosix(path6.relative(targetDir, path6.join(subPaths.skillsDir, skillName, "SKILL.md")));
+          const relPath = this.toPosix(path9.relative(targetDir, path9.join(subPaths.skillsDir, skillName, "SKILL.md")));
           const existing = lockfile.files[relPath];
           const existingOwners = existing?.owners ?? [];
           const owners = resolved.targetBundle && declaresAsset(`skills/${skillName}/SKILL.md`) ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
@@ -2590,14 +3054,14 @@ ${YAML2.stringify(meta).trim()}
         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);
+          for (const entry of await fs7.readdir(dir, { withFileTypes: true })) {
+            const abs = path9.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 sideRel = this.toPosix(path9.relative(targetDir, abs));
+            if (abs === path9.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;
@@ -2616,11 +3080,11 @@ ${YAML2.stringify(meta).trim()}
         }
       }
       for (const workflowFile of resolved.workflows) {
-        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 src = path9.join(registryDir, "workflows", workflowFile);
+        const dest = path9.join(subPaths.workflowsDir, workflowFile);
+        const actualMethod = await this.deployFile(src, dest, iterMethod, options.force);
         const hash = await this.calculateHash(src);
-        const relPath = this.toPosix(path6.relative(targetDir, dest));
+        const relPath = this.toPosix(path9.relative(targetDir, dest));
         const existing = lockfile.files[relPath];
         const existingOwners = existing?.owners ?? [];
         const owners = resolved.targetBundle && declaresAsset(`workflows/${workflowFile}`) ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
@@ -2638,12 +3102,12 @@ ${YAML2.stringify(meta).trim()}
         }
       }
       for (const ruleFile of resolved.rules) {
-        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 src = path9.join(registryDir, "rules", ruleFile);
+        const dest = path9.join(subPaths.rulesDir, ruleFile);
+        if (await fs7.pathExists(src)) {
+          const actualMethod = await this.deployFile(src, dest, iterMethod, options.force);
           const hash = await this.calculateHash(src);
-          const relPath = this.toPosix(path6.relative(targetDir, dest));
+          const relPath = this.toPosix(path9.relative(targetDir, dest));
           const existing = lockfile.files[relPath];
           const existingOwners = existing?.owners ?? [];
           const owners = resolved.targetBundle ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
@@ -2669,27 +3133,33 @@ ${YAML2.stringify(meta).trim()}
           lockfile.bundleModes[resolved.targetBundle] = options.mode;
         }
       }
-      if (hasCanonicalAgents && effectiveFanout.length > 0 && path6.resolve(targetDir) === path6.resolve(agentsTarget)) {
+      if (hasCanonicalAgents && effectiveFanout.length > 0 && path9.resolve(targetDir) === path9.resolve(agentsTarget)) {
         await this.applyFanout(effectiveFanout, resolved, registryDir, scope, targetDir, lockfile, options, projections);
       }
-      await fs4.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
+      if (hasCanonicalAgents && effectiveFanout.includes("claude") && path9.resolve(targetDir) === path9.resolve(agentsTarget)) {
+        await this.applySessionGuard(scope, workspaceRootOf(agentsTarget), lockfile, options, projections);
+      }
+      if (hasCanonicalAgents && effectiveFanout.length > 0 && path9.resolve(targetDir) === path9.resolve(agentsTarget)) {
+        await this.applyPermissionPreset(scope, workspaceRootOf(agentsTarget), lockfile, options, effectiveFanout, projections);
+      }
+      await fs7.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
     }
     return { installed: resolved, targetDirs, dryRun: false, method, projections };
   }
 };
 
 // src/core/uninstaller.ts
-import path7 from "path";
-import crypto2 from "crypto";
-import fs5 from "fs-extra";
+import path10 from "path";
+import crypto3 from "crypto";
+import fs8 from "fs-extra";
 var UninstallEngine = class {
   registry;
   constructor(registry2) {
     this.registry = registry2 || new RegistryResolver();
   }
   async calculateHash(filePath) {
-    const buffer = await fs5.readFile(filePath);
-    return "sha256:" + crypto2.createHash("sha256").update(buffer).digest("hex");
+    const buffer = await fs8.readFile(filePath);
+    return "sha256:" + crypto3.createHash("sha256").update(buffer).digest("hex");
   }
   /**
    * Determines whether a projected file still carries our managed marker. Agent
@@ -2698,14 +3168,14 @@ var UninstallEngine = class {
    * frontmatter, so the marker is checked against the whole content.
    */
   async isManagedProjection(absPath, isAgentsMd, recordedHash) {
-    const content = await fs5.readFile(absPath, "utf8");
+    const content = await fs8.readFile(absPath, "utf8");
     if (isAgentsMd) {
       return content.includes("managed-by: agents-united");
     }
     if (HostProjector.hasManagedMarker(content)) return true;
     if (recordedHash) {
-      const bytes = await fs5.readFile(absPath);
-      return `sha256:${crypto2.createHash("sha256").update(bytes).digest("hex")}` === recordedHash;
+      const bytes = await fs8.readFile(absPath);
+      return `sha256:${crypto3.createHash("sha256").update(bytes).digest("hex")}` === recordedHash;
     }
     return false;
   }
@@ -2714,16 +3184,16 @@ var UninstallEngine = class {
    * (e.g. `.claude/agents/` and then `.claude/`). Only ever removes empty dirs.
    */
   async removeEmptyProjectionDirs(workspaceRoot, projPath) {
-    let dir = path7.dirname(path7.join(workspaceRoot, projPath));
+    let dir = path10.dirname(path10.join(workspaceRoot, projPath));
     while (dir !== workspaceRoot && dir.startsWith(workspaceRoot)) {
       try {
-        const entries = await fs5.readdir(dir);
+        const entries = await fs8.readdir(dir);
         if (entries.length > 0) break;
-        await fs5.rmdir(dir);
+        await fs8.rmdir(dir);
       } catch {
         break;
       }
-      dir = path7.dirname(dir);
+      dir = path10.dirname(dir);
     }
   }
   /**
@@ -2732,8 +3202,8 @@ var UninstallEngine = class {
    */
   async removeProjections(workspaceRoot, projectedTo, force, projectionHashes) {
     for (const projPath of projectedTo) {
-      const absProjection = path7.join(workspaceRoot, projPath);
-      if (!await fs5.pathExists(absProjection)) {
+      const absProjection = path10.join(workspaceRoot, projPath);
+      if (!await fs8.pathExists(absProjection)) {
         continue;
       }
       const isAgentsMd = projPath === "AGENTS.md";
@@ -2749,14 +3219,14 @@ var UninstallEngine = class {
   }
   async safeRemoveProjection(absPath) {
     try {
-      const lstat = await fs5.lstat(absPath);
+      const lstat = await fs8.lstat(absPath);
       if (lstat.isSymbolicLink()) {
-        await fs5.unlink(absPath);
+        await fs8.unlink(absPath);
         return;
       }
     } catch {
     }
-    await fs5.remove(absPath);
+    await fs8.remove(absPath);
   }
   /**
    * Installed-addon freshness (plan 003): after a child bundle (one with a
@@ -2785,9 +3255,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 = path7.join(workspaceRoot, artifact.relPath);
-      if (!await fs5.pathExists(dest)) continue;
-      await fs5.writeFile(dest, artifact.content, "utf8");
+      const dest = path10.join(workspaceRoot, artifact.relPath);
+      if (!await fs8.pathExists(dest)) continue;
+      await fs8.writeFile(dest, artifact.content, "utf8");
       const hash = await this.calculateHash(dest);
       if (lockfile.projections?.[artifact.relPath]) {
         lockfile.projections[artifact.relPath].hash = hash;
@@ -2809,15 +3279,15 @@ var UninstallEngine = class {
     return options.scope || "project";
   }
   async safeRemove(targetDir, relPath) {
-    const fullPath = path7.join(targetDir, relPath);
-    if (relPath.startsWith("skills" + path7.sep) || relPath.startsWith("skills/")) {
+    const fullPath = path10.join(targetDir, relPath);
+    if (relPath.startsWith("skills" + path10.sep) || relPath.startsWith("skills/")) {
       const parts = relPath.split(/[/\\]/);
       if (parts.length >= 2) {
-        const skillDir = path7.join(targetDir, parts[0], parts[1]);
+        const skillDir = path10.join(targetDir, parts[0], parts[1]);
         try {
-          const lstat = await fs5.lstat(skillDir);
+          const lstat = await fs8.lstat(skillDir);
           if (lstat.isSymbolicLink()) {
-            await fs5.unlink(skillDir);
+            await fs8.unlink(skillDir);
             return;
           }
         } catch {
@@ -2825,19 +3295,19 @@ var UninstallEngine = class {
       }
     }
     try {
-      const lstat = await fs5.lstat(fullPath);
+      const lstat = await fs8.lstat(fullPath);
       if (lstat.isSymbolicLink()) {
-        await fs5.unlink(fullPath);
+        await fs8.unlink(fullPath);
         return;
       }
     } catch {
     }
-    await fs5.remove(fullPath);
+    await fs8.remove(fullPath);
   }
   async uninstall(identifier, options = {}) {
     const scope = this.parseScope(options);
     const hosts = this.parseHosts(options);
-    const targetDirs = hosts.map((h) => AgentHostAdapter.resolveHostDir(scope, h, options.targetDir));
+    const targetDirs = hosts.map((h) => h === "agents" ? resolveStateDir(scope, options.targetDir) : AgentHostAdapter.resolveHostDir(scope, h, options.targetDir));
     const resolved = await this.registry.resolve(identifier).catch(() => null);
     const totalRemoved = [];
     const totalKept = [];
@@ -2845,10 +3315,10 @@ var UninstallEngine = class {
     const retainedOwners = /* @__PURE__ */ new Set();
     for (const targetDir of targetDirs) {
       const subPaths = AgentHostAdapter.getSubPaths(targetDir);
-      if (!await fs5.pathExists(subPaths.lockfile)) {
+      if (!await fs8.pathExists(subPaths.lockfile)) {
         continue;
       }
-      const lockfile = await fs5.readJson(subPaths.lockfile);
+      const lockfile = await fs8.readJson(subPaths.lockfile);
       const removedFiles = [];
       const keptFiles = [];
       const staleRecords = [];
@@ -2902,7 +3372,7 @@ var UninstallEngine = class {
         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 = path7.resolve(path7.dirname(targetDir));
+            const workspaceRoot = workspaceRootOf(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) {
@@ -2923,8 +3393,8 @@ var UninstallEngine = class {
                       covering.forEach((o) => retainedOwners.add(o));
                       continue;
                     }
-                    const absProjection = path7.join(workspaceRoot, projRelPath);
-                    const existedOnDisk = await fs5.pathExists(absProjection);
+                    const absProjection = path10.join(workspaceRoot, projRelPath);
+                    const existedOnDisk = await fs8.pathExists(absProjection);
                     if (existedOnDisk) {
                       if (proj.managedMarker) {
                         const managed = await this.isManagedProjection(absProjection, projRelPath === "AGENTS.md");
@@ -2969,8 +3439,8 @@ var UninstallEngine = class {
                 if (assetMeta.projectedTo && assetMeta.projectedTo.length > 0) {
                   await this.removeProjections(workspaceRoot, assetMeta.projectedTo, options.force, lockfile.projections);
                 }
-                const fullPath = path7.join(targetDir, relPath);
-                if (await fs5.pathExists(fullPath) || await fs5.pathExists(fullPath).catch(() => false)) {
+                const fullPath = path10.join(targetDir, relPath);
+                if (await fs8.pathExists(fullPath) || await fs8.pathExists(fullPath).catch(() => false)) {
                   if (!options.force && assetMeta.method !== "symlink") {
                     const currentHash = await this.calculateHash(fullPath).catch(() => null);
                     if (currentHash && currentHash !== assetMeta.hash) {
@@ -2988,10 +3458,10 @@ var UninstallEngine = class {
               }
             }
             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 (await fs8.pathExists(dir)) {
+                const entries = await fs8.readdir(dir).catch(() => []);
                 if (entries.length === 0) {
-                  await fs5.remove(dir);
+                  await fs8.remove(dir);
                 }
               }
             }
@@ -3020,7 +3490,26 @@ var UninstallEngine = class {
               lockfile.installed.workflows = lockfile.installed.workflows.filter((w) => survival.has(`workflows/${w}`));
             }
             await this.refreshParentCoordination(bundleName, workspaceRoot, lockfile, scope);
-            await fs5.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
+            const guard = lockfile.sessionGuard;
+            if (lockfile.installed.bundles.length === 0 && guard && !("off" in guard)) {
+              const guardFile = path10.isAbsolute(guard.file) ? guard.file : path10.join(workspaceRoot, guard.file);
+              const outcome = await removeSessionGuard(guardFile, { createdFile: guard.createdFile });
+              if (outcome === "removed" || outcome === "deleted-file") removedFiles.push(guard.file);
+              delete lockfile.sessionGuard;
+            }
+            const preset = lockfile.permissionPreset;
+            if (lockfile.installed.bundles.length === 0 && preset && !("off" in preset)) {
+              const presetFile = path10.isAbsolute(preset.file) ? preset.file : path10.join(workspaceRoot, preset.file);
+              const outcome = await removePermissionPreset(presetFile, preset.entries, { createdFile: preset.createdFile });
+              if (outcome === "removed" || outcome === "deleted-file") removedFiles.push(preset.file);
+              delete lockfile.permissionPreset;
+            }
+            await fs8.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
+            if (isSidecarDir(targetDir) && lockfile.installed.bundles.length === 0) {
+              await fs8.remove(targetDir);
+              const claudeDir = path10.dirname(targetDir);
+              if ((await fs8.readdir(claudeDir).catch(() => ["keep"])).length === 0) await fs8.remove(claudeDir);
+            }
           } else {
             for (const [relPath, m] of Object.entries(lockfile.files)) {
               const owners = assetOwners(m);
@@ -3042,8 +3531,8 @@ var UninstallEngine = class {
         const itemTargetRelPaths = Object.keys(lockfile.files).filter((p) => p.includes(identifier));
         if (!options.dryRun) {
           for (const relPath of itemTargetRelPaths) {
-            const fullPath = path7.join(targetDir, relPath);
-            if (await fs5.pathExists(fullPath) || await fs5.pathExists(fullPath).catch(() => false)) {
+            const fullPath = path10.join(targetDir, relPath);
+            if (await fs8.pathExists(fullPath) || await fs8.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];
@@ -3056,7 +3545,7 @@ var UninstallEngine = class {
             }
             delete lockfile.files[relPath];
           }
-          await fs5.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
+          await fs8.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
         } else {
           removedFiles.push(...itemTargetRelPaths);
         }
@@ -3080,23 +3569,23 @@ var UninstallEngine = class {
 };
 
 // src/core/inventory.ts
-import path8 from "path";
-import os2 from "os";
-import fs6 from "fs-extra";
+import path11 from "path";
+import os4 from "os";
+import fs9 from "fs-extra";
 var InventoryScanner = class _InventoryScanner {
   registry;
   constructor(registry2) {
     this.registry = registry2 || new RegistryResolver();
   }
   static formatDisplayLocation(scope, host, targetDir, fanout) {
-    const home = os2.homedir();
+    const home = os4.homedir();
     const cwd = process.cwd();
     let prettyPath = targetDir;
     if (targetDir.startsWith(cwd)) {
-      const rel = path8.relative(cwd, targetDir);
+      const rel = path11.relative(cwd, targetDir);
       prettyPath = rel ? `./${rel.replace(/\\/g, "/")}` : ".";
     } else if (targetDir.startsWith(home)) {
-      const rel = path8.relative(home, targetDir);
+      const rel = path11.relative(home, targetDir);
       prettyPath = `~/${rel.replace(/\\/g, "/")}`;
     }
     const fanoutSuffix = fanout && fanout.length > 0 ? ` + ${fanout.join(", ")}` : "";
@@ -3126,14 +3615,14 @@ var InventoryScanner = class _InventoryScanner {
     const candidateDirs = [];
     if (options.targetDir) {
       candidateDirs.push({
-        dir: path8.resolve(options.targetDir),
+        dir: path11.resolve(options.targetDir),
         scope: options.scope || "project",
         host: hosts[0] || "agents"
       });
     } else {
       for (const scope of scopes) {
         for (const host of hosts) {
-          const dir = AgentHostAdapter.resolveHostDir(scope, host);
+          const dir = host === "agents" ? resolveStateDir(scope, void 0, { cwd }) : AgentHostAdapter.resolveHostDir(scope, host);
           candidateDirs.push({ dir, scope, host });
         }
       }
@@ -3143,15 +3632,15 @@ var InventoryScanner = class _InventoryScanner {
     const standaloneRecords = [];
     const scannedTargetDirs = /* @__PURE__ */ new Set();
     const scannedLocationsMap = /* @__PURE__ */ new Map();
-    const home = os2.homedir();
+    const home = os4.homedir();
     for (const scope of scopes) {
-      const canonicalDir = AgentHostAdapter.resolveHostDir(scope, "agents", options.targetDir);
+      const canonicalDir = resolveStateDir(scope, options.targetDir, { cwd });
       let displayLoc = canonicalDir;
       if (canonicalDir.startsWith(cwd)) {
-        const rel = path8.relative(cwd, canonicalDir);
+        const rel = path11.relative(cwd, canonicalDir);
         displayLoc = rel ? `./${rel.replace(/\\/g, "/")}` : ".";
       } else if (canonicalDir.startsWith(home)) {
-        const rel = path8.relative(home, canonicalDir);
+        const rel = path11.relative(home, canonicalDir);
         displayLoc = `~/${rel.replace(/\\/g, "/")}`;
       }
       scannedLocationsMap.set(`${scope}:${canonicalDir}`, {
@@ -3163,14 +3652,14 @@ var InventoryScanner = class _InventoryScanner {
       });
     }
     for (const item of candidateDirs) {
-      const lockfilePath = path8.join(item.dir, "agents-united.json");
-      if (!await fs6.pathExists(lockfilePath)) {
+      const lockfilePath = path11.join(item.dir, "agents-united.json");
+      if (!await fs9.pathExists(lockfilePath)) {
         continue;
       }
       scannedTargetDirs.add(item.dir);
       let lockfile;
       try {
-        lockfile = await fs6.readJson(lockfilePath);
+        lockfile = await fs9.readJson(lockfilePath);
       } catch {
         continue;
       }
@@ -3319,9 +3808,9 @@ var InventoryScanner = class _InventoryScanner {
 };
 
 // src/core/updater.ts
-import path9 from "path";
-import crypto3 from "crypto";
-import fs7 from "fs-extra";
+import path12 from "path";
+import crypto4 from "crypto";
+import fs10 from "fs-extra";
 var UpdateEngine = class _UpdateEngine {
   registry;
   scanner;
@@ -3344,8 +3833,8 @@ var UpdateEngine = class _UpdateEngine {
     return deduplicated;
   }
   async calculateHash(filePath) {
-    const buffer = await fs7.readFile(filePath);
-    return "sha256:" + crypto3.createHash("sha256").update(buffer).digest("hex");
+    const buffer = await fs10.readFile(filePath);
+    return "sha256:" + crypto4.createHash("sha256").update(buffer).digest("hex");
   }
   /**
    * Determines whether a projected file still carries our managed marker (plan 007
@@ -3353,14 +3842,14 @@ var UpdateEngine = class _UpdateEngine {
    * the AGENTS.md bridge has no frontmatter so it is checked over the whole content.
    */
   async isManagedProjection(absPath, isAgentsMd, recordedHash) {
-    const content = await fs7.readFile(absPath, "utf8");
+    const content = await fs10.readFile(absPath, "utf8");
     if (isAgentsMd) {
       return content.includes("managed-by: agents-united");
     }
     if (HostProjector.hasManagedMarker(content)) return true;
     if (recordedHash) {
-      const bytes = await fs7.readFile(absPath);
-      return `sha256:${crypto3.createHash("sha256").update(bytes).digest("hex")}` === recordedHash;
+      const bytes = await fs10.readFile(absPath);
+      return `sha256:${crypto4.createHash("sha256").update(bytes).digest("hex")}` === recordedHash;
     }
     return false;
   }
@@ -3369,13 +3858,13 @@ var UpdateEngine = class _UpdateEngine {
    * every recorded projection still carries the managed marker.
    */
   async staleProjection(record, lockfile) {
-    let workspaceRoot = path9.dirname(record.targetDir);
+    const workspaceRoot = workspaceRootOf(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 = path9.join(workspaceRoot, projPath);
-        if (await fs7.pathExists(absProjection)) {
+        const absProjection = path12.join(workspaceRoot, projPath);
+        if (await fs10.pathExists(absProjection)) {
           const managed = await this.isManagedProjection(absProjection, projPath === "AGENTS.md", lockfile.projections?.[projPath]?.hash);
           if (!managed) {
             return projPath;
@@ -3390,16 +3879,16 @@ var UpdateEngine = class _UpdateEngine {
   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));
+    let dir = path12.dirname(path12.join(workspaceRoot, projPath));
     while (dir !== workspaceRoot && dir.startsWith(workspaceRoot)) {
       try {
-        const entries = await fs7.readdir(dir);
+        const entries = await fs10.readdir(dir);
         if (entries.length > 0) break;
-        await fs7.rmdir(dir);
+        await fs10.rmdir(dir);
       } catch {
         break;
       }
-      dir = path9.dirname(dir);
+      dir = path12.dirname(dir);
     }
   }
   /** Drops one projected path from every canonical file record (host-agnostic). */
@@ -3445,11 +3934,11 @@ var UpdateEngine = class _UpdateEngine {
       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 absProjection = path12.join(workspaceRoot, projRelPath);
+      if (await fs10.pathExists(absProjection)) {
         const managed = await this.isManagedProjection(absProjection, posixPath === "AGENTS.md");
         if (!managed) continue;
-        await fs7.remove(absProjection);
+        await fs10.remove(absProjection);
         await this.removeEmptyProjectionDirs(workspaceRoot, projRelPath);
       }
       delete projections[projRelPath];
@@ -3509,8 +3998,8 @@ var UpdateEngine = class _UpdateEngine {
     if (options.dryRun) {
       const dryProjections = [];
       for (const record of recordsToUpdate) {
-        const lockfilePath = path9.join(record.targetDir, "agents-united.json");
-        if (await fs7.pathExists(lockfilePath)) {
+        const lockfilePath = path12.join(record.targetDir, "agents-united.json");
+        if (await fs10.pathExists(lockfilePath)) {
           const dryResult = await this.installer.install(record.name, {
             scope: record.scope,
             method: record.method,
@@ -3536,18 +4025,18 @@ var UpdateEngine = class _UpdateEngine {
     const skipped = [];
     const collectedProjections = [];
     for (const record of recordsToUpdate) {
-      const lockfilePath = path9.join(record.targetDir, "agents-united.json");
-      if (!await fs7.pathExists(lockfilePath)) {
+      const lockfilePath = path12.join(record.targetDir, "agents-united.json");
+      if (!await fs10.pathExists(lockfilePath)) {
         continue;
       }
-      const lockfile = await fs7.readJson(lockfilePath);
+      const lockfile = await fs10.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 = path9.join(record.targetDir, relPath);
-            if (await fs7.pathExists(fullPath)) {
+            const fullPath = path12.join(record.targetDir, relPath);
+            if (await fs10.pathExists(fullPath)) {
               const currentHash = await this.calculateHash(fullPath).catch(() => null);
               if (currentHash && currentHash !== assetMeta.hash) {
                 hasConflict = true;
@@ -3576,11 +4065,11 @@ var UpdateEngine = class _UpdateEngine {
         }
       }
       const migratedGenerativeUi = await this.migrateLegacyGenerativeUiProjections(
-        path9.dirname(record.targetDir),
+        workspaceRootOf(record.targetDir),
         lockfile
       );
       if (migratedGenerativeUi.length > 0) {
-        await fs7.writeJson(lockfilePath, lockfile, { spaces: 2 });
+        await fs10.writeJson(lockfilePath, lockfile, { spaces: 2 });
       }
       const installResult = await this.installer.install(record.name, {
         scope: record.scope,
@@ -3594,11 +4083,11 @@ var UpdateEngine = class _UpdateEngine {
       if (installResult.projections) {
         collectedProjections.push(...installResult.projections);
       }
-      if (await fs7.pathExists(lockfilePath)) {
-        const updatedLockfile = await fs7.readJson(lockfilePath);
+      if (await fs10.pathExists(lockfilePath)) {
+        const updatedLockfile = await fs10.readJson(lockfilePath);
         updatedLockfile.bundleVersions = updatedLockfile.bundleVersions || {};
         updatedLockfile.bundleVersions[record.name] = record.upstreamVersion;
-        await fs7.writeJson(lockfilePath, updatedLockfile, { spaces: 2 });
+        await fs10.writeJson(lockfilePath, updatedLockfile, { spaces: 2 });
         if (updatedLockfile.fanout) {
           record.fanout = updatedLockfile.fanout;
           record.projections = updatedLockfile.fanout;
@@ -3625,18 +4114,18 @@ var UpdateEngine = class _UpdateEngine {
 };
 
 // src/core/doctor.ts
-import path12 from "path";
-import fs10 from "fs-extra";
-import crypto4 from "crypto";
+import path16 from "path";
+import fs14 from "fs-extra";
+import crypto5 from "crypto";
 import YAML3 from "yaml";
 
 // src/core/claude-capabilities.ts
-import path11 from "path";
-import fs9 from "fs-extra";
+import path14 from "path";
+import fs12 from "fs-extra";
 
 // src/core/cline-capabilities.ts
-import path10 from "path";
-import fs8 from "fs-extra";
+import path13 from "path";
+import fs11 from "fs-extra";
 import { execFile } from "child_process";
 var defaultProcessRunner = (executable, args, options) => {
   return new Promise((resolve) => {
@@ -3693,7 +4182,7 @@ var ClineCapabilityProbe = class {
       return this.customResolver();
     }
     const envBin = process.env.CLINE_BIN_PATH;
-    if (envBin && path10.isAbsolute(envBin) && fs8.existsSync(envBin)) {
+    if (envBin && path13.isAbsolute(envBin) && fs11.existsSync(envBin)) {
       return {
         executable: envBin,
         prefixArgs: [],
@@ -3707,25 +4196,25 @@ var ClineCapabilityProbe = class {
       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)) {
+          const fullPath = path13.join(dir, exeName);
+          if (fs11.existsSync(fullPath)) {
+            const adjacentWrapper1 = path13.join(dir, "node_modules", "cline", "bin", "cline");
+            const adjacentWrapper2 = path13.join(dir, "node_modules", "@cline", "cline", "bin", "cline");
+            if (fs11.existsSync(adjacentWrapper1)) {
               return {
                 executable: process.execPath,
                 prefixArgs: [adjacentWrapper1],
                 source: "node-wrapper"
               };
             }
-            if (fs8.existsSync(adjacentWrapper2)) {
+            if (fs11.existsSync(adjacentWrapper2)) {
               return {
                 executable: process.execPath,
                 prefixArgs: [adjacentWrapper2],
                 source: "node-wrapper"
               };
             }
-            const ext = path10.extname(fullPath).toLowerCase();
+            const ext = path13.extname(fullPath).toLowerCase();
             if (ext === ".cmd" || ext === ".bat") {
               return {
                 executable: "cmd.exe",
@@ -3743,8 +4232,8 @@ var ClineCapabilityProbe = class {
       }
     } else {
       for (const dir of dirs) {
-        const fullPath = path10.join(dir, "cline");
-        if (fs8.existsSync(fullPath)) {
+        const fullPath = path13.join(dir, "cline");
+        if (fs11.existsSync(fullPath)) {
           return {
             executable: fullPath,
             prefixArgs: [],
@@ -3851,7 +4340,7 @@ var ClaudeCapabilityProbe = class {
       return this.customResolver();
     }
     const envBin = process.env.CLAUDE_BIN_PATH;
-    if (envBin && path11.isAbsolute(envBin) && fs9.existsSync(envBin)) {
+    if (envBin && path14.isAbsolute(envBin) && fs12.existsSync(envBin)) {
       return {
         executable: envBin,
         prefixArgs: [],
@@ -3865,25 +4354,25 @@ var ClaudeCapabilityProbe = class {
       const exeNames = ["claude.cmd", "claude.bat", "claude.exe", "claude"];
       for (const dir of dirs) {
         for (const exeName of exeNames) {
-          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)) {
+          const fullPath = path14.join(dir, exeName);
+          if (fs12.existsSync(fullPath)) {
+            const adjacentWrapper1 = path14.join(dir, "node_modules", "@anthropic-ai", "claude-code", "cli.js");
+            const adjacentWrapper2 = path14.join(dir, "node_modules", "claude", "bin", "claude");
+            if (fs12.existsSync(adjacentWrapper1)) {
               return {
                 executable: process.execPath,
                 prefixArgs: [adjacentWrapper1],
                 source: "node-wrapper"
               };
             }
-            if (fs9.existsSync(adjacentWrapper2)) {
+            if (fs12.existsSync(adjacentWrapper2)) {
               return {
                 executable: process.execPath,
                 prefixArgs: [adjacentWrapper2],
                 source: "node-wrapper"
               };
             }
-            const ext = path11.extname(fullPath).toLowerCase();
+            const ext = path14.extname(fullPath).toLowerCase();
             if (ext === ".cmd" || ext === ".bat") {
               return {
                 executable: "cmd.exe",
@@ -3901,8 +4390,8 @@ var ClaudeCapabilityProbe = class {
       }
     } else {
       for (const dir of dirs) {
-        const fullPath = path11.join(dir, "claude");
-        if (fs9.existsSync(fullPath)) {
+        const fullPath = path14.join(dir, "claude");
+        if (fs12.existsSync(fullPath)) {
           return {
             executable: fullPath,
             prefixArgs: [],
@@ -3993,83 +4482,368 @@ var ClaudeCapabilityProbe = class {
   }
 };
 
-// src/core/doctor.ts
-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");
-    }
-    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;
-  }
+// src/core/mcp-locations.ts
+import path15 from "path";
+import os5 from "os";
+import fs13 from "fs-extra";
+function resolveHomeDir() {
+  return process.env.USERPROFILE || process.env.HOME || os5.homedir();
+}
+function resolveAppDataDir(homeDir) {
+  return process.env.APPDATA || (process.platform === "darwin" ? path15.join(homeDir, "Library", "Application Support") : path15.join(homeDir, ".config"));
+}
+function isServerMap(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+var McpLocationRegistry = class _McpLocationRegistry {
   /**
-   * 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 **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
-   * (installer primary path vs parent-bundle refresh path). Matching *either* means the
-   * projection is fresh, which keeps the check false-positive free while still catching
-   * content that matches neither.
+   * Declarative catalog of known MCP configuration files across AI tools, CLIs, extensions, and workspaces.
    */
-  static async renderProjectionVariants(owners, installedBundles, host) {
-    if (owners.size === 0) return null;
-    let resolver;
-    try {
-      resolver = new RegistryResolver();
-      await resolver.loadBundles();
-    } catch {
-      return null;
-    }
-    const registryDir = resolver.getRegistryDir();
-    const variants = /* @__PURE__ */ new Map();
-    for (const owner of owners) {
-      try {
-        const bundleDef = await resolver.getBundle(owner);
-        if (!bundleDef) continue;
-        const resolved = await resolver.resolve(bundleDef.name);
-        for (const excludeAddons of [void 0, installedBundles]) {
-          const artifacts = host === "cline" ? await ClineProjector.planCompoundProjection(
-            bundleDef,
-            "project",
-            resolved,
+  static LOCATIONS = [
+    // --- Google Antigravity & Gemini ---
+    {
+      id: "antigravity-global",
+      host: "gemini",
+      category: "cli",
+      label: "Google Antigravity & Gemini Global Config",
+      resolvePath: (_, home) => path15.join(home, ".gemini", "config", "mcp_config.json"),
+      isPrimary: true
+    },
+    {
+      id: "antigravity-system",
+      host: "gemini",
+      category: "desktop",
+      label: "Google Antigravity System Config",
+      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) => path15.join(cwd, ".gemini", "config", "mcp_config.json")
+    },
+    {
+      id: "gemini-appdata",
+      host: "gemini",
+      category: "cli",
+      label: "Google Gemini AppData Config",
+      resolvePath: (_, __, appData) => path15.join(appData, "gemini", "config", "mcp_config.json")
+    },
+    // --- Cline CLI & VS Code Extension ---
+    {
+      id: "cline-cli-settings",
+      host: "cline",
+      category: "cli",
+      label: "Cline CLI MCP Settings",
+      resolvePath: (_, home) => path15.join(home, ".cline", "data", "settings", "cline_mcp_settings.json"),
+      isPrimary: true
+    },
+    {
+      id: "cline-extension-settings",
+      host: "cline",
+      category: "extension",
+      label: "Cline VS Code Extension Global Settings",
+      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) => 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) => path15.join(home, ".cline", "settings", "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-home-flat",
+      host: "cline",
+      category: "cli",
+      label: "Cline Home Flat Settings",
+      resolvePath: (_, home) => path15.join(home, "cline_mcp_settings.json")
+    },
+    {
+      id: "cline-workspace-flat",
+      host: "cline",
+      category: "workspace",
+      label: "Cline Workspace Settings",
+      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) => path15.join(cwd, ".cline", "mcp.json")
+    },
+    // --- Roo Code Extension ---
+    {
+      id: "roo-code-extension-settings",
+      host: "cline",
+      category: "extension",
+      label: "Roo Code VS Code Extension Settings",
+      resolvePath: (_, __, appData) => path15.join(appData, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json")
+    },
+    // --- Cursor IDE / CLI ---
+    {
+      id: "cursor-workspace",
+      host: "cursor",
+      category: "workspace",
+      label: "Cursor Workspace Config",
+      resolvePath: (cwd) => path15.join(cwd, ".cursor", "mcp.json"),
+      isPrimary: true
+    },
+    {
+      id: "cursor-global",
+      host: "cursor",
+      category: "desktop",
+      label: "Cursor Global User Config",
+      resolvePath: (_, home) => path15.join(home, ".cursor", "mcp.json")
+    },
+    // --- Claude Code CLI & Claude Desktop ---
+    // Plan 029 A4 — Claude Code's documented MCP config paths. The project scope is `.mcp.json` at
+    // the repo root; the user scope (`mcpServers`) and the local scope
+    // (`projects.<abs-path>.mcpServers`) both live in `~/.claude.json`. Claude *Desktop* keeps its
+    // own separate file, which is why that entry is untouched.
+    // (Replaced here: `.claude/mcp.json`, `<cwd>/claude.json` and `~/claude.json` — none of them is
+    // a Claude Code MCP config, and `~/claude.json` was a mis-spelling of `~/.claude.json`.)
+    {
+      id: "claude-project",
+      host: "claude",
+      category: "workspace",
+      label: "Claude Code Project Config (.mcp.json)",
+      resolvePath: (cwd) => path15.join(cwd, ".mcp.json"),
+      isPrimary: true
+    },
+    {
+      id: "claude-user-local",
+      host: "claude",
+      category: "cli",
+      label: "Claude Code User & Local Config (~/.claude.json)",
+      resolvePath: (_, home) => path15.join(home, ".claude.json"),
+      // One file, two scopes: `mcpServers` is the user scope, `projects.<abs-path>.mcpServers` is
+      // the local scope. A workspace can reach both, so discovery reports the union (a local entry
+      // wins on a name collision). The project key is tried in its raw, resolved and forward-slash
+      // spellings because Claude Code writes the absolute project path as the key.
+      selectServers: (config, cwd) => {
+        const user = isServerMap(config?.mcpServers) ? config.mcpServers : {};
+        const projects = isServerMap(config?.projects) ? config.projects : {};
+        const resolved = path15.resolve(cwd);
+        let local = {};
+        for (const key of [cwd, resolved, resolved.split(path15.sep).join("/")]) {
+          const entry = projects[key];
+          if (isServerMap(entry?.mcpServers)) {
+            local = entry.mcpServers;
+            break;
+          }
+        }
+        const merged = { ...user, ...local };
+        return Object.keys(merged).length > 0 ? merged : void 0;
+      }
+    },
+    {
+      id: "claude-desktop-global",
+      host: "claude",
+      category: "desktop",
+      label: "Claude Desktop Global Config",
+      resolvePath: (_, __, appData) => path15.join(appData, "Claude", "claude_desktop_config.json")
+    },
+    // --- Windsurf IDE ---
+    {
+      id: "windsurf-global",
+      host: "windsurf",
+      category: "desktop",
+      label: "Windsurf Global Config",
+      resolvePath: (_, home) => path15.join(home, ".codeium", "windsurf", "mcp_config.json"),
+      isPrimary: true
+    },
+    {
+      id: "windsurf-appdata",
+      host: "windsurf",
+      category: "desktop",
+      label: "Windsurf AppData Config",
+      resolvePath: (_, __, appData) => path15.join(appData, "Windsurf", "mcp_config.json")
+    },
+    // --- OpenCode & Codex ---
+    {
+      id: "opencode-workspace",
+      host: "opencode",
+      category: "workspace",
+      label: "OpenCode Workspace Config",
+      resolvePath: (cwd) => path15.join(cwd, ".opencode", "mcp.json"),
+      isPrimary: true
+    },
+    {
+      id: "opencode-global",
+      host: "opencode",
+      category: "cli",
+      label: "OpenCode Global Config",
+      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 = resolveHomeDir();
+    const appData = resolveAppDataDir(homeDir);
+    const results = [];
+    const seenPaths = /* @__PURE__ */ new Set();
+    for (const desc of _McpLocationRegistry.LOCATIONS) {
+      const resolved = path15.normalize(desc.resolvePath(cwd, homeDir, appData));
+      const key = resolved.toLowerCase();
+      if (seenPaths.has(key)) continue;
+      seenPaths.add(key);
+      const exists = await fs13.pathExists(resolved);
+      let serverCount = 0;
+      let servers;
+      if (exists) {
+        try {
+          const config = await fs13.readJson(resolved);
+          const rawServers = desc.selectServers ? desc.selectServers(config, cwd) : config?.mcpServers || config?.servers || config;
+          if (rawServers && typeof rawServers === "object") {
+            servers = rawServers;
+            serverCount = Object.keys(rawServers).length;
+          }
+        } catch {
+        }
+      }
+      results.push({
+        id: desc.id,
+        host: desc.host,
+        category: desc.category,
+        label: desc.label,
+        path: resolved,
+        exists,
+        serverCount,
+        servers,
+        isPrimary: desc.isPrimary
+      });
+    }
+    return results;
+  }
+  /**
+   * Returns discovered locations filtered for specific host(s).
+   */
+  static async discoverForHosts(hosts, cwd = process.cwd()) {
+    const all = await _McpLocationRegistry.discoverAll(cwd);
+    const hostSet = new Set(hosts.map((h) => h === "agents" ? "gemini" : h));
+    return all.filter((loc) => hostSet.has(loc.host));
+  }
+  /**
+   * Resolves the primary target write path for a given host runtime.
+   */
+  static getPrimaryWritePath(host, cwd = process.cwd()) {
+    const homeDir = resolveHomeDir();
+    const appData = resolveAppDataDir(homeDir);
+    const targetHost = host === "agents" ? "gemini" : host;
+    const desc = _McpLocationRegistry.LOCATIONS.find((l) => l.host === targetHost && l.isPrimary);
+    if (desc) {
+      return path15.normalize(desc.resolvePath(cwd, homeDir, appData));
+    }
+    return path15.normalize(path15.join(cwd, ".cursor", "mcp.json"));
+  }
+};
+
+// src/core/doctor.ts
+var DECLARED_DELTA_HOSTS = /* @__PURE__ */ new Set(["claude", "antigravity", "cline"]);
+var MCP_AUDIT_HOSTS = /* @__PURE__ */ new Set(["claude", "antigravity", "cline"]);
+var MCP_LOCATION_HOST = {
+  claude: "claude",
+  antigravity: "gemini",
+  cline: "cline"
+};
+function mcpAddCommand(host, server, workspaceRoot) {
+  if (host === "antigravity") {
+    return `Add it with: agy mcp add ${server} -- <command> [args...]`;
+  }
+  if (host === "cline") {
+    const settingsPath = McpLocationRegistry.getPrimaryWritePath("cline", workspaceRoot);
+    return `Add it with the interactive wizard: cline mcp install|add <name> (or cline config mcp for the current list); settings live in ${settingsPath}.`;
+  }
+  return `Add it with: claude mcp add ${server} -- <command> [args...]`;
+}
+var DoctorEngine = class _DoctorEngine {
+  static async isManagedProjection(absPath, isAgentsMd, recordedHash) {
+    const content = await fs14.readFile(absPath, "utf8");
+    if (isAgentsMd) {
+      return content.includes("managed-by: agents-united");
+    }
+    if (HostProjector.hasManagedMarker(content)) return true;
+    if (recordedHash) {
+      const bytes = await fs14.readFile(absPath);
+      return `sha256:${crypto5.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 fs14.pathExists(path16.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 **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
+   * (installer primary path vs parent-bundle refresh path). Matching *either* means the
+   * projection is fresh, which keeps the check false-positive free while still catching
+   * content that matches neither.
+   */
+  static async renderProjectionVariants(owners, installedBundles, host) {
+    if (owners.size === 0) return null;
+    let resolver;
+    try {
+      resolver = new RegistryResolver();
+      await resolver.loadBundles();
+    } catch {
+      return null;
+    }
+    const registryDir = resolver.getRegistryDir();
+    const variants = /* @__PURE__ */ new Map();
+    for (const owner of owners) {
+      try {
+        const bundleDef = await resolver.getBundle(owner);
+        if (!bundleDef) continue;
+        const resolved = await resolver.resolve(bundleDef.name);
+        for (const excludeAddons of [void 0, installedBundles]) {
+          const artifacts = host === "cline" ? await ClineProjector.planCompoundProjection(
+            bundleDef,
+            "project",
+            resolved,
             registryDir,
             excludeAddons
           ) : await ClaudeProjector.planCompoundProjection(
@@ -4090,10 +4864,62 @@ var DoctorEngine = class _DoctorEngine {
         continue;
       }
     }
-    return variants;
+    return variants;
+  }
+  /**
+   * Plan 029 A3 — the servers the INSTALLED roles declare, read from each state-dir agent's
+   * `mcpServers:` frontmatter. Names only: a credential, an `env` block or an inline server
+   * definition never reaches this set (Risk R4).
+   */
+  static async declaredMcpServers(agentsDir) {
+    const names = /* @__PURE__ */ new Set();
+    if (!await fs14.pathExists(agentsDir)) return [];
+    for (const file of (await fs14.readdir(agentsDir)).filter((f) => f.endsWith(".md"))) {
+      const content = await fs14.readFile(path16.join(agentsDir, file), "utf8").catch(() => null);
+      if (content === null) continue;
+      const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+      if (!match) continue;
+      let meta;
+      try {
+        meta = YAML3.parse(match[1]) ?? void 0;
+      } catch {
+        continue;
+      }
+      const entries = Array.isArray(meta?.mcpServers) ? meta?.mcpServers : [];
+      for (const entry of entries) {
+        const name = typeof entry === "string" ? entry : entry?.name;
+        if (typeof name === "string" && name.trim().length > 0) names.add(name.trim());
+      }
+    }
+    return [...names].sort();
+  }
+  /**
+   * Plan 029 A3 — warn for every server an installed role declares that this host has NOT
+   * configured, printing that host's own add command. STRICTLY READ-ONLY: doctor reads the MCP
+   * location registry, never installs a server and never writes a config file (the printed command
+   * belongs to the user, and is never executed here).
+   */
+  static async auditMcpServers(host, workspaceRoot, agentsDir, warnings) {
+    const declared = await _DoctorEngine.declaredMcpServers(agentsDir);
+    if (declared.length === 0) return [];
+    const discovered = await McpLocationRegistry.discoverForHosts(
+      [MCP_LOCATION_HOST[host]],
+      workspaceRoot
+    );
+    const configured = /* @__PURE__ */ new Set();
+    for (const location of discovered) {
+      for (const server of Object.keys(location.servers ?? {})) configured.add(server.toLowerCase());
+    }
+    const unconfigured = declared.filter((server) => !configured.has(server.toLowerCase()));
+    for (const server of unconfigured) {
+      warnings.push(
+        `MCP server "${server}" is declared by the installed roles but not configured for --host ${host}. ${mcpAddCommand(host, server, workspaceRoot)}`
+      );
+    }
+    return unconfigured;
   }
   static async runDoctor(targetDir, host) {
-    const root = AgentHostAdapter.resolveHostDir("project", "agents", targetDir);
+    const root = resolveStateDir("project", targetDir);
     const subPaths = AgentHostAdapter.getSubPaths(root);
     const issues = [];
     const warnings = [];
@@ -4104,11 +4930,11 @@ var DoctorEngine = class _DoctorEngine {
     let clineCapability;
     let claudeCapability;
     let isInitialized = false;
-    const lockfileExists = await fs10.pathExists(subPaths.lockfile);
-    const agentsDirExists = await fs10.pathExists(subPaths.agentsDir);
+    const lockfileExists = await fs14.pathExists(subPaths.lockfile);
+    const agentsDirExists = await fs14.pathExists(subPaths.agentsDir);
     if (lockfileExists) {
       try {
-        const parsed = await fs10.readJson(subPaths.lockfile);
+        const parsed = await fs14.readJson(subPaths.lockfile);
         manifest = parsed;
         agentsCount = parsed.installed?.agents?.length || 0;
         skillsCount = parsed.installed?.skills?.length || 0;
@@ -4122,11 +4948,11 @@ var DoctorEngine = class _DoctorEngine {
     } 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 fs10.pathExists(subPaths.agentsDir)) {
-      const agentFiles = await fs10.readdir(subPaths.agentsDir);
+    if (await fs14.pathExists(subPaths.agentsDir)) {
+      const agentFiles = await fs14.readdir(subPaths.agentsDir);
       for (const file of agentFiles) {
         if (file.endsWith(".md")) {
-          const content = await fs10.readFile(path12.join(subPaths.agentsDir, file), "utf8");
+          const content = await fs14.readFile(path16.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.`);
@@ -4143,14 +4969,14 @@ var DoctorEngine = class _DoctorEngine {
         }
       }
     }
-    if (await fs10.pathExists(subPaths.workflowsDir)) {
-      const remainingWorkflowFiles = (await fs10.readdir(subPaths.workflowsDir)).filter((f) => f.endsWith(".md"));
+    if (await fs14.pathExists(subPaths.workflowsDir)) {
+      const remainingWorkflowFiles = (await fs14.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 = path12.resolve(path12.dirname(root));
+      const workspaceRoot = workspaceRootOf(root);
       const warnedProjectionPaths = /* @__PURE__ */ new Set();
       const pushProjectionWarning = (projPath, message) => {
         if (warnedProjectionPaths.has(projPath)) return;
@@ -4161,8 +4987,8 @@ var DoctorEngine = class _DoctorEngine {
         const projectedTo = assetMeta.projectedTo;
         if (!projectedTo || projectedTo.length === 0) continue;
         for (const projPath of projectedTo) {
-          const absProjection = path12.join(workspaceRoot, projPath);
-          if (!await fs10.pathExists(absProjection)) {
+          const absProjection = path16.join(workspaceRoot, projPath);
+          if (!await fs14.pathExists(absProjection)) {
             const superseding = await this.findSupersedingProjection(projPath, relPath, manifest, workspaceRoot);
             if (superseding) {
               const owner = superseding.owners[0];
@@ -4186,8 +5012,8 @@ var DoctorEngine = class _DoctorEngine {
       }
       if (manifest.projections) {
         for (const [projRelPath, proj] of Object.entries(manifest.projections)) {
-          const absPath = path12.join(workspaceRoot, projRelPath);
-          if (!await fs10.pathExists(absPath)) {
+          const absPath = path16.join(workspaceRoot, projRelPath);
+          if (!await fs14.pathExists(absPath)) {
             const superseding = await this.findSupersedingProjection(projRelPath, proj.canonical, manifest, workspaceRoot);
             if (superseding) {
               const owner = superseding.owners[0];
@@ -4230,13 +5056,13 @@ var DoctorEngine = class _DoctorEngine {
             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;
+            const absPath = path16.join(workspaceRoot, projRelPath);
+            if (!await fs14.pathExists(absPath)) continue;
             if (!proj.managedMarker) continue;
-            const content = await fs10.readFile(absPath, "utf8");
+            const content = await fs14.readFile(absPath, "utf8");
             if (!HostProjector.hasManagedMarker(content)) continue;
             if (proj.hash) {
-              const diskHash = `sha256:${crypto4.createHash("sha256").update(await fs10.readFile(absPath)).digest("hex")}`;
+              const diskHash = `sha256:${crypto5.createHash("sha256").update(await fs14.readFile(absPath)).digest("hex")}`;
               if (diskHash !== proj.hash) {
                 const owner = proj.owners[0];
                 pushProjectionWarning(
@@ -4284,6 +5110,77 @@ var DoctorEngine = class _DoctorEngine {
         }
       }
     }
+    if (manifest && isSidecarDir(root)) {
+      for (const [relPath, meta] of Object.entries(manifest.files)) {
+        const abs = path16.join(root, relPath);
+        if (!meta.hash || !await fs14.pathExists(abs)) continue;
+        const diskHash = `sha256:${crypto5.createHash("sha256").update(await fs14.readFile(abs)).digest("hex")}`;
+        if (diskHash !== meta.hash) {
+          warnings.push(`Sidecar snapshot modified: ${relPath} \u2014 .claude/.agents-united/ is machine-owned. Run 'agents update --force' to restore it.`);
+        }
+      }
+    }
+    let sessionGuard;
+    const guardRecord = manifest?.sessionGuard;
+    if (guardRecord) {
+      if ("off" in guardRecord) {
+        sessionGuard = "off";
+      } else {
+        const guardFile = path16.isAbsolute(guardRecord.file) ? guardRecord.file : path16.join(workspaceRootOf(root), guardRecord.file);
+        const state = await inspectSessionGuard(guardFile);
+        sessionGuard = state === "absent" ? "missing" : state;
+        if (state === "missing" || state === "absent") {
+          warnings.push(`Session guard missing from ${guardRecord.file}: plain Claude sessions are unguarded. Run 'agents update' to restore it.`);
+        } else if (state === "modified") {
+          warnings.push(`Session guard in ${guardRecord.file} was edited by hand; agents-united leaves it as-is.`);
+        } else if (state === "skipped-invalid") {
+          warnings.push(`Session guard not wired: ${guardRecord.file} is not valid JSON (comments or trailing commas?), so agents-united left it untouched. Paste this into it by hand:
+${sessionGuardSnippet()}`);
+        }
+      }
+    }
+    let permissionPreset;
+    const presetRecord = manifest?.permissionPreset;
+    if (presetRecord) {
+      if ("off" in presetRecord) {
+        permissionPreset = "off";
+      } else {
+        const presetFile = path16.isAbsolute(presetRecord.file) ? presetRecord.file : path16.join(workspaceRootOf(root), presetRecord.file);
+        if (!await fs14.pathExists(presetFile)) {
+          permissionPreset = "missing";
+          warnings.push(`Permission preset missing: ${presetRecord.file} not found. Run 'agents update' to restore it.`);
+        } else {
+          const text2 = await fs14.readFile(presetFile, "utf8").catch(() => null);
+          let parsed = null;
+          try {
+            parsed = text2 === null ? null : JSON.parse(text2);
+          } catch {
+            parsed = null;
+          }
+          if (parsed === null) {
+            permissionPreset = "skipped-invalid";
+            warnings.push(`Permission preset not wired: ${presetRecord.file} is not valid JSON (comments or trailing commas?), so agents-united left it untouched.`);
+          } else {
+            const allow = parsed.permissions?.allow ?? [];
+            const stillPresent = presetRecord.entries.every((e) => allow.includes(e));
+            permissionPreset = stillPresent ? "wired" : "missing";
+            if (!stillPresent) {
+              warnings.push(`Permission preset partially removed from ${presetRecord.file}. Run 'agents update' to restore it, or --no-permission-preset to drop it for good.`);
+            }
+          }
+        }
+      }
+    }
+    let declaredDeltas;
+    if (host && DECLARED_DELTA_HOSTS.has(host)) {
+      const ledger = loadTranslationLedger(new RegistryResolver().getRegistryDir());
+      declaredDeltas = ledger.filter(
+        (e) => e.host === host && (e.disposition === "degraded" || e.disposition === "unsupported")
+      );
+    }
+    if (host && MCP_AUDIT_HOSTS.has(host)) {
+      await _DoctorEngine.auditMcpServers(host, workspaceRootOf(root), subPaths.agentsDir, warnings);
+    }
     if (host === "cline") {
       const probe = new ClineCapabilityProbe();
       clineCapability = await probe.probe();
@@ -4306,17 +5203,20 @@ var DoctorEngine = class _DoctorEngine {
       agentsCount,
       skillsCount,
       workflowsCount,
+      permissionPreset,
       clineCapability,
-      claudeCapability
+      claudeCapability,
+      sessionGuard,
+      declaredDeltas
     };
   }
 };
 
 // src/core/cline-launcher.ts
-import path13 from "path";
-import os3 from "os";
-import crypto5 from "crypto";
-import fs11 from "fs-extra";
+import path17 from "path";
+import os6 from "os";
+import crypto6 from "crypto";
+import fs15 from "fs-extra";
 var ClineLauncher = class _ClineLauncher {
   probe;
   runner;
@@ -4329,7 +5229,7 @@ var ClineLauncher = class _ClineLauncher {
    */
   static generateTeamName(bundleName, workspace) {
     const sanitizedBundle = bundleName.replace(/[^A-Za-z0-9_-]/g, "-");
-    const hash = crypto5.createHash("sha256").update(path13.resolve(workspace)).digest("hex").slice(0, 8);
+    const hash = crypto6.createHash("sha256").update(path17.resolve(workspace)).digest("hex").slice(0, 8);
     const prefix = `au-${sanitizedBundle}`;
     const maxPrefixLen = 64 - 9;
     const truncatedPrefix = prefix.slice(0, maxPrefixLen);
@@ -4353,19 +5253,19 @@ var ClineLauncher = class _ClineLauncher {
     if (isGlobal) {
       targetDir = AgentHostAdapter.resolveHostDir("global", "agents");
       scope = "global";
-      workspace = os3.homedir();
+      workspace = os6.homedir();
     } else {
       workspace = cwd;
-      targetDir = path13.join(cwd, ".agents");
+      targetDir = path17.join(cwd, ".agents");
       scope = "project";
     }
-    const lockfilePath = path13.join(targetDir, "agents-united.json");
-    if (!await fs11.pathExists(lockfilePath)) {
+    const lockfilePath = path17.join(targetDir, "agents-united.json");
+    if (!await fs15.pathExists(lockfilePath)) {
       if (!isGlobal) {
         const globalTarget = AgentHostAdapter.resolveHostDir("global", "agents");
-        const globalLockfile = path13.join(globalTarget, "agents-united.json");
-        if (await fs11.pathExists(globalLockfile)) {
-          const gLock = await fs11.readJson(globalLockfile);
+        const globalLockfile = path17.join(globalTarget, "agents-united.json");
+        if (await fs15.pathExists(globalLockfile)) {
+          const gLock = await fs15.readJson(globalLockfile);
           if (gLock.installed?.bundles?.includes(bundleName)) {
             return this.resolveInstallation(bundleName, { ...options, global: true });
           }
@@ -4373,14 +5273,14 @@ var ClineLauncher = class _ClineLauncher {
       }
       throw new Error(`Bundle '${bundleName}' is not installed in ${scope} scope.`);
     }
-    const lockfile = await fs11.readJson(lockfilePath);
+    const lockfile = await fs15.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 = path13.join(workspace, manifestRel);
-    if (!hasClineFanout || !await fs11.pathExists(manifestPath)) {
+    const manifestPath = path17.join(workspace, manifestRel);
+    if (!hasClineFanout || !await fs15.pathExists(manifestPath)) {
       throw new Error(
         `Bundle '${bundleName}' is not projected to Cline. Run 'agents update ${bundleName} --fanout cline' first.`
       );
@@ -4480,9 +5380,9 @@ var ClineLauncher = class _ClineLauncher {
 };
 
 // src/core/claude-launcher.ts
-import path14 from "path";
-import os4 from "os";
-import fs12 from "fs-extra";
+import path18 from "path";
+import os7 from "os";
+import fs16 from "fs-extra";
 var DEFAULT_COORDINATOR = "orchestrator-engineering.md";
 var ClaudeLauncher = class _ClaudeLauncher {
   probe;
@@ -4501,7 +5401,7 @@ var ClaudeLauncher = class _ClaudeLauncher {
    */
   static resolveCoordinatorName(orchestrator) {
     const file = (orchestrator && orchestrator.trim().length > 0 ? orchestrator.trim() : DEFAULT_COORDINATOR).replace(/\.md$/i, "");
-    return ClaudeProjector.stripSubagentPrefix(path14.basename(file));
+    return ClaudeProjector.stripSubagentPrefix(path18.basename(file));
   }
   /**
    * Resolve an installed bundle for Claude Code activation. Mirrors `ClineLauncher.resolveInstallation`:
@@ -4514,21 +5414,21 @@ var ClaudeLauncher = class _ClaudeLauncher {
     let scope;
     let workspace;
     if (isGlobal) {
-      targetDir = AgentHostAdapter.resolveHostDir("global", "agents");
+      targetDir = resolveStateDir("global");
       scope = "global";
-      workspace = os4.homedir();
+      workspace = os7.homedir();
     } else {
       workspace = cwd;
-      targetDir = path14.join(cwd, ".agents");
+      targetDir = resolveStateDir("project", void 0, { cwd });
       scope = "project";
     }
-    const lockfilePath = path14.join(targetDir, "agents-united.json");
-    if (!await fs12.pathExists(lockfilePath)) {
+    const lockfilePath = path18.join(targetDir, "agents-united.json");
+    if (!await fs16.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);
+        const globalTarget = resolveStateDir("global");
+        const globalLockfile = path18.join(globalTarget, "agents-united.json");
+        if (await fs16.pathExists(globalLockfile)) {
+          const gLock = await fs16.readJson(globalLockfile);
           if (gLock.installed?.bundles?.includes(bundleName)) {
             return this.resolveInstallation(bundleName, { ...options, global: true });
           }
@@ -4536,14 +5436,14 @@ var ClaudeLauncher = class _ClaudeLauncher {
       }
       throw new Error(`Bundle '${bundleName}' is not installed in ${scope} scope.`);
     }
-    const lockfile = await fs12.readJson(lockfilePath);
+    const lockfile = await fs16.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)) {
+    const manifestPath = path18.join(workspace, manifestRel);
+    if (!hasClaudeFanout && !await fs16.pathExists(manifestPath)) {
       throw new Error(
         `Bundle '${bundleName}' is not projected to Claude. Run 'agents update ${bundleName} --fanout claude' first.`
       );
@@ -4654,260 +5554,319 @@ var ClaudeLauncher = class _ClaudeLauncher {
   }
 };
 
-// src/core/prerequisites.ts
-import path16 from "path";
-import os6 from "os";
-import fs14 from "fs-extra";
+// src/core/antigravity-launcher.ts
+import path20 from "path";
+import os8 from "os";
+import fs18 from "fs-extra";
 
-// src/core/mcp-locations.ts
-import path15 from "path";
-import os5 from "os";
-import fs13 from "fs-extra";
-var McpLocationRegistry = class _McpLocationRegistry {
+// src/core/antigravity-capabilities.ts
+import path19 from "path";
+import fs17 from "fs-extra";
+var AGY_MIN_VERSION = { major: 1, minor: 2, patch: 12 };
+function meetsVersionFloor(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 !== AGY_MIN_VERSION.major) return major > AGY_MIN_VERSION.major;
+  if (minor !== AGY_MIN_VERSION.minor) return minor > AGY_MIN_VERSION.minor;
+  return patch >= AGY_MIN_VERSION.patch;
+}
+function parseModeValues(help) {
+  const line = help.split("\n").find((candidate) => /--mode\b/.test(candidate));
+  if (!line) return [];
+  const afterPlaceholder = line.includes(">") ? line.slice(line.indexOf(">") + 1) : line;
+  return Array.from(
+    new Set(
+      afterPlaceholder.split(",").map((value) => value.trim()).filter((value) => /^[a-z][a-z-]*$/.test(value))
+    )
+  );
+}
+var AntigravityCapabilityProbe = class {
+  runner;
+  customResolver;
+  constructor(runner, options) {
+    this.runner = runner || defaultProcessRunner;
+    this.customResolver = options?.resolveExecutable;
+  }
   /**
-   * Declarative catalog of known MCP configuration files across AI tools, CLIs, extensions, and workspaces.
+   * Safe executable resolution across POSIX and Windows layouts.
    */
-  static LOCATIONS = [
-    // --- Google Antigravity & Gemini ---
-    {
-      id: "antigravity-global",
-      host: "gemini",
-      category: "cli",
-      label: "Google Antigravity & Gemini Global Config",
-      resolvePath: (_, home) => path15.join(home, ".gemini", "config", "mcp_config.json"),
-      isPrimary: true
-    },
-    {
-      id: "antigravity-system",
-      host: "gemini",
-      category: "desktop",
-      label: "Google Antigravity System Config",
-      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) => path15.join(cwd, ".gemini", "config", "mcp_config.json")
-    },
-    {
-      id: "gemini-appdata",
-      host: "gemini",
-      category: "cli",
-      label: "Google Gemini AppData Config",
-      resolvePath: (_, __, appData) => path15.join(appData, "gemini", "config", "mcp_config.json")
-    },
-    // --- Cline CLI & VS Code Extension ---
-    {
-      id: "cline-cli-settings",
-      host: "cline",
-      category: "cli",
-      label: "Cline CLI MCP Settings",
-      resolvePath: (_, home) => path15.join(home, ".cline", "data", "settings", "cline_mcp_settings.json"),
-      isPrimary: true
-    },
-    {
-      id: "cline-extension-settings",
-      host: "cline",
-      category: "extension",
-      label: "Cline VS Code Extension Global Settings",
-      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) => 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) => path15.join(home, ".cline", "settings", "cline_mcp_settings.json")
-    },
-    {
-      id: "cline-home-flat",
-      host: "cline",
-      category: "cli",
-      label: "Cline Home Flat Settings",
-      resolvePath: (_, home) => path15.join(home, "cline_mcp_settings.json")
-    },
-    {
-      id: "cline-workspace-flat",
-      host: "cline",
-      category: "workspace",
-      label: "Cline Workspace Settings",
-      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) => path15.join(cwd, ".cline", "mcp.json")
-    },
-    // --- Roo Code Extension ---
-    {
-      id: "roo-code-extension-settings",
-      host: "cline",
-      category: "extension",
-      label: "Roo Code VS Code Extension Settings",
-      resolvePath: (_, __, appData) => path15.join(appData, "Code", "User", "globalStorage", "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json")
-    },
-    // --- Cursor IDE / CLI ---
-    {
-      id: "cursor-workspace",
-      host: "cursor",
-      category: "workspace",
-      label: "Cursor Workspace Config",
-      resolvePath: (cwd) => path15.join(cwd, ".cursor", "mcp.json"),
-      isPrimary: true
-    },
-    {
-      id: "cursor-global",
-      host: "cursor",
-      category: "desktop",
-      label: "Cursor Global User Config",
-      resolvePath: (_, home) => path15.join(home, ".cursor", "mcp.json")
-    },
-    // --- Claude Code CLI & Claude Desktop ---
-    {
-      id: "claude-workspace-dot",
-      host: "claude",
-      category: "workspace",
-      label: "Claude Code Workspace Config",
-      resolvePath: (cwd) => path15.join(cwd, ".claude", "mcp.json"),
-      isPrimary: true
-    },
-    {
-      id: "claude-workspace-flat",
-      host: "claude",
-      category: "workspace",
-      label: "Claude Workspace claude.json",
-      resolvePath: (cwd) => path15.join(cwd, "claude.json")
-    },
-    {
-      id: "claude-global-dot",
-      host: "claude",
-      category: "cli",
-      label: "Claude Code Global Config",
-      resolvePath: (_, home) => path15.join(home, ".claude", "mcp.json")
-    },
-    {
-      id: "claude-global-flat",
-      host: "claude",
-      category: "cli",
-      label: "Claude Code Global claude.json",
-      resolvePath: (_, home) => path15.join(home, "claude.json")
-    },
-    {
-      id: "claude-desktop-global",
-      host: "claude",
-      category: "desktop",
-      label: "Claude Desktop Global Config",
-      resolvePath: (_, __, appData) => path15.join(appData, "Claude", "claude_desktop_config.json")
-    },
-    // --- Windsurf IDE ---
-    {
-      id: "windsurf-global",
-      host: "windsurf",
-      category: "desktop",
-      label: "Windsurf Global Config",
-      resolvePath: (_, home) => path15.join(home, ".codeium", "windsurf", "mcp_config.json"),
-      isPrimary: true
-    },
-    {
-      id: "windsurf-appdata",
-      host: "windsurf",
-      category: "desktop",
-      label: "Windsurf AppData Config",
-      resolvePath: (_, __, appData) => path15.join(appData, "Windsurf", "mcp_config.json")
-    },
-    // --- OpenCode & Codex ---
-    {
-      id: "opencode-workspace",
-      host: "opencode",
-      category: "workspace",
-      label: "OpenCode Workspace Config",
-      resolvePath: (cwd) => path15.join(cwd, ".opencode", "mcp.json"),
-      isPrimary: true
-    },
-    {
-      id: "opencode-global",
-      host: "opencode",
-      category: "cli",
-      label: "OpenCode Global Config",
-      resolvePath: (_, home) => path15.join(home, ".config", "opencode", "mcp.json")
+  resolveExecutable() {
+    if (this.customResolver) {
+      return this.customResolver();
+    }
+    const envBin = process.env.AGY_BIN_PATH;
+    if (envBin && path19.isAbsolute(envBin) && fs17.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 = ["agy.exe", "agy.cmd", "agy.bat", "agy"];
+      for (const dir of dirs) {
+        for (const exeName of exeNames) {
+          const fullPath = path19.join(dir, exeName);
+          if (!fs17.existsSync(fullPath)) continue;
+          const ext = path19.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 = path19.join(dir, "agy");
+        if (fs17.existsSync(fullPath)) {
+          return {
+            executable: fullPath,
+            prefixArgs: [],
+            source: "path-executable"
+          };
+        }
+      }
     }
-  ];
+    return null;
+  }
   /**
-   * Discovers all MCP configuration files across the filesystem, inspecting existence and parsing server definitions.
+   * Run the read-only capability probe against the local Antigravity CLI. Never throws: an absent
+   * executable, a non-zero exit and a runner error are all reported as data.
    */
-  static async discoverAll(cwd = process.cwd()) {
-    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 = path15.normalize(desc.resolvePath(cwd, homeDir, appData));
-      const key = resolved.toLowerCase();
-      if (seenPaths.has(key)) continue;
-      seenPaths.add(key);
-      const exists = await fs13.pathExists(resolved);
-      let serverCount = 0;
-      let servers;
-      if (exists) {
-        try {
-          const config = await fs13.readJson(resolved);
-          const rawServers = config?.mcpServers || config?.servers || config;
-          if (rawServers && typeof rawServers === "object") {
-            servers = rawServers;
-            serverCount = Object.keys(rawServers).length;
-          }
-        } catch {
-        }
+  async probe() {
+    const cmd = this.resolveExecutable();
+    const diagnostics = [];
+    if (!cmd) {
+      diagnostics.push("Antigravity CLI (agy) not found on PATH or via AGY_BIN_PATH.");
+      return {
+        installed: false,
+        agentFlag: false,
+        promptInteractive: false,
+        modes: [],
+        meetsVersionFloor: false,
+        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(
+          `Antigravity CLI version check failed (exit code ${verRes.exitCode}): ${verRes.stderr.trim()}`
+        );
+        return {
+          installed: false,
+          command: cmd,
+          agentFlag: false,
+          promptInteractive: false,
+          modes: [],
+          meetsVersionFloor: false,
+          diagnostics
+        };
       }
-      results.push({
-        id: desc.id,
-        host: desc.host,
-        category: desc.category,
-        label: desc.label,
-        path: resolved,
-        exists,
-        serverCount,
-        servers,
-        isPrimary: desc.isPrimary
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      diagnostics.push(`Error executing Antigravity CLI version check: ${msg}`);
+      return {
+        installed: false,
+        command: cmd,
+        agentFlag: false,
+        promptInteractive: false,
+        modes: [],
+        meetsVersionFloor: false,
+        diagnostics
+      };
+    }
+    let agentFlag = false;
+    let promptInteractive = false;
+    let modes = [];
+    try {
+      const helpRes = await this.runner(cmd.executable, [...cmd.prefixArgs, "--help"], {
+        timeoutMs: 5e3
       });
+      if (helpRes.exitCode === 0) {
+        const help = helpRes.stdout;
+        agentFlag = help.includes("--agent");
+        promptInteractive = help.includes("--prompt-interactive");
+        modes = parseModeValues(help);
+      } else {
+        diagnostics.push(
+          `Antigravity CLI help probe returned non-zero (exit code ${helpRes.exitCode}); the --agent / --prompt-interactive / --mode surface could not be verified.`
+        );
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      diagnostics.push(`Antigravity CLI help probe failed: ${msg}`);
     }
-    return results;
+    return {
+      installed: true,
+      version,
+      command: cmd,
+      agentFlag,
+      promptInteractive,
+      modes,
+      meetsVersionFloor: meetsVersionFloor(version),
+      diagnostics
+    };
+  }
+};
+
+// src/core/antigravity-launcher.ts
+var DEFAULT_COORDINATOR2 = "orchestrator-engineering.md";
+var AntigravityLauncher = class _AntigravityLauncher {
+  probe;
+  runner;
+  constructor(probe, runner) {
+    this.probe = probe || new AntigravityCapabilityProbe();
+    this.runner = runner || defaultProcessRunner;
   }
   /**
-   * Returns discovered locations filtered for specific host(s).
+   * The `--agent` value must equal the canonical coordinator definition's basename without `.md`.
+   *
+   * Mirrors `ClaudeLauncher.resolveCoordinatorName` (same strip of a leading `subagent-` prefix and
+   * the `.md` suffix) without importing the Claude lane: on Antigravity the canonical file under
+   * `.agents/agents/` is installed verbatim, so its basename *is* the agent name.
    */
-  static async discoverForHosts(hosts, cwd = process.cwd()) {
-    const all = await _McpLocationRegistry.discoverAll(cwd);
-    const hostSet = new Set(hosts.map((h) => h === "agents" ? "gemini" : h));
-    return all.filter((loc) => hostSet.has(loc.host));
+  static resolveCoordinatorName(orchestrator) {
+    const file = (orchestrator && orchestrator.trim().length > 0 ? orchestrator.trim() : DEFAULT_COORDINATOR2).replace(/\.md$/i, "");
+    return path20.basename(file).replace(/^subagent-/, "");
   }
   /**
-   * Resolves the primary target write path for a given host runtime.
+   * Resolve an installed bundle for Antigravity activation. Mirrors
+   * `ClaudeLauncher.resolveInstallation`: same state-dir discovery (`.agents/` store or the
+   * store-less sidecar), same global→project fallback, same error text.
+   *
+   * No host gate is applied here on purpose. The `agents` host IS the canonical store, so a bundle
+   * present in this lockfile is by definition projected to the Antigravity lane; requiring a
+   * separate fanout signal would make `agents start --host antigravity` fail on exactly the install
+   * it is meant to launch. Whether the canonical coordinator file exists is checked by the caller
+   * before anything is spawned.
    */
-  static getPrimaryWritePath(host, cwd = process.cwd()) {
-    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 path15.normalize(desc.resolvePath(cwd, homeDir, appData));
+  async resolveInstallation(bundleName, options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const isGlobal = !!options.global;
+    let targetDir;
+    let scope;
+    let workspace;
+    if (isGlobal) {
+      targetDir = resolveStateDir("global");
+      scope = "global";
+      workspace = os8.homedir();
+    } else {
+      workspace = cwd;
+      targetDir = resolveStateDir("project", void 0, { cwd });
+      scope = "project";
     }
-    return path15.normalize(path15.join(cwd, ".cursor", "mcp.json"));
+    const lockfilePath = path20.join(targetDir, "agents-united.json");
+    if (!await fs18.pathExists(lockfilePath)) {
+      if (!isGlobal) {
+        const globalTarget = resolveStateDir("global");
+        const globalLockfile = path20.join(globalTarget, "agents-united.json");
+        if (await fs18.pathExists(globalLockfile)) {
+          const gLock = await fs18.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 fs18.readJson(lockfilePath);
+    if (!lockfile.installed?.bundles?.includes(bundleName)) {
+      throw new Error(`Bundle '${bundleName}' is not installed in ${scope} scope.`);
+    }
+    const manifestRel = `.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml`;
+    return {
+      scope,
+      workspace,
+      lockfile,
+      manifestPath: path20.join(workspace, manifestRel)
+    };
+  }
+  /**
+   * Plan the argv and bootstrap prompt for an Antigravity 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 } = options;
+    const command = report.command || {
+      executable: "agy",
+      prefixArgs: [],
+      source: "path-executable"
+    };
+    const coordinatorName = _AntigravityLauncher.resolveCoordinatorName(orchestrator);
+    const coordinatorCanonical = `.agents/agents/${coordinatorName}.md`;
+    const manifestRel = scope === "global" ? `~/.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml` : `.agents/plugins/${bundleName}/agents-united/teams/${bundleName}.yaml`;
+    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 bootstrapPrompt = [
+      `You are coordinating the "${bundleName}" team in Agents United.`,
+      `Read the Team Manifest at "${manifestRel}" and your coordinator role definition at "${coordinatorCanonical}" before acting.`,
+      `Delegate specialist work with the invoke_subagent tool; register a specialist with define_subagent only when it is not already reachable by name, and pass the canonical role body verbatim rather than a summary.`,
+      `Use specialist roles only when necessary.`,
+      `Before installing any recommended addon, explain the requirement to the user and request explicit confirmation to run: agents add <addon> -t agents -y.`,
+      taskText
+    ].join("\n\n");
+    const env = {};
+    const argv = [...command.prefixArgs];
+    argv.push("--agent");
+    argv.push(coordinatorName);
+    if (prompt && prompt.trim().length > 0) {
+      argv.push("--prompt-interactive");
+      argv.push(prompt);
+    }
+    return {
+      bundleName,
+      scope,
+      workspace,
+      executable: command.executable,
+      argv,
+      bootstrapPrompt,
+      env
+    };
+  }
+  /**
+   * Launch the Antigravity session from the argv array. Mirrors `ClaudeLauncher.launch`: no shell is
+   * ever used to interpret the command (`shell: false` on the spawn options below), `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", () => {
+        resolve();
+      });
+    });
   }
 };
 
 // src/core/prerequisites.ts
+import path21 from "path";
+import os9 from "os";
+import fs19 from "fs-extra";
 var PrerequisiteChecker = class _PrerequisiteChecker {
   /**
    * Discovers all candidate and existing MCP configuration files across AI hosts
@@ -5018,21 +5977,21 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
         });
       }
     }
-    const homeDir = os6.homedir();
+    const homeDir = os9.homedir();
     const dirCandidates = [
-      path16.join(cwd, ".gemini", "antigravity", "mcp"),
-      path16.join(homeDir, ".gemini", "antigravity", "mcp")
+      path21.join(cwd, ".gemini", "antigravity", "mcp"),
+      path21.join(homeDir, ".gemini", "antigravity", "mcp")
     ];
     for (const dir of dirCandidates) {
-      if (await fs14.pathExists(dir)) {
-        const entries = await fs14.readdir(dir).catch(() => []);
+      if (await fs19.pathExists(dir)) {
+        const entries = await fs19.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: path16.join(dir, entry),
+              path: path21.join(dir, entry),
               disabled: false,
               serverKey: entry
             });
@@ -5057,14 +6016,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 = path16.join(cwd, "node_modules", ...pkgName.split("/"));
-    if (await fs14.pathExists(modulePath)) {
+    const modulePath = path21.join(cwd, "node_modules", ...pkgName.split("/"));
+    if (await fs19.pathExists(modulePath)) {
       return { installed: true, location: modulePath };
     }
-    const pkgJsonPath = path16.join(cwd, "package.json");
-    if (await fs14.pathExists(pkgJsonPath)) {
+    const pkgJsonPath = path21.join(cwd, "package.json");
+    if (await fs19.pathExists(pkgJsonPath)) {
       try {
-        const pkg = await fs14.readJson(pkgJsonPath);
+        const pkg = await fs19.readJson(pkgJsonPath);
         const deps = {
           ...pkg.dependencies,
           ...pkg.devDependencies,
@@ -5087,20 +6046,20 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
       return { set: true, source: "process.env" };
     }
     const envFiles = [
-      path16.join(cwd, ".env.local"),
-      path16.join(cwd, ".env")
+      path21.join(cwd, ".env.local"),
+      path21.join(cwd, ".env")
     ];
     for (const envFile of envFiles) {
-      if (await fs14.pathExists(envFile)) {
+      if (await fs19.pathExists(envFile)) {
         try {
-          const content = await fs14.readFile(envFile, "utf8");
+          const content = await fs19.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: path16.basename(envFile) };
+              return { set: true, source: path21.basename(envFile) };
             }
           }
         } catch {
@@ -5306,11 +6265,11 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
    * activating disabled servers and appending missing definitions.
    */
   static async autoConfigureConfigFile(targetFilePath, mcpNames, mode = "operational", envVars = {}) {
-    await fs14.ensureDir(path16.dirname(targetFilePath));
+    await fs19.ensureDir(path21.dirname(targetFilePath));
     let existingConfig = {};
-    if (await fs14.pathExists(targetFilePath)) {
+    if (await fs19.pathExists(targetFilePath)) {
       try {
-        existingConfig = await fs14.readJson(targetFilePath);
+        existingConfig = await fs19.readJson(targetFilePath);
       } catch {
         existingConfig = {};
       }
@@ -5342,7 +6301,7 @@ var PrerequisiteChecker = class _PrerequisiteChecker {
     } else {
       existingConfig.mcpServers = existingServers;
     }
-    await fs14.writeJson(targetFilePath, existingConfig, { spaces: 2 });
+    await fs19.writeJson(targetFilePath, existingConfig, { spaces: 2 });
     return {
       success: true,
       targetFile: targetFilePath,
@@ -5387,7 +6346,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) => fs15.pathExistsSync(path17.join(cwd, marker)));
+    const found = host.detectionMarkers.some((marker) => fs20.pathExistsSync(path22.join(cwd, marker)));
     if (found) detected.push(host.id);
   }
   return detected;
@@ -5618,12 +6577,12 @@ 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, 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 = {}) => {
+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("--canonical-store", "Keep the .agents/ main library even for a Claude-only install (by default a Claude-only install is store-less: its state lives in the hidden .claude/.agents-united/ folder, ADR 0022)").option("--session-guard [where]", "Claude lane only: also guard PLAIN Claude sessions (no --agent) by adding one managed hook entry that blocks `git push --force`, `.env` writes and `vercel --prod`. where = project (.claude/settings.json, default) | local (.claude/settings.local.json) | user (~/.claude/settings.json). Everything else in the file is kept; invalid JSON is never rewritten. Sticky; --no-session-guard turns it off.").option("--permission-preset [tier]", 'Opt-in only, never implied by -y: pre-approve a small, fixed set of commands in .claude/settings.local.json (never the shared/committed settings.json) so background specialists are not refused command approval outside auto mode. tier = verify (default: git status/diff/log, npx tsc/vitest/eslint) | build (adds npm install/run/test \u2014 executes project code, request explicitly). Never includes git commit/push, rm, curl/wget, or any deploy/publish command. Workspace-scoped only (ignored for --global). Sticky; --no-permission-preset turns it off. Claude only today; other hosts report "not supported yet".').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";
   let method = options.copy ? "copy" : "symlink";
-  let hosts = options.target ? (Array.isArray(options.target) ? options.target : options.target.split(",")).map(
+  let hosts = options.target ? (Array.isArray(options.target) ? options.target : splitHostList(String(options.target))).map(
     (h) => h.trim().toLowerCase()
   ) : ["agents"];
   const unknownHosts = hosts.filter((h) => !isKnownHost(h));
@@ -5632,6 +6591,7 @@ cli.command("add [identifier]", "Add a bundle, agent, skill, or workflow to proj
     hosts = hosts.filter(isKnownHost);
     if (hosts.length === 0) hosts = ["agents"];
   }
+  let selectedHosts = [...hosts];
   const flagPlan = planInstallTargets(hosts);
   hosts = flagPlan.hosts;
   if (flagPlan.addedCanonicalStore) {
@@ -5642,7 +6602,7 @@ cli.command("add [identifier]", "Add a bundle, agent, skill, or workflow to proj
   }
   let fanout = flagPlan.fanout;
   if (options.fanout) {
-    const rawFanout = Array.isArray(options.fanout) ? options.fanout : String(options.fanout).split(",");
+    const rawFanout = Array.isArray(options.fanout) ? options.fanout : splitHostList(String(options.fanout));
     const parsedFanout = rawFanout.map((h) => h.trim().toLowerCase());
     const invalidFanout = parsedFanout.filter((h) => !isKnownHost(h) || !HOST_REGISTRY[h].projectionCapable);
     if (invalidFanout.length > 0) {
@@ -5700,6 +6660,7 @@ cli.command("add [identifier]", "Add a bundle, agent, skill, or workflow to proj
     });
     if (Array.isArray(hostSelection) && hostSelection.length > 0) {
       const wizardPlan = planInstallTargets(hostSelection);
+      selectedHosts = [...hostSelection];
       hosts = wizardPlan.hosts;
       fanout = Array.from(/* @__PURE__ */ new Set([...fanout, ...wizardPlan.fanout]));
       if (wizardPlan.addedCanonicalStore) {
@@ -5746,6 +6707,42 @@ cli.command("add [identifier]", "Add a bundle, agent, skill, or workflow to proj
       method = methodSelection;
     }
   }
+  let sessionGuard;
+  if (options.sessionGuard === false) {
+    sessionGuard = false;
+  } else if (options.sessionGuard === true || options.sessionGuard === "") {
+    sessionGuard = "project";
+  } else if (typeof options.sessionGuard === "string") {
+    const where = options.sessionGuard.trim().toLowerCase();
+    if (where !== "project" && where !== "local" && where !== "user") {
+      note(`--session-guard accepts project, local or user (got "${options.sessionGuard}").`, "Invalid option");
+      process.exit(1);
+    }
+    sessionGuard = where;
+  } else if (isInteractive && fanout.includes("claude")) {
+    const recordedLockfile = path22.join(resolveStateDir(scope), "agents-united.json");
+    const recorded = await fs20.readJson(recordedLockfile).catch(() => null);
+    if (!recorded?.sessionGuard) {
+      const answer = await confirm({
+        message: scope === "global" ? "Also guard plain Claude sessions on this machine? (blocks git push --force, .env writes and vercel --prod in ~/.claude/settings.json)" : "Also guard plain Claude sessions in this repo? (blocks git push --force, .env writes and vercel --prod via .claude/settings.json)",
+        initialValue: true
+      });
+      if (typeof answer === "boolean") sessionGuard = answer ? scope === "global" ? "user" : "project" : false;
+    }
+  }
+  let permissionPreset;
+  if (options.permissionPreset === false) {
+    permissionPreset = false;
+  } else if (options.permissionPreset === true || options.permissionPreset === "") {
+    permissionPreset = "verify";
+  } else if (typeof options.permissionPreset === "string") {
+    const tier = options.permissionPreset.trim().toLowerCase();
+    if (tier !== "verify" && tier !== "build") {
+      note(`--permission-preset accepts verify or build (got "${options.permissionPreset}").`, "Invalid option");
+      process.exit(1);
+    }
+    permissionPreset = tier;
+  }
   if (!identifier) {
     const bundles = await registry.listBundles();
     const domainMeta = {
@@ -5992,6 +6989,16 @@ To bypass this gate and install draft assets anyway, pass: --allow-under-constru
       }
     }
   }
+  const storeShape = planInstallTargets([...selectedHosts, ...fanout], {
+    canonicalStore: options.canonicalStore === true,
+    pluginLane: options.plugin === true
+  }).storeShape;
+  if (storeShape === "sidecar" && !options.dryRun) {
+    note(
+      "Claude only: no .agents/ main library is created. The install state is kept in the hidden\n.claude/.agents-united/ folder (machine-owned \u2014 do not edit). Add --canonical-store to keep .agents/.",
+      "Claude-only install"
+    );
+  }
   const s = spinner();
   s.start(`Resolving "${identifier}"...`);
   try {
@@ -6004,6 +7011,9 @@ To bypass this gate and install draft assets anyway, pass: --allow-under-constru
       // 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,
+      sessionGuard,
+      permissionPreset,
+      storeShape,
       mode: executionMode,
       allowMissingPrereqs: options.allowMissingPrereqs,
       yes: options.yes,
@@ -6231,7 +7241,7 @@ cli.command("update [identifier]", "Update installed packages to upstream regist
   intro(pc.cyan("Agents United \u2014 Package Update Engine"));
   let updateFanout;
   if (options.fanout !== void 0) {
-    const rawFanout = Array.isArray(options.fanout) ? options.fanout : String(options.fanout).split(",");
+    const rawFanout = Array.isArray(options.fanout) ? options.fanout : splitHostList(String(options.fanout));
     const parsedFanout = rawFanout.map((h) => h.trim().toLowerCase()).filter(Boolean);
     const invalidFanout = parsedFanout.filter((h) => !isKnownHost(h) || !HOST_REGISTRY[h].projectionCapable);
     if (invalidFanout.length > 0) {
@@ -6374,7 +7384,7 @@ Updates Available: ${report.outdatedCount > 0 ? pc.yellow(pc.bold(`${report.outd
       const unprojected = [];
       for (const rec of result.updated) {
         try {
-          const lf = await fs15.readJson(path17.join(rec.targetDir, "agents-united.json"));
+          const lf = await fs20.readJson(path22.join(rec.targetDir, "agents-united.json"));
           if (!lf.fanout || lf.fanout.length === 0) unprojected.push(rec.name);
         } catch {
         }
@@ -7097,7 +8107,7 @@ cli.command("init", "Initialize project workspace directory and install recommen
   const s = spinner();
   s.start(`Initializing workspace with bundle "${options.bundle}"...`);
   try {
-    const initTargets = (Array.isArray(options.target) ? options.target : String(options.target || "agents").split(",")).map((h) => h.trim().toLowerCase());
+    const initTargets = (Array.isArray(options.target) ? options.target : splitHostList(String(options.target || "agents"))).map((h) => h.trim().toLowerCase());
     const initPlan = planInstallTargets(initTargets);
     const result = await installer.install(options.bundle, {
       scope: "project",
@@ -7124,8 +8134,20 @@ cli.command("start <bundle> [prompt]", "Start an installed bundle team in its ho
       await runClaudeStart(bundle, prompt, options);
       return;
     }
+    if (effectiveHost === "antigravity") {
+      await runAntigravityStart(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");
+      note(
+        pc.yellow(
+          `Host '${options.host}' has no activation launcher. Launcher-capable lanes: claude, antigravity, cline.
+Re-run with --host claude|antigravity|cline to choose one explicitly.`
+        ),
+        "Host Runtime"
+      );
+      outro(pc.yellow("No session launched."));
+      return;
     }
     const resolution = await launcher.resolveInstallation(bundle, {
       global: options.global,
@@ -7222,6 +8244,7 @@ cli.command("doctor", "Verify health of installed agents, frontmatter schemas, a
       report.warnings.forEach((w) => console.log(`  \u26A0 ${w}`));
       console.log();
     }
+    printDeclaredDeltas(report, options.host);
     outro(pc.blue("\u2728 Workspace is ready for initialization."));
     return;
   }
@@ -7229,6 +8252,27 @@ cli.command("doctor", "Verify health of installed agents, frontmatter schemas, a
   console.log(`  \u26A1 Installed Skills:    ${pc.bold(report.skillsCount.toString())}`);
   console.log(`  \u{1F504} Installed Workflow Skills: ${pc.bold(report.workflowsCount.toString())}
 `);
+  if (report.sessionGuard) {
+    const label = {
+      wired: pc.green("\u2714 Wired (plain Claude sessions guarded)"),
+      off: pc.dim("Off (declined)"),
+      missing: pc.yellow("\u2716 Missing \u2014 run agents update"),
+      modified: pc.yellow("\u26A0 Edited by hand \u2014 left as-is"),
+      "skipped-invalid": pc.yellow("\u26A0 Not wired \u2014 settings file is not valid JSON (see warning)")
+    };
+    console.log(`  \u{1F6E1}  Session Guard:      ${label[report.sessionGuard]}
+`);
+  }
+  if (report.permissionPreset) {
+    const label = {
+      wired: pc.green("\u2714 Wired (npm test/tsc/vitest/eslint pre-approved)"),
+      off: pc.dim("Off (declined)"),
+      missing: pc.yellow("\u2716 Missing or partially removed \u2014 run agents update"),
+      "skipped-invalid": pc.yellow("\u26A0 Not wired \u2014 settings.local.json is not valid JSON (see warning)")
+    };
+    console.log(`  \u{1F511} Permission Preset:   ${label[report.permissionPreset]}
+`);
+  }
   if (report.clineCapability) {
     console.log(pc.bold(pc.cyan("Cline Runtime & Native Discovery Audit:")));
     console.log(`  Installed: ${report.clineCapability.installed ? pc.green("\u2714 Detected") : pc.yellow("\u2716 Not Found")}`);
@@ -7254,6 +8298,7 @@ cli.command("doctor", "Verify health of installed agents, frontmatter schemas, a
     report.warnings.forEach((w) => console.log(`  \u26A0 ${w}`));
     console.log();
   }
+  printDeclaredDeltas(report, options.host);
   if (report.valid && report.issues.length === 0) {
     outro(pc.green("\u2714 All installed agents and frontmatter schemas are healthy!"));
   } else {
@@ -7270,19 +8315,108 @@ async function resolveStartHost(bundle, options) {
     return "cline";
   }
   if (explicitHost.length > 0) {
+    if (explicitHost === "antigravity") {
+      return "antigravity";
+    }
+    if (isKnownHost(explicitHost) && HOST_REGISTRY[explicitHost].profile === "antigravity") {
+      return "antigravity";
+    }
     return "unsupported";
   }
+  let recordedHosts = [];
   let recordedFanout = [];
   try {
-    const detection = await new ClaudeLauncher().resolveInstallation(bundle, {
+    const detection = await new AntigravityLauncher().resolveInstallation(bundle, {
       global: options.global,
       cwd: process.cwd()
     });
+    recordedHosts = detection.lockfile.hosts || [];
     recordedFanout = detection.lockfile.fanout || [];
   } catch {
+    recordedHosts = [];
     recordedFanout = [];
   }
-  return recordedFanout.includes("claude") ? "claude" : "cline";
+  if (recordedFanout.includes("claude")) return "claude";
+  if (recordedHosts.includes("cline") || recordedFanout.includes("cline")) return "cline";
+  const isAntigravityProfile = (host) => isKnownHost(host) && HOST_REGISTRY[host].profile === "antigravity";
+  if (recordedHosts.length > 0 && recordedHosts.every(isAntigravityProfile)) return "antigravity";
+  return "cline";
+}
+async function runAntigravityStart(bundle, prompt, options) {
+  const launcher = new AntigravityLauncher();
+  const probe = new AntigravityCapabilityProbe();
+  const resolution = await launcher.resolveInstallation(bundle, {
+    global: options.global,
+    cwd: process.cwd()
+  });
+  const bundleDef = await registry.getBundle(bundle);
+  const coordinatorName = AntigravityLauncher.resolveCoordinatorName(bundleDef?.orchestrator);
+  const coordinatorRel = path22.posix.join(".agents", "agents", `${coordinatorName}.md`);
+  const probeReport = await probe.probe();
+  if (!probeReport.installed) {
+    note(
+      pc.yellow(
+        `Host: ${pc.cyan("antigravity")} \u2014 the agy CLI was not found on PATH or via AGY_BIN_PATH.
+
+Desktop route (nothing was launched):
+  1. Open this workspace in the Antigravity app.
+  2. @-mention the coordinator definition: ${pc.bold(coordinatorRel)}
+
+To use the CLI lane instead, install agy / put it on PATH, or set AGY_BIN_PATH.`
+      ),
+      "Antigravity (desktop route)"
+    );
+    outro(pc.yellow("No session launched."));
+    return;
+  }
+  const plan = launcher.planActivation({
+    bundleName: bundle,
+    workspace: resolution.workspace,
+    scope: resolution.scope,
+    report: probeReport,
+    prompt,
+    orchestrator: bundleDef?.orchestrator
+  });
+  if (options.dryRun) {
+    note(
+      `Bundle: ${plan.bundleName}
+Tier: ${bundleDef?.tier ?? "not declared (Tier-1 domain default)"}
+Scope: ${plan.scope}
+Workspace: ${plan.workspace}
+Executable: ${plan.executable}
+Argv: ${plan.argv.map((a) => a.includes(" ") || a.includes("\n") ? `"${a.replace(/\n/g, "\\n")}"` : a).join(" ")}`,
+      "Antigravity Activation Plan (dry run)"
+    );
+    outro(pc.yellow("Dry run complete. No processes launched."));
+    return;
+  }
+  const coordinatorDirEntry = path22.join(resolution.workspace, ".agents", "agents", coordinatorName, "agent.md");
+  const coordinatorPath = path22.join(resolution.workspace, ".agents", "agents", `${coordinatorName}.md`);
+  const coordinatorFound = await fs20.pathExists(coordinatorPath) || await fs20.pathExists(coordinatorDirEntry);
+  if (!coordinatorFound) {
+    outro(
+      pc.red(
+        `Canonical coordinator "${coordinatorRel}" was not found in ${resolution.workspace}.
+Run 'agents add ${bundle}' before starting an Antigravity session.`
+      )
+    );
+    process.exit(1);
+  }
+  if (!probeReport.promptInteractive) {
+    note(
+      pc.yellow("The capability probe could not confirm --prompt-interactive from `agy --help`; the opening prompt is still passed as a single argv element."),
+      "Antigravity CLI"
+    );
+  }
+  note(
+    `Host: ${pc.cyan("antigravity")}
+Executable: ${plan.executable}
+Workspace: ${plan.workspace}
+Agent: ${coordinatorName}`,
+    "Starting Antigravity Session"
+  );
+  await launcher.launch(plan);
+  outro(pc.green(`\u2714 Antigravity session finished.`));
 }
 function resolveClaudeTeamsPosture(teamsOption, tier) {
   if (teamsOption === true) return { active: true, reason: "explicit", tier };
@@ -7320,8 +8454,8 @@ async function runClaudeStart(bundle, prompt, options) {
   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 manifestAvailable = await fs20.pathExists(resolution.manifestPath);
+  const pluginDir = options.plugin ? path22.join(".agents", "plugins", bundle).split(path22.sep).join("/") : void 0;
   const plan = launcher.planActivation({
     bundleName: bundle,
     workspace: resolution.workspace,
@@ -7377,7 +8511,7 @@ 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))) {
+  if (!await fs20.pathExists(path22.join(resolution.workspace, coordinatorRel))) {
     outro(
       pc.red(
         `Claude projection "${coordinatorRel}" was not found in ${resolution.workspace}.
@@ -7399,6 +8533,15 @@ function renderClaudeCapabilityBlock(capability) {
   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 printDeclaredDeltas(report, host) {
+  if (!report.declaredDeltas || report.declaredDeltas.length === 0) return;
+  console.log(pc.bold(pc.cyan(`Declared Deltas for --host ${host} (docs/host-primitive-matrix.md):`)));
+  for (const delta of report.declaredDeltas) {
+    const tag = delta.disposition === "unsupported" ? pc.red("unsupported") : pc.yellow("degraded");
+    console.log(`  \u2022 ${pc.bold(delta.feature)} (${tag}): ${delta.rationale}`);
+  }
+  console.log();
+}
 function renderClaudeActivationPlan(plan, report, recordedFanout, posture) {
   const envEntries = Object.keys(plan.env);
   const pluginFlagIndex = plan.argv.indexOf("--plugin-dir");