agentwheel 0.20.0 → 0.20.1

package/dist/{apply-7HJQQOCI.js → apply-R5VHCIUN.js}

@@ -4,8 +4,8 @@ import {
   applyInstallPlan,
   recoverPendingApply,
   uninstall
-} from "./chunk-USHT7FGV.js";
-import "./chunk-HOYIIUL5.js";
+} from "./chunk-AFVGRRZW.js";
+import "./chunk-BJEZXIXX.js";
 import "./chunk-7VPI5J5Y.js";
 export {
   applyCombinedInstallPlan,

package/dist/{chunk-USHT7FGV.js → chunk-AFVGRRZW.js}

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import {
   acquireApplyLock,
+  applyJournalPath,
   artifactFormatSchema,
   artifactTypeSchema,
   assertApplyJournalRecoveryAllowed,
@@ -11,6 +12,7 @@ import {
   fileKindSchema,
   installManifestPath,
   installationTypeSchema,
+  listApplyJournals,
   localPathExists,
   localTransport,
   metadataDir,
@@ -22,7 +24,7 @@ import {
   rollbackCompletedOperations,
   sourceLockPath,
   writeApplyJournal
-} from "./chunk-HOYIIUL5.js";
+} from "./chunk-BJEZXIXX.js";
 import {
   pathExists,
   writeJsonAtomic
@@ -549,16 +551,15 @@ async function readInstallManifest(targetRoot, adapter, transport = localTranspo
 async function listInstallManifests(targetRoot, adapter, transport = localTransport) {
   const dir = metadataDir(targetRoot);
   const suffix = ".install-manifest.json";
-  const prefix = `${adapter}.`;
   const found = [];
   for (const fileName of await transport.listDir(dir)) {
     if (!fileName.endsWith(suffix)) continue;
     const stateKey = fileName.slice(0, -suffix.length);
-    if (stateKey !== adapter && !stateKey.startsWith(prefix)) continue;
     const path = join(dir, fileName);
     try {
       const raw = JSON.parse(await transport.readFile(path));
       const parsed = installManifestSchema.parse(raw);
+      if (parsed.adapter !== adapter) continue;
       found.push({ path, fileName, stateKey, manifest: { ...parsed, revision: computeManifestRevision(raw) } });
     } catch (error) {
       throw new Error(`Unreadable install manifest at ${path}: ${error instanceof Error ? error.message : String(error)}`);
@@ -566,6 +567,10 @@ async function listInstallManifests(targetRoot, adapter, transport = localTransp
   }
   return found.sort((a, b) => a.fileName.localeCompare(b.fileName));
 }
+async function computeInstallManifestInventoryRevision(targetRoot, adapter, transport = localTransport) {
+  const inventory = (await listInstallManifests(targetRoot, adapter, transport)).map((item) => [item.fileName, item.manifest.revision]);
+  return createHash2("sha256").update(JSON.stringify(inventory)).digest("hex");
+}
 async function writeInstallManifest(manifest, transport = localTransport) {
   const next = withManifestRevision(manifest);
   await transport.writeJsonAtomic(installManifestPath(next.targetRoot, next.adapter, {
@@ -1360,6 +1365,7 @@ async function recoverPendingApply(targetRoot, adapter, transport = localTranspo
   assertGovernedRuntimeTransportSupported(transport);
   const lock = await acquireApplyLock(targetRoot, adapter, transport, {}, scope);
   try {
+    await assertRuntimeJournalGate(targetRoot, adapter, transport, scope, true);
     const journal = await readApplyJournal(targetRoot, adapter, transport, scope);
     if (!journal) return void 0;
     assertApplyJournalRecoveryAllowed(journal);
@@ -1402,6 +1408,26 @@ async function recoverPendingApply(targetRoot, adapter, transport = localTranspo
     await lock.release();
   }
 }
+async function assertRuntimeJournalGate(targetRoot, adapter, transport, scope, allowRequestedJournal = false) {
+  const pending = await listApplyJournals(targetRoot, adapter, transport, {
+    installationType: scope.installationType
+  });
+  if (pending.length === 0) return;
+  const requestedPath = applyJournalPath(targetRoot, adapter, scope);
+  if (allowRequestedJournal && pending.length === 1 && pending[0].path === requestedPath) return;
+  throw new Error(
+    `Cannot mutate ${adapter}/${scope.installationType ?? "local"} at ${targetRoot} while runtime apply journal(s) are pending: ` + pending.map((item) => item.path).join(", ")
+  );
+}
+async function assertRuntimeStateRevision(plan, transport) {
+  if (!plan.runtimeStateRevision) return;
+  const current = await computeInstallManifestInventoryRevision(plan.targetRoot, plan.adapter, transport);
+  if (current !== plan.runtimeStateRevision) {
+    throw new Error(
+      `Runtime manifest inventory changed after planning: expected ${plan.runtimeStateRevision}, found ${current}; replan needed.`
+    );
+  }
+}
 async function applyPlanTransactionally(plan, options = {}) {
   const transport = options.transport ?? localTransport;
   const scope = { installationType: plan.installationType, stateKey: plan.stateKey };
@@ -1412,6 +1438,8 @@ async function applyPlanTransactionally(plan, options = {}) {
   assertGovernedRuntimeTransportSupported(transport);
   const lock = await acquireApplyLock(plan.targetRoot, plan.adapter, transport, options.lock, scope);
   try {
+    await assertRuntimeJournalGate(plan.targetRoot, plan.adapter, transport, scope);
+    await assertRuntimeStateRevision(plan, transport);
     await assertBaseRevision(plan, transport);
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const graphLockDigest = options.graphLockDigest ?? plan.graphLockDigest;
@@ -1493,7 +1521,7 @@ async function uninstall(plan, options = {}) {
   const preserved = [...preservedKept, ...skipped].filter((operation) => operation.preserveInManifest !== false);
   for (const operation of [...removable, ...preserved]) assertOperationContained(operation, plan.targetRoot);
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  const finalManifest = withManifestRevision({
+  let finalManifest = withManifestRevision({
     version: 2,
     adapter: plan.adapter,
     installationType: plan.installationType,
@@ -1517,8 +1545,25 @@ async function uninstall(plan, options = {}) {
   });
   const lock = await acquireApplyLock(plan.targetRoot, plan.adapter, transport, resolvedOptions.lock, scope);
   try {
+    await assertRuntimeJournalGate(plan.targetRoot, plan.adapter, transport, scope);
+    await assertRuntimeStateRevision(plan, transport);
     await assertBaseRevision(plan, transport);
     await assertExactMergeRemovalPreconditions(removable, transport);
+    const revalidatedSkips = /* @__PURE__ */ new Map();
+    for (const operation of skipped) {
+      const entry = await applyOperation(operation, {
+        transport,
+        now,
+        graphLockDigest: operation.graphLockDigest ?? plan.graphLockDigest
+      });
+      if (entry) revalidatedSkips.set(operation.relativeDestPath, entry);
+    }
+    if (revalidatedSkips.size > 0) {
+      finalManifest = withManifestRevision({
+        ...finalManifest,
+        entries: finalManifest.entries.map((entry) => revalidatedSkips.get(entry.path) ?? entry)
+      });
+    }
     const mutation = mutationMetadataForApplyJournal();
     const journal = {
       version: mutation ? 2 : 1,
@@ -1724,9 +1769,33 @@ async function applyOperation(operation, context) {
     if (!operation.desiredHash) {
       throw new Error(`Invalid skip operation missing hash: ${operation.relativeDestPath}`);
     }
+    let verifiedCurrentHash = operation.currentHash;
+    if (operation.mode === managedInstructionBlockMode) {
+      const selector = managedInstructionSelector(operation.logicalSelector, operation.artifactType, operation.artifactName);
+      if (!await managedInstructionBlockLanded(operation.destPath, selector, operation.desiredHash, transport)) {
+        throw new Error(`Managed block changed after planning: ${operation.relativeDestPath}`);
+      }
+      verifiedCurrentHash = operation.desiredHash;
+    } else if (operation.mergeStrategy && hasMergeRemovalContent(operation.mergeRemoval)) {
+      if (!await transport.pathExists(operation.destPath)) {
+        throw new Error(`Merge skip destination disappeared after planning: ${operation.relativeDestPath}`);
+      }
+      assertExactMergeContribution(operation.mergeRemoval, operation.mergeStrategy, await transport.readFile(operation.destPath));
+      verifiedCurrentHash = await transport.hashPath(operation.destPath);
+    } else if (!operation.semanticPlugin && !operation.programmaticOperation) {
+      if (!await transport.pathExists(operation.destPath)) {
+        throw new Error(`Skip destination disappeared after planning: ${operation.relativeDestPath}`);
+      }
+      const currentHash = await transport.hashPath(operation.destPath);
+      const expectedHash = operation.currentHash ?? operation.desiredHash;
+      if (currentHash !== expectedHash) {
+        throw new Error(`Skip destination changed after planning: ${operation.relativeDestPath}`);
+      }
+      verifiedCurrentHash = currentHash;
+    }
     return manifestEntryForOperation(operation, {
       now,
-      hash: (operation.mergeStrategy || operation.mode === managedInstructionBlockMode) && operation.currentHash ? operation.currentHash : operation.desiredHash,
+      hash: (operation.mergeStrategy || operation.mode === managedInstructionBlockMode) && verifiedCurrentHash ? verifiedCurrentHash : operation.desiredHash,
       sourceHash: operation.desiredHash,
       graphLockDigest: context.graphLockDigest
     });
@@ -2210,6 +2279,7 @@ export {
   installManifestSchema,
   readInstallManifest,
   listInstallManifests,
+  computeInstallManifestInventoryRevision,
   writeInstallManifest,
   normalizeTargetRoot,
   withManifestRevision,

package/dist/{chunk-HOYIIUL5.js → chunk-BJEZXIXX.js}

@@ -344,7 +344,7 @@ var targetRegistryInputSchema = z2.union([
   targetRegistrySchema
 ]);
 var adapterSchema = z2.object({
-  name: z2.string().min(1),
+  name: z2.string().regex(/^[a-z0-9][a-z0-9._-]*$/i, "adapter name must be a canonical path-safe identifier"),
   displayName: z2.string().min(1).optional(),
   targets: z2.partialRecord(
     artifactTypeSchema,
@@ -460,6 +460,7 @@ function metadataDir(targetRoot) {
   return join(targetRoot, ".agentwheel");
 }
 function stateKeyFor(adapter, scope = {}) {
+  assertPathSafeAdapterName(adapter);
   if (scope.stateKey) {
     const explicit = sanitizeStateKey(scope.stateKey);
     const adapterScoped = scope.fleetId && explicit !== adapter && !explicit.startsWith(`${adapter}.`) ? `${adapter}.${explicit}` : explicit;
@@ -470,6 +471,11 @@ function stateKeyFor(adapter, scope = {}) {
   const fingerprint = scope.targetFingerprint ? `.${scope.targetFingerprint}` : "";
   return sanitizeStateKey(`${adapter}.${installationType}${fingerprint}`);
 }
+function assertPathSafeAdapterName(adapter) {
+  if (!/^[a-z0-9][a-z0-9._-]*$/i.test(adapter)) {
+    throw new Error(`Adapter name '${adapter}' is not a canonical path-safe identifier.`);
+  }
+}
 function installManifestPath(targetRoot, adapter, scope = {}) {
   return join(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.install-manifest.json`);
 }
@@ -2618,8 +2624,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-7HJQQOCI.js"),
-      import("./transaction-IM5MZS4B.js")
+      import("./apply-R5VHCIUN.js"),
+      import("./transaction-ITXC7FFV.js")
     ]);
     let missingReservation = false;
     for (const entry of pending) {
@@ -2782,7 +2788,8 @@ function upsertRuntimeJournal(entries, link2, status) {
 
 // src/install/transaction.ts
 function applyLockPath(targetRoot, adapter, scope = {}) {
-  return join6(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.apply-lock`);
+  const installationType = scope.installationType ?? "local";
+  return join6(metadataDir(targetRoot), `${stateKeyFor(adapter, { installationType })}.runtime-apply-lock`);
 }
 function applyJournalPath(targetRoot, adapter, scope = {}) {
   return join6(metadataDir(targetRoot), `${stateKeyFor(adapter, scope)}.apply-journal.json`);
@@ -2850,6 +2857,19 @@ async function readApplyJournal(targetRoot, adapter, transport = localTransport,
   if (!await transport.pathExists(path)) return void 0;
   return parseApplyJournal(JSON.parse(await transport.readFile(path)));
 }
+async function listApplyJournals(targetRoot, adapter, transport = localTransport, scope = {}) {
+  const installationType = scope.installationType ?? "local";
+  const suffix = ".apply-journal.json";
+  const found = [];
+  for (const fileName of await transport.listDir(metadataDir(targetRoot))) {
+    if (!fileName.endsWith(suffix)) continue;
+    const path = join6(metadataDir(targetRoot), fileName);
+    const journal = parseApplyJournal(JSON.parse(await transport.readFile(path)));
+    if (journal.adapter !== adapter || (journal.installationType ?? "local") !== installationType) continue;
+    found.push({ path, journal });
+  }
+  return found.sort((a, b) => a.path.localeCompare(b.path));
+}
 async function readLinkedLocalApplyJournal(path, operationId, expectedDigest, expectedTransportDescription) {
   const absolutePath = resolve9(path);
   const journal = parseApplyJournal(JSON.parse(await readFile7(absolutePath, "utf8")));
@@ -3129,6 +3149,7 @@ export {
   acquireApplyLock,
   writeApplyJournal,
   readApplyJournal,
+  listApplyJournals,
   readLinkedLocalApplyJournal,
   removeApplyJournal,
   abortApplyJournal,

package/dist/index.js

@@ -9,6 +9,7 @@ import {
   canonicalizeGraphLock,
   claudeInstructionBridgesAgents,
   combineMergeRemovals,
+  computeInstallManifestInventoryRevision,
   computeManifestRevision,
   computeTargetFingerprint,
   desiredManagedInstructionBlockHash,
@@ -30,7 +31,7 @@ import {
   uninstall,
   withManifestRevision,
   writeInstallManifest
-} from "./chunk-USHT7FGV.js";
+} from "./chunk-AFVGRRZW.js";
 import {
   CURRENT_WORKSPACE_SCHEMA_VERSION,
   GovernedMutation,
@@ -38,6 +39,7 @@ import {
   acquireApplyLock,
   adapterSchema,
   adapterTargetSupport,
+  applyLockPath,
   artifactFormatSchema,
   artifactTypeSchema,
   assertGovernedRuntimeTransportSupported,
@@ -53,6 +55,7 @@ import {
   installRootForAdapterInstallationType,
   installRootForArtifacts,
   isCompositeWorkspaceProfile,
+  listApplyJournals,
   listMutationReceipts,
   loadAdapterConfig,
   localTransport,
@@ -86,7 +89,7 @@ import {
   workspaceExportsSchema,
   workspaceSelectionImportSchema,
   writeWorkspaceConfig
-} from "./chunk-HOYIIUL5.js";
+} from "./chunk-BJEZXIXX.js";
 import {
   inferSourceDriverName
 } from "./chunk-EMDIG24I.js";
@@ -1449,6 +1452,7 @@ async function createCombinedInstallPlan(desiredArtifacts, adapter, targetRoot,
   const installationType = resolveInstallationTypeForArtifacts(adapter, installableArtifacts.map((artifact) => artifact.type), requestedInstallationType);
   const installRoot = installRootForArtifacts(adapter, targetRoot, installationType, installableArtifacts.map((artifact) => artifact.type), transport.kind === "ssh");
   await validateArtifactsForInstall(installableArtifacts, adapter, installationType);
+  const runtimeStateRevision = await computeInstallManifestInventoryRevision(installRoot, adapter.name, transport);
   for (const artifact of installableArtifacts) {
     if (artifact.meta.dependencyRole !== "root" && isGuardedMergeTarget(artifact.type)) {
       throw new Error(`Dependency-provided ${artifact.type} artifacts cannot be installed until per-subentry ownership exists: ${artifact.type}/${artifact.name}`);
@@ -1462,7 +1466,7 @@ async function createCombinedInstallPlan(desiredArtifacts, adapter, targetRoot,
     }
   }
   await addProgrammaticOperations(desired, adapter, installRoot);
-  return createPlanFromOperations(desired, adapter, installRoot, manifest, transport, { ...options, installationType });
+  return createPlanFromOperations(desired, adapter, installRoot, manifest, transport, { ...options, installationType, runtimeStateRevision });
 }
 async function createPlanFromOperations(desiredOps, adapter, targetRoot, manifest, transport, options) {
   const workspaceOwner = options.workspaceOwner;
@@ -1512,7 +1516,7 @@ async function createPlanFromOperations(desiredOps, adapter, targetRoot, manifes
         }
       }
       const incompleteMergeOwnership = existing2 && existing2.mergeStrategy && !("mergeCreatedDestination" in existing2 && existing2.mergeCreatedDestination === true) && !("mergeRemoval" in existing2 && hasMergeRemovalContent(existing2.mergeRemoval));
-      const adoptExisting = exists2 && (!existing2 || incompleteMergeOwnership) && options.forceConflict === true;
+      const adoptExisting = exists2 && (incompleteMergeOwnership || !existing2 && options.forceConflict === true);
       let mergeRemoval;
       try {
         mergeRemoval = await mergeRemovalForInstall(op.sourcePath, op.mergeStrategy, currentContent, {
@@ -1544,7 +1548,7 @@ async function createPlanFromOperations(desiredOps, adapter, targetRoot, manifes
           mergeCreatedDestination: existing2?.mergeCreatedDestination,
           currentHash: currentHash2,
           manifestHash: existing2?.hash,
-          reason: existing2 ? "force repairing exact incomplete merge ownership" : "force adopting exact unmanaged merge contribution"
+          reason: existing2 ? "repairing exact incomplete merge ownership" : "force adopting exact unmanaged merge contribution"
         });
         continue;
       }
@@ -1684,6 +1688,10 @@ async function createPlanFromOperations(desiredOps, adapter, targetRoot, manifes
   }
   for (const operation of operations) assertOperationContained(operation, targetRoot);
   operations.sort((a, b) => a.relativeDestPath.localeCompare(b.relativeDestPath));
+  const runtimeStateRevision = await computeInstallManifestInventoryRevision(targetRoot, adapter.name, transport);
+  if (options.runtimeStateRevision && runtimeStateRevision !== options.runtimeStateRevision) {
+    throw new Error("Runtime manifest inventory changed during planning; replan needed.");
+  }
   return {
     adapter: adapter.name,
     installationType: options.installationType ?? defaultInstallationType,
@@ -1692,6 +1700,7 @@ async function createPlanFromOperations(desiredOps, adapter, targetRoot, manifes
     operations,
     hasBlockingChanges: operations.some((op) => op.action === "drift" || op.action === "conflict"),
     baseRevision: options.baseRevision ?? manifest?.revision ?? null,
+    runtimeStateRevision,
     migrationReport: migration.report,
     graphLockDigest: options.graphLockDigest,
     adapterCode: adapter.programmatic ? { modulePath: adapter.programmatic.modulePath, hash: adapter.programmatic.hash } : void 0,
@@ -2182,6 +2191,7 @@ function isPendingInstallOperation(operation) {
 // src/install/uninstall.ts
 import { join as join13 } from "path";
 async function createUninstallPlan(manifest, transport = localTransport) {
+  const runtimeStateRevision = await computeInstallManifestInventoryRevision(manifest.targetRoot, manifest.adapter, transport);
   const operations = [];
   for (const entry of manifest.entries) {
     const semanticPlugin = "semanticPlugin" in entry ? entry.semanticPlugin : void 0;
@@ -2237,6 +2247,9 @@ async function createUninstallPlan(manifest, transport = localTransport) {
     }
   }
   operations.sort((a, b) => a.relativeDestPath.localeCompare(b.relativeDestPath));
+  if (runtimeStateRevision !== await computeInstallManifestInventoryRevision(manifest.targetRoot, manifest.adapter, transport)) {
+    throw new Error("Runtime manifest inventory changed during uninstall planning; replan needed.");
+  }
   return {
     adapter: manifest.adapter,
     installationType: "installationType" in manifest ? manifest.installationType : defaultInstallationType,
@@ -2245,10 +2258,12 @@ async function createUninstallPlan(manifest, transport = localTransport) {
     operations,
     hasBlockingChanges: operations.some((operation) => operation.action === "conflict"),
     baseRevision: manifest.revision,
+    runtimeStateRevision,
     adapterCode: manifest.adapterCode
   };
 }
 async function createOwnershipUninstallPlan(manifest, remainingDesired, adapter, transport = localTransport, options = {}) {
+  const runtimeStateRevision = await computeInstallManifestInventoryRevision(manifest.targetRoot, manifest.adapter, transport);
   const installationType = "installationType" in manifest ? manifest.installationType : defaultInstallationType;
   const stateKey = "stateKey" in manifest ? manifest.stateKey : void 0;
   const desiredPlan = await createCombinedInstallPlan(remainingDesired, adapter, manifest.targetRoot, void 0, transport, { installationType, stateKey });
@@ -2338,6 +2353,9 @@ async function createOwnershipUninstallPlan(manifest, remainingDesired, adapter,
     }
   }
   operations.sort((a, b) => a.relativeDestPath.localeCompare(b.relativeDestPath));
+  if (runtimeStateRevision !== await computeInstallManifestInventoryRevision(manifest.targetRoot, manifest.adapter, transport)) {
+    throw new Error("Runtime manifest inventory changed during ownership uninstall planning; replan needed.");
+  }
   return {
     adapter: manifest.adapter,
     installationType,
@@ -2346,6 +2364,7 @@ async function createOwnershipUninstallPlan(manifest, remainingDesired, adapter,
     operations,
     hasBlockingChanges: operations.some((operation) => operation.action === "conflict"),
     baseRevision: manifest.revision,
+    runtimeStateRevision,
     adapterCode: manifest.adapterCode,
     graphLockDigest: options.graphLockDigest
   };
@@ -6914,7 +6933,7 @@ import { rm as rm7 } from "fs/promises";
 // src/lifecycle/source-plan.ts
 import { createHash as createHash8 } from "crypto";
 import { mkdir as mkdir14 } from "fs/promises";
-import { dirname as dirname17, join as join33, resolve as resolve14 } from "path";
+import { dirname as dirname17, join as join33, resolve as resolve15 } from "path";
 
 // src/resolve/graph-diff.ts
 function diffGraphLocks(previous, next) {
@@ -7735,6 +7754,185 @@ async function createExactMcpRetirementPlan(desiredArtifacts, adapter, targetRoo
   };
 }
 
+// src/model/fleet.ts
+import { lstat as lstat2, readFile as readFile20, realpath } from "fs/promises";
+import { homedir as homedir7 } from "os";
+import { isAbsolute as isAbsolute2, relative as relative7, resolve as resolve14 } from "path";
+async function resolveWorkspaceScope(request = {}) {
+  const selected = [request.user === true, request.local === true, request.fleet !== void 0].filter(Boolean).length;
+  if (selected > 1) {
+    throw new Error("Choose exactly one workspace selector: --user, --local, or --fleet <id>.");
+  }
+  const globalRoot = resolve14(request.globalRoot ?? homedir7());
+  if (request.user) {
+    const config2 = await readWorkspaceConfig(globalRoot);
+    assertNonFleetScope("user", config2);
+    return { kind: "user", root: globalRoot, config: config2 };
+  }
+  if (request.fleet !== void 0) {
+    const id = fleetIdSchema.parse(request.fleet);
+    const registration = await showRegisteredFleet(id, { globalRoot });
+    const root = await assertCanonicalDirectory(registration.root, `Registered fleet '${id}' root`);
+    const config2 = await readRequiredConfig(root, `fleet '${id}'`);
+    assertFleetContract(id, registration, config2);
+    return { kind: "fleet", root, fleetId: id, config: config2 };
+  }
+  const cwd = resolve14(request.cwd ?? process.cwd());
+  const discoveredRoot = await findExistingWorkspaceRoot(cwd);
+  if (!discoveredRoot || discoveredRoot === globalRoot) {
+    if (request.local === true && cwd !== globalRoot) {
+      return { kind: "local", root: cwd, config: await readWorkspaceConfig(cwd) };
+    }
+    throw missingScopeError(request.local === true ? "local" : "implicit local");
+  }
+  const config = await readRequiredConfig(discoveredRoot, "local");
+  assertNonFleetScope("local", config);
+  return { kind: "local", root: discoveredRoot, config };
+}
+async function registerFleet(request) {
+  const id = fleetIdSchema.parse(request.id);
+  const requiredPackages = sortedUnique4(request.requiredPackages);
+  if (requiredPackages.length === 0) throw new Error("Fleet registration requires at least one --required-package <name>.");
+  const globalRoot = resolve14(request.globalRoot ?? homedir7());
+  const home = await readWorkspaceConfig(globalRoot);
+  if (supportsFleetConfig(home) && home.fleetId) {
+    throw new Error(`The home config is fleet '${home.fleetId}', so it cannot own the global fleet registry.`);
+  }
+  const existing = supportsFleetConfig(home) ? await canonicalizeExistingFleetRoots(home.fleets, globalRoot) : {};
+  if (existing[id]) throw new Error(`Fleet '${id}' is already registered.`);
+  const root = await assertCanonicalDirectory(request.root, `Fleet '${id}' root`);
+  const duplicateRoot = Object.entries(existing).find(([, value]) => value.root === root);
+  if (duplicateRoot) throw new Error(`Fleet root ${root} is already registered as '${duplicateRoot[0]}'.`);
+  if (root === globalRoot) throw new Error("A fleet root must be outside the user config root contract.");
+  const target = await readRequiredConfig(root, `fleet '${id}'`);
+  const registration = registeredFleetSchema.parse({ root, requiredPackages });
+  assertFleetContract(id, registration, target);
+  const upgraded = workspaceConfigSchema.parse({
+    ...home,
+    schemaVersion: CURRENT_WORKSPACE_SCHEMA_VERSION,
+    exports: home.schemaVersion >= 2 ? home.exports : { selections: {} },
+    fleets: { ...existing, [id]: registration }
+  });
+  const configPath = globalWorkspaceConfigPath(globalRoot);
+  declareMutationPath(configPath);
+  await writeJsonAtomic(configPath, upgraded);
+  return { id, ...registration };
+}
+async function canonicalizeExistingFleetRoots(fleets, globalRoot) {
+  const canonical = /* @__PURE__ */ new Map();
+  const normalized = {};
+  for (const [id, registration] of Object.entries(fleets).sort(([a], [b]) => a.localeCompare(b))) {
+    const root = await canonicalizeDirectory(registration.root, `Registered fleet '${id}' root`);
+    if (root === globalRoot) throw new Error(`Registered fleet '${id}' root must be outside the user config root contract.`);
+    const incumbent = canonical.get(root);
+    if (incumbent) {
+      throw new Error(`Fleet root ${root} is registered more than once as '${incumbent}' and '${id}'.`);
+    }
+    canonical.set(root, id);
+    normalized[id] = registeredFleetSchema.parse({ ...registration, root });
+  }
+  return normalized;
+}
+async function listRegisteredFleets(options = {}) {
+  const globalRoot = resolve14(options.globalRoot ?? homedir7());
+  const home = await readWorkspaceConfig(globalRoot);
+  if (!supportsFleetConfig(home)) return [];
+  return Object.entries(home.fleets).sort(([a], [b]) => a.localeCompare(b)).map(([id, registration]) => ({ id, ...registration }));
+}
+async function showRegisteredFleet(idInput, options = {}) {
+  const id = fleetIdSchema.parse(idInput);
+  const fleets = await listRegisteredFleets(options);
+  const registration = fleets.find((candidate) => candidate.id === id);
+  if (!registration) {
+    throw new Error(`Unknown fleet '${id}'. Use 'agentwheel fleet list' or register it with 'agentwheel fleet register'.`);
+  }
+  return registration;
+}
+async function resolveWorkspaceOwnershipScope(workspaceRootInput, options = {}) {
+  const workspaceRoot = await canonicalizeDirectory(resolve14(workspaceRootInput), "Workspace ownership root");
+  if (options.fleetId) {
+    return { root: workspaceRoot, fleetId: fleetIdSchema.parse(options.fleetId) };
+  }
+  const syntacticallyContaining = (await listRegisteredFleets({ globalRoot: options.globalRoot })).filter((fleet2) => containsPath(resolve14(fleet2.root), workspaceRoot));
+  const registered = await Promise.all(syntacticallyContaining.map(async (fleet2) => ({
+    ...fleet2,
+    root: await canonicalizeDirectory(fleet2.root, `Registered fleet '${fleet2.id}' root`)
+  })));
+  const containing = registered.filter((fleet2) => containsPath(fleet2.root, workspaceRoot));
+  if (containing.length > 1) {
+    throw new Error(
+      `Workspace ${workspaceRoot} is contained by multiple registered fleets: ` + containing.map((fleet2) => `'${fleet2.id}' at ${fleet2.root}`).join(", ") + ". Resolve the overlapping registrations before planning ownership."
+    );
+  }
+  const fleet = containing[0];
+  if (fleet) assertFleetContract(fleet.id, fleet, await readRequiredConfig(fleet.root, `fleet '${fleet.id}'`));
+  return fleet ? { root: fleet.root, fleetId: fleet.id } : { root: workspaceRoot };
+}
+async function readRequiredConfig(root, label) {
+  const path = workspaceConfigPath(root);
+  if (!await pathExists(path)) throw missingScopeError(label);
+  try {
+    return workspaceConfigSchema.parse(JSON.parse(await readFile20(path, "utf8")));
+  } catch (error) {
+    throw new Error(`Invalid ${label} Agentwheel config at ${path}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function assertFleetContract(id, registration, config) {
+  if (!supportsFleetConfig(config)) {
+    throw new Error(`Fleet '${id}' config must use schemaVersion 3 or newer before registration or selection.`);
+  }
+  if (config.fleetId !== id) {
+    throw new Error(`Fleet fleetId mismatch: expected '${id}', found '${config.fleetId ?? "missing"}'.`);
+  }
+  if (Object.keys(config.fleets).length > 0) {
+    throw new Error(`Fleet '${id}' config may not contain the home fleets registry.`);
+  }
+  const names = new Set(config.packages.map((pkg) => pkg.name));
+  for (const packageName of registration.requiredPackages) {
+    if (!names.has(packageName)) throw new Error(`Fleet '${id}' is missing required package '${packageName}'.`);
+  }
+}
+async function assertCanonicalDirectory(input, label) {
+  const canonical = await canonicalizeDirectory(input, label);
+  const normalized = resolve14(input);
+  const stats = await lstat2(input);
+  if (stats.isSymbolicLink() || canonical !== normalized || input !== normalized) {
+    throw new Error(`${label} must be canonical and symlink-unambiguous: ${input} resolves to ${canonical}.`);
+  }
+  return canonical;
+}
+async function canonicalizeDirectory(input, label) {
+  if (!isAbsolute2(input)) throw new Error(`${label} must be an absolute canonical path.`);
+  let canonical;
+  try {
+    canonical = await realpath(input);
+  } catch {
+    throw new Error(`${label} does not exist: ${input}`);
+  }
+  const stats = await lstat2(canonical);
+  if (!stats.isDirectory()) throw new Error(`${label} is not a directory: ${input}`);
+  return canonical;
+}
+function missingScopeError(label) {
+  return new Error(
+    `Missing ${label} Agentwheel workspace config. Select --user, --local, or --fleet <id>, or run 'agentwheel init workspace' in the intended local root. Agentwheel never falls back to home desired state.`
+  );
+}
+function assertNonFleetScope(kind, config) {
+  if (supportsFleetConfig(config) && config.fleetId) {
+    throw new Error(
+      `The ${kind} config declares fleetId '${config.fleetId}'. Select it through the registered --fleet <id> scope.`
+    );
+  }
+}
+function sortedUnique4(values) {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+function containsPath(parent, candidate) {
+  const path = relative7(parent, candidate);
+  return path === "" || !path.startsWith("..") && !isAbsolute2(path);
+}
+
 // src/lifecycle/source-plan.ts
 async function createGraphSourcePlan(options) {
   if (options.roots.length === 0) {
@@ -7813,7 +8011,11 @@ async function createGraphSourcePlan(options) {
   const graphLockDigest = digestGraphLock(bundle.graphLock);
   const graphDiff = diffGraphLocks(previousLock, bundle.graphLock);
   const manifest = await readInstallManifest(resolvedInstallRoot, options.adapter.name, transport, { installationType: resolvedInstallationType, stateKey });
-  const workspaceOwner = workspaceOwnerForRoot(workspaceRoot, options.fleetId);
+  const ownership = await resolveWorkspaceOwnershipScope(workspaceRoot, {
+    fleetId: options.fleetId,
+    globalRoot: options.globalRoot
+  });
+  const workspaceOwner = workspaceOwnerForRoot(ownership.root, ownership.fleetId);
   const plan = options.retireExactMcp ? await createExactMcpRetirementPlan(
     desiredArtifacts,
     options.adapter,
@@ -7847,7 +8049,8 @@ async function createGraphSourcePlan(options) {
       workspaceOwner,
       globalRoot: options.globalRoot,
       stateKey,
-      plannedPaths: plan.operations.map((operation) => operation.relativeDestPath)
+      plannedPaths: plan.operations.map((operation) => operation.relativeDestPath),
+      plannedOperations: plan.operations
     });
   }
   return {
@@ -7874,7 +8077,8 @@ async function assertNoForeignWorkspaceStateForPlan(plan, options) {
     workspaceOwner: options.workspaceOwner,
     globalRoot: options.globalRoot,
     stateKey: plan.stateKey,
-    plannedPaths: options.plannedPaths ?? plan.operations.map((operation) => operation.relativeDestPath)
+    plannedPaths: options.plannedPaths ?? plan.operations.map((operation) => operation.relativeDestPath),
+    plannedOperations: plan.operations
   });
 }
 function graphLockPathForTarget(workspaceRoot, targetKey2, adapter, targetFingerprintParts2) {
@@ -7924,8 +8128,15 @@ var workspaceOwnerPrefix2 = "workspace-root:";
 async function assertNoForeignWorkspaceState(check) {
   const planned = new Set(check.plannedPaths);
   if (planned.size === 0) return;
+  const plannedOperations = /* @__PURE__ */ new Map();
+  for (const operation of check.plannedOperations) {
+    if (!planned.has(operation.relativeDestPath)) continue;
+    const operations = plannedOperations.get(operation.relativeDestPath) ?? [];
+    operations.push(operation);
+    plannedOperations.set(operation.relativeDestPath, operations);
+  }
   const manifests = await listInstallManifests(check.installRoot, check.adapter, check.transport);
-  const root = resolve14(check.workspaceRoot);
+  const root = resolve15(check.workspaceRoot);
   const ownsSubWorkspaces = root !== globalConfigRoot(check.globalRoot);
   const foreign = [];
   for (const entry of manifests) {
@@ -7937,7 +8148,15 @@ async function assertNoForeignWorkspaceState(check) {
       if (ownedByWorkspace(owner, check.workspaceOwner, root, ownsSubWorkspaces)) continue;
       const bucket = byOwner.get(owner) ?? { entryCount: 0, collidingPaths: [] };
       bucket.entryCount += 1;
-      if (planned.has(manifestEntry.path)) bucket.collidingPaths.push(manifestEntry.path);
+      if (planned.has(manifestEntry.path) && !await isDisjointVerifiedMergeContribution(
+        check,
+        manifestEntry.path,
+        manifestEntry.mergeStrategy,
+        manifestEntry.mergeRemoval,
+        plannedOperations.get(manifestEntry.path) ?? []
+      )) {
+        bucket.collidingPaths.push(manifestEntry.path);
+      }
       byOwner.set(owner, bucket);
     }
     for (const [owner, bucket] of byOwner) {
@@ -7959,6 +8178,34 @@ async function assertNoForeignWorkspaceState(check) {
     parseWorkspaceOwner(check.workspaceOwner)?.fleetId ? "Reconcile the owners with an explicit agentwheel fleet normalize operation before planning this fleet." : "Re-run from the owning workspace, or pass --force-foreign-state to plan against it anyway."
   ].join("\n"));
 }
+async function isDisjointVerifiedMergeContribution(check, relativePath, foreignStrategy, foreignRemoval, operations) {
+  if (!foreignStrategy || !hasMergeRemovalContent(foreignRemoval) || operations.length !== 1) return false;
+  const operation = operations[0];
+  if (operation.mergeStrategy !== foreignStrategy || !hasMergeRemovalContent(operation.mergeRemoval)) return false;
+  if (!disjointMcpMergeContributions(foreignStrategy, foreignRemoval, operation.mergeRemoval)) return false;
+  try {
+    const content = await check.transport.readFile(join33(check.installRoot, relativePath));
+    assertExactMergeContribution(foreignRemoval, foreignStrategy, content);
+    assertExactMergeContribution(operation.mergeRemoval, foreignStrategy, content);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function disjointMcpMergeContributions(strategy, left, right) {
+  const leftNames = mcpServerNames(strategy, left);
+  const rightNames = mcpServerNames(strategy, right);
+  if (!leftNames || !rightNames) return false;
+  return [...leftNames].every((name) => !rightNames.has(name));
+}
+function mcpServerNames(strategy, removal) {
+  if (strategy !== "codex-toml-mcp" && strategy !== "json-deep") return void 0;
+  const keys = Object.keys(removal);
+  if (strategy === "json-deep" && (keys.length !== 1 || keys[0] !== "mcpServers")) return void 0;
+  const servers = removal.mcpServers ?? (strategy === "codex-toml-mcp" ? removal : void 0);
+  if (!servers || Array.isArray(servers) || typeof servers !== "object") return void 0;
+  return new Set(Object.keys(servers));
+}
 function globalConfigRoot(globalRoot) {
   return dirname17(dirname17(globalWorkspaceConfigPath(globalRoot)));
 }
@@ -8031,17 +8278,17 @@ function selectionImportKey2(selection) {
     exportHash: selection.exportHash,
     exportName: selection.exportName,
     extends: selection.extends,
-    inherited: sortedUnique4(selection.inherited),
-    additions: sortedUnique4(selection.additions),
-    exclusions: sortedUnique4(selection.exclusions),
-    effective: sortedUnique4(selection.effective)
+    inherited: sortedUnique5(selection.inherited),
+    additions: sortedUnique5(selection.additions),
+    exclusions: sortedUnique5(selection.exclusions),
+    effective: sortedUnique5(selection.effective)
   });
 }
-function sortedUnique4(values) {
+function sortedUnique5(values) {
   return [...new Set(values)].sort((a, b) => a.localeCompare(b));
 }
 function selectorKey(selectors) {
-  return sortedUnique4(selectors).join("\0");
+  return sortedUnique5(selectors).join("\0");
 }
 async function assertTrusted(sources, options) {
   if (sources.length === 0) return;
@@ -8102,7 +8349,7 @@ function targetLabel(target) {
 }
 
 // src/runtime/target.ts
-import { basename as basename18, dirname as dirname18, join as join34, resolve as resolve15 } from "path";
+import { basename as basename18, dirname as dirname18, join as join34, resolve as resolve16 } from "path";
 var runtimeMarkers = [
   { adapter: "openclaw", dirs: [".openclaw", ".clawdbot", ".moltbot"] },
   { adapter: "claude", dirs: [".claude"] },
@@ -8111,9 +8358,9 @@ var runtimeMarkers = [
   { adapter: "copilot", dirs: [".github"] }
 ];
 async function resolveRuntimeTarget(request = {}) {
-  const cwd = resolve15(request.cwd ?? process.cwd());
+  const cwd = resolve16(request.cwd ?? process.cwd());
   if (request.targetRoot) {
-    const targetRoot = resolve15(request.targetRoot);
+    const targetRoot = resolve16(request.targetRoot);
     return {
       adapter: request.adapter ?? "openclaw",
       installationType: request.installationType,
@@ -8145,7 +8392,7 @@ async function resolveRuntimeTarget(request = {}) {
 async function resolveAllRuntimeTargets(request = {}) {
   if (request.targetRoot) return [await resolveRuntimeTarget(request)];
   if (request.agent) return [await resolveRuntimeTarget(request)];
-  const cwd = resolve15(request.cwd ?? process.cwd());
+  const cwd = resolve16(request.cwd ?? process.cwd());
   const workspaceRoot = await findWorkspaceRoot(cwd);
   const config = await readMergedWorkspaceConfig(workspaceRoot, { globalRoot: request.globalRoot });
   const targets = Object.entries(config.agents).map(([name]) => targetFromAgent(name, config, workspaceRoot, request.installationType, request.fleetId));
@@ -8155,8 +8402,8 @@ async function resolveAllRuntimeTargets(request = {}) {
   return targets;
 }
 async function resolveProfileRuntimeTargets(request) {
-  const cwd = resolve15(request.cwd ?? process.cwd());
-  const workspaceRoot = request.targetRoot ? resolve15(request.targetRoot) : await findWorkspaceRoot(cwd);
+  const cwd = resolve16(request.cwd ?? process.cwd());
+  const workspaceRoot = request.targetRoot ? resolve16(request.targetRoot) : await findWorkspaceRoot(cwd);
   const config = await readMergedWorkspaceConfig(workspaceRoot, { globalRoot: request.globalRoot });
   const profile = config.profiles[request.profile];
   if (!profile) {
@@ -8222,7 +8469,7 @@ async function detectRuntimeTarget(cwd = process.cwd(), adapterFilter) {
   return unique[0];
 }
 async function detectRuntimeTargets(cwd = process.cwd(), adapterFilter) {
-  const root = resolve15(cwd);
+  const root = resolve16(cwd);
   const matches = [];
   for (const marker of runtimeMarkers) {
     if (adapterFilter && marker.adapter !== adapterFilter) continue;
@@ -8271,7 +8518,7 @@ function dedupeTargets(matches) {
   return [...byKey.values()];
 }
 function runtimeScanRoot(request) {
-  const root = resolve15(request.targetRoot ?? request.cwd ?? process.cwd());
+  const root = resolve16(request.targetRoot ?? request.cwd ?? process.cwd());
   if (request.targetRoot) return root;
   return runtimeMarkers.some((marker) => marker.dirs.includes(basename18(root))) ? dirname18(root) : root;
 }
@@ -8581,8 +8828,8 @@ function shellQuoteArg(value) {
 }
 
 // src/cli/update-check.ts
-import { mkdir as mkdir15, readFile as readFile20, writeFile as writeFile11 } from "fs/promises";
-import { homedir as homedir7 } from "os";
+import { mkdir as mkdir15, readFile as readFile21, writeFile as writeFile11 } from "fs/promises";
+import { homedir as homedir8 } from "os";
 import { dirname as dirname19, join as join35 } from "path";
 var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_TIMEOUT_MS = 300;
@@ -8591,7 +8838,7 @@ async function maybeCheckForUpdate(options) {
   if (isDisabled(options)) return;
   const now = options.now?.() ?? /* @__PURE__ */ new Date();
   const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
-  const cachePath = options.cachePath ?? join35(homedir7(), ".agentwheel", "update-check.json");
+  const cachePath = options.cachePath ?? join35(homedir8(), ".agentwheel", "update-check.json");
   try {
     const cached = await readCache(cachePath);
     if (cached && now.getTime() - Date.parse(cached.checkedAt) < ttlMs) {
@@ -8628,7 +8875,7 @@ async function fetchLatestVersion(fetchImpl, timeoutMs) {
 }
 async function readCache(path) {
   try {
-    const parsed = JSON.parse(await readFile20(path, "utf8"));
+    const parsed = JSON.parse(await readFile21(path, "utf8"));
     if (typeof parsed.checkedAt !== "string" || typeof parsed.latest !== "string") return void 0;
     return { checkedAt: parsed.checkedAt, latest: parsed.latest };
   } catch {
@@ -8660,9 +8907,9 @@ function normalizeVersion(version) {
 
 // src/model/package-validate.ts
 import { stat as stat12 } from "fs/promises";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 async function validatePackage(root) {
-  const packageRoot = resolve16(root);
+  const packageRoot = resolve17(root);
   const findings = [];
   const manifestPath = await findPackageManifestPath(packageRoot);
   if (!manifestPath) {
@@ -8763,7 +9010,7 @@ async function validateManifestComposeInclude(packageRoot, selector, optional, f
   try {
     validateSelector(selector, "compose.include", findings, manifestPath, { fragmentsOnly: true, aliases });
     if (isCrossPackageSelector(selector)) return;
-    const full = resolve16(packageRoot, selector);
+    const full = resolve17(packageRoot, selector);
     if (full !== packageRoot && !full.startsWith(`${packageRoot}/`)) {
       findings.push({ level: "error", message: `Compose include escapes package root: ${selector}`, path: manifestPath });
       return;
@@ -8816,11 +9063,11 @@ function isCrossPackageSelector(value) {
 }
 
 // src/model/package-migrate.ts
-import { readFile as readFile21, rename as rename3, writeFile as writeFile12 } from "fs/promises";
-import { join as join37, resolve as resolve17 } from "path";
+import { readFile as readFile22, rename as rename3, writeFile as writeFile12 } from "fs/promises";
+import { join as join37, resolve as resolve18 } from "path";
 import { applyEdits, modify, parse as parse2 } from "jsonc-parser";
 async function migratePackageManifest(root) {
-  const packageRoot = resolve17(root);
+  const packageRoot = resolve18(root);
   for (const name of openPackManifestNames) {
     const path = join37(packageRoot, name);
     if (await pathExists(path)) {
@@ -8834,7 +9081,7 @@ async function migratePackageManifest(root) {
   const from = join37(packageRoot, legacyName);
   const toName = legacyName.endsWith(".jsonc") ? "openpack.jsonc" : "openpack.json";
   const to = join37(packageRoot, toName);
-  const content = await readFile21(from, "utf8");
+  const content = await readFile22(from, "utf8");
   const updated = updateSchemaVersion(content);
   declareMutationPath(from);
   declareMutationPath(to);
@@ -8882,7 +9129,7 @@ function resolveCliVersion() {
 }
 
 // src/lifecycle/ownership.ts
-import { resolve as resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 async function planArtifactOwnershipHandoff(request) {
   return validateOwnershipHandoff(request, request.transport ?? localTransport);
 }
@@ -8895,7 +9142,9 @@ async function applyArtifactOwnershipHandoff(request) {
   const scope = { installationType: request.installationType, stateKey: request.stateKey };
   const lock = await acquireApplyLock(request.targetRoot, request.adapter, transport, {}, scope);
   try {
-    if (await readApplyJournal(request.targetRoot, request.adapter, transport, scope)) {
+    if ((await listApplyJournals(request.targetRoot, request.adapter, transport, {
+      installationType: request.installationType
+    })).length > 0) {
       throw new Error("Cannot hand off ownership while an apply journal is pending. Recover or abort it first.");
     }
     const plan = await validateOwnershipHandoff(request, transport);
@@ -9001,8 +9250,8 @@ function containedArtifactPath(targetRoot, relativePath) {
   if (!relativePath || relativePath.startsWith("/") || relativePath.includes("\0")) {
     throw new Error(`Unsafe managed artifact path: ${relativePath}`);
   }
-  const root = resolve18(targetRoot);
-  const candidate = resolve18(root, relativePath);
+  const root = resolve19(targetRoot);
+  const candidate = resolve19(root, relativePath);
   if (candidate !== root && !candidate.startsWith(`${root}/`)) {
     throw new Error(`Managed artifact path escapes target root: ${relativePath}`);
   }
@@ -9035,8 +9284,8 @@ function assertManifestIdentity(manifest, request) {
 
 // src/version/policy.ts
 import { execFile as execFile3 } from "child_process";
-import { readFile as readFile22 } from "fs/promises";
-import { join as join39, resolve as resolve19 } from "path";
+import { readFile as readFile23 } from "fs/promises";
+import { join as join39, resolve as resolve20 } from "path";
 import { promisify as promisify3 } from "util";
 import { parse as parseJsonc } from "jsonc-parser";
 import { z as z5 } from "zod";
@@ -9130,7 +9379,7 @@ async function discoverVersionsFromSource(pkg, workspaceRoot) {
     if (tagged.length > 0) return tagged;
   }
   if (driverName === "local") {
-    const root = resolve19(workspaceRoot, pkg.source);
+    const root = resolve20(workspaceRoot, pkg.source);
     const manifest2 = await readPackageManifest(root);
     const current = manifest2 ? [{ version: manifest2.version, ref: pkg.requestedRef ?? root }] : [];
     try {
@@ -9244,7 +9493,7 @@ function versionCachePath(workspaceRoot) {
 async function readVersionCache(path) {
   if (!await pathExists(path)) return { schemaVersion: 1, sources: {} };
   try {
-    return versionCacheSchema.parse(JSON.parse(await readFile22(path, "utf8")));
+    return versionCacheSchema.parse(JSON.parse(await readFile23(path, "utf8")));
   } catch {
     return { schemaVersion: 1, sources: {} };
   }
@@ -9252,8 +9501,8 @@ async function readVersionCache(path) {
 
 // src/profile/members.ts
 import { execFile as execFile4 } from "child_process";
-import { readFile as readFile23 } from "fs/promises";
-import { join as join40, resolve as resolve20 } from "path";
+import { readFile as readFile24 } from "fs/promises";
+import { join as join40, resolve as resolve21 } from "path";
 import { promisify as promisify4 } from "util";
 import { z as z7 } from "zod";
 
@@ -9428,7 +9677,7 @@ async function invokeMemberStatus(member, parentWorkspace, chain, options, cliEn
   let stderr = "";
   try {
     if (member.transport === "local") {
-      const workspace = resolve20(parentWorkspace, member.workspace);
+      const workspace = resolve21(parentWorkspace, member.workspace);
       const result = await execFileAsync4(process.execPath, [cliEntry, ...args], {
         cwd: workspace,
         env: env2,
@@ -9474,7 +9723,7 @@ async function runMemberAgentwheel(member, parentWorkspace, args, chain) {
         process.execPath,
         [process.argv[1], "--no-update-check", ...args],
         {
-          cwd: resolve20(parentWorkspace, member.workspace),
+          cwd: resolve21(parentWorkspace, member.workspace),
           env: env2,
           maxBuffer: 20 * 1024 * 1024
         }
@@ -9554,7 +9803,7 @@ function memberCachePath(workspaceRoot, profileName, memberId) {
 async function readMemberCache(path) {
   if (!await pathExists(path)) return void 0;
   try {
-    return memberCacheSchema.parse(JSON.parse(await readFile23(path, "utf8")));
+    return memberCacheSchema.parse(JSON.parse(await readFile24(path, "utf8")));
   } catch {
     return void 0;
   }
@@ -9575,7 +9824,7 @@ function assertNoCompositeCycle(workspaceRoot, profileName, chain) {
   }
 }
 function compositeKey(workspaceRoot, profileName) {
-  return `${resolve20(workspaceRoot)}#${profileName}`;
+  return `${resolve21(workspaceRoot)}#${profileName}`;
 }
 
 // src/status/repository.ts
@@ -9623,8 +9872,8 @@ function valueAfter(lines, prefix) {
 
 // src/catalogue/client.ts
 import { createHash as createHash9 } from "crypto";
-import { readFile as readFile24, rm as rm8 } from "fs/promises";
-import { homedir as homedir8 } from "os";
+import { readFile as readFile25, rm as rm8 } from "fs/promises";
+import { homedir as homedir9 } from "os";
 import { join as join41 } from "path";
 
 // src/model/catalogue.ts
@@ -9841,7 +10090,7 @@ var CatalogueClient = class {
   async readCache() {
     if (!await pathExists(this.cachePath)) return void 0;
     try {
-      const value = JSON.parse(await readFile24(this.cachePath, "utf8"));
+      const value = JSON.parse(await readFile25(this.cachePath, "utf8"));
       const envelope = catalogueCacheEnvelopeSchema.parse(value);
       if (envelope.contentHash) {
         const contentHash = catalogueContentHash(envelope.enriched, envelope.vercel);
@@ -9902,7 +10151,7 @@ var CatalogueClient = class {
   }
 };
 function defaultCatalogueCachePath() {
-  return join41(homedir8(), ".agentwheel", "catalogue-cache.json");
+  return join41(homedir9(), ".agentwheel", "catalogue-cache.json");
 }
 function sameSources2(a, b) {
   return a.length === b.length && a.every((source, index) => source === b[index]);
@@ -10271,7 +10520,7 @@ function includesToken(normalizedText, token) {
 
 // src/semantic/index.ts
 import { createHash as createHash10 } from "crypto";
-import { homedir as homedir9 } from "os";
+import { homedir as homedir10 } from "os";
 import { join as join42 } from "path";
 import { env, pipeline } from "@huggingface/transformers";
 var DEFAULT_SEMANTIC_INDEX_URL = "https://raw.githubusercontent.com/NestDevLab/agentwheel-registry/main/catalogue-semantic-index/gte-v1/";
@@ -10366,7 +10615,7 @@ var SemanticSearchClient = class {
   }
 };
 async function embedQuery(query) {
-  env.cacheDir = join42(homedir9(), ".agentwheel", "semantic-models");
+  env.cacheDir = join42(homedir10(), ".agentwheel", "semantic-models");
   const extractor = await pipeline("feature-extraction", CONTRACT.model.id, {
     revision: CONTRACT.model.revision,
     dtype: CONTRACT.model.dtype,
@@ -10451,7 +10700,7 @@ function ensureTrailingSlash(value) {
 
 // src/trial/skill.ts
 import { createHash as createHash11 } from "crypto";
-import { readFile as readFile25, stat as stat13 } from "fs/promises";
+import { readFile as readFile26, stat as stat13 } from "fs/promises";
 import { join as join43 } from "path";
 import { parse as parseYaml2 } from "yaml";
 var MAX_TRIAL_SKILL_BYTES = 512 * 1024;
@@ -10469,7 +10718,7 @@ async function createSkillTrial(driver, resolved, selectors) {
   if (info.size > MAX_TRIAL_SKILL_BYTES) {
     throw new Error(`Skill trial exceeds the ${MAX_TRIAL_SKILL_BYTES / 1024} KiB content limit.`);
   }
-  const content = await readFile25(path, "utf8");
+  const content = await readFile26(path, "utf8");
   const frontmatter = readSkillFrontmatter(content, artifact);
   return {
     schemaVersion: 1,
@@ -10498,166 +10747,11 @@ function readSkillFrontmatter(content, artifact) {
   return { name: value.name, description: value.description };
 }
 
-// src/model/fleet.ts
-import { lstat as lstat2, readFile as readFile26, realpath } from "fs/promises";
-import { homedir as homedir10 } from "os";
-import { isAbsolute as isAbsolute2, resolve as resolve21 } from "path";
-async function resolveWorkspaceScope(request = {}) {
-  const selected = [request.user === true, request.local === true, request.fleet !== void 0].filter(Boolean).length;
-  if (selected > 1) {
-    throw new Error("Choose exactly one workspace selector: --user, --local, or --fleet <id>.");
-  }
-  const globalRoot = resolve21(request.globalRoot ?? homedir10());
-  if (request.user) {
-    const config2 = await readWorkspaceConfig(globalRoot);
-    assertNonFleetScope("user", config2);
-    return { kind: "user", root: globalRoot, config: config2 };
-  }
-  if (request.fleet !== void 0) {
-    const id = fleetIdSchema.parse(request.fleet);
-    const registration = await showRegisteredFleet(id, { globalRoot });
-    const root = await assertCanonicalDirectory(registration.root, `Registered fleet '${id}' root`);
-    const config2 = await readRequiredConfig(root, `fleet '${id}'`);
-    assertFleetContract(id, registration, config2);
-    return { kind: "fleet", root, fleetId: id, config: config2 };
-  }
-  const cwd = resolve21(request.cwd ?? process.cwd());
-  const discoveredRoot = await findExistingWorkspaceRoot(cwd);
-  if (!discoveredRoot || discoveredRoot === globalRoot) {
-    if (request.local === true && cwd !== globalRoot) {
-      return { kind: "local", root: cwd, config: await readWorkspaceConfig(cwd) };
-    }
-    throw missingScopeError(request.local === true ? "local" : "implicit local");
-  }
-  const config = await readRequiredConfig(discoveredRoot, "local");
-  assertNonFleetScope("local", config);
-  return { kind: "local", root: discoveredRoot, config };
-}
-async function registerFleet(request) {
-  const id = fleetIdSchema.parse(request.id);
-  const requiredPackages = sortedUnique5(request.requiredPackages);
-  if (requiredPackages.length === 0) throw new Error("Fleet registration requires at least one --required-package <name>.");
-  const globalRoot = resolve21(request.globalRoot ?? homedir10());
-  const home = await readWorkspaceConfig(globalRoot);
-  if (supportsFleetConfig(home) && home.fleetId) {
-    throw new Error(`The home config is fleet '${home.fleetId}', so it cannot own the global fleet registry.`);
-  }
-  const existing = supportsFleetConfig(home) ? await canonicalizeExistingFleetRoots(home.fleets, globalRoot) : {};
-  if (existing[id]) throw new Error(`Fleet '${id}' is already registered.`);
-  const root = await assertCanonicalDirectory(request.root, `Fleet '${id}' root`);
-  const duplicateRoot = Object.entries(existing).find(([, value]) => value.root === root);
-  if (duplicateRoot) throw new Error(`Fleet root ${root} is already registered as '${duplicateRoot[0]}'.`);
-  if (root === globalRoot) throw new Error("A fleet root must be outside the user config root contract.");
-  const target = await readRequiredConfig(root, `fleet '${id}'`);
-  const registration = registeredFleetSchema.parse({ root, requiredPackages });
-  assertFleetContract(id, registration, target);
-  const upgraded = workspaceConfigSchema.parse({
-    ...home,
-    schemaVersion: CURRENT_WORKSPACE_SCHEMA_VERSION,
-    exports: home.schemaVersion >= 2 ? home.exports : { selections: {} },
-    fleets: { ...existing, [id]: registration }
-  });
-  const configPath = globalWorkspaceConfigPath(globalRoot);
-  declareMutationPath(configPath);
-  await writeJsonAtomic(configPath, upgraded);
-  return { id, ...registration };
-}
-async function canonicalizeExistingFleetRoots(fleets, globalRoot) {
-  const canonical = /* @__PURE__ */ new Map();
-  const normalized = {};
-  for (const [id, registration] of Object.entries(fleets).sort(([a], [b]) => a.localeCompare(b))) {
-    const root = await canonicalizeDirectory(registration.root, `Registered fleet '${id}' root`);
-    if (root === globalRoot) throw new Error(`Registered fleet '${id}' root must be outside the user config root contract.`);
-    const incumbent = canonical.get(root);
-    if (incumbent) {
-      throw new Error(`Fleet root ${root} is registered more than once as '${incumbent}' and '${id}'.`);
-    }
-    canonical.set(root, id);
-    normalized[id] = registeredFleetSchema.parse({ ...registration, root });
-  }
-  return normalized;
-}
-async function listRegisteredFleets(options = {}) {
-  const globalRoot = resolve21(options.globalRoot ?? homedir10());
-  const home = await readWorkspaceConfig(globalRoot);
-  if (!supportsFleetConfig(home)) return [];
-  return Object.entries(home.fleets).sort(([a], [b]) => a.localeCompare(b)).map(([id, registration]) => ({ id, ...registration }));
-}
-async function showRegisteredFleet(idInput, options = {}) {
-  const id = fleetIdSchema.parse(idInput);
-  const fleets = await listRegisteredFleets(options);
-  const registration = fleets.find((candidate) => candidate.id === id);
-  if (!registration) {
-    throw new Error(`Unknown fleet '${id}'. Use 'agentwheel fleet list' or register it with 'agentwheel fleet register'.`);
-  }
-  return registration;
-}
-async function readRequiredConfig(root, label) {
-  const path = workspaceConfigPath(root);
-  if (!await pathExists(path)) throw missingScopeError(label);
-  try {
-    return workspaceConfigSchema.parse(JSON.parse(await readFile26(path, "utf8")));
-  } catch (error) {
-    throw new Error(`Invalid ${label} Agentwheel config at ${path}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-function assertFleetContract(id, registration, config) {
-  if (!supportsFleetConfig(config)) {
-    throw new Error(`Fleet '${id}' config must use schemaVersion 3 or newer before registration or selection.`);
-  }
-  if (config.fleetId !== id) {
-    throw new Error(`Fleet fleetId mismatch: expected '${id}', found '${config.fleetId ?? "missing"}'.`);
-  }
-  if (Object.keys(config.fleets).length > 0) {
-    throw new Error(`Fleet '${id}' config may not contain the home fleets registry.`);
-  }
-  const names = new Set(config.packages.map((pkg) => pkg.name));
-  for (const packageName of registration.requiredPackages) {
-    if (!names.has(packageName)) throw new Error(`Fleet '${id}' is missing required package '${packageName}'.`);
-  }
-}
-async function assertCanonicalDirectory(input, label) {
-  const canonical = await canonicalizeDirectory(input, label);
-  const normalized = resolve21(input);
-  const stats = await lstat2(input);
-  if (stats.isSymbolicLink() || canonical !== normalized || input !== normalized) {
-    throw new Error(`${label} must be canonical and symlink-unambiguous: ${input} resolves to ${canonical}.`);
-  }
-  return canonical;
-}
-async function canonicalizeDirectory(input, label) {
-  if (!isAbsolute2(input)) throw new Error(`${label} must be an absolute canonical path.`);
-  let canonical;
-  try {
-    canonical = await realpath(input);
-  } catch {
-    throw new Error(`${label} does not exist: ${input}`);
-  }
-  const stats = await lstat2(canonical);
-  if (!stats.isDirectory()) throw new Error(`${label} is not a directory: ${input}`);
-  return canonical;
-}
-function missingScopeError(label) {
-  return new Error(
-    `Missing ${label} Agentwheel workspace config. Select --user, --local, or --fleet <id>, or run 'agentwheel init workspace' in the intended local root. Agentwheel never falls back to home desired state.`
-  );
-}
-function assertNonFleetScope(kind, config) {
-  if (supportsFleetConfig(config) && config.fleetId) {
-    throw new Error(
-      `The ${kind} config declares fleetId '${config.fleetId}'. Select it through the registered --fleet <id> scope.`
-    );
-  }
-}
-function sortedUnique5(values) {
-  return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort((a, b) => a.localeCompare(b));
-}
-
 // src/lifecycle/fleet-normalize.ts
 import { createHash as createHash12 } from "crypto";
 import { readFile as readFile27, readdir as readdir9, rm as rm9 } from "fs/promises";
 import { homedir as homedir11 } from "os";
-import { basename as basename19, isAbsolute as isAbsolute3, join as join44, relative as relative7, resolve as resolve22 } from "path";
+import { basename as basename19, isAbsolute as isAbsolute3, join as join44, relative as relative8, resolve as resolve22 } from "path";
 async function planFleetNormalization(request) {
   const normalizedRequest = normalizeRequest(request);
   const destinationScope = await resolveWorkspaceScope({
@@ -11403,7 +11497,7 @@ async function relevantGraphLocks(workspaceRoot, selected, targetKeys, include)
     if (!path.endsWith(".graph-lock.json")) continue;
     const lock = await readGraphLock(path);
     if (!lock.canonical.roots.some((candidate2) => selected.has(candidate2.rootId))) continue;
-    const parts = relative7(root, path).split(/[\\/]/);
+    const parts = relative8(root, path).split(/[\\/]/);
     if (parts.length !== 3) throw new Error(`Graph lock path is not canonical: ${path}`);
     const [targetKey2, adapter, fileName] = parts;
     if (targetKeys && !targetKeys.has(targetKey2)) continue;
@@ -11976,6 +12070,7 @@ async function acquireJournalManifestLocks(manifests) {
   try {
     const unique = /* @__PURE__ */ new Map();
     for (const item of manifests) unique.set(item.path, item);
+    const acquiredPaths = /* @__PURE__ */ new Set();
     for (const item of [...unique.values()].sort((a, b) => a.path.localeCompare(b.path))) {
       const raw = await readOptionalRecord(item.path) ?? item.before ?? item.after;
       if (!raw && !(item.targetRoot && item.adapter && item.installationType && item.stateKey)) {
@@ -11988,9 +12083,13 @@ async function acquireJournalManifestLocks(manifests) {
       const installationType = manifest?.installationType ?? item.installationType;
       const stateKey = manifest?.stateKey ?? item.stateKey;
       const scope = { installationType, stateKey };
-      const lock = await acquireApplyLock(targetRoot, adapter, void 0, {}, scope);
-      locks.push(lock);
-      if (await readApplyJournal(targetRoot, adapter, void 0, scope)) {
+      const lockPath = applyLockPath(targetRoot, adapter, scope);
+      if (!acquiredPaths.has(lockPath)) {
+        const lock = await acquireApplyLock(targetRoot, adapter, void 0, {}, scope);
+        locks.push(lock);
+        acquiredPaths.add(lockPath);
+      }
+      if ((await listApplyJournals(targetRoot, adapter, void 0, { installationType })).length > 0) {
         throw new Error(`Cannot normalize while an Agentwheel apply journal is pending for ${item.path}.`);
       }
     }
@@ -13522,10 +13621,13 @@ async function buildGraphPlansForTarget(target, source, options, behavior) {
           targetOptions.focusedArtifact,
           focusedArtifactOwnerKeys(result.bundle.graphLock, previousGroupLock, scopedRootId, targetOptions.focusedArtifact)
         )).map((operation) => operation.relativeDestPath);
+        const ownership = await resolveWorkspaceOwnershipScope(group.target.workspaceRoot, {
+          fleetId: group.target.fleetId
+        });
         await assertNoForeignWorkspaceStateForPlan(scopedResult.plan, {
           transport,
           workspaceRoot: group.target.workspaceRoot,
-          workspaceOwner: workspaceOwnerForRoot(group.target.workspaceRoot, group.target.fleetId),
+          workspaceOwner: workspaceOwnerForRoot(ownership.root, ownership.fleetId),
           plannedPaths: focusedPaths
         });
       }
@@ -14092,6 +14194,8 @@ function keepManifestEntryOperation(entry, targetRoot, scopeDescription, operati
     semanticPlugin: entry.semanticPlugin,
     execute: entry.executed,
     mergeStrategy: entry.mergeStrategy,
+    mergeRemoval: "mergeRemoval" in entry ? entry.mergeRemoval : void 0,
+    mergeCreatedDestination: "mergeCreatedDestination" in entry ? entry.mergeCreatedDestination : void 0,
     composedFrom: entry.composedFrom,
     installName: fresh?.installName ?? ("installName" in entry ? entry.installName : entry.artifactName),
     logicalSelector: fresh?.logicalSelector ?? ("logicalSelector" in entry ? entry.logicalSelector : `${entry.artifactType}/${entry.artifactName}`),

package/dist/{transaction-IM5MZS4B.js → transaction-ITXC7FFV.js}

@@ -8,6 +8,7 @@ import {
   applyLockPath,
   assertApplyJournalRecoveryAllowed,
   assertGovernedRuntimeTransportSupported,
+  listApplyJournals,
   localPathExists,
   mutationMetadataForApplyJournal,
   readApplyJournal,
@@ -16,7 +17,7 @@ import {
   removeApplyJournal,
   rollbackCompletedOperations,
   writeApplyJournal
-} from "./chunk-HOYIIUL5.js";
+} from "./chunk-BJEZXIXX.js";
 import "./chunk-7VPI5J5Y.js";
 export {
   abortApplyJournal,
@@ -27,6 +28,7 @@ export {
   applyLockPath,
   assertApplyJournalRecoveryAllowed,
   assertGovernedRuntimeTransportSupported,
+  listApplyJournals,
   localPathExists,
   mutationMetadataForApplyJournal,
   readApplyJournal,

package/openpack.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentwheel",
-  "version": "0.20.0",
+  "version": "0.20.1",
   "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.0"
+  version: "0.20.1"
 ---
 
 # agentwheel

package/skills/agentwheel-discovery/SKILL.md

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