agentwheel 0.20.19 → 0.20.20

package/README.md

@@ -644,6 +644,11 @@ project's curated selection for a remote runtime.
 }
 ```
 
+Configured packages can opt into adapter runtimes with `"runtimes": ["claude"]`. Profile and
+named-agent plans match the declared target adapter; plain workspace commands match each package's
+configured adapter. Agents sharing an adapter receive the same package roots. Upgrade every member
+to a version supporting this field before using it in shared configuration.
+
 The import is data-only: Agentwheel resolves the package first, then reads only
 `exports.selections` from that resolved source's `.agentwheel/config.json`. It never imports the
 source project's agents, profiles, SSH fields, adapter modules, trust policy, or other workspace

package/dist/{apply-QJHTL7IK.js → apply-Z5GVCPA4.js}

@@ -5,8 +5,8 @@ import {
   commitManifestMetadataJournal,
   recoverPendingApply,
   uninstall
-} from "./chunk-L37KQVRS.js";
-import "./chunk-BHT57MK5.js";
+} from "./chunk-45WVSUJA.js";
+import "./chunk-FGFPAZ4J.js";
 import "./chunk-BNIF3FUR.js";
 export {
   applyCombinedInstallPlan,

package/dist/{chunk-L37KQVRS.js → chunk-45WVSUJA.js}

@@ -24,7 +24,7 @@ import {
   rollbackCompletedOperations,
   sourceLockPath,
   writeApplyJournal
-} from "./chunk-BHT57MK5.js";
+} from "./chunk-FGFPAZ4J.js";
 import {
   pathExists,
   writeJsonAtomic

package/dist/{chunk-BHT57MK5.js → chunk-FGFPAZ4J.js}

@@ -1525,6 +1525,188 @@ function readMutationPathDeclarations(operationIdInput) {
   return [...paths].sort((a, b) => a.localeCompare(b));
 }
 
+// src/adapters/claude.ts
+var claudeAdapter = {
+  name: "claude",
+  displayName: "Claude Code",
+  targets: {
+    instructions: {
+      local: { enabled: true, dest: "CLAUDE.md", mode: "managed-block" },
+      user: { enabled: true, root: "home", dest: ".claude/CLAUDE.md", mode: "managed-block" }
+    },
+    rules: {
+      local: { enabled: true, dest: ".claude/rules", formats: ["markdown-rule", "claude-markdown-rule"] },
+      user: { enabled: true, root: "home", dest: ".claude/rules", formats: ["markdown-rule", "claude-markdown-rule"] }
+    },
+    skills: {
+      local: { enabled: true, dest: ".claude/skills" },
+      user: { enabled: true, root: "home", dest: ".claude/skills" }
+    },
+    commands: {
+      local: { enabled: true, dest: ".claude/commands" },
+      user: { enabled: true, root: "home", dest: ".claude/commands" }
+    },
+    subagents: {
+      local: { enabled: true, dest: ".claude/agents" },
+      user: { enabled: true, root: "home", dest: ".claude/agents" }
+    },
+    plugins: {
+      local: { enabled: true, dest: ".agentwheel/plugins/claude", semantic: "claude-plugin" },
+      user: { enabled: true, root: "home", dest: ".agentwheel/plugins/claude", semantic: "claude-plugin" }
+    },
+    mcp: {
+      local: { enabled: true, dest: ".mcp.json", merge: "json-deep" }
+    },
+    hooks: {
+      local: { enabled: true, dest: ".claude/settings.json", merge: "json-deep" },
+      user: { enabled: true, root: "home", dest: ".claude/settings.json", merge: "json-deep" }
+    },
+    settings: {
+      local: { enabled: true, dest: ".claude/settings.json", merge: "json-deep" },
+      user: { enabled: true, root: "home", dest: ".claude/settings.json", merge: "json-deep" }
+    }
+  }
+};
+
+// src/adapters/copilot.ts
+var copilotAdapter = {
+  name: "copilot",
+  displayName: "GitHub Copilot CLI",
+  targets: {
+    instructions: {
+      local: { enabled: true, dest: ".github/copilot-instructions.md", mode: "managed-block" },
+      user: { enabled: true, root: "home", dest: ".copilot/copilot-instructions.md", mode: "managed-block" }
+    },
+    rules: {
+      local: { enabled: true, dest: ".github/instructions", formats: ["markdown-rule", "copilot-instruction-rule"], semantic: "copilot-instruction" },
+      user: { enabled: true, root: "home", dest: ".copilot/instructions", formats: ["markdown-rule", "copilot-instruction-rule"], semantic: "copilot-instruction" }
+    },
+    commands: {
+      local: { enabled: true, dest: ".github/prompts", semantic: "copilot-prompt" }
+    },
+    skills: {
+      local: { enabled: true, dest: ".github/skills" },
+      user: { enabled: true, root: "home", dest: ".copilot/skills" }
+    },
+    plugins: {
+      user: { enabled: true, root: "home", dest: ".agentwheel/plugins/copilot", semantic: "copilot-plugin" }
+    },
+    subagents: {
+      local: { enabled: true, dest: ".github/agents", semantic: "copilot-agent" },
+      user: { enabled: true, root: "home", dest: ".copilot/agents", semantic: "copilot-agent" }
+    },
+    mcp: {
+      local: { enabled: true, dest: ".github/mcp.json", merge: "json-deep" },
+      user: { enabled: true, root: "home", dest: ".copilot/mcp-config.json", merge: "json-deep" }
+    },
+    hooks: {
+      local: { enabled: true, dest: ".github/hooks" },
+      user: { enabled: true, root: "home", dest: ".copilot/hooks" }
+    },
+    settings: {
+      local: { enabled: true, dest: ".github/settings.json", merge: "json-deep" },
+      user: { enabled: true, root: "home", dest: ".copilot/settings.json", merge: "json-deep" }
+    }
+  }
+};
+
+// src/adapters/codex.ts
+var codexAdapter = {
+  name: "codex",
+  displayName: "Codex CLI",
+  targets: {
+    instructions: {
+      local: { enabled: true, dest: "AGENTS.md", mode: "managed-block" },
+      user: { enabled: true, root: "home", dest: ".codex/AGENTS.md", mode: "managed-block" }
+    },
+    skills: {
+      local: { enabled: true, dest: ".agents/skills" },
+      user: { enabled: true, root: "home", dest: ".agents/skills" }
+    },
+    plugins: {
+      local: { enabled: true, dest: ".agentwheel/plugins/codex", semantic: "codex-plugin" },
+      user: { enabled: true, root: "home", dest: ".agentwheel/plugins/codex", semantic: "codex-plugin" }
+    },
+    subagents: {
+      local: { enabled: true, dest: ".codex/agents", semantic: "codex-subagent" },
+      user: { enabled: true, root: "home", dest: ".codex/agents", semantic: "codex-subagent" }
+    },
+    mcp: {
+      local: { enabled: true, dest: ".codex/config.toml", merge: "codex-toml-mcp" },
+      user: { enabled: true, root: "home", dest: ".codex/config.toml", merge: "codex-toml-mcp" }
+    },
+    hooks: {
+      local: { enabled: true, dest: ".codex/hooks.json", merge: "json-deep" },
+      user: { enabled: true, root: "home", dest: ".codex/hooks.json", merge: "json-deep" }
+    }
+  }
+};
+
+// src/adapters/hermes.ts
+var hermesAdapter = {
+  name: "hermes",
+  displayName: "Hermes",
+  targets: {
+    instructions: {
+      local: { enabled: true, dest: "AGENTS.md", mode: "managed-block" },
+      // Hermes documents SOUL.md as the user-level instruction surface.
+      user: { enabled: true, root: "home", dest: ".hermes/SOUL.md", mode: "managed-block" }
+    },
+    skills: {
+      user: { enabled: true, root: "home", dest: ".hermes/skills" }
+    },
+    mcp: {
+      user: { enabled: true, root: "home", dest: ".hermes/config.yaml", merge: "yaml-deep" }
+    },
+    settings: {
+      user: { enabled: true, root: "home", dest: ".hermes/config.yaml", merge: "yaml-deep" }
+    },
+    plugins: {
+      user: { enabled: true, root: "home", dest: ".agentwheel/plugins/hermes", semantic: "hermes-plugin" }
+    }
+  }
+};
+
+// src/adapters/openclaw.ts
+var openClawAdapter = {
+  name: "openclaw",
+  displayName: "OpenClaw",
+  targets: {
+    instructions: {
+      user: { enabled: true, root: "home", dest: ".openclaw/workspace/AGENTS.md", mode: "managed-block" }
+    },
+    skills: {
+      local: { enabled: true, dest: "skills" },
+      user: { enabled: true, root: "home", dest: ".openclaw/skills" }
+    },
+    subagents: {
+      user: { enabled: true, root: "home", dest: ".openclaw/workspace-subagents", semantic: "openclaw-subagent" }
+    },
+    mcp: {
+      user: { enabled: true, root: "home", dest: ".openclaw/openclaw.json", merge: "openclaw-json-deep" }
+    },
+    settings: {
+      user: { enabled: true, root: "home", dest: ".openclaw/openclaw.json", merge: "openclaw-json-deep" }
+    },
+    plugins: {
+      local: { enabled: true, dest: ".openclaw/plugins", formats: ["openclaw-plugin", "openclaw-clawhub-plugin"], semantic: "openclaw-plugin" }
+    }
+  }
+};
+
+// src/adapters/index.ts
+var adapters = [openClawAdapter, claudeAdapter, codexAdapter, hermesAdapter, copilotAdapter];
+function getAdapter(name) {
+  const adapter = adapters.find((candidate) => candidate.name === name);
+  if (!adapter) {
+    throw new Error(`Unknown adapter: ${name}`);
+  }
+  return adapter;
+}
+function listAdapters() {
+  return [...adapters];
+}
+
 // src/model/workspace.ts
 var artifactSelectorListSchema = z7.array(z7.string().min(1));
 var CURRENT_WORKSPACE_SCHEMA_VERSION = 4;
@@ -1562,6 +1744,9 @@ var workspacePackageBaseSchema = z7.object({
   source: z7.string().min(1),
   driver: z7.enum(["local", "git", "skillkit", "vercel-skills", "mcp-registry", "clawhub"]).default("local"),
   adapter: z7.string().min(1).default("openclaw"),
+  runtimes: z7.array(z7.string().min(1)).min(1).refine((runtimes) => new Set(runtimes).size === runtimes.length, {
+    message: "Package runtimes must be unique."
+  }).transform((runtimes) => [...runtimes].sort()).optional(),
   adapterConfig: z7.string().min(1).optional(),
   adapterModule: z7.string().min(1).optional(),
   adapterCodeHash: z7.string().min(16).optional(),
@@ -1726,7 +1911,25 @@ var workspaceConfigSchema = z7.discriminatedUnion("schemaVersion", [
   workspaceConfigV2Schema,
   workspaceConfigV3Schema,
   workspaceConfigV4Schema
-]);
+]).superRefine((config, ctx) => {
+  const known = /* @__PURE__ */ new Set([
+    ...listAdapters().map((adapter) => adapter.name),
+    ...Object.values(config.agents).map((agent) => agent.adapter),
+    ...Object.values(config.profiles).flatMap((profile) => "runtimes" in profile && profile.runtimes ? profile.runtimes.map((runtime) => runtime.agent ? config.agents[runtime.agent]?.adapter ?? runtime.adapter : runtime.adapter) : [])
+  ]);
+  for (const [index, pkg] of config.packages.entries()) {
+    for (const [runtimeIndex, runtime] of (pkg.runtimes ?? []).entries()) {
+      if (!known.has(runtime)) ctx.addIssue({
+        code: "custom",
+        path: ["packages", index, "runtimes", runtimeIndex],
+        message: `Unknown package runtime adapter '${runtime}'. Use a built-in adapter or an adapter declared by an agent/profile runtime.`
+      });
+    }
+  }
+});
+function packagesForTarget(packages, target, targetForPackage) {
+  return packages.filter((pkg) => !pkg.runtimes || pkg.runtimes.includes((targetForPackage?.(pkg) ?? target).adapter));
+}
 function supportsFleetConfig(config) {
   return config.schemaVersion === 3 || config.schemaVersion === 4;
 }
@@ -2865,8 +3068,8 @@ async function recoverMutationRuntime(operationId, options = {}) {
     }
     mutation = GovernedMutation.activateExisting(receipt, baseline, lock);
     const [{ recoverPendingApply }, { readLinkedLocalApplyJournal: readLinkedLocalApplyJournal2, removeApplyJournal: removeApplyJournal2, localPathExists: localPathExists2 }] = await Promise.all([
-      import("./apply-QJHTL7IK.js"),
-      import("./transaction-JHZJWBII.js")
+      import("./apply-Z5GVCPA4.js"),
+      import("./transaction-NLAIJ2ZZ.js")
     ]);
     let missingReservation = false;
     for (const entry of pending) {
@@ -3361,6 +3564,7 @@ export {
   installRootForArtifacts,
   installRootForAdapterInstallationType,
   loadAdapterConfig,
+  getAdapter,
   readMutationReceipt,
   listMutationReceipts,
   declareMutationPath,
@@ -3380,6 +3584,7 @@ export {
   fleetIdSchema,
   registeredFleetSchema,
   workspaceConfigSchema,
+  packagesForTarget,
   supportsFleetConfig,
   workspaceConfigPath,
   readWorkspaceConfig,

package/dist/index.js

@@ -37,7 +37,7 @@ import {
   uninstall,
   withManifestRevision,
   writeInstallManifest
-} from "./chunk-L37KQVRS.js";
+} from "./chunk-45WVSUJA.js";
 import {
   CURRENT_WORKSPACE_SCHEMA_VERSION,
   GovernedMutation,
@@ -56,6 +56,7 @@ import {
   findExistingWorkspaceRoot,
   findWorkspaceRoot,
   fleetIdSchema,
+  getAdapter,
   globalWorkspaceConfigPath,
   installManifestPath,
   installRootForAdapterInstallationType,
@@ -74,6 +75,7 @@ import {
   packageItemRequireSchema,
   packageItemSuggestSchema,
   packageSupersedesEntrySchema,
+  packagesForTarget,
   parseSemver,
   readApplyJournal,
   readMergedWorkspaceConfig,
@@ -98,7 +100,7 @@ import {
   workspaceSelectionImportSchema,
   writeApplyJournal,
   writeWorkspaceConfig
-} from "./chunk-BHT57MK5.js";
+} from "./chunk-FGFPAZ4J.js";
 import {
   inferSourceDriverName
 } from "./chunk-QABA4WUP.js";
@@ -125,185 +127,6 @@ import { Command } from "commander";
 // src/adapters/resolve.ts
 import { resolve as resolve2 } from "path";
 
-// src/adapters/claude.ts
-var claudeAdapter = {
-  name: "claude",
-  displayName: "Claude Code",
-  targets: {
-    instructions: {
-      local: { enabled: true, dest: "CLAUDE.md", mode: "managed-block" },
-      user: { enabled: true, root: "home", dest: ".claude/CLAUDE.md", mode: "managed-block" }
-    },
-    rules: {
-      local: { enabled: true, dest: ".claude/rules", formats: ["markdown-rule", "claude-markdown-rule"] },
-      user: { enabled: true, root: "home", dest: ".claude/rules", formats: ["markdown-rule", "claude-markdown-rule"] }
-    },
-    skills: {
-      local: { enabled: true, dest: ".claude/skills" },
-      user: { enabled: true, root: "home", dest: ".claude/skills" }
-    },
-    commands: {
-      local: { enabled: true, dest: ".claude/commands" },
-      user: { enabled: true, root: "home", dest: ".claude/commands" }
-    },
-    subagents: {
-      local: { enabled: true, dest: ".claude/agents" },
-      user: { enabled: true, root: "home", dest: ".claude/agents" }
-    },
-    plugins: {
-      local: { enabled: true, dest: ".agentwheel/plugins/claude", semantic: "claude-plugin" },
-      user: { enabled: true, root: "home", dest: ".agentwheel/plugins/claude", semantic: "claude-plugin" }
-    },
-    mcp: {
-      local: { enabled: true, dest: ".mcp.json", merge: "json-deep" }
-    },
-    hooks: {
-      local: { enabled: true, dest: ".claude/settings.json", merge: "json-deep" },
-      user: { enabled: true, root: "home", dest: ".claude/settings.json", merge: "json-deep" }
-    },
-    settings: {
-      local: { enabled: true, dest: ".claude/settings.json", merge: "json-deep" },
-      user: { enabled: true, root: "home", dest: ".claude/settings.json", merge: "json-deep" }
-    }
-  }
-};
-
-// src/adapters/copilot.ts
-var copilotAdapter = {
-  name: "copilot",
-  displayName: "GitHub Copilot CLI",
-  targets: {
-    instructions: {
-      local: { enabled: true, dest: ".github/copilot-instructions.md", mode: "managed-block" },
-      user: { enabled: true, root: "home", dest: ".copilot/copilot-instructions.md", mode: "managed-block" }
-    },
-    rules: {
-      local: { enabled: true, dest: ".github/instructions", formats: ["markdown-rule", "copilot-instruction-rule"], semantic: "copilot-instruction" },
-      user: { enabled: true, root: "home", dest: ".copilot/instructions", formats: ["markdown-rule", "copilot-instruction-rule"], semantic: "copilot-instruction" }
-    },
-    commands: {
-      local: { enabled: true, dest: ".github/prompts", semantic: "copilot-prompt" }
-    },
-    skills: {
-      local: { enabled: true, dest: ".github/skills" },
-      user: { enabled: true, root: "home", dest: ".copilot/skills" }
-    },
-    plugins: {
-      user: { enabled: true, root: "home", dest: ".agentwheel/plugins/copilot", semantic: "copilot-plugin" }
-    },
-    subagents: {
-      local: { enabled: true, dest: ".github/agents", semantic: "copilot-agent" },
-      user: { enabled: true, root: "home", dest: ".copilot/agents", semantic: "copilot-agent" }
-    },
-    mcp: {
-      local: { enabled: true, dest: ".github/mcp.json", merge: "json-deep" },
-      user: { enabled: true, root: "home", dest: ".copilot/mcp-config.json", merge: "json-deep" }
-    },
-    hooks: {
-      local: { enabled: true, dest: ".github/hooks" },
-      user: { enabled: true, root: "home", dest: ".copilot/hooks" }
-    },
-    settings: {
-      local: { enabled: true, dest: ".github/settings.json", merge: "json-deep" },
-      user: { enabled: true, root: "home", dest: ".copilot/settings.json", merge: "json-deep" }
-    }
-  }
-};
-
-// src/adapters/codex.ts
-var codexAdapter = {
-  name: "codex",
-  displayName: "Codex CLI",
-  targets: {
-    instructions: {
-      local: { enabled: true, dest: "AGENTS.md", mode: "managed-block" },
-      user: { enabled: true, root: "home", dest: ".codex/AGENTS.md", mode: "managed-block" }
-    },
-    skills: {
-      local: { enabled: true, dest: ".agents/skills" },
-      user: { enabled: true, root: "home", dest: ".agents/skills" }
-    },
-    plugins: {
-      local: { enabled: true, dest: ".agentwheel/plugins/codex", semantic: "codex-plugin" },
-      user: { enabled: true, root: "home", dest: ".agentwheel/plugins/codex", semantic: "codex-plugin" }
-    },
-    subagents: {
-      local: { enabled: true, dest: ".codex/agents", semantic: "codex-subagent" },
-      user: { enabled: true, root: "home", dest: ".codex/agents", semantic: "codex-subagent" }
-    },
-    mcp: {
-      local: { enabled: true, dest: ".codex/config.toml", merge: "codex-toml-mcp" },
-      user: { enabled: true, root: "home", dest: ".codex/config.toml", merge: "codex-toml-mcp" }
-    },
-    hooks: {
-      local: { enabled: true, dest: ".codex/hooks.json", merge: "json-deep" },
-      user: { enabled: true, root: "home", dest: ".codex/hooks.json", merge: "json-deep" }
-    }
-  }
-};
-
-// src/adapters/hermes.ts
-var hermesAdapter = {
-  name: "hermes",
-  displayName: "Hermes",
-  targets: {
-    instructions: {
-      local: { enabled: true, dest: "AGENTS.md", mode: "managed-block" },
-      // Hermes documents SOUL.md as the user-level instruction surface.
-      user: { enabled: true, root: "home", dest: ".hermes/SOUL.md", mode: "managed-block" }
-    },
-    skills: {
-      user: { enabled: true, root: "home", dest: ".hermes/skills" }
-    },
-    mcp: {
-      user: { enabled: true, root: "home", dest: ".hermes/config.yaml", merge: "yaml-deep" }
-    },
-    settings: {
-      user: { enabled: true, root: "home", dest: ".hermes/config.yaml", merge: "yaml-deep" }
-    },
-    plugins: {
-      user: { enabled: true, root: "home", dest: ".agentwheel/plugins/hermes", semantic: "hermes-plugin" }
-    }
-  }
-};
-
-// src/adapters/openclaw.ts
-var openClawAdapter = {
-  name: "openclaw",
-  displayName: "OpenClaw",
-  targets: {
-    instructions: {
-      user: { enabled: true, root: "home", dest: ".openclaw/workspace/AGENTS.md", mode: "managed-block" }
-    },
-    skills: {
-      local: { enabled: true, dest: "skills" },
-      user: { enabled: true, root: "home", dest: ".openclaw/skills" }
-    },
-    subagents: {
-      user: { enabled: true, root: "home", dest: ".openclaw/workspace-subagents", semantic: "openclaw-subagent" }
-    },
-    mcp: {
-      user: { enabled: true, root: "home", dest: ".openclaw/openclaw.json", merge: "openclaw-json-deep" }
-    },
-    settings: {
-      user: { enabled: true, root: "home", dest: ".openclaw/openclaw.json", merge: "openclaw-json-deep" }
-    },
-    plugins: {
-      local: { enabled: true, dest: ".openclaw/plugins", formats: ["openclaw-plugin", "openclaw-clawhub-plugin"], semantic: "openclaw-plugin" }
-    }
-  }
-};
-
-// src/adapters/index.ts
-var adapters = [openClawAdapter, claudeAdapter, codexAdapter, hermesAdapter, copilotAdapter];
-function getAdapter(name) {
-  const adapter = adapters.find((candidate) => candidate.name === name);
-  if (!adapter) {
-    throw new Error(`Unknown adapter: ${name}`);
-  }
-  return adapter;
-}
-
 // src/adapters/programmatic.ts
 import { stat, readFile, writeFile } from "fs/promises";
 import { tmpdir } from "os";
@@ -6030,7 +5853,7 @@ var SnapshotConflictError = class extends Error {
 };
 var cacheLocks = /* @__PURE__ */ new Map();
 async function resolveDependencyGraph(roots, options) {
-  if (roots.length === 0) throw new Error("At least one graph root is required.");
+  if (roots.length === 0 && !options.allowEmptyRoots) throw new Error("At least one graph root is required.");
   const fetchCache = /* @__PURE__ */ new Map();
   const nodesByKey = /* @__PURE__ */ new Map();
   const nodesBySource = /* @__PURE__ */ new Map();
@@ -8197,7 +8020,7 @@ function targetEndpoint(value, transportKind) {
 
 // src/lifecycle/source-plan.ts
 async function createGraphSourcePlan(options) {
-  if (options.roots.length === 0) {
+  if (options.roots.length === 0 && !options.allowEmptyRoots) {
     throw new Error("At least one source is required for a graph plan.");
   }
   if (options.freshGraphOnly && options.readOnly !== true) {
@@ -8313,7 +8136,8 @@ async function createGraphSourcePlan(options) {
     offline: options.offline,
     previousLock,
     warn,
-    runtime: options.adapter.name
+    runtime: options.adapter.name,
+    allowEmptyRoots: options.allowEmptyRoots
   });
   assertFrozenGraph(previousLock, graph, lockMode, lockLabel);
   assertTrustArtifactPolicy(graph, trustPolicy);
@@ -8372,6 +8196,16 @@ async function createGraphSourcePlan(options) {
       warn
     });
     const plan = priorState.migration && !basePlan.stateMigration ? { ...basePlan, stateMigration: priorState.migration } : basePlan;
+    if (options.excludedRootIds?.length && previousLock) {
+      const excludedRoots = new Set(options.excludedRootIds);
+      const excludedNodeIds = new Set(previousLock.canonical.roots.filter((root) => excludedRoots.has(root.rootId)).map((root) => root.graphNodeId));
+      for (const operation of plan.operations) {
+        const excludedOwner = operation.owners?.length && operation.owners.every((owner) => excludedRoots.has(owner));
+        if (operation.action === "remove" && (excludedOwner || operation.graphNodeId && excludedNodeIds.has(operation.graphNodeId))) {
+          operation.reason = "excluded by package runtimes";
+        }
+      }
+    }
     plan.targetStateFilePreconditions = {
       graphLockPath,
       graphLockRevision: stableLock ? digestGraphLock(stableLock) : null,
@@ -9256,8 +9090,17 @@ async function syncProfile(options) {
   if (selected && packages.some((pkg) => pkg.selection)) {
     throw new Error("--select/--skill cannot be combined with a package selection import.");
   }
+  if (!options.source) {
+    const adapters = new Set(profile.runtimes.map((runtime) => resolveProfileRuntimeTarget(runtime, config, options.workspaceRoot, options.installationType, options.fleetId).adapter));
+    for (const pkg of packages) {
+      if (pkg.runtimes && !pkg.runtimes.some((runtime) => adapters.has(runtime))) {
+        options.warn?.(`Package '${pkg.name}' matches no runtime in profile '${options.profile}'.`);
+      }
+    }
+  }
   for (const runtime of profile.runtimes) {
     const target = resolveProfileRuntimeTarget(runtime, config, options.workspaceRoot, options.installationType, options.fleetId);
+    const runtimePackages = options.source ? packages : packagesForTarget(packages, target);
     const transport = transportForTarget(target);
     const adapter = await resolveAdapter({
       adapter: target.adapter,
@@ -9270,7 +9113,7 @@ async function syncProfile(options) {
     const installationType = target.installationType ?? defaultInstallationType;
     resolveInstallationTypeForAdapter(adapter, installationType);
     const graphPlan = await createGraphSourcePlan({
-      roots: packages.map((pkg) => ({
+      roots: runtimePackages.map((pkg) => ({
         rootId: pkg.name,
         source: pkg.source,
         mode: options.mode ?? pkg.mode,
@@ -9319,14 +9162,16 @@ async function syncProfile(options) {
       forceConflict: options.forceConflict,
       forceForeignState: options.forceForeignState,
       replaceConflict: options.replaceConflict,
-      recoverLegacyState: options.recoverLegacyState
+      recoverLegacyState: options.recoverLegacyState,
+      allowEmptyRoots: runtimePackages.length === 0,
+      excludedRootIds: options.source ? [] : packages.filter((pkg) => !runtimePackages.includes(pkg)).map((pkg) => pkg.name)
     });
     try {
       const result = {
         runtime: adapter.name,
         targetRoot: installRootForAdapterInstallationType(adapter, target.targetRoot, installationType, transport.kind === "ssh"),
         transport: transport.kind,
-        packageName: packages.map((pkg) => pkg.name).join(","),
+        packageName: runtimePackages.map((pkg) => pkg.name).join(",") || "(no packages)",
         plan: graphPlan.plan,
         graphPlan,
         graphLockDigest: graphPlan.graphLockDigest,
@@ -12468,7 +12313,7 @@ async function planFleetNormalization(request) {
     const destinationDeclaration = canonicalJson2(destinationPackage);
     if (sourceDeclaration !== destinationDeclaration) {
       throw new Error(
-        `Package '${name}' has divergent declarations. Source, driver, adapter, adapter configuration, installation type, version policy, selections, aliases, overrides, and suggestions must match before normalization.`
+        `Package '${name}' has divergent declarations. Source, driver, adapter, adapter configuration, installation type, version policy, runtime restrictions, selections, aliases, overrides, and suggestions must match before normalization.`
       );
     }
     packages.push({ name, declarationDigest: sha2565(sourceDeclaration) });
@@ -14504,8 +14349,9 @@ ownershipCommand.command("recovery-plan").description("write a read-only per-pat
   }
   const installationType = target.installationType ?? resolveInstallationTypeForAdapter(adapter, void 0);
   const config = await readMergedWorkspaceConfig(target.workspaceRoot);
-  if (config.packages.length === 0) throw new Error("Fleet has no configured source packages.");
-  await withFreshReadOnlyGraphPlan(target, adapter, adapterOptionsForTarget(target, {}), installationType, config.packages, async (graphPlan) => {
+  const targetPackages = packagesForCliTarget(config.packages, target, {});
+  if (targetPackages.length === 0) throw new Error("Fleet target has no configured source packages.");
+  await withFreshReadOnlyGraphPlan(target, adapter, adapterOptionsForTarget(target, {}), installationType, targetPackages, async (graphPlan) => {
     const installRoot = installRootForAdapterInstallationType(adapter, target.targetRoot, installationType, transport.kind === "ssh");
     const report = await planLegacyRecovery({
       graphPlan,
@@ -14632,7 +14478,7 @@ ownershipCommand.command("adopt-legacy").description("move proven legacy-keyed o
   if (target.transport === "ssh") throw new Error("Legacy ownership adoption does not support SSH targets.");
   const config = await readMergedWorkspaceConfig(target.workspaceRoot);
   const groups = /* @__PURE__ */ new Map();
-  for (const pkg of config.packages) graphGroupForPackage(groups, target, pkg, plainInstallOptions).packages.push(pkg);
+  for (const pkg of packagesForCliTarget(config.packages, target, plainInstallOptions)) graphGroupForPackage(groups, target, pkg, plainInstallOptions).packages.push(pkg);
   if (groups.size === 0) throw new Error(`No configured source packages in ${target.workspaceRoot}.`);
   const installationTypes = [...new Set([...groups.values()].map((candidate) => candidate.installationType))];
   if (installationTypes.length > 1) {
@@ -14974,7 +14820,7 @@ async function runInstallCommand(nameOrSource, options, behavior) {
   for (const target of targets) {
     const targetOptions = optionsForResolvedTarget(normalizedOptions, target);
     const config = await readMergedWorkspaceConfig(target.workspaceRoot);
-    const configured = nameOrSource ? findConfiguredPackageForTarget(config.packages, nameOrSource, targetOptions, target) : void 0;
+    const configured = nameOrSource ? findConfiguredPackageForTarget(packagesForCliTarget(config.packages, target, targetOptions), nameOrSource, targetOptions, target) : void 0;
     let source;
     let scope = configured?.name;
     let extraPackage;
@@ -15065,11 +14911,11 @@ async function buildPlanReport(nameOrSource, options) {
       yes: normalizedOptions.yes,
       trustPatterns: normalizedOptions.trust ?? [],
       readOnly: true,
-      isTTY: false
+      isTTY: false,
+      warn: collectWarning
     });
     for (const result of results) {
       reportTargets.push(installPlanReportTarget(result.plan, result.graphLockDigest));
-      reportWarnings.push(...result.warnings);
     }
     return planReport(reportTargets, reportWarnings);
   }
@@ -15077,7 +14923,7 @@ async function buildPlanReport(nameOrSource, options) {
   for (const target of targets) {
     const targetOptions = optionsForResolvedTarget(normalizedOptions, target);
     const config = await readMergedWorkspaceConfig(target.workspaceRoot);
-    const configured = nameOrSource ? findConfiguredPackageForTarget(config.packages, nameOrSource, targetOptions, target) : void 0;
+    const configured = nameOrSource ? findConfiguredPackageForTarget(packagesForCliTarget(config.packages, target, targetOptions), nameOrSource, targetOptions, target) : void 0;
     let source;
     let scope = configured?.name;
     let extraPackage;
@@ -15307,13 +15153,13 @@ async function resolveCliTargets(options, behavior = {}) {
   if (normalizedOptions.profile && (normalizedOptions.all || normalizedOptions.allDetected || normalizedOptions.agent)) {
     throw new Error("--profile cannot be combined with --all, --all-detected, or --agent.");
   }
-  const adapters2 = adapterListFromOption(normalizedOptions.adapter);
-  if (adapters2.length > 1) {
+  const adapters = adapterListFromOption(normalizedOptions.adapter);
+  if (adapters.length > 1) {
     if (normalizedOptions.all || normalizedOptions.allDetected || normalizedOptions.agent || normalizedOptions.profile) {
       throw new Error("--adapter <a,b> cannot be combined with --all, --all-detected, --agent, or --profile. Use a profile for mixed configured targets.");
     }
     const targets = [];
-    for (const adapter of adapters2) {
+    for (const adapter of adapters) {
       targets.push(await resolveRuntimeTarget({
         cwd: scopeRoot,
         targetRoot: normalizedOptions.targetRoot,
@@ -15459,7 +15305,7 @@ async function runSkillUpdateCommand(skillName, options) {
   const targets = await resolveCliTargets(normalizedOptions, { preferAllProfile: true });
   for (const target of targets) {
     const config = await readMergedWorkspaceConfig(target.workspaceRoot);
-    const owner = await configuredPackageForSkill(target, config.packages, skillName, normalizedOptions, options.package);
+    const owner = await configuredPackageForSkill(target, packagesForCliTarget(config.packages, target, normalizedOptions), skillName, normalizedOptions, options.package);
     const mode = owner.mode === "tracking" ? "update" : "install";
     console.log(`Skill ${skillName}: ${owner.name} (${mode}).`);
     await runConfiguredGraphPackages(target, {
@@ -15512,22 +15358,28 @@ async function buildGraphPlansForTarget(target, source, options, behavior) {
 async function collectGraphPlansForTarget(target, source, options, behavior, bundleRoots) {
   const targetOptions = optionsForResolvedTarget(options, target);
   const config = await readMergedWorkspaceConfig(target.workspaceRoot);
+  const targetPackages = packagesForCliTarget(config.packages, target, targetOptions);
   const groups = /* @__PURE__ */ new Map();
   const selectedArtifacts = selectedArtifactsFromOptions(targetOptions);
   const dependencyUpdateSelectors = sortedUniqueValues(targetOptions.dependency ?? []);
   const scopedDependencyUpdate = behavior.mode === "update" && dependencyUpdateSelectors.length > 0;
-  const scopedPackage = targetOptions.scope ? findConfiguredPackage(config.packages, targetOptions.scope) : void 0;
+  const scopedPackage = targetOptions.scope ? findConfiguredPackage(targetPackages, targetOptions.scope) : void 0;
   const scopedRootId = scopedPackage?.name ?? (source ? targetOptions.scope : void 0);
   if (targetOptions.scope && !scopedPackage && !source) throw new Error(`Configured package not found: ${targetOptions.scope}`);
   if (scopedPackage && targetOptions.onlySource) {
     const group = graphGroupForPackage(groups, target, scopedPackage, targetOptions);
     group.packages.push(scopedPackage);
   } else if (!source || !targetOptions.onlySource) {
-    for (const pkg of config.packages) {
+    for (const pkg of targetPackages) {
       const group = graphGroupForPackage(groups, target, pkg, targetOptions);
       group.packages.push(pkg);
     }
   }
+  if (!source && !targetOptions.scope) {
+    for (const pkg of config.packages.filter((candidate) => !targetPackages.includes(candidate))) {
+      graphGroupForPackage(groups, target, pkg, targetOptions);
+    }
+  }
   if (source) {
     let entry = targetOptions.extraPackage ?? await packageEntryFromSource(source, target.workspaceRoot, {
       ...targetOptions,
@@ -15567,6 +15419,11 @@ async function collectGraphPlansForTarget(target, source, options, behavior, bun
     const adapter = await resolveAdapterForTarget(group.target, { ...group.adapterOptions, warn: targetOptions.warn });
     const transport = transportForTarget(group.target);
     const allPackages = [...group.packages, ...group.extraPackages];
+    const excludedRootIds = config.packages.filter((pkg) => !targetPackages.includes(pkg) && graphGroupKey(targetForPackage(target, pkg, targetOptions), {
+      installationType: targetOptions.installationType ?? pkg.installationType ?? target.installationType ?? "local",
+      adapterConfig: targetOptions.adapterConfig ?? target.adapterConfig ?? pkg.adapterConfig,
+      adapterModule: targetOptions.adapterModule ?? target.adapterModule ?? pkg.adapterModule
+    }) === graphGroupKey(group.target, { ...group.adapterOptions, installationType: group.installationType })).map((pkg) => pkg.name);
     const groupHasScope = !scopedRootId || allPackages.some((pkg) => pkg.name === scopedRootId || pkg.source === targetOptions.scope);
     if (behavior.mode === "install" && scopedRootId && !groupHasScope) continue;
     if (behavior.readOnly !== true && targetOptions.dryRun !== true) {
@@ -15665,15 +15522,16 @@ async function collectGraphPlansForTarget(target, source, options, behavior, bun
     ];
     if (behavior.mode === "update") {
       const changed = roots.filter((root) => root.useLock === false);
-      if (changed.length === 0 && !scopedDependencyUpdate) {
+      if (changed.length === 0 && !scopedDependencyUpdate && excludedRootIds.length === 0) {
         const label = targetOptions.scope ? ` ${targetOptions.scope}` : "";
         console.log(`No tracking packages to update${label}.`);
         continue;
       }
     }
-    if (roots.length === 0) continue;
     const result = await createGraphSourcePlan({
       roots,
+      allowEmptyRoots: roots.length === 0,
+      excludedRootIds,
       targetRoot: group.target.targetRoot,
       workspaceRoot: group.target.workspaceRoot,
       fleetId: group.target.fleetId,
@@ -16307,7 +16165,7 @@ async function uninstallConfiguredPackage(target, packageName, options) {
   if (removed.length === 0) {
     throw new Error(`Configured package not found: ${packageName}`);
   }
-  const remaining = config.packages.filter((pkg) => !removed.includes(pkg));
+  const remaining = packagesForCliTarget(config.packages.filter((pkg) => !removed.includes(pkg)), target, options);
   const groups = /* @__PURE__ */ new Map();
   for (const pkg of remaining) {
     const group = graphGroupForPackage(groups, target, pkg, options);
@@ -16443,6 +16301,9 @@ function targetForPackage(target, pkg, options) {
   const installationType = options.installationType ?? pkg.installationType ?? target.installationType;
   return options.adapter || target.source !== "cwd" ? { ...target, installationType } : { ...target, adapter: pkg.adapter, installationType };
 }
+function packagesForCliTarget(packages, target, options) {
+  return packagesForTarget(packages, target, (pkg) => targetForPackage(target, pkg, options));
+}
 function graphGroupKey(target, options) {
   return JSON.stringify({
     adapter: target.adapter,
@@ -16619,7 +16480,7 @@ async function collectTargetStatus(target, options) {
     observation.manifestRevision
   ]).sort())).digest("hex") : null;
   const packages = [];
-  for (const pkg of config.packages) {
+  for (const pkg of packagesForCliTarget(config.packages, target, options)) {
     const root = effectiveGraphLock?.canonical.roots.find((candidate) => candidate.rootId === pkg.name);
     const node = root ? effectiveGraphLock?.canonical.nodes.find((candidate) => candidate.id === root.graphNodeId) : void 0;
     const availability = await discoverPackageVersions(pkg, target.workspaceRoot, {
@@ -17357,9 +17218,9 @@ function isHomePath(path) {
 }
 function adapterListFromOption(adapter) {
   if (!adapter) return [];
-  const adapters2 = splitSelectorList(adapter);
-  const unique = [...new Set(adapters2)];
-  if (unique.length !== adapters2.length) {
+  const adapters = splitSelectorList(adapter);
+  const unique = [...new Set(adapters)];
+  if (unique.length !== adapters.length) {
     throw new Error(`Duplicate adapter in --adapter: ${adapter}`);
   }
   return unique;

package/dist/{transaction-JHZJWBII.js → transaction-NLAIJ2ZZ.js}

@@ -18,7 +18,7 @@ import {
   removeApplyJournal,
   rollbackCompletedOperations,
   writeApplyJournal
-} from "./chunk-BHT57MK5.js";
+} from "./chunk-FGFPAZ4J.js";
 import "./chunk-BNIF3FUR.js";
 export {
   abortApplyJournal,

package/openpack.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 2,
   "name": "NestDevLab/agentwheel",
-  "version": "0.20.19",
+  "version": "0.20.20",
   "provides": [
     { "type": "skills", "path": "skills" }
   ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentwheel",
-  "version": "0.20.19",
+  "version": "0.20.20",
   "description": "Weave skills, rules, and instructions across every AI agent.",
   "type": "module",
   "license": "MIT",

package/skills/agentwheel/SKILL.md

@@ -5,7 +5,7 @@ allowed-tools: [Bash]
 license: MIT
 metadata:
   author: NestDevLab
-  version: "0.20.19"
+  version: "0.20.20"
 ---
 
 # agentwheel
@@ -357,6 +357,12 @@ Current config shape:
 
 Use named targets:
 
+Configured packages may declare `"runtimes": ["claude"]` to select adapter runtimes. All
+configured-package plans honor it, including `--agent`, `--profile`, status, and update. Named
+targets match their declared adapter; plain workspace commands match each package's adapter.
+Agents sharing an adapter cannot be selected separately. Upgrade all members to a version
+supporting this field before adding it to shared configuration.
+
 ```bash
 agentwheel fleet register example-fleet --root /srv/agentwheel/fleets/example-fleet --required-package core-agent-pack
 agentwheel fleet list
@@ -475,6 +481,9 @@ Drift means a managed runtime output changed outside agentwheel. Fix drift by ch
   colliding upstream artifact.
 - Eject an item into `.agentwheel/ejected` when the user wants local ownership.
 
+When the plan instead keeps a file as foreign or refuses because another workspace owns it, that is
+an ownership problem, not drift: see "Choosing an ownership command" under Troubleshooting.
+
 Append durable local instruction text:
 
 ```bash
@@ -646,3 +655,23 @@ before Fleet qualification, owns paths under a fingerprint-only legacy key, run
 --from-workspace-root <previous-owner-root> --json` from that workspace. It moves only proven,
 still-desired entries into the stable state; add `--carry-drift` only after reviewing the drifted
 paths. Apply the emitted command, then require a normal install plan without force flags.
+
+### Choosing an ownership command
+
+`agentwheel ownership --help` lists the commands; each subcommand's `--help` is the authoritative flag
+reference. All of them dry-run by default and change only manifest metadata.
+
+| Situation | Command |
+|---|---|
+| Unclear who owns what | `ownership recovery-plan` (read-only evidence report) |
+| Refused: paths owned under a fingerprint-only legacy key | `ownership adopt-legacy` |
+| `adopt-legacy` says entries are "already owned by the destination owner" (mixed legacy manifest) | Run a normal `install --agent <agent>` first; it migrates the state and keeps the foreign entry. Then hand off that entry. |
+| Plan keeps one file as a `foreign artifact owned by …` in a stable manifest | `ownership handoff <type/name>` with `--from-workspace-root <root>`, or `--from-unknown-owner` for `workspace:unknown`; add `--to-fleet <id>` for a Fleet owner |
+| Stale foreign entry already covered by the Fleet manifest | `ownership retire-stale` |
+
+`handoff` refuses a file whose runtime hash differs from the manifest. If the drift is reviewed and
+harmless, add `--carry-drift`; applying then also needs `--expected-runtime-hash` from the dry-run.
+The recorded hash is kept, so the next install reports `DRIFT` for that file. Replacing it needs
+`install --agent <agent> --force-drift`, which also force-refreshes every merge contribution of that
+target (for example hooks): check that each merge destination is byte-identical afterwards. Never
+narrow that install with `--select`: it removes unselected merge contributions.

package/skills/agentwheel-discovery/SKILL.md

@@ -5,7 +5,7 @@ allowed-tools: [Bash]
 license: MIT
 metadata:
   author: NestDevLab
-  version: "0.20.19"
+  version: "0.20.20"
 ---
 
 # Agentwheel Discovery