agents-united 0.5.0 → 0.7.0

package/README.md

@@ -17,7 +17,7 @@ Curated teams of orchestrators, sub-agents, skills, and workflows — installed
 
 - **🪶 Essentials-First & On-Demand Growth**: Every department installs as a lean **Essentials bundle** by default. When a task requires specialized capabilities, the Lead Orchestrator automatically detects the gap, recommends the exact addon, and can auto-install it directly into your project scope.
 - **🌐 One Library, Every Assistant**: Author in `.agents/` as your single source of truth. Agents United automatically projects and translates compatible configurations to **Google Antigravity 2.0 / Gemini**, **Anthropic Claude Code**, **Cursor**, **Cline**, **OpenCode**, and **Codex / AGENTS.md**.
-- **🚀 Cline Native Activation**: Launch specialized teams into Cline CLI sessions with `agents start`, featuring packaged native plugins with `package.json` manifests in `.agents/plugins/<bundle>/`, skill toolkits, coordinator rules, and declarative team manifests.
+- **🚀 Cline Native Activation**: Bundles activate **automatically** in any Cline CLI session — skills discovered natively from `.agents/skills/`, configured-agent roles (`.cline/agents/*.yml`) exposed as spawnable `subagent_*` tools, coordinator rules (`.cline/rules/`), slash-command workflows (`.cline/workflows/`), and spec-conformant Agent Plugin packages (`plugin.json`, agent-plugins.org) in `.agents/plugins/<bundle>/`. No install step required; `agents start` remains available as an optional pre-seeded team-session launcher.
 - **🏛️ 8 Department Domains & 26 Bundles**: Complete coverage across Software Engineering, System Architecture, Product Design, Growth & Marketing, Security, Deep Research, Business Strategy, and Universal Meta-Skills.
 - **🤖 58 Specialized Agents, 91 Skills & 69 Workflows**: 8 Lead Orchestrators coordinating 50 domain sub-agents, backed by 91 production-grade runbooks and 69 deterministic workflows.
 - **⚡ Modern Cloud & AI Tooling**: First-class runbooks for Modal.com, Replicate, RunPod, local LLMs/vLLM, LangChain, LlamaIndex, Qdrant, Vercel, Supabase, Turso, and Azure Bicep.
@@ -119,7 +119,7 @@ Agents United provides **24 curated bundles**, **46 specialized agents** (8 Orch
 | **🔒 Security Operations** | `security-operations` | — | `orchestrator-security` |
 | **🔬 Deep Technical Research** | `deep-research` | — | `orchestrator-research` |
 | **💼 Business Strategy & Economics** | `business-strategy` | — | `orchestrator-business` |
-| **🏢 Organization Bundles (Experimental)** | `digital-agency` 🚧 | *(Currently under development)* | `orchestrator-digital-agency-director` |
+| **🏢 Organization Bundles (Experimental)** | `digital-agency` ⚡ | *(Cross-functional composite)* | `orchestrator-marketing` (Campaign Director / Chris) |
 
 <details>
 <summary><strong>🔍 Click to expand full Department & Agent Roster Breakdown</strong></summary>
@@ -173,7 +173,7 @@ Agents United provides **24 curated bundles**, **46 specialized agents** (8 Orch
 - **Essentials Base (`business-strategy`)**: `subagent-business-panel-experts`
 
 #### 🏢 Organization Bundles (Tier 2 / Experimental)
-- **Digital Product Agency (`digital-agency` 🚧)**: *(Currently under development)*
+- **Digital Product Agency (`digital-agency` ⚡)**: 10-agent cross-functional AstrolabsAI team (Chris / Ava / Kaan / Jamileh / Yavuz / Jale + engineering, QA & compliance) with Tri-Tier MCP execution modes and the Subagent-First Planning Dialogue Loop (ADR 0014).
 
 </details>
 
@@ -297,9 +297,13 @@ agents remove mobile-development -g -y
 ---
 
 ### `agents start <bundle> [prompt]`
-Starts an installed team bundle in its host runtime. **By design, this command currently targets the Cline CLI** because Cline provides an open, programmatic CLI (`cline "prompt"`) that allows us to inject a team context directly from the terminal (unlike other editors which do not yet expose this). 
+Launches an **optional pre-seeded team session** in the Cline CLI. Activation itself is automatic (ADR 0013 native discovery): after `agents add`, *any* `cline` session in the workspace already sees the bundle's skills, `subagent_*` agent tools, rules, and workflow commands. What `agents start` adds on top:
 
-It automatically resolves project vs. global installations, verifies that Cline projections are up-to-date, probes for the `cline` executable on your system, constructs safe non-shell evaluated arguments, and launches the session.
+1. **Coordinator persona bootstrap** — the session starts *as* the bundle's Lead Orchestrator (reads the Team Manifest and coordinator role prompt).
+2. **Persistent team state** — `--team-name au-<bundle>-<hash>` gives a resumable team board (`~/.cline/data/teams/`).
+3. **Addon pre-authorization** — `--allow-addons` skips per-addon consent prompts for the session.
+
+**By design, this command currently targets the Cline CLI** because Cline provides an open, programmatic CLI (`cline "prompt"`) that allows us to inject a team context directly from the terminal (unlike other editors which do not yet expose this). It automatically resolves project vs. global installations, probes for the `cline` executable on your system (Windows node-wrapper, `cmd.exe` shim bridge, or POSIX binary), constructs safe non-shell evaluated arguments, and launches the session.
 
 ```bash
 # Start an installed team in Cline
@@ -363,7 +367,7 @@ Audits workspace agent directories, verifies frontmatter schema validity, valida
 # General workspace health audit
 agents doctor
 
-# Audit Cline runtime installation, capability probe, and compound projection integrity
+# Audit Cline runtime installation, capability probe, and native discovery projection integrity
 agents doctor --host cline
 ```
 
@@ -411,6 +415,19 @@ Organization bundles operate across three dynamic execution envelopes:
 > [!TIP]
 > **Zero Friction Onboarding**: You can start working with your Lead Orchestrator immediately using native tools. If your task needs live integrations (e.g. *"Set up Playwright browser testing"*), your Orchestrator will inspect your OS, configure the exact MCP server, test the connection, and activate it interactively!
 
+### Subagent-First Planning Dialogue Loop (ADR 0014)
+
+Organization bundles can opt into a **delegation-first planning protocol**: the Lead Orchestrator plans *with the user* (Socratic grilling via `/grill-me` / `/grill-with-docs`) and *with the team* — spawning up to 2 **Planning Sidekicks** into the planning conversation, running a bounded **Specialist Council** (every relevant specialist returns a ≤150-word Scope-of-Work Statement), and presenting a **Delegation Map** before any execution starts. Inter-specialist discussion is bounded by a declarative **Consultation Budget**, and each specialist's per-invocation run is hard-capped via Cline `maxIterations`:
+
+| Budget cap | Default | Meaning |
+| :--- | :--- | :--- |
+| `maxPlanningRounds` | 2 | Orchestrator ↔ council cycles per task |
+| `maxPeerExchangesPerPair` | 2 | Directed questions per specialist pair |
+| `summaryWordCap` | 150 | Words per Scope-of-Work Statement |
+| `maxIterations` | 8 | Per-invocation iteration cap (`.cline/agents/*.yml`) |
+
+Currently enabled for `digital-agency` (`planningLoop.enabled` in `registry/bundles.json`); rollout to the remaining bundles is tracked in [`ROADMAP.md`](ROADMAP.md). See [ADR 0014](./docs/adr/0014-subagent-first-planning-loop.md) and [Plan 012](./plans/012-subagent-first-planning-loop.md).
+
 ---
 ## 🌐 One Library, Every Assistant
 
@@ -537,20 +554,25 @@ When contributing new skills or adapting external skills:
 3. **Deterministic Verifications**: Include clear validation commands, error recovery procedures, and code exemplars.
 
 ### 6. Pull Request (PR) Workflow
-1. **Create a Feature Branch**: Always branch from `dev`:
+
+We use a two-line branch model — `main` is the release line, `dev` is the **protected** integration line. Full walkthrough: [`docs/workflow-guide.md`](docs/workflow-guide.md).
+
+1. **Branch from a fresh `dev`** (direct pushes to `dev` are rejected — changes arrive via PR only):
    ```bash
-   git checkout dev
-   git pull origin dev
-   git checkout -b feat/your-feature-name
+   git switch dev && git pull origin dev
+   git switch -c feat/your-feature-name   # or fix/, docs/, ci/
    ```
 2. **Follow TDD (Red-Green-Refactor)**: Author failing unit/E2E tests in `tests/` before implementing code.
 3. **Run Pre-PR Verification**:
    ```bash
+   npm run typecheck && npm test
    npm run build
-   npm test
    git diff --cached   # Audit staged files for accidental secrets or temp files
    ```
-4. **Submit Pull Request**: Open a PR targeting the `dev` branch with a concise description of changes and test results.
+4. **Push early & open PR #1 → base `dev`**: CI runs automatically (typecheck, build, full Vitest suite on `ubuntu-latest`). The PR can only merge once the required **`test`** status check passes.
+5. **Release via PR #2 → base `main`** (compare `dev`): merging triggers **semantic-release** — `feat:` bumps the minor version, `fix:` the patch — then the sync workflow auto-merges `main` back into `dev`.
+
+> Commit messages follow **Conventional Commits**: `feat:` / `fix:` drive releases; `docs:`, `ci:`, `chore:`, `refactor:`, `test:`, `perf:` accumulate without releasing. Emergency production hotfixes branch from `main` and PR directly into it.
 
 ---
 

package/dist/cli.js

@@ -342,47 +342,120 @@ import path4 from "path";
 import fs2 from "fs-extra";
 var ClineProjector = class {
   /**
-   * Render a Cline role definition from canonical agent markdown content.
+   * Managed marker inserted after YAML frontmatter in every rendered artifact.
    */
-  static renderRole(canonicalContent, canonicalRelPath) {
+  static marker(canonicalRelPath) {
     const normCanonical = canonicalRelPath.replace(/\\/g, "/");
-    const marker = `<!-- managed-by: agents-united | profile: cline | canonical: ${normCanonical} | do not edit -->`;
-    const preamble = `## Cline runtime note
+    return `<!-- managed-by: agents-united | profile: cline | canonical: ${normCanonical} | do not edit -->`;
+  }
+  static runtimeNote = `## Cline runtime note
 
 Use the equivalent capabilities available in this Cline session. Canonical tool names describe
-intent and may differ from Cline's runtime tool names. For delegation, prefer Agent Teams when
-available, then session subagents; otherwise complete the role in the main session.`;
+intent and may differ from Cline's runtime tool names. For delegation, prefer the configured
+subagent_* agent tools (projected under .cline/agents/), then session subagents; otherwise
+complete the role in the main session.`;
+  /**
+   * Strip the canonical `subagent-` prefix. Cline prefixes configured-agent tool
+   * names with `subagent_` itself, so keeping the prefix would produce names like
+   * `subagent_subagent_marketing_growth_strategist`.
+   */
+  static stripSubagentPrefix(name) {
+    return name.trim().replace(/^subagent-/, "");
+  }
+  /**
+   * Slugify a workflow display name into a usable slash-command name
+   * (e.g. "Digital Agency Full-Funnel Campaign Orchestration" -> "digital-agency-full-funnel-campaign-orchestration").
+   */
+  static slugifyWorkflowName(name) {
+    return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  }
+  /**
+   * Render a Cline Configured Agent definition (.cline/agents/<role>.yml) from
+   * canonical agent markdown content. Cline 3.x consumes YAML files with
+   * frontmatter (name, description) and treats the body as the agent system prompt.
+   */
+  static renderConfiguredAgent(canonicalContent, canonicalRelPath, defaultMaxIterations) {
     const match = canonicalContent.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
     if (!match) {
-      return `${marker}
-
-${preamble}
-
-${canonicalContent.trim()}`;
+      throw new Error(`Canonical agent ${canonicalRelPath} is missing YAML frontmatter.`);
     }
-    const rawYaml = match[1];
-    const rawBody = match[2];
     let parsed = {};
     try {
-      parsed = yaml.parse(rawYaml) || {};
+      parsed = yaml.parse(match[1]) || {};
     } catch {
       parsed = {};
     }
-    const cleanFrontmatter = {};
-    if (parsed.name) cleanFrontmatter.name = parsed.name;
-    if (parsed.description) cleanFrontmatter.description = parsed.description;
-    if (parsed.providerId) cleanFrontmatter.providerId = parsed.providerId;
-    if (parsed.modelId) cleanFrontmatter.modelId = parsed.modelId;
-    if (parsed.cwd) cleanFrontmatter.cwd = parsed.cwd;
-    if (parsed.maxIterations) cleanFrontmatter.maxIterations = parsed.maxIterations;
+    const baseName = canonicalRelPath.replace(/\\/g, "/").split("/").pop() ?? "";
+    const rawName = typeof parsed.name === "string" && parsed.name.trim().length > 0 ? parsed.name.trim() : baseName.replace(/\.md$/i, "");
+    const cleanFrontmatter = {
+      name: this.stripSubagentPrefix(rawName)
+    };
+    if (typeof parsed.description === "string" && parsed.description.trim().length > 0) {
+      cleanFrontmatter.description = parsed.description.trim();
+    }
+    if (typeof parsed.maxIterations === "number") {
+      cleanFrontmatter.maxIterations = parsed.maxIterations;
+    } else if (typeof defaultMaxIterations === "number") {
+      cleanFrontmatter.maxIterations = defaultMaxIterations;
+    }
     const frontmatterStr = yaml.stringify(cleanFrontmatter).trim();
-    const bodyStr = rawBody.trim();
+    const bodyStr = match[2].trim();
     return `---
 ${frontmatterStr}
 ---
-${marker}
+${this.marker(canonicalRelPath)}
 
-${preamble}
+${this.runtimeNote}
+
+${bodyStr}
+`;
+  }
+  /**
+   * Derive the slash-command slug for a workflow from its frontmatter name,
+   * falling back to the canonical filename. Kept separate from the renderer so the
+   * projection filename and the frontmatter `name` are guaranteed to match.
+   */
+  static workflowSlug(canonicalContent, canonicalRelPath) {
+    const match = canonicalContent.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+    let humanName;
+    if (match) {
+      try {
+        const parsed = yaml.parse(match[1]) || {};
+        if (typeof parsed.name === "string" && parsed.name.trim().length > 0) {
+          humanName = parsed.name.trim();
+        }
+      } catch {
+      }
+    }
+    const baseName = canonicalRelPath.replace(/\\/g, "/").split("/").pop() ?? "";
+    return this.slugifyWorkflowName(humanName ?? baseName.replace(/\.md$/i, ""));
+  }
+  /**
+   * Render a Cline workflow projection (.cline/workflows/<slug>.md). The frontmatter
+   * `name` is slugified so the workflow surfaces as a usable /<slug> command; the
+   * human-readable title stays in `description` and the untouched body.
+   */
+  static renderWorkflowProjection(canonicalContent, canonicalRelPath) {
+    const slug = this.workflowSlug(canonicalContent, canonicalRelPath);
+    const match = canonicalContent.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+    let description;
+    if (match) {
+      try {
+        const parsed = yaml.parse(match[1]) || {};
+        if (typeof parsed.description === "string" && parsed.description.trim().length > 0) {
+          description = parsed.description.trim();
+        }
+      } catch {
+      }
+    }
+    const cleanFrontmatter = { name: slug };
+    if (description) cleanFrontmatter.description = description;
+    const frontmatterStr = yaml.stringify(cleanFrontmatter).trim();
+    const bodyStr = match ? match[2].trim() : canonicalContent.trim();
+    return `---
+${frontmatterStr}
+---
+${this.marker(canonicalRelPath)}
 
 ${bodyStr}
 `;
@@ -450,6 +523,12 @@ ${bodyStr}
         fallbacks: ["adaptive-session", "single-orchestrator"]
       }
     };
+    if (bundle.planningLoop?.enabled) {
+      manifest.planningLoop = bundle.planningLoop;
+      if (bundle.personaAliases && Object.keys(bundle.personaAliases).length > 0) {
+        manifest.personas = Object.entries(bundle.personaAliases).map(([persona, role]) => ({ persona, role }));
+      }
+    }
     return yaml.stringify(manifest);
   }
   /**
@@ -471,6 +550,40 @@ ${bodyStr}
     const addonSection = addons.length > 0 ? `
 ### Recommended Addon Policy
 When user tasks require capabilities from: ${addons.join(", ")}, explain the capability and request user confirmation to install via \`agents add <addon> -t cline -y\` before running the installation.` : "";
+    const planning = bundle.planningLoop?.enabled === true ? bundle.planningLoop : void 0;
+    const budget = planning?.budget;
+    const delegationStep = planning ? "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. 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 ? `
+
+## 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.
+
+### Phase 0 \u2014 User Alignment
+If 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).
+
+### Phase 0.5 \u2014 Sidekick Clarification
+Spawn 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.
+
+### Phase 1 \u2014 Specialist Council
+Have 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.
+
+### Phase 2 \u2014 Delegation Map
+Synthesize the council output into a task \u2192 specialist map and present it to the user BEFORE execution. Then delegate per the map.
+
+### Consultation Budget (hard caps)
+- Planning rounds (orchestrator \u2194 council): max ${budget?.maxPlanningRounds ?? 2}
+- Peer exchanges per specialist pair: max ${budget?.maxPeerExchangesPerPair ?? 2} directed questions
+- Scope-of-Work statement length: max ${budget?.summaryWordCap ?? 150} words
+- Specialist per-invocation iteration cap: maxIterations: ${budget?.maxIterations ?? 8} (rendered into .cline/agents/*.yml)` : "";
+    const personaSection = planning && bundle.personaAliases && Object.keys(bundle.personaAliases).length > 0 ? `
+
+### Persona \u2192 Spawnable Tool Map
+| Persona | Role / Spawnable tool |
+|---|---|
+${Object.entries(bundle.personaAliases).map(([persona, role]) => {
+      const target = role.startsWith("subagent-") ? `${role} \u2192 \`subagent_${this.stripSubagentPrefix(role).replace(/-/g, "_")}\`` : `${role} (you, the coordinator)`;
+      return `| ${persona} | ${target} |`;
+    }).join("\n")}` : "";
     return `# Agents United \u2014 ${bundle.name} Coordinator Rule
 ${marker}
 
@@ -480,9 +593,10 @@ ${marker}
 
 ## Activation Protocol
 1. At session start, read the Team Manifest (\`${manifestRelPath}\`) and coordinator role prompt (\`.agents/${coordinatorCanonical}\`).
-2. Delegate specialist tasks using **Agent Teams** (\`team_spawn_teammate\`, \`team_delegate_task\`) when available, assigning non-overlapping scopes.
+${delegationStep}
 3. For lightweight read-only research, use session subagents.
 4. Only specialist roles declared in the Team Manifest are active in this workspace.
+${planningSection}${personaSection}
 ${specialistLines.length > 0 ? `
 ### Installed Specialist Roles
 ${specialistLines.join("\n")}` : ""}
@@ -497,23 +611,16 @@ ${addonSection}
   static async planCompoundProjection(bundle, scope, resolved, registryDir, excludeAddons = []) {
     const artifacts = [];
     const baseDir = `.agents/plugins/${bundle.name}`;
-    const pluginManifest = {
-      name: `agents-united-${bundle.name}`,
-      version: "1.0.0",
-      description: bundle.description || "",
-      cline: {
-        plugins: [
-          {
-            capabilities: ["skills", "tools", "workflows"],
-            skills: ["./skills"]
-          }
-        ]
-      }
+    const agentPluginManifest = {
+      $schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+      name: bundle.name,
+      version: bundle.version || "1.0.0",
+      description: bundle.description || ""
     };
     artifacts.push({
       kind: "plugin-manifest",
-      relPath: `${baseDir}/package.json`.replace(/\\/g, "/"),
-      content: JSON.stringify(pluginManifest, null, 2),
+      relPath: `${baseDir}/plugin.json`.replace(/\\/g, "/"),
+      content: JSON.stringify(agentPluginManifest, null, 2),
       managedMarker: false
     });
     for (const agentFile of resolved.agents) {
@@ -521,11 +628,16 @@ ${addonSection}
       const srcPath = path4.join(registryDir, "agents", agentFile);
       if (await fs2.pathExists(srcPath)) {
         const content = await fs2.readFile(srcPath, "utf8");
-        const rendered = this.renderRole(content, canonicalRel);
+        const rendered = this.renderConfiguredAgent(
+          content,
+          canonicalRel,
+          bundle.planningLoop?.enabled === true ? bundle.planningLoop.budget?.maxIterations : void 0
+        );
+        const roleName = this.stripSubagentPrefix(agentFile.replace(/\.md$/i, ""));
         artifacts.push({
           kind: "role",
           canonical: canonicalRel,
-          relPath: `${baseDir}/agents/${agentFile}`.replace(/\\/g, "/"),
+          relPath: `.cline/agents/${roleName}.yml`.replace(/\\/g, "/"),
           content: rendered,
           managedMarker: true
         });
@@ -564,10 +676,26 @@ ${addonSection}
         }
       }
     }
+    for (const workflowFile of resolved.workflows) {
+      const canonicalRel = `workflows/${workflowFile}`;
+      const srcPath = path4.join(registryDir, "workflows", workflowFile);
+      if (await fs2.pathExists(srcPath)) {
+        const content = await fs2.readFile(srcPath, "utf8");
+        const slug = this.workflowSlug(content, canonicalRel);
+        const rendered = this.renderWorkflowProjection(content, canonicalRel);
+        artifacts.push({
+          kind: "workflow",
+          canonical: canonicalRel,
+          relPath: `.cline/workflows/${slug}.md`.replace(/\\/g, "/"),
+          content: rendered,
+          managedMarker: true
+        });
+      }
+    }
     const ruleContent = this.renderCoordinatorRule(bundle, scope, excludeAddons);
     artifacts.push({
       kind: "rule",
-      relPath: `${baseDir}/rules/agents-united-${bundle.name}.md`.replace(/\\/g, "/"),
+      relPath: `.cline/rules/agents-united-${bundle.name}.md`.replace(/\\/g, "/"),
       content: ruleContent,
       managedMarker: true
     });
@@ -675,7 +803,7 @@ var HostProjector = class _HostProjector {
       return { content: content2, warnings };
     }
     if (profile === "cline") {
-      const content2 = ClineProjector.renderRole(md, canonicalRelPath);
+      const content2 = ClineProjector.renderConfiguredAgent(md, canonicalRelPath);
       return { content: content2, warnings };
     }
     const out = {};
@@ -1014,21 +1142,6 @@ var InstallEngine = class _InstallEngine {
               }
             }
           }
-          if (lockfile.files) {
-            for (const [canonKey, fileMeta] of Object.entries(lockfile.files)) {
-              if (fileMeta.projectedTo) {
-                const staleClinePaths = fileMeta.projectedTo.filter((p) => p.startsWith(".cline/"));
-                for (const stalePath of staleClinePaths) {
-                  const absPath = path5.join(root, stalePath);
-                  if (await fs3.pathExists(absPath)) {
-                    await fs3.remove(absPath);
-                    await this.removeEmptyProjectionDirs(root, stalePath);
-                  }
-                  this.removeProjectedTo(lockfile, canonKey, stalePath);
-                }
-              }
-            }
-          }
           for (const artifact of artifacts) {
             const dest = path5.join(root, artifact.relPath);
             if (await fs3.pathExists(dest) && !options.force) {
@@ -1116,7 +1229,8 @@ var InstallEngine = class _InstallEngine {
         const content = await fs3.readFile(path5.join(registryDir, "agents", agentFile), "utf8");
         const canonicalRel = this.canonicalRelAgent(agentFile);
         const res = HostProjector.projectAgent(content, HOST_REGISTRY[host].profile, canonicalRel);
-        const dest = path5.join(base, subdir, agentFile);
+        const projName = host === "cline" ? `${agentFile.replace(/\.md$/i, "").replace(/^subagent-/, "")}.yml` : agentFile;
+        const dest = path5.join(base, subdir, projName);
         if (await fs3.pathExists(dest) && !options.force) {
           const existing = await fs3.readFile(dest, "utf8");
           if (!HostProjector.hasManagedMarker(existing)) {
@@ -2030,6 +2144,14 @@ var ClineCapabilityProbe = class {
                 source: "node-wrapper"
               };
             }
+            const ext = path9.extname(fullPath).toLowerCase();
+            if (ext === ".cmd" || ext === ".bat") {
+              return {
+                executable: "cmd.exe",
+                prefixArgs: ["/c", fullPath],
+                source: "path-executable"
+              };
+            }
             return {
               executable: fullPath,
               prefixArgs: [],
@@ -2202,7 +2324,7 @@ var DoctorEngine = class {
         for (const [projRelPath, proj] of Object.entries(manifest.projections)) {
           const absPath = path10.join(workspaceRoot, projRelPath);
           if (!await fs8.pathExists(absPath)) {
-            warnings.push(`Missing compound projection ${projRelPath} (owners: ${proj.owners.join(", ")}).`);
+            warnings.push(`Missing Cline projection ${projRelPath} (owners: ${proj.owners.join(", ")}).`);
             continue;
           }
           if (proj.managedMarker) {
@@ -2373,14 +2495,14 @@ var ClineLauncher = class _ClineLauncher {
     const coordinatorFile = (orchestrator || "orchestrator-engineering.md").replace(/\.md$/, "");
     const coordinatorCanonical = `.agents/agents/${coordinatorFile}.md`;
     const addonPolicyText = allowAddons ? "Addon auto-installation is pre-authorized for this session." : `Before installing any recommended addon, explain the requirement to the user and request explicit confirmation to run: agents add <addon> -t cline ${scope === "global" ? "-g " : ""}-y.`;
-    const pluginInstallText = `Before proceeding, ensure you have installed this bundle's plugin by running: cline plugin install .agents/plugins/${bundleName}`;
+    const deploymentNoteText = `Deployment note: this bundle is already projected natively for this workspace (skills, rules, workflows, and configured subagent roles) - no "cline plugin install" step is needed.`;
     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.`,
       `Use specialist roles only when necessary.`,
       addonPolicyText,
-      pluginInstallText,
+      deploymentNoteText,
       taskText
     ].join("\n\n");
     const argv = [...command.prefixArgs];
@@ -3344,7 +3466,7 @@ cli.command("add [identifier]", "Add a bundle, agent, skill, or workflow to proj
         {
           value: "cline",
           label: HOST_REGISTRY.cline.label,
-          hint: detectedHosts.includes("cline") ? "found in this project" : "roles, skills, coordinator rules & team manifests for Cline"
+          hint: detectedHosts.includes("cline") ? "found in this project" : "configured agents, skills, rules, workflows & team manifests for Cline"
         },
         {
           value: "opencode",
@@ -3699,6 +3821,12 @@ ${renderProjections(result.projections)}` : ""),
       "Installation Success"
     );
     const hasClineProjection = result.projections.some((p) => p.host === "cline");
+    if (hasClineProjection && !options.dryRun) {
+      note(
+        pc.green(`Already active: any Cline session in this workspace now sees this bundle's skills, subagent_* agent tools, rules & workflow commands (ADR 0013 native discovery).`),
+        "Native Activation"
+      );
+    }
     if (options.start && !hasClineProjection) {
       throw new Error("--start requires Cline projection. Add -t cline or --fanout cline.");
     }
@@ -3762,8 +3890,10 @@ ${renderProjections(result.projections)}` : ""),
     if (!options.dryRun && hosts.includes("agents") && result.projections.length === 0) {
       note(
         pc.yellow(
-          `Tip: only Antigravity reads the main library (.agents/) directly.
-To use this bundle in Cline, Claude Code & others: agents update ${identifier} --fanout cline,claude`
+          `Tip: Antigravity reads the main library (.agents/) directly, and Cline natively
+discovers skills from .agents/skills/ (ADR 0013). For Cline configured agents,
+rules & workflows run: agents update ${identifier} --fanout cline
+(add claude, cursor, opencode, codex for other assistants)`
         ),
         "One library, every assistant"
       );
@@ -3974,8 +4104,8 @@ Updates Available: ${report.outdatedCount > 0 ? pc.yellow(pc.bold(`${report.outd
       if (unprojected.length > 0) {
         note(
           pc.yellow(
-            `Tip: not synced to other assistants yet (only Antigravity reads .agents/).
-To add Cline & friends: agents update ${unprojected[0]} --fanout cline,claude`
+            `Tip: not fully synced to other assistants yet (Antigravity reads .agents/ directly; Cline natively discovers .agents/skills/).
+For Cline configured agents, rules & workflows: agents update ${unprojected[0]} --fanout cline`
           ),
           "One library, every assistant"
         );
@@ -4398,6 +4528,12 @@ Projections:
 ${renderProjections(result.projections)}` : ""),
         "Installation Success"
       );
+      if (result.projections.some((p) => p.host === "cline")) {
+        note(
+          pc.green(`Already active: any Cline session in this workspace now sees this bundle's skills, subagent_* agent tools, rules & workflow commands (ADR 0013 native discovery). Use "agents start ${bundle.name}" for a pre-seeded team session.`),
+          "Native Activation"
+        );
+      }
       outro(pc.green(`\u2728 Installation of "${bundle.name}" complete!`));
     } catch (err) {
       installSpinner.stop(pc.red("Installation failed"));
@@ -4453,7 +4589,7 @@ cli.command("list", "List available bundles grouped by department domain").alias
       domainOptions.push({
         value: "__full_tree__",
         label: "\u{1F333} View Full Static Catalog Tree",
-        hint: "expand all 18 bundles and 8 departments at once"
+        hint: `expand all ${bundles.length} bundles and ${new Set(bundles.map((b) => b.domain).filter(Boolean)).size} departments at once`
       });
       const selectedDomain = await select({
         message: "Select Department Domain to explore:",
@@ -4730,10 +4866,11 @@ cli.command("doctor", "Verify health of installed agents, frontmatter schemas, a
     console.log(pc.bold(pc.cyan("\u{1F4A1} Get Started:")));
     console.log(`  \u{1F449} ${pc.bold("agents add")}                      Launch the interactive installation wizard`);
     console.log(`  \u{1F449} ${pc.bold("agents add software-engineering")} Install the engineering essentials team`);
-    console.log(`  \u{1F449} ${pc.bold("agents list")}                     Browse all 23 bundles and 8 departments
+    const bundleCount = (await registry.listBundles()).length;
+    console.log(`  \u{1F449} ${pc.bold("agents list")}                     Browse all ${bundleCount} bundles by department
 `);
     if (report.clineCapability) {
-      console.log(pc.bold(pc.cyan("Cline Runtime & Compound Projection Audit:")));
+      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")}`);
       if (report.clineCapability.version) {
         console.log(`  Version: ${report.clineCapability.version}`);
@@ -4754,13 +4891,13 @@ cli.command("doctor", "Verify health of installed agents, frontmatter schemas, a
   console.log(`  \u{1F504} Installed Workflows: ${pc.bold(report.workflowsCount.toString())}
 `);
   if (report.clineCapability) {
-    console.log(pc.bold(pc.cyan("Cline Runtime & Compound Projection Audit:")));
+    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")}`);
     if (report.clineCapability.version) {
       console.log(`  Version: ${report.clineCapability.version}`);
     }
     console.log(`  Named Teams: ${report.clineCapability.namedTeams ? pc.green("\u2714 Supported") : pc.yellow("\u2716 Unsupported (Adaptive fallback)")}`);
-    console.log(`  Role Definitions: ${report.agentsCount} prepared (activation via "agents start")
+    console.log(`  Configured Agents: ${report.agentsCount} active natively in any Cline session ("agents start" = optional team-session launcher)
 `);
   }
   if (report.issues.length > 0) {