agents-united 1.2.0 → 1.3.0

package/README.md

@@ -368,7 +368,7 @@ agents doctor --host cline
 ---
 ## 🌐 One Library, Every Assistant
 
-The `.agents/` folder is the **main library** — the *one* folder you edit. **Antigravity reads it directly**; every other assistant (Claude Code, Cursor, Cline, OpenCode, Codex) can't read it natively, so Agents United writes **translated copies** it keeps in sync for you.
+The `.agents/` folder is the **main library** — the *one* folder you edit. **Antigravity reads it directly** for interactive sessions (CLI TUI and desktop); see [ADR 0009](./docs/adr/0009-host-conformance-targets.md). Every other assistant (Claude Code, Cursor, Cline, OpenCode, Codex) can't read it natively, so Agents United writes **translated copies** it keeps in sync for you.
 
 - **Edit only `.agents/`.** That's your source of truth — the `agents-united.json` lockfile tracks it.
 - **Other assistants get their own translated copies**, in their own folders (`.claude/agents/`, `.cline/agents/`, …). Don't edit those — they're machine-managed and rewritten on every `agents update`.

package/dist/cli.js

@@ -419,8 +419,10 @@ ${bodyStr}
   }
   /**
    * Render Team Manifest YAML matching ClineTeamManifest schema.
+   * @param excludeAddons optional addon names to omit from `recommendedAddons`
+   *   (used to stop advertising bundles already present in the workspace).
    */
-  static renderTeamManifest(bundle, scope) {
+  static renderTeamManifest(bundle, scope, excludeAddons = []) {
     const coordinatorFile = bundle.orchestrator || `${bundle.name}.md`;
     const coordinatorName = coordinatorFile.replace(/\.md$/, "");
     const coordinatorCanonical = `agents/${coordinatorFile}`;
@@ -430,7 +432,7 @@ ${bodyStr}
     }));
     const sortedSkills = [...bundle.skills || []].sort();
     const sortedWorkflows = [...bundle.workflows || []].sort();
-    const recommendedAddons = bundle.recommendedAddons || [];
+    const recommendedAddons = (bundle.recommendedAddons || []).filter((a) => !excludeAddons.includes(a));
     const manifest = {
       schemaVersion: 1,
       bundle: bundle.name,
@@ -452,8 +454,10 @@ ${bodyStr}
   }
   /**
    * Render the coordinator rule file (.cline/rules/agents-united-<bundle>.md).
+   * @param excludeAddons optional addon names to omit from the "Recommended Addon
+   *   Policy" list (used to stop advertising bundles already installed).
    */
-  static renderCoordinatorRule(bundle, scope) {
+  static renderCoordinatorRule(bundle, scope, excludeAddons = []) {
     const marker = `<!-- managed-by: agents-united | profile: cline | bundle: ${bundle.name} | do not edit -->`;
     const manifestRelPath = scope === "global" ? `~/.cline/agents-united/teams/${bundle.name}.yaml` : `.cline/agents-united/teams/${bundle.name}.yaml`;
     const coordinatorFile = bundle.orchestrator || `${bundle.name}.md`;
@@ -463,7 +467,7 @@ ${bodyStr}
       const name = agentFile.replace(/\.md$/, "");
       return `- **${name}**: \`.agents/agents/${agentFile}\``;
     });
-    const addons = bundle.recommendedAddons || [];
+    const addons = (bundle.recommendedAddons || []).filter((a) => !excludeAddons.includes(a));
     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.` : "";
@@ -487,8 +491,10 @@ ${addonSection}
   }
   /**
    * Plan all compound artifacts for a bundle installation into Cline.
+   * @param excludeAddons optional addon names forwarded to the coordinator rule and
+   *   team manifest renderers so already-installed bundles are not advertised.
    */
-  static async planCompoundProjection(bundle, scope, resolved, registryDir) {
+  static async planCompoundProjection(bundle, scope, resolved, registryDir, excludeAddons = []) {
     const artifacts = [];
     const baseDir = scope === "global" ? ".cline" : ".cline";
     for (const agentFile of resolved.agents) {
@@ -539,14 +545,14 @@ ${addonSection}
         }
       }
     }
-    const ruleContent = this.renderCoordinatorRule(bundle, scope);
+    const ruleContent = this.renderCoordinatorRule(bundle, scope, excludeAddons);
     artifacts.push({
       kind: "rule",
       relPath: `${baseDir}/rules/agents-united-${bundle.name}.md`.replace(/\\/g, "/"),
       content: ruleContent,
       managedMarker: true
     });
-    const manifestContent = this.renderTeamManifest(bundle, scope);
+    const manifestContent = this.renderTeamManifest(bundle, scope, excludeAddons);
     artifacts.push({
       kind: "team-manifest",
       relPath: `${baseDir}/agents-united/teams/${bundle.name}.yaml`.replace(/\\/g, "/"),
@@ -948,6 +954,11 @@ var InstallEngine = class _InstallEngine {
       if (host === "cline") {
         const bundleDef = resolved.targetBundle ? await this.registry.getBundle(resolved.targetBundle) : void 0;
         if (bundleDef) {
+          const declared = /* @__PURE__ */ new Set();
+          if (bundleDef.orchestrator) declared.add(`agents/${bundleDef.orchestrator}`);
+          (bundleDef.agents || []).forEach((a) => declared.add(`agents/${a}`));
+          (bundleDef.skills || []).forEach((s) => declared.add(`skills/${s}/SKILL.md`));
+          (bundleDef.workflows || []).forEach((w) => declared.add(`workflows/${w}`));
           const artifacts = await ClineProjector.planCompoundProjection(bundleDef, scope, resolved, registryDir);
           for (const artifact of artifacts) {
             const dest = path5.join(root, artifact.relPath);
@@ -978,14 +989,16 @@ var InstallEngine = class _InstallEngine {
             lockfile.projections = lockfile.projections || {};
             const existingProj = lockfile.projections[artifact.relPath];
             const bundleName = bundleDef.name;
-            const owners = existingProj?.owners ? Array.from(/* @__PURE__ */ new Set([...existingProj.owners, bundleName])) : [bundleName];
+            const declares = artifact.kind === "rule" || artifact.kind === "team-manifest" || (artifact.canonical ? declared.has(artifact.canonical) : false);
+            const priorOwners = existingProj?.owners ?? [];
+            const owners = declares ? Array.from(/* @__PURE__ */ new Set([...priorOwners, bundleName])) : priorOwners;
             lockfile.projections[artifact.relPath] = {
               host: "cline",
               kind: artifact.kind,
               canonical: artifact.canonical,
               owners,
               hash: deployedHash,
-              installedAt: now,
+              installedAt: existingProj?.installedAt ?? now,
               managedMarker: artifact.managedMarker
             };
             projections.push({ host, path: artifact.relPath, kind: artifact.kind, warnings: [] });
@@ -993,6 +1006,38 @@ var InstallEngine = class _InstallEngine {
               this.recordProjectedTo(lockfile, artifact.canonical, artifact.relPath);
             }
           }
+          if (bundleDef.parentBundle) {
+            const parentDef = await this.registry.getBundle(bundleDef.parentBundle);
+            if (parentDef) {
+              const parentProjection = await ClineProjector.planCompoundProjection(
+                parentDef,
+                scope,
+                resolved,
+                registryDir,
+                lockfile.installed.bundles
+              );
+              for (const artifact of parentProjection) {
+                if (artifact.kind !== "rule" && artifact.kind !== "team-manifest") continue;
+                if (artifact.content === void 0) continue;
+                const dest = path5.join(root, artifact.relPath);
+                if (!await fs3.pathExists(dest)) continue;
+                await this.deployProjection(dest, artifact.content);
+                const deployedHash = await this.calculateHash(dest);
+                lockfile.projections = lockfile.projections || {};
+                const existingProj = lockfile.projections[artifact.relPath];
+                lockfile.projections[artifact.relPath] = {
+                  host: "cline",
+                  kind: artifact.kind,
+                  canonical: artifact.canonical,
+                  // Preserve existing ownership; the parent remains the sole owner.
+                  owners: existingProj?.owners ?? [],
+                  hash: deployedHash,
+                  installedAt: existingProj?.installedAt ?? now,
+                  managedMarker: artifact.managedMarker
+                };
+              }
+            }
+          }
           continue;
         }
       }
@@ -1048,6 +1093,16 @@ var InstallEngine = class _InstallEngine {
       if (options.fanout !== void 0) {
         lockfile.fanout = effectiveFanout;
       }
+      const declared = /* @__PURE__ */ new Set();
+      if (resolved.targetBundle) {
+        const bundleDef = await this.registry.getBundle(resolved.targetBundle);
+        if (bundleDef) {
+          if (bundleDef.orchestrator) declared.add(`agents/${bundleDef.orchestrator}`);
+          (bundleDef.agents || []).forEach((a) => declared.add(`agents/${a}`));
+          (bundleDef.skills || []).forEach((s) => declared.add(`skills/${s}/SKILL.md`));
+          (bundleDef.workflows || []).forEach((w) => declared.add(`workflows/${w}`));
+        }
+      }
       for (const agentFile of resolved.agents) {
         const src = path5.join(registryDir, "agents", agentFile);
         const dest = path5.join(subPaths.agentsDir, agentFile);
@@ -1060,14 +1115,18 @@ var InstallEngine = class _InstallEngine {
         }
         const actualMethod = await this.deployFile(src, dest, method, options.force);
         const hash = await this.calculateHash(src);
-        const relPath = path5.relative(targetDir, dest);
-        const previousProjections = lockfile.files[relPath]?.projectedTo;
+        const relPath = this.toPosix(path5.relative(targetDir, dest));
+        const existing = lockfile.files[relPath];
+        const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
+        const declaresAsset = declared.has(`agents/${agentFile}`);
+        const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
         lockfile.files[relPath] = {
           hash,
-          bundle: resolved.targetBundle,
+          bundle: existing?.bundle ?? resolved.targetBundle,
+          owners,
           method: actualMethod,
-          installedAt: now,
-          ...previousProjections ? { projectedTo: previousProjections } : {}
+          installedAt: existing?.installedAt ?? now,
+          ...existing?.projectedTo ? { projectedTo: existing.projectedTo } : {}
         };
         if (!lockfile.installed.agents.includes(agentFile)) {
           lockfile.installed.agents.push(agentFile);
@@ -1080,14 +1139,18 @@ var InstallEngine = class _InstallEngine {
         const skillFile = path5.join(src, "SKILL.md");
         if (await fs3.pathExists(skillFile)) {
           const hash = await this.calculateHash(skillFile);
-          const relPath = path5.relative(targetDir, path5.join(subPaths.skillsDir, skillName, "SKILL.md"));
-          const previousProjections = lockfile.files[relPath]?.projectedTo;
+          const relPath = this.toPosix(path5.relative(targetDir, path5.join(subPaths.skillsDir, skillName, "SKILL.md")));
+          const existing = lockfile.files[relPath];
+          const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
+          const declaresAsset = declared.has(`skills/${skillName}/SKILL.md`);
+          const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
           lockfile.files[relPath] = {
             hash,
-            bundle: resolved.targetBundle,
+            bundle: existing?.bundle ?? resolved.targetBundle,
+            owners,
             method: actualMethod,
-            installedAt: now,
-            ...previousProjections ? { projectedTo: previousProjections } : {}
+            installedAt: existing?.installedAt ?? now,
+            ...existing?.projectedTo ? { projectedTo: existing.projectedTo } : {}
           };
         }
         if (!lockfile.installed.skills.includes(skillName)) {
@@ -1099,14 +1162,18 @@ var InstallEngine = class _InstallEngine {
         const dest = path5.join(subPaths.workflowsDir, workflowFile);
         const actualMethod = await this.deployFile(src, dest, method, options.force);
         const hash = await this.calculateHash(src);
-        const relPath = path5.relative(targetDir, dest);
-        const previousProjections = lockfile.files[relPath]?.projectedTo;
+        const relPath = this.toPosix(path5.relative(targetDir, dest));
+        const existing = lockfile.files[relPath];
+        const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
+        const declaresAsset = declared.has(`workflows/${workflowFile}`);
+        const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
         lockfile.files[relPath] = {
           hash,
-          bundle: resolved.targetBundle,
+          bundle: existing?.bundle ?? resolved.targetBundle,
+          owners,
           method: actualMethod,
-          installedAt: now,
-          ...previousProjections ? { projectedTo: previousProjections } : {}
+          installedAt: existing?.installedAt ?? now,
+          ...existing?.projectedTo ? { projectedTo: existing.projectedTo } : {}
         };
         if (!lockfile.installed.workflows.includes(workflowFile)) {
           lockfile.installed.workflows.push(workflowFile);
@@ -1118,12 +1185,18 @@ var InstallEngine = class _InstallEngine {
         if (await fs3.pathExists(src)) {
           const actualMethod = await this.deployFile(src, dest, method, options.force);
           const hash = await this.calculateHash(src);
-          const relPath = path5.relative(targetDir, dest);
+          const relPath = this.toPosix(path5.relative(targetDir, dest));
+          const existing = lockfile.files[relPath];
+          const existingOwners = existing?.owners ?? (existing?.bundle ? [existing.bundle] : []);
+          const declaresAsset = true;
+          const owners = resolved.targetBundle && declaresAsset ? Array.from(/* @__PURE__ */ new Set([...existingOwners, resolved.targetBundle])) : existingOwners;
           lockfile.files[relPath] = {
             hash,
-            bundle: resolved.targetBundle,
+            bundle: existing?.bundle ?? resolved.targetBundle,
+            owners,
             method: actualMethod,
-            installedAt: now
+            installedAt: existing?.installedAt ?? now,
+            ...existing?.projectedTo ? { projectedTo: existing.projectedTo } : {}
           };
         }
       }
@@ -1223,6 +1296,42 @@ var UninstallEngine = class {
     }
     await fs4.remove(absPath);
   }
+  /**
+   * Installed-addon freshness (plan 003): after a child bundle (one with a
+   * `parentBundle`) is removed, re-render the parent's coordinator rule + team
+   * manifest excluding every remaining installed bundle in the lockfile, so the
+   * removed addon returns to the parent's recommendedAddons. Presentation-free:
+   * the two projection files carry the managed marker trustees inside (rule) and
+   * are overwritten directly via fs-extra. If a parent artifact does not exist in
+   * the workspace (parent not installed as its own bundle), it is skipped.
+   */
+  async refreshParentCoordination(bundleName, workspaceRoot, lockfile, scope) {
+    const bundleDef = await this.registry.getBundle(bundleName);
+    if (!bundleDef?.parentBundle) return;
+    const parentDef = await this.registry.getBundle(bundleDef.parentBundle);
+    if (!parentDef) return;
+    const parentResolved = await this.registry.resolve(parentDef.name).catch(() => null);
+    if (!parentResolved) return;
+    const registryDir = this.registry.getRegistryDir();
+    const projection = await ClineProjector.planCompoundProjection(
+      parentDef,
+      scope,
+      parentResolved,
+      registryDir,
+      lockfile.installed.bundles
+    );
+    for (const artifact of projection) {
+      if (artifact.kind !== "rule" && artifact.kind !== "team-manifest") continue;
+      if (artifact.content === void 0) continue;
+      const dest = path6.join(workspaceRoot, artifact.relPath);
+      if (!await fs4.pathExists(dest)) continue;
+      await fs4.writeFile(dest, artifact.content, "utf8");
+      const hash = await this.calculateHash(dest);
+      if (lockfile.projections?.[artifact.relPath]) {
+        lockfile.projections[artifact.relPath].hash = hash;
+      }
+    }
+  }
   parseHosts(options) {
     if (options.hosts && options.hosts.length > 0) return options.hosts;
     if (options.target) {
@@ -1281,6 +1390,11 @@ var UninstallEngine = class {
         if (lockfile.installed.bundles.includes(bundleName)) {
           if (!options.dryRun) {
             const workspaceRoot = path6.resolve(path6.dirname(targetDir));
+            const ownedFiles = Object.entries(lockfile.files).filter(([, m]) => (m.owners ?? (m.bundle ? [m.bundle] : [])).includes(bundleName));
+            const ownedProjections = lockfile.projections ? Object.values(lockfile.projections).filter((p) => p.owners.includes(bundleName)).length : 0;
+            if (ownedFiles.length === 0 && ownedProjections === 0) {
+              throw new Error(`No installed assets found matching "${bundleName}".`);
+            }
             if (lockfile.projections) {
               for (const [projRelPath, proj] of Object.entries(lockfile.projections)) {
                 if (proj.owners.includes(bundleName)) {
@@ -1308,7 +1422,10 @@ var UninstallEngine = class {
               }
             }
             for (const [relPath, assetMeta] of Object.entries(lockfile.files)) {
-              if (assetMeta.bundle === bundleName) {
+              const assetOwners = assetMeta.owners ?? (assetMeta.bundle ? [assetMeta.bundle] : []);
+              if (!assetOwners.includes(bundleName)) continue;
+              const newOwners = assetOwners.filter((o) => o !== bundleName);
+              if (newOwners.length === 0) {
                 if (assetMeta.projectedTo && assetMeta.projectedTo.length > 0) {
                   await this.removeProjections(workspaceRoot, assetMeta.projectedTo, options.force);
                 }
@@ -1324,21 +1441,28 @@ var UninstallEngine = class {
                   removedFiles.push(relPath);
                 }
                 delete lockfile.files[relPath];
+              } else {
+                lockfile.files[relPath] = { ...assetMeta, owners: newOwners };
               }
             }
             lockfile.installed.bundles = lockfile.installed.bundles.filter((b) => b !== bundleName);
             if (lockfile.bundleVersions) {
               delete lockfile.bundleVersions[bundleName];
             }
-            if (resolved.agents) {
-              lockfile.installed.agents = lockfile.installed.agents.filter((a) => !resolved.agents.includes(a));
-            }
-            if (resolved.skills) {
-              lockfile.installed.skills = lockfile.installed.skills.filter((s) => !resolved.skills.includes(s));
-            }
-            if (resolved.workflows) {
-              lockfile.installed.workflows = lockfile.installed.workflows.filter((w) => !resolved.workflows.includes(w));
+            const surviving = lockfile.installed.bundles.filter((b) => b !== bundleName);
+            const survival = /* @__PURE__ */ new Set();
+            for (const b of surviving) {
+              const bdef = await this.registry.getBundle(b);
+              if (!bdef) continue;
+              if (bdef.orchestrator) survival.add(`agents/${bdef.orchestrator}`);
+              (bdef.agents || []).forEach((a) => survival.add(`agents/${a}`));
+              (bdef.skills || []).forEach((s) => survival.add(`skills/${s}/SKILL.md`));
+              (bdef.workflows || []).forEach((w) => survival.add(`workflows/${w}`));
             }
+            lockfile.installed.agents = lockfile.installed.agents.filter((a) => survival.has(`agents/${a}`));
+            lockfile.installed.skills = lockfile.installed.skills.filter((s) => survival.has(`skills/${s}/SKILL.md`));
+            lockfile.installed.workflows = lockfile.installed.workflows.filter((w) => survival.has(`workflows/${w}`));
+            await this.refreshParentCoordination(bundleName, workspaceRoot, lockfile, scope);
             await fs4.writeJson(subPaths.lockfile, lockfile, { spaces: 2 });
           } else {
             removedFiles.push(...resolved.agents, ...resolved.skills, ...resolved.workflows);
@@ -2020,6 +2144,30 @@ var DoctorEngine = class {
           }
         }
       }
+      const installedBundles = manifest.installed?.bundles ?? [];
+      const fileOwnersOf = (rec) => rec.owners ?? (rec.bundle ? [rec.bundle] : []);
+      if (manifest.projections) {
+        for (const [projRelPath, proj] of Object.entries(manifest.projections)) {
+          for (const owner of proj.owners) {
+            if (!installedBundles.includes(owner)) {
+              warnings.push(`Projection ${projRelPath} is owned by bundle "${owner}" which is not in installed.bundles.`);
+            }
+          }
+        }
+      }
+      for (const [relPath, rec] of Object.entries(manifest.files)) {
+        for (const owner of fileOwnersOf(rec)) {
+          if (!installedBundles.includes(owner)) {
+            warnings.push(`File record ${relPath} is owned by bundle "${owner}" which is not in installed.bundles.`);
+          }
+        }
+      }
+      for (const bundleName of installedBundles) {
+        const fileCount = Object.values(manifest.files).filter((m) => fileOwnersOf(m).includes(bundleName)).length;
+        if (fileCount === 0) {
+          warnings.push(`Installed bundle "${bundleName}" owns zero file records.`);
+        }
+      }
     }
     if (host === "cline") {
       const probe = new ClineCapabilityProbe();