plugnz 0.0.8 → 0.0.10

package/dist/plugnz.mjs

@@ -9339,10 +9339,23 @@ var dcode = {
         continue;
       const row = entry;
       const path = typeof row.installPath === "string" ? row.installPath : typeof row.install_path === "string" ? row.install_path : undefined;
+      let declaredVersion;
+      if (path && existsSync8(path)) {
+        for (const relative of ["plugin.json", ".claude-plugin/plugin.json", ".codex-plugin/plugin.json"]) {
+          try {
+            const manifest = JSON.parse(readFileSync6(join11(path, relative), "utf8"));
+            if (typeof manifest.version === "string") {
+              declaredVersion = manifest.version;
+              break;
+            }
+          } catch {}
+        }
+      }
       const at = id.indexOf("@");
       const name = at < 0 ? id : id.slice(0, at);
       const marketplace = at < 0 ? undefined : id.slice(at + 1);
-      const plugin = { id, name, ...marketplace ? { marketplace } : {}, ...path && existsSync8(path) ? { path } : {}, ...typeof row.version === "string" ? { version: row.version } : {}, ...enabled.enabledPlugins[id] === true ? { enabled: true } : { enabled: false } };
+      const version = typeof row.version === "string" ? row.version : declaredVersion;
+      const plugin = { id, name, ...marketplace ? { marketplace } : {}, ...path && existsSync8(path) ? { path } : {}, ...version === undefined ? {} : { version }, ...enabled.enabledPlugins[id] === true ? { enabled: true } : { enabled: false } };
       result.push(plugin);
     }
     return result;
@@ -10239,6 +10252,91 @@ function frame(hash, bytes) {
   hash.update(bytes);
 }
 
+// src/lifecycle-operation-record.ts
+var FIELDS = ["schemaVersion", "adapterId", "target", "targetObservationId", "operationId", "attemptId", "scopeId", "packageName", "nativeId", "sourceType", "sourceRevision", "sourceLocator", "packageVersion", "action", "route", "detectedVersion", "versionProbeId", "evidenceId", "mutationGroupId", "mutationInvocationOperationId", "artifactId", "projectedFingerprint", "affectedNativeIds", "affectedOperationIds", "prior", "expected", "rollbackReference"];
+function parseSerializedLifecycleOperation(value) {
+  const row = object2(value);
+  exact(row, FIELDS);
+  if (row.schemaVersion !== 1)
+    invalid2("operation schemaVersion must be 1");
+  for (const field of ["adapterId", "targetObservationId", "operationId", "attemptId", "scopeId", "packageName", "nativeId", "sourceRevision", "detectedVersion", "versionProbeId", "evidenceId", "mutationGroupId", "mutationInvocationOperationId", "rollbackReference"])
+    string(row[field]);
+  parsePersistedTargetIdentity(row.target, "sealed operation target");
+  choice(row.sourceType, ["local", "git"]);
+  choice(row.route, ["native", "managed"]);
+  choice(row.action, ["install", "update", "route-migrate", "disable-nonconforming", "retire-orphan", "remove"]);
+  for (const field of ["sourceLocator", "packageVersion", "artifactId"])
+    if (row[field] !== null)
+      string(row[field]);
+  digest(row.projectedFingerprint);
+  for (const field of ["affectedNativeIds", "affectedOperationIds"]) {
+    if (!Array.isArray(row[field]) || row[field].length === 0)
+      invalid2("affected identities must be nonempty arrays");
+    for (const item of row[field])
+      string(item);
+  }
+  for (const field of ["prior", "expected"])
+    readback(row[field]);
+  return value;
+}
+function readback(value) {
+  const row = object2(value);
+  exact(row, ["adapterId", "target", "scopeId", "packageName", "nativeId", "route", "presence", "enablement", "activation", "transition", "installedFingerprint", "contentRoots", "retention"]);
+  for (const field of ["adapterId", "scopeId", "packageName", "nativeId"])
+    string(row[field]);
+  parsePersistedTargetIdentity(row.target, "operation readback target");
+  choice(row.route, ["native", "managed", "none"]);
+  choice(row.presence, ["present", "absent"]);
+  choice(row.enablement, ["enabled", "disabled", "not-applicable", "unknown"]);
+  choice(row.activation, ["active", "inactive", "unknown"]);
+  digest(row.installedFingerprint);
+  const transition = object2(row.transition);
+  exact(transition, ["requirement", "status"]);
+  choice(transition.requirement, ["none", "restart", "reload", "unknown"]);
+  choice(transition.status, ["effective", "pending", "unknown"]);
+  if (!Array.isArray(row.contentRoots))
+    invalid2("content roots must be an array");
+  for (const value of row.contentRoots) {
+    const root = object2(value);
+    exact(root, ["label", "path", "fingerprint"]);
+    string(root.label);
+    string(root.path);
+    digest(root.fingerprint);
+  }
+  const retention = object2(row.retention);
+  exact(retention, ["pluginData", "inactiveMetadata"]);
+  for (const field of ["pluginData", "inactiveMetadata"]) {
+    const resource = object2(retention[field]);
+    exact(resource, ["state", "fingerprint"]);
+    choice(resource.state, ["present", "absent", "missing", "not-observed"]);
+    digest(resource.fingerprint);
+  }
+}
+function object2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    invalid2("expected object");
+  return value;
+}
+function exact(row, fields) {
+  if (Object.keys(row).some((key) => !fields.includes(key)) || fields.some((key) => !(key in row)))
+    invalid2("operation fields do not match schema");
+}
+function string(value) {
+  if (typeof value !== "string" || !value || /[\r\n\u0000]/u.test(value))
+    invalid2("expected stable nonempty string");
+}
+function choice(value, choices) {
+  if (typeof value !== "string" || !choices.includes(value))
+    invalid2("invalid operation enum");
+}
+function digest(value) {
+  if (value !== null && (typeof value !== "string" || !/^[a-f0-9]{64}$/u.test(value)))
+    invalid2("invalid operation fingerprint");
+}
+function invalid2(message) {
+  throw new Error(`invalid sealed lifecycle operation: ${message}`);
+}
+
 // src/state.ts
 var PENDING_OPERATIONS = ["install", "update", "route-migrate", "disable-nonconforming", "retire-orphan", "remove"];
 var JOURNAL_ACTIONS = [...PENDING_OPERATIONS, "unchanged", "retain-prior"];
@@ -10306,39 +10404,41 @@ function validateLifecycleStateDocument(value, minimumStateGeneration) {
       continue;
     const attempt = attemptsById.get(scope.lastAttemptId);
     if (attempt === undefined)
-      invalid2(`deployment scope '${scope.id}' references unknown last attempt '${scope.lastAttemptId}'`);
+      invalid3(`deployment scope '${scope.id}' references unknown last attempt '${scope.lastAttemptId}'`);
     if (!attempt.scopeIds.includes(scope.id))
-      invalid2(`deployment scope '${scope.id}' last attempt does not include that scope`);
+      invalid3(`deployment scope '${scope.id}' last attempt does not include that scope`);
   }
   for (const activation of activations) {
     if (!scopeIds.has(activation.scopeId))
-      invalid2(`activation '${activationKey(activation)}' references unknown scope '${activation.scopeId}'`);
+      invalid3(`activation '${activationKey(activation)}' references unknown scope '${activation.scopeId}'`);
     if (activation.pending === undefined)
       continue;
     const attempt = attemptsById.get(activation.pending.attemptId);
     if (attempt === undefined)
-      invalid2(`activation '${activationKey(activation)}' references unknown pending attempt '${activation.pending.attemptId}'`);
+      invalid3(`activation '${activationKey(activation)}' references unknown pending attempt '${activation.pending.attemptId}'`);
     if (!attempt.scopeIds.includes(activation.scopeId))
-      invalid2(`activation '${activationKey(activation)}' pending attempt does not include its scope`);
+      invalid3(`activation '${activationKey(activation)}' pending attempt does not include its scope`);
     const matchingEntries = attempt.journal.filter((entry) => entry.scopeId === activation.scopeId && entry.packageId === activation.packageId && entry.nativeId === activation.nativeId);
     if (matchingEntries.length !== 1)
-      invalid2(`activation '${activationKey(activation)}' pending attempt must contain exactly one matching package/native journal entry`);
+      invalid3(`activation '${activationKey(activation)}' pending attempt must contain exactly one matching package/native journal entry`);
     validatePendingSemantics(activation, attempt, matchingEntries[0]);
   }
   for (const attempt of attempts) {
     for (const scopeId of attempt.scopeIds)
       if (!scopeIds.has(scopeId))
-        invalid2(`attempt '${attempt.id}' references unknown scope '${scopeId}'`);
+        invalid3(`attempt '${attempt.id}' references unknown scope '${scopeId}'`);
     for (const entry of attempt.journal) {
       operationIds.push(entry.operationId);
       if (!attempt.scopeIds.includes(entry.scopeId))
-        invalid2(`attempt '${attempt.id}' journal references scope '${entry.scopeId}' outside the attempt`);
+        invalid3(`attempt '${attempt.id}' journal references scope '${entry.scopeId}' outside the attempt`);
+      if (entry.sealedOperation !== undefined && entry.sealedOperation.attemptId !== attempt.id)
+        invalid3(`attempt '${attempt.id}' sealed operation references another attempt`);
     }
   }
   unique(operationIds, "journal operation id");
   for (const tombstone of tombstones)
     if (!scopeIds.has(tombstone.scopeId))
-      invalid2(`tombstone '${tombstone.id}' references unknown scope '${tombstone.scopeId}'`);
+      invalid3(`tombstone '${tombstone.id}' references unknown scope '${tombstone.scopeId}'`);
   return value;
 }
 function findRecord(records, host, id) {
@@ -10374,9 +10474,9 @@ function parseV1Install(value, index) {
   const rec = asObject(value, "install record");
   const unknown = Object.keys(rec).find((key) => !V1_RECORD_FIELDS.has(key));
   if (unknown !== undefined)
-    invalid2(`unsupported install field '${unknown}'`);
+    invalid3(`unsupported install field '${unknown}'`);
   if (typeof rec["host"] !== "string" || typeof rec["id"] !== "string" || typeof rec["source"] !== "string" || typeof rec["sourceSha"] !== "string") {
-    invalid2("install record is missing required fields");
+    invalid3("install record is missing required fields");
   }
   const host = rec["host"];
   const id = rec["id"];
@@ -10390,7 +10490,7 @@ function parseV1Install(value, index) {
   optionalLegacyString(rec["installedFingerprint"], "installedFingerprint");
   optionalLegacyString(rec["ownership"], "ownership");
   if (rec["pending"] !== undefined && rec["pending"] !== "install" && rec["pending"] !== "remove")
-    invalid2("pending must be install or remove");
+    invalid3("pending must be install or remove");
   const record = { host, id, source, sourceSha };
   if (typeof rec["installedAt"] === "string")
     record.installedAt = rec["installedAt"];
@@ -10427,7 +10527,7 @@ function importV1(records) {
       scopes.set(scopeId, scope);
     }
     const relativeDir = legacyRelativeDir(record);
-    const attemptId = record.pending === undefined ? undefined : `legacy-attempt-${digest(`${scopeId}\x00${record.id}\x00${record.pending}`)}`;
+    const attemptId = record.pending === undefined ? undefined : `legacy-attempt-${digest2(`${scopeId}\x00${record.id}\x00${record.pending}`)}`;
     state.activations.push({
       scopeId,
       packageId: record.id,
@@ -10462,7 +10562,7 @@ function importV1(records) {
         mutationStarted: true,
         scopeIds: [scopeId],
         journal: [{
-          operationId: `legacy-operation-${digest(attemptId)}`,
+          operationId: `legacy-operation-${digest2(attemptId)}`,
           scopeId,
           packageId: record.id,
           nativeId: record.id,
@@ -10521,7 +10621,7 @@ function validateScope(value, label) {
   const target = validateTarget(rec["target"], `${label}.target`);
   const canonicalId = canonicalScopeId(source, target);
   if (id !== canonicalId)
-    invalid2(`deployment scope '${id}' does not match canonical Source and target identity '${canonicalId}'`);
+    invalid3(`deployment scope '${id}' does not match canonical Source and target identity '${canonicalId}'`);
   oneOf(rec["authority"], ["legacy-import", "authoritative"], `${label}.authority`);
   oneOf(rec["lifecycle"], ["active", "retiring", "retired"], `${label}.lifecycle`);
   oneOf(rec["selectorMode"], ["legacy-unknown", "all", "explicit", "retired"], `${label}.selectorMode`);
@@ -10532,15 +10632,15 @@ function validateScope(value, label) {
   optionalTimestamp(rec["updatedAt"], `${label}.updatedAt`);
   optionalTimestamp(rec["retiredAt"], `${label}.retiredAt`);
   if (rec["authority"] === "legacy-import" && (rec["selectorMode"] !== "legacy-unknown" || desired !== undefined || lastConverged !== undefined))
-    invalid2(`deployment scope '${id}' legacy import cannot carry desired or converged authority`);
+    invalid3(`deployment scope '${id}' legacy import cannot carry desired or converged authority`);
   if (rec["authority"] === "authoritative" && rec["lifecycle"] !== "retired" && desired === undefined)
-    invalid2(`deployment scope '${id}' authoritative lifecycle requires desired state`);
+    invalid3(`deployment scope '${id}' authoritative lifecycle requires desired state`);
   if (desired !== undefined && rec["selectorMode"] !== "all" && rec["selectorMode"] !== "explicit")
-    invalid2(`deployment scope '${id}' desired state requires all or explicit selector mode`);
+    invalid3(`deployment scope '${id}' desired state requires all or explicit selector mode`);
   if (rec["lifecycle"] === "retired" && rec["selectorMode"] !== "retired")
-    invalid2(`deployment scope '${id}' retired lifecycle requires retired selector mode`);
+    invalid3(`deployment scope '${id}' retired lifecycle requires retired selector mode`);
   if (lastConverged !== undefined && desired !== undefined && lastConverged.generation > desired.generation)
-    invalid2(`deployment scope '${id}' last-converged generation exceeds desired generation`);
+    invalid3(`deployment scope '${id}' last-converged generation exceeds desired generation`);
   return value;
 }
 function validateSource(value, label) {
@@ -10557,7 +10657,7 @@ function validateTarget(value, label) {
     return parsePersistedTargetIdentity(value, label);
   } catch (error) {
     if (error instanceof TargetIdentityValidationError)
-      invalid2(error.message);
+      invalid3(error.message);
     throw error;
   }
 }
@@ -10570,7 +10670,7 @@ function validateDesired(value, label) {
   timestamp(rec["validatedAt"], `${label}.validatedAt`);
   const packages = array(rec["packages"], `${label}.packages`).map((item, index) => validateDesiredPackage(item, `${label}.packages[${index}]`));
   if (packages.length === 0)
-    invalid2(`${label}.packages must not be empty; retire the scope explicitly`);
+    invalid3(`${label}.packages must not be empty; retire the scope explicitly`);
   unique(packages.map((item) => item.packageId), `${label} package identity`);
   unique(packages.map((item) => item.nativeId), `${label} native identity`);
   return value;
@@ -10584,7 +10684,7 @@ function validateDesiredPackage(value, label) {
   const capabilities = stringArray(rec["requiredCapabilities"], `${label}.requiredCapabilities`);
   sortedUniqueRequired(capabilities, `${label}.requiredCapabilities`, true);
   if (typeof rec["adoptionRequested"] !== "boolean")
-    invalid2(`${label}.adoptionRequested must be a boolean`);
+    invalid3(`${label}.adoptionRequested must be a boolean`);
   return value;
 }
 function validateActivation(value, label) {
@@ -10599,7 +10699,7 @@ function validateActivation(value, label) {
   const route = validateRoute(rec["route"], `${label}.route`);
   const ownershipObject = asObject(rec["ownership"], `${label}.ownership`);
   if (route.kind !== "legacy-unverified" && ownershipObject["kind"] === "legacy-claim")
-    invalid2("legacy ownership cannot use a verified route");
+    invalid3("legacy ownership cannot use a verified route");
   const ownership = validateOwnership(ownershipObject, `${label}.ownership`);
   const fingerprints = validateFingerprints(rec["fingerprints"], `${label}.fingerprints`);
   oneOf(rec["activationState"], ["active", "inactive", "retained", "nonconforming", "unknown"], `${label}.activationState`);
@@ -10612,13 +10712,13 @@ function validateActivation(value, label) {
   optionalTimestamp(rec["createdAt"], `${label}.createdAt`);
   optionalTimestamp(rec["updatedAt"], `${label}.updatedAt`);
   if (route.kind === "legacy-unverified" !== (ownership.kind === "legacy-claim"))
-    invalid2(`${label} legacy route and ownership claim must agree`);
+    invalid3(`${label} legacy route and ownership claim must agree`);
   if (route.kind !== "legacy-unverified" && (rec["sourceRevision"] === undefined || fingerprints.source === undefined || fingerprints.projected === undefined || fingerprints.installed === undefined))
-    invalid2(`${label} verified route requires source revision plus source, projected, and installed fingerprints`);
+    invalid3(`${label} verified route requires source revision plus source, projected, and installed fingerprints`);
   if (rec["readbackState"] === "verified" && fingerprints.installed === undefined)
-    invalid2(`${label} verified readback requires an installed fingerprint`);
+    invalid3(`${label} verified readback requires an installed fingerprint`);
   if (pending === undefined && rec["readbackState"] === "pending")
-    invalid2(`${label} pending readback requires a pending operation`);
+    invalid3(`${label} pending readback requires a pending operation`);
   return value;
 }
 function validateRoute(value, label) {
@@ -10678,7 +10778,7 @@ function validatePendingSemantics(activation, attempt, journal) {
   const pending = activation.pending;
   const identity = `activation '${activationKey(activation)}'`;
   if (pending.operation !== journal.action)
-    invalid2(`${identity} pending operation must match journal action`);
+    invalid3(`${identity} pending operation must match journal action`);
   const isRetirement = pending.operation === "retire-orphan" || pending.operation === "remove";
   let journalState;
   let attemptPhases;
@@ -10711,11 +10811,11 @@ function validatePendingSemantics(activation, attempt, journal) {
       break;
   }
   if (journal.state !== journalState)
-    invalid2(`${identity} pending phase ${pending.phase} requires journal ${journalState}`);
+    invalid3(`${identity} pending phase ${pending.phase} requires journal ${journalState}`);
   if (!attemptPhases.includes(attempt.phase))
-    invalid2(`${identity} pending phase ${pending.phase} requires attempt ${attemptPhases.join(" or ")}`);
+    invalid3(`${identity} pending phase ${pending.phase} requires attempt ${attemptPhases.join(" or ")}`);
   if (attempt.mutationStarted !== mutationStarted)
-    invalid2(`${identity} ${pending.phase} pending work requires mutationStarted ${String(mutationStarted)}`);
+    invalid3(`${identity} ${pending.phase} pending work requires mutationStarted ${String(mutationStarted)}`);
 }
 function validateAttempt(value, label) {
   const rec = asObject(value, label);
@@ -10725,31 +10825,31 @@ function validateAttempt(value, label) {
   oneOf(rec["phase"], ["accepted", "applying", "readback", "pruning", "finalizing", "completed", "failed", "recovery-required"], `${label}.phase`);
   const mutationStarted = rec["mutationStarted"];
   if (typeof mutationStarted !== "boolean")
-    invalid2(`${label}.mutationStarted must be a boolean`);
+    invalid3(`${label}.mutationStarted must be a boolean`);
   const scopeIds = stringArray(rec["scopeIds"], `${label}.scopeIds`);
   if (scopeIds.length === 0)
-    invalid2(`${label}.scopeIds must not be empty`);
+    invalid3(`${label}.scopeIds must not be empty`);
   unique(scopeIds, `${label}.scopeIds`);
   const journal = array(rec["journal"], `${label}.journal`).map((item, index) => validateJournal(item, `${label}.journal[${index}]`));
   for (const entry of journal) {
     if (!commandAllowsJournalAction(command, entry.action))
-      invalid2(`${label} command ${command} cannot journal action ${entry.action}`);
+      invalid3(`${label} command ${command} cannot journal action ${entry.action}`);
   }
   const journalShowsMutation = journal.some((entry) => MUTATION_STARTED_JOURNAL_STATES.has(entry.state));
   if (journalShowsMutation && !mutationStarted)
-    invalid2(`${label} journal shows mutation began but mutationStarted is false`);
+    invalid3(`${label} journal shows mutation began but mutationStarted is false`);
   if (mutationStarted && !journalShowsMutation)
-    invalid2(`${label} mutationStarted is true but no journal row shows mutation began`);
+    invalid3(`${label} mutationStarted is true but no journal row shows mutation began`);
   optionalTimestamp(rec["startedAt"], `${label}.startedAt`);
   optionalTimestamp(rec["updatedAt"], `${label}.updatedAt`);
   optionalTimestamp(rec["completedAt"], `${label}.completedAt`);
   if (rec["phase"] === "completed" && rec["completedAt"] === undefined)
-    invalid2(`${label} completed attempt requires completedAt`);
+    invalid3(`${label} completed attempt requires completedAt`);
   return value;
 }
 function validateJournal(value, label) {
   const rec = asObject(value, label);
-  exactFields2(rec, ["operationId", "scopeId", "packageId", "nativeId", "action", "state", "route", "startedAt", "updatedAt"], "journal entry");
+  exactFields2(rec, ["operationId", "scopeId", "packageId", "nativeId", "action", "state", "route", "startedAt", "updatedAt", "sealedOperation", "settlement"], "journal entry");
   requiredString(rec["operationId"], `${label}.operationId`);
   requiredString(rec["scopeId"], `${label}.scopeId`);
   optionalString(rec["packageId"], `${label}.packageId`);
@@ -10758,6 +10858,20 @@ function validateJournal(value, label) {
   oneOf(rec["state"], ["pending", "applying", "applied", "readback-verified", "rollback", "rolled-back", "cleanup-pending", "completed", "failed", "not-attempted"], `${label}.state`);
   if (rec["route"] !== undefined)
     validateRoute(rec["route"], `${label}.route`);
+  if (rec["sealedOperation"] !== undefined) {
+    const operation = parseSerializedLifecycleOperation(rec["sealedOperation"]);
+    if (operation.operationId !== rec["operationId"] || operation.scopeId !== rec["scopeId"] || operation.packageName !== rec["packageId"] || operation.nativeId !== rec["nativeId"] || operation.action !== rec["action"])
+      invalid3(`${label} sealed operation does not match journal identity`);
+  }
+  if (rec["settlement"] !== undefined) {
+    oneOf(rec["settlement"], ["commit", "rollback"], `${label}.settlement`);
+    if (rec["sealedOperation"] === undefined || !["readback-verified", "cleanup-pending", "completed", "rolled-back"].includes(String(rec["state"])))
+      invalid3(`${label} settlement requires a sealed, verified receipt`);
+    if (rec["settlement"] === "rollback" && !["cleanup-pending", "rolled-back"].includes(String(rec["state"])))
+      invalid3(`${label} rollback settlement contradicts journal state`);
+    if (rec["settlement"] === "commit" && rec["state"] === "rolled-back")
+      invalid3(`${label} committed settlement cannot be rolled back`);
+  }
   optionalTimestamp(rec["startedAt"], `${label}.startedAt`);
   optionalTimestamp(rec["updatedAt"], `${label}.updatedAt`);
   return value;
@@ -10790,19 +10904,19 @@ function validateTombstone(value, label) {
   const route = validateRoute(rec["route"], `${label}.route`);
   const ownershipObject = asObject(rec["ownership"], `${label}.ownership`);
   if (ownershipObject["kind"] === "legacy-claim")
-    invalid2("tombstone ownership must be revalidated before retirement");
+    invalid3("tombstone ownership must be revalidated before retirement");
   const ownership = validateOwnership(ownershipObject, `${label}.ownership`);
   const fingerprints = validateFingerprints(rec["fingerprints"], `${label}.fingerprints`);
   const pins = stringArray(rec["pins"], `${label}.pins`);
   sortedUniqueRequired(pins, `${label}.pins`, true);
   if (rec["retentionState"] !== "plugin-state-retained")
-    invalid2(`${label}.retentionState must be plugin-state-retained`);
+    invalid3(`${label}.retentionState must be plugin-state-retained`);
   optionalTimestamp(rec["activatedAt"], `${label}.activatedAt`);
   timestamp(rec["retiredAt"], `${label}.retiredAt`);
   if (route.kind === "legacy-unverified" || ownership.kind === "legacy-claim")
-    invalid2("tombstone ownership must be revalidated before retirement");
+    invalid3("tombstone ownership must be revalidated before retirement");
   if (fingerprints.source === undefined || fingerprints.projected === undefined || fingerprints.installed === undefined)
-    invalid2(`${label} requires source, projected, and installed fingerprints`);
+    invalid3(`${label} requires source, projected, and installed fingerprints`);
   return value;
 }
 function legacySourceBinding(source) {
@@ -10813,7 +10927,7 @@ function legacySourceBinding(source) {
     return binding;
   }
   if (!isAbsolute4(source))
-    invalid2(`legacy local source must be an absolute path: ${source}`);
+    invalid3(`legacy local source must be an absolute path: ${source}`);
   const binding = { kind: "local", locator: source };
   validateCanonicalSourceBinding(binding, "legacy source");
   return binding;
@@ -10822,7 +10936,7 @@ function validateCanonicalSourceBinding(source, label) {
   try {
     validateSourceBinding(source);
   } catch (error) {
-    invalid2(`${label}: ${error.message}`);
+    invalid3(`${label}: ${error.message}`);
   }
 }
 function compatibilitySourceUri(source) {
@@ -10835,7 +10949,7 @@ function canonicalScopeId(source, target) {
   try {
     return createDeploymentScopeIdentity(source, target).id;
   } catch (error) {
-    invalid2(error.message);
+    invalid3(error.message);
   }
 }
 function legacyRelativeDir(record) {
@@ -10848,7 +10962,7 @@ function legacyRelativeDir(record) {
     return;
   return candidate;
 }
-function digest(value) {
+function digest2(value) {
   const hash = new CryptoHasher("sha256");
   hash.update(value);
   return hash.digest("hex").slice(0, 24);
@@ -10864,59 +10978,59 @@ function pendingV1(operation) {
 }
 function asObject(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
-    invalid2(`${label} must be an object`);
+    invalid3(`${label} must be an object`);
   return value;
 }
 function exactFields2(record, allowed, label) {
   const allowedSet = new Set(allowed);
   const unknown = Object.keys(record).find((key) => !allowedSet.has(key));
   if (unknown !== undefined)
-    invalid2(`unsupported ${label} field '${unknown}'`);
+    invalid3(`unsupported ${label} field '${unknown}'`);
 }
 function array(value, label) {
   if (!Array.isArray(value))
-    invalid2(`${label} must be an array`);
+    invalid3(`${label} must be an array`);
   return value;
 }
 function requiredString(value, label) {
   if (typeof value !== "string" || value.trim() === "")
-    invalid2(`${label} must be a non-empty string`);
+    invalid3(`${label} must be a non-empty string`);
   return value;
 }
 function optionalString(value, label) {
   if (value !== undefined && (typeof value !== "string" || value.length === 0))
-    invalid2(`${label} must be a non-empty string`);
+    invalid3(`${label} must be a non-empty string`);
 }
 function stringArray(value, label) {
   const values = array(value, label);
   if (values.some((item) => typeof item !== "string" || item.length === 0))
-    invalid2(`${label} must contain non-empty strings`);
+    invalid3(`${label} must contain non-empty strings`);
   return values;
 }
 function optionalLegacyString(value, label) {
   if (value !== undefined && typeof value !== "string")
-    invalid2(`${label} must be a string`);
+    invalid3(`${label} must be a string`);
 }
 function optionalLegacyPins(value) {
   if (value === undefined)
     return;
   if (!Array.isArray(value) || value.some((pin) => typeof pin !== "string" || pin.length === 0))
-    invalid2("pins must be non-empty strings");
+    invalid3("pins must be non-empty strings");
   return value;
 }
 function safeInteger(value, label, minimum) {
   if (!Number.isSafeInteger(value) || value < minimum)
-    invalid2(`${label} must be a safe integer >= ${minimum}`);
+    invalid3(`${label} must be a safe integer >= ${minimum}`);
   return value;
 }
 function oneOf(value, values, label) {
   if (typeof value !== "string" || !values.includes(value))
-    invalid2(`${label} must be one of: ${values.join(", ")}`);
+    invalid3(`${label} must be one of: ${values.join(", ")}`);
   return value;
 }
 function timestamp(value, label) {
   if (typeof value !== "string" || !validTimestamp(value))
-    invalid2(`${label} must be an ISO-8601 UTC timestamp`);
+    invalid3(`${label} must be an ISO-8601 UTC timestamp`);
   return value;
 }
 function optionalTimestamp(value, label) {
@@ -10935,21 +11049,21 @@ function relativePath(value, label) {
     return path;
   const segments = path.split("/");
   if (path.trim() !== path || path.includes("\\") || /[\u0000-\u001f\u007f]/u.test(path) || isAbsolute4(path) || /^[a-z]:\//iu.test(path) || segments.some((segment) => segment === "" || segment === "." || segment === ".."))
-    invalid2(`${label} must be a canonical Source-relative path`);
+    invalid3(`${label} must be a canonical Source-relative path`);
   return path;
 }
 function contentAddress(value, label) {
   const key = requiredString(value, label);
   if (!/^sha256:[0-9a-f]{64}$/u.test(key))
-    invalid2(`${label} must be sha256 followed by 64 lowercase hexadecimal characters`);
+    invalid3(`${label} must be sha256 followed by 64 lowercase hexadecimal characters`);
   return key;
 }
 function sortedUniqueRequired(values, label, allowEmpty = false) {
   if (!allowEmpty && values.length === 0)
-    invalid2(`${label} must not be empty`);
+    invalid3(`${label} must not be empty`);
   const sorted = [...new Set(values)].sort();
   if (sorted.length !== values.length || sorted.some((value, index) => value !== values[index]))
-    invalid2(`${label} must be sorted and unique`);
+    invalid3(`${label} must be sorted and unique`);
 }
 function sortedUnique(values) {
   return [...new Set(values)].sort();
@@ -10958,7 +11072,7 @@ function unique(values, label) {
   const seen = new Set;
   for (const value of values) {
     if (seen.has(value))
-      invalid2(`duplicate ${label}: ${value}`);
+      invalid3(`duplicate ${label}: ${value}`);
     seen.add(value);
   }
 }
@@ -10968,10 +11082,25 @@ function removeUndefined(record) {
       delete record[key];
   return record;
 }
-function invalid2(message) {
+function invalid3(message) {
   throw new Error(`Invalid state.json: ${message}`);
 }
 
+// src/pending-lifecycle.ts
+var UNRESOLVED = new Set(["pending", "applying", "applied", "readback-verified", "rollback", "cleanup-pending"]);
+function pendingLifecycleOperations(state = readLifecycleState().state) {
+  return state.attempts.filter((attempt) => attempt.command !== "legacy-recovery").flatMap((attempt) => attempt.journal.filter((row) => UNRESOLVED.has(row.state)).map((row) => ({
+    host: state.scopes.find((scope) => scope.id === row.scopeId).target.kind,
+    scopeId: row.scopeId,
+    attemptId: attempt.id,
+    operationId: row.operationId,
+    id: row.nativeId ?? row.packageId ?? row.operationId,
+    action: row.action,
+    phase: row.state,
+    command: attempt.command
+  })));
+}
+
 // src/fingerprint.ts
 import { lstatSync as lstatSync6, readFileSync as readFileSync12, readdirSync as readdirSync7 } from "node:fs";
 import { isAbsolute as isAbsolute5, join as join17 } from "node:path";
@@ -11234,6 +11363,10 @@ function checkStaleness(host, state, out) {
 function runDoctor(hostList = hosts, state = readState()) {
   const findings = [];
   const selected = new Set(hostList.map((host) => host.id));
+  for (const pending of pendingLifecycleOperations()) {
+    if (selected.has(pending.host))
+      findings.push({ host: pending.host, mark: "✗", message: `operation '${pending.operationId}' has pending ${pending.action}/${pending.phase} in attempt '${pending.attemptId}' — retry '${pending.command}' for scope '${pending.scopeId}'` });
+  }
   for (const record of state) {
     if (record.pending !== undefined && selected.has(record.host)) {
       findings.push({ host: record.host, mark: "!", message: `install '${record.id}' has pending ${record.pending} intent — retry the ${record.pending === "remove" ? "remove" : "add/update"} operation` });
@@ -12435,14 +12568,14 @@ function exitCodeForLifecycleReport(report) {
 }
 function parseLifecycleReport(value) {
   if (!isObject2(value)) {
-    throw invalid3("lifecycle report must be an object");
+    throw invalid4("lifecycle report must be an object");
   }
   exactFields3(value, ["schemaVersion", "command", "plan", "outcomes", "summary"], "lifecycle report");
   if (value["schemaVersion"] !== LIFECYCLE_REPORT_SCHEMA_VERSION) {
-    throw invalid3("lifecycle report schemaVersion must be 1");
+    throw invalid4("lifecycle report schemaVersion must be 1");
   }
   if (!isObject2(value["command"]) || !Array.isArray(value["plan"]) || !Array.isArray(value["outcomes"]) || !isObject2(value["summary"])) {
-    throw invalid3("lifecycle report must contain command, plan, outcomes, and summary");
+    throw invalid4("lifecycle report must contain command, plan, outcomes, and summary");
   }
   const command = value["command"];
   const plan = value["plan"];
@@ -12451,19 +12584,19 @@ function parseLifecycleReport(value) {
   assertCommand(command);
   const commandName = command["name"];
   if (!plan.every(isObject2) || !outcomes.every(isObject2))
-    throw invalid3("lifecycle plan and outcomes must contain objects");
+    throw invalid4("lifecycle plan and outcomes must contain objects");
   const planned = new Map;
   const plannedPairs = new Set;
   for (const operation of plan) {
     assertPlanOperation(operation, command["sourceSnapshots"], commandName);
     const operationId = operation["operationId"];
     if (typeof operationId !== "string" || operationId.length === 0)
-      throw invalid3("every planned operation needs a nonempty operationId");
+      throw invalid4("every planned operation needs a nonempty operationId");
     if (planned.has(operationId))
-      throw invalid3(`duplicate planned operation '${operationId}'`);
+      throw invalid4(`duplicate planned operation '${operationId}'`);
     const pair = JSON.stringify([operation["scope"].id, operation["package"]]);
     if (plannedPairs.has(pair))
-      throw invalid3(`duplicate planned package pair for '${operation["package"]}'`);
+      throw invalid4(`duplicate planned package pair for '${operation["package"]}'`);
     plannedPairs.add(pair);
     planned.set(operationId, operation);
   }
@@ -12472,7 +12605,7 @@ function parseLifecycleReport(value) {
     assertOutcome(outcome, command["sourceSnapshots"], command["dryRun"], commandName);
     const operationId = outcome["operationId"];
     if (typeof operationId !== "string" || operationId.length === 0)
-      throw invalid3("every outcome needs a nonempty operationId");
+      throw invalid4("every outcome needs a nonempty operationId");
     if (seen.has(operationId))
       throw protocol("protocol.duplicate-outcome", `duplicate outcome for planned operation '${operationId}'`);
     seen.add(operationId);
@@ -12503,7 +12636,7 @@ var PLAN_IDENTITY_FIELDS = [
   "action",
   "route"
 ];
-function invalid3(diagnostic) {
+function invalid4(diagnostic) {
   return protocol("protocol.invalid-report", diagnostic);
 }
 function contradiction(diagnostic) {
@@ -12515,20 +12648,20 @@ function protocol(code, diagnostic) {
 function assertCommand(command) {
   exactFields3(command, ["name", "dryRun", "sourceSnapshots"], "lifecycle command");
   if (!oneOf2(LIFECYCLE_COMMANDS, command["name"]) || typeof command["dryRun"] !== "boolean" || !Array.isArray(command["sourceSnapshots"])) {
-    throw invalid3("lifecycle command must contain a known name, dryRun boolean, and sourceSnapshots array");
+    throw invalid4("lifecycle command must contain a known name, dryRun boolean, and sourceSnapshots array");
   }
   const ids = new Set;
   for (const context of command["sourceSnapshots"]) {
     if (!isObject2(context) || !nonempty(context["id"]) || !isObject2(context["reference"]))
-      throw invalid3("source snapshot context is malformed");
+      throw invalid4("source snapshot context is malformed");
     exactFields3(context, ["id", "reference"], "source snapshot context");
     if (ids.has(context["id"]))
-      throw invalid3(`duplicate source snapshot '${context["id"]}'`);
+      throw invalid4(`duplicate source snapshot '${context["id"]}'`);
     ids.add(context["id"]);
     const reference = context["reference"];
     exactFields3(reference, ["binding", "revision", "fingerprint"], `source snapshot '${context["id"]}' reference`);
     if (!isObject2(reference["binding"]) || !nonempty(reference["revision"]) || !nonempty(reference["fingerprint"]))
-      throw invalid3(`source snapshot '${context["id"]}' is malformed`);
+      throw invalid4(`source snapshot '${context["id"]}' is malformed`);
     const binding = reference["binding"];
     assertSourceBinding(binding, `source snapshot '${context["id"]}'`);
   }
@@ -12555,27 +12688,27 @@ var OUTCOME_FIELDS = [
 function assertPlanOperation(operation, snapshots, command, shape = "plan") {
   exactFields3(operation, shape === "plan" ? PLAN_OPERATION_FIELDS : OUTCOME_FIELDS, `lifecycle ${shape}`);
   if (!nonempty(operation["operationId"]) || !oneOf2(LIFECYCLE_COVERAGE_KINDS, operation["coverage"]) || !isObject2(operation["scope"]) || !nullableString(operation["sourceSnapshotId"]) || !nonempty(operation["package"]) || !nullableString(operation["nativeId"]) || !oneOf2(LIFECYCLE_PLAN_ACTIONS, operation["action"]) || !oneOf2(LIFECYCLE_ROUTES, operation["route"])) {
-    throw invalid3("planned operation contains a missing or invalid field");
+    throw invalid4("planned operation contains a missing or invalid field");
   }
   assertScope(operation["scope"]);
   if (operation["sourceSnapshotId"] !== null && !snapshots.some((snapshot) => snapshot.id === operation["sourceSnapshotId"])) {
-    throw invalid3(`planned operation '${operation["operationId"]}' references an unknown source snapshot`);
+    throw invalid4(`planned operation '${operation["operationId"]}' references an unknown source snapshot`);
   }
   const snapshot = snapshots.find((candidate) => candidate.id === operation["sourceSnapshotId"]);
   if (snapshot !== undefined && !sameSourceBinding(snapshot.reference.binding, operation["scope"].source)) {
-    throw invalid3(`planned operation '${operation["operationId"]}' scope contradicts its source snapshot`);
+    throw invalid4(`planned operation '${operation["operationId"]}' scope contradicts its source snapshot`);
   }
   if (operation["coverage"] === "retirement" && operation["action"] !== "retire-orphan" && operation["action"] !== "not-attempted") {
-    throw invalid3(`orphan retirement '${operation["operationId"]}' has a non-retirement action`);
+    throw invalid4(`orphan retirement '${operation["operationId"]}' has a non-retirement action`);
   }
   if (operation["coverage"] === "desired-pair" && operation["action"] === "retire-orphan") {
-    throw invalid3(`Desired pair '${operation["operationId"]}' has a retirement action`);
+    throw invalid4(`Desired pair '${operation["operationId"]}' has a retirement action`);
   }
   if ((command === "add" || command === "update") && operation["coverage"] !== "desired-pair") {
-    throw invalid3(`${command} cannot contain retirement coverage`);
+    throw invalid4(`${command} cannot contain retirement coverage`);
   }
   if ((command === "remove" || command === "retire-source") && operation["coverage"] !== "retirement") {
-    throw invalid3(`${command} cannot contain desired-pair coverage`);
+    throw invalid4(`${command} cannot contain desired-pair coverage`);
   }
   if (operation["action"] === "not-attempted" !== (operation["route"] === "none")) {
     throw contradiction(`planned operation '${operation["operationId"]}' must pair action not-attempted with route none`);
@@ -12584,7 +12717,7 @@ function assertPlanOperation(operation, snapshots, command, shape = "plan") {
 function assertOutcome(outcome, snapshots, dryRun, command) {
   assertPlanOperation(outcome, snapshots, command, "outcome");
   if (!oneOf2(LIFECYCLE_OPERATION_RESULTS, outcome["result"]) || !oneOf2(LIFECYCLE_RESOURCE_STATES, outcome["resourceState"]) || !oneOf2(LIFECYCLE_ACTIVATION_STATES, outcome["activationState"]) || typeof outcome["changed"] !== "boolean" || !(outcome["reason"] === null || isObject2(outcome["reason"]))) {
-    throw invalid3(`outcome '${outcome["operationId"]}' contains a missing or invalid field`);
+    throw invalid4(`outcome '${outcome["operationId"]}' contains a missing or invalid field`);
   }
   const reason = outcome["reason"];
   if (reason !== null)
@@ -12607,7 +12740,7 @@ function assertOutcome(outcome, snapshots, dryRun, command) {
   const notices = outcome["notices"];
   if (notices !== undefined) {
     if (!Array.isArray(notices) || notices.some((item) => typeof item !== "string" || item.length === 0)) {
-      throw invalid3(`outcome '${outcome["operationId"]}' notices must be non-empty strings`);
+      throw invalid4(`outcome '${outcome["operationId"]}' notices must be non-empty strings`);
     }
     if (outcome["result"] !== "succeeded")
       throw contradiction(`outcome '${outcome["operationId"]}' can report a dropped pin only after success`);
@@ -12627,7 +12760,13 @@ function assertOutcome(outcome, snapshots, dryRun, command) {
   }
   const containment = outcome["action"] === "retain-prior" || outcome["action"] === "disable-nonconforming";
   const appliedDisablement = outcome["action"] === "disable-nonconforming" && outcome["changed"] === true;
-  if (containment && !dryRun) {
+  if (outcome["action"] === "disable-nonconforming" && outcome["result"] === "succeeded") {
+    throw contradiction(`disablement '${outcome["operationId"]}' cannot claim Desired convergence`);
+  }
+  if (!dryRun && outcome["action"] === "disable-nonconforming" && outcome["resourceState"] === "retained" && outcome["activationState"] === "inactive" && outcome["changed"] !== true) {
+    throw contradiction(`disablement '${outcome["operationId"]}' cannot claim inactive containment without a verified mutation`);
+  }
+  if (containment && !dryRun && (outcome["action"] === "retain-prior" || isObject2(reason) && reason["category"] === "capability")) {
     const expectedResourceState = "retained";
     const expectedActivationState = outcome["action"] === "retain-prior" ? "retained-prior" : appliedDisablement ? "inactive" : "active-nonconforming";
     if (outcome["result"] !== "failed" || outcome["resourceState"] !== expectedResourceState || outcome["activationState"] !== expectedActivationState) {
@@ -12673,7 +12812,7 @@ function isKnownSafeReadbackState(resourceState, activationState) {
 function assertSummary(summary, outcomes, dryRun) {
   exactFields3(summary, ["result", "terminalPhase", "mutationStarted", "changed", "failureCategory", "reason", "recoveryId", "readbackId"], "lifecycle summary");
   if (!oneOf2(LIFECYCLE_COMMAND_RESULTS, summary["result"]) || !oneOf2(LIFECYCLE_TERMINAL_PHASES, summary["terminalPhase"]) || typeof summary["mutationStarted"] !== "boolean" || typeof summary["changed"] !== "boolean" || !(summary["failureCategory"] === null || oneOf2(LIFECYCLE_REASON_CATEGORIES, summary["failureCategory"])) || !(summary["reason"] === null || isObject2(summary["reason"])) || !nullableString(summary["recoveryId"]) || !nullableString(summary["readbackId"])) {
-    throw invalid3("lifecycle summary contains a missing or invalid field");
+    throw invalid4("lifecycle summary contains a missing or invalid field");
   }
   const reason = summary["reason"];
   if (reason !== null)
@@ -12761,21 +12900,21 @@ function assertSummary(summary, outcomes, dryRun) {
 function assertReason(reason) {
   exactFields3(reason, ["category", "code", "diagnostic", "capabilityId", "evidenceId"], "lifecycle reason");
   if (!oneOf2(LIFECYCLE_REASON_CATEGORIES, reason["category"]) || !oneOf2(LIFECYCLE_REASON_CODES, reason["code"]) || !hasText(reason["diagnostic"]) || !nullableText(reason["capabilityId"]) || !nullableText(reason["evidenceId"])) {
-    throw invalid3("lifecycle reason contains a missing or invalid field");
+    throw invalid4("lifecycle reason contains a missing or invalid field");
   }
   if (reason["code"].slice(0, reason["code"].indexOf(".")) !== reason["category"]) {
-    throw invalid3(`reason code '${reason["code"]}' does not belong to category '${reason["category"]}'`);
+    throw invalid4(`reason code '${reason["code"]}' does not belong to category '${reason["category"]}'`);
   }
   if (reason["category"] === "capability" && reason["capabilityId"] === null)
-    throw invalid3("capability reason needs a capabilityId");
+    throw invalid4("capability reason needs a capabilityId");
   if (reason["category"] !== "capability" && (reason["capabilityId"] !== null || reason["evidenceId"] !== null)) {
-    throw invalid3("only capability reasons may carry capability or evidence identifiers");
+    throw invalid4("only capability reasons may carry capability or evidence identifiers");
   }
 }
 function assertScope(scope) {
   exactFields3(scope, ["id", "source", "target"], "deployment scope");
   if (!nonempty(scope["id"]) || !isObject2(scope["source"]) || !isObject2(scope["target"])) {
-    throw invalid3("planned operation has a malformed deployment scope");
+    throw invalid4("planned operation has a malformed deployment scope");
   }
   assertSourceBinding(scope["source"], "planned operation deployment scope");
   exactFields3(scope["target"], ["kind", "instance"], "deployment scope target");
@@ -12783,28 +12922,28 @@ function assertScope(scope) {
   try {
     canonical = createDeploymentScopeIdentity(scope["source"], scope["target"]);
   } catch (error) {
-    throw invalid3(`planned operation has an invalid deployment scope: ${unknownErrorDiagnostic(error)}`);
+    throw invalid4(`planned operation has an invalid deployment scope: ${unknownErrorDiagnostic(error)}`);
   }
   if (!sameScope(scope, canonical)) {
-    throw invalid3("planned operation deployment scope id contradicts its Source and target identity");
+    throw invalid4("planned operation deployment scope id contradicts its Source and target identity");
   }
 }
 function assertSourceBinding(binding, label) {
   if (binding["kind"] === "local") {
     exactFields3(binding, ["kind", "locator"], `${label} Source binding`);
     if (!nonempty(binding["locator"]))
-      throw invalid3(`${label} local Source binding needs a locator`);
+      throw invalid4(`${label} local Source binding needs a locator`);
   } else if (binding["kind"] === "git") {
     exactFields3(binding, ["kind", "locator", "ref"], `${label} Source binding`);
     if (!nonempty(binding["locator"]) || !nonempty(binding["ref"]))
-      throw invalid3(`${label} git Source binding needs a locator and ref`);
+      throw invalid4(`${label} git Source binding needs a locator and ref`);
   } else {
-    throw invalid3(`${label} Source binding has an unknown kind`);
+    throw invalid4(`${label} Source binding has an unknown kind`);
   }
   try {
     validateSourceBinding(binding);
   } catch (error) {
-    throw invalid3(`${label} has an invalid Source binding: ${unknownErrorDiagnostic(error)}`);
+    throw invalid4(`${label} has an invalid Source binding: ${unknownErrorDiagnostic(error)}`);
   }
 }
 function sameScope(left, right) {
@@ -12832,7 +12971,7 @@ function exactFields3(record, allowed, label) {
   const fields = new Set(allowed);
   const unknown = Object.keys(record).find((key) => !fields.has(key));
   if (unknown !== undefined)
-    throw invalid3(`${label} has unsupported field '${unknown}'`);
+    throw invalid4(`${label} has unsupported field '${unknown}'`);
 }
 function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -12885,21 +13024,21 @@ function inventoryPackageSemantics(plugin) {
   const manifest = manifests[0];
   if (manifest?.mcpServers !== undefined) {
     if (!isRecord4(manifest.mcpServers))
-      invalid4("plugin manifest mcpServers must be an object");
+      invalid5("plugin manifest mcpServers must be an object");
     mcp.push(`${manifest.path}#mcpServers`);
   }
   const autoUpdate = [];
   if (manifest !== undefined && manifest.extensions !== undefined) {
     const extension = manifest.extensions;
     if (!isRecord4(extension))
-      invalid4("plugin manifest extensions must be an object");
+      invalid5("plugin manifest extensions must be an object");
     const dcode = extension["com.langchain.deepagents.code"];
     if (dcode !== undefined) {
       if (!isRecord4(dcode))
-        invalid4("dcode plugin manifest extension must be an object");
+        invalid5("dcode plugin manifest extension must be an object");
       if (Object.hasOwn(dcode, "autoUpdate")) {
         if (typeof dcode["autoUpdate"] !== "boolean")
-          invalid4("dcode plugin manifest autoUpdate must be boolean");
+          invalid5("dcode plugin manifest autoUpdate must be boolean");
         autoUpdate.push({
           dialect: "dcode-manifest-extension",
           path: manifest.path,
@@ -12980,7 +13119,7 @@ function requiredSemanticsForOperation(inventory, operation) {
     ]));
   }
   if (inventory === undefined)
-    invalid4(`${operation} semantic admission requires Source inventory`);
+    invalid5(`${operation} semantic admission requires Source inventory`);
   const required = new Set(inventory.requiredSemantics);
   required.add("readback");
   required.add("rollback");
@@ -12998,7 +13137,7 @@ function inventorySkillPolicy(root, skill) {
         continue;
       const value = frontmatter[field];
       if (typeof value !== "boolean")
-        invalid4(`skill invocation policy ${field} must be boolean: ${skill}`);
+        invalid5(`skill invocation policy ${field} must be boolean: ${skill}`);
       declarations.push({ dialect: "claude-frontmatter", path: skill, field, direction: "model", allowed: !value });
     }
     for (const field of USER_INVOCATION_ALIASES) {
@@ -13006,7 +13145,7 @@ function inventorySkillPolicy(root, skill) {
         continue;
       const value = frontmatter[field];
       if (typeof value !== "boolean")
-        invalid4(`skill invocation policy ${field} must be boolean: ${skill}`);
+        invalid5(`skill invocation policy ${field} must be boolean: ${skill}`);
       declarations.push({ dialect: "claude-frontmatter", path: skill, field, direction: "user", allowed: value });
     }
   }
@@ -13016,11 +13155,11 @@ function inventorySkillPolicy(root, skill) {
     const policy = parsed["policy"];
     if (policy !== undefined) {
       if (!isRecord4(policy))
-        invalid4(`Codex invocation sidecar policy must be an object: ${sidecar}`);
+        invalid5(`Codex invocation sidecar policy must be an object: ${sidecar}`);
       if (Object.hasOwn(policy, "allow_implicit_invocation")) {
         const value = policy["allow_implicit_invocation"];
         if (typeof value !== "boolean")
-          invalid4(`Codex invocation sidecar policy must be boolean: ${sidecar}`);
+          invalid5(`Codex invocation sidecar policy must be boolean: ${sidecar}`);
         declarations.push({
           dialect: "codex-sidecar",
           path: sidecar,
@@ -13041,7 +13180,7 @@ function inventorySkillPolicy(root, skill) {
 function onePolicyValue(declarations, direction, skill) {
   const values = new Set(declarations.filter((entry) => entry.direction === direction).map((entry) => entry.allowed));
   if (values.size > 1)
-    invalid4(`conflicting ${direction}-invocation policy declarations: ${skill}`);
+    invalid5(`conflicting ${direction}-invocation policy declarations: ${skill}`);
   return values.values().next().value ?? true;
 }
 function openingFrontmatter(raw, path) {
@@ -13053,7 +13192,7 @@ function openingFrontmatter(raw, path) {
 function requiredOpeningFrontmatter(raw, path) {
   const frontmatter = openingFrontmatter(raw, path);
   if (frontmatter === undefined)
-    invalid4(`component frontmatter is required: ${path}`);
+    invalid5(`component frontmatter is required: ${path}`);
   return frontmatter;
 }
 function parseYamlObject(raw, label) {
@@ -13061,10 +13200,10 @@ function parseYamlObject(raw, label) {
   try {
     parsed = yamlParse(raw);
   } catch (error) {
-    invalid4(`${label} has invalid YAML (${errorDiagnostic(error)})`);
+    invalid5(`${label} has invalid YAML (${errorDiagnostic(error)})`);
   }
   if (!isRecord4(parsed))
-    invalid4(`${label} must be an object`);
+    invalid5(`${label} must be an object`);
   return parsed;
 }
 function parseTomlObject(raw, path) {
@@ -13072,10 +13211,10 @@ function parseTomlObject(raw, path) {
   try {
     parsed = parse(raw);
   } catch (error) {
-    invalid4(`command ${path} has invalid TOML (${errorDiagnostic(error)})`);
+    invalid5(`command ${path} has invalid TOML (${errorDiagnostic(error)})`);
   }
   if (!isRecord4(parsed))
-    invalid4(`command ${path} must be an object`);
+    invalid5(`command ${path} must be an object`);
   return parsed;
 }
 function parseJsonObject(path, label) {
@@ -13083,10 +13222,10 @@ function parseJsonObject(path, label) {
   try {
     parsed = JSON.parse(readFileSync15(path, "utf8"));
   } catch (error) {
-    invalid4(`${label} has invalid JSON (${errorDiagnostic(error)})`);
+    invalid5(`${label} has invalid JSON (${errorDiagnostic(error)})`);
   }
   if (!isRecord4(parsed))
-    invalid4(`${label} must be an object`);
+    invalid5(`${label} must be an object`);
   return parsed;
 }
 function readSemanticManifests(root) {
@@ -13111,7 +13250,7 @@ function inventoryHooks(root, files, manifests) {
       return cached;
     const value = parseJsonObject(join21(root, path), `hook configuration ${path}`);
     if (Object.keys(value).some((field) => field !== "hooks") || !isRecord4(value["hooks"])) {
-      invalid4(`hook configuration ${path} must contain only a top-level hooks object`);
+      invalid5(`hook configuration ${path} must contain only a top-level hooks object`);
     }
     const observation = validateHookEventMap(value["hooks"], `hook configuration ${path}`);
     documents.set(path, observation);
@@ -13127,7 +13266,7 @@ function inventoryHooks(root, files, manifests) {
     addDocument("hooks/hooks.json", null, "default-file");
   for (const manifest of manifests.filter((candidate) => Object.hasOwn(candidate, "hooks"))) {
     if (manifest.path === ".plugin/plugin.json") {
-      invalid4("hook declarations in .plugin/plugin.json have no source-backed native contract");
+      invalid5("hook declarations in .plugin/plugin.json have no source-backed native contract");
     }
     const declaration = manifest["hooks"];
     const addInline = (value, label, arrayItem) => {
@@ -13135,10 +13274,10 @@ function inventoryHooks(root, files, manifests) {
       let form = arrayItem ? "manifest-inline-array" : "manifest-inline-event-map";
       if (Object.hasOwn(value, "hooks")) {
         if (Object.keys(value).some((field) => field !== "hooks") || !isRecord4(value["hooks"])) {
-          invalid4(`inline hook declaration ${label} has an ambiguous hooks wrapper`);
+          invalid5(`inline hook declaration ${label} has an ambiguous hooks wrapper`);
         }
         if (arrayItem)
-          invalid4(`inline hook declaration ${label} cannot use a file-document wrapper inside an array`);
+          invalid5(`inline hook declaration ${label} cannot use a file-document wrapper inside an array`);
         eventMap = value["hooks"];
         form = "manifest-inline-wrapped";
       }
@@ -13161,10 +13300,10 @@ function inventoryHooks(root, files, manifests) {
         else if (manifest.path === ".claude-plugin/plugin.json" && isRecord4(item)) {
           addInline(item, `${manifest.path}#hooks[${index}]`, true);
         } else
-          invalid4(`plugin manifest ${manifest.path} hooks[${index}] has an unsupported shape`);
+          invalid5(`plugin manifest ${manifest.path} hooks[${index}] has an unsupported shape`);
       }
     } else {
-      invalid4(`plugin manifest ${manifest.path} hooks must be a path, object, or non-empty supported array`);
+      invalid5(`plugin manifest ${manifest.path} hooks must be a path, object, or non-empty supported array`);
     }
   }
   return {
@@ -13176,54 +13315,54 @@ function inventoryHooks(root, files, manifests) {
 function declaredHookPath(root, declaration) {
   const withoutPrefix = declaration.slice(2);
   if (!declaration.startsWith("./") || declaration.includes("\\") || /^[a-z]:\//iu.test(withoutPrefix)) {
-    invalid4(`declared hook path must start with './' and use portable separators: ${declaration}`);
+    invalid5(`declared hook path must start with './' and use portable separators: ${declaration}`);
   }
   const path = portable(relative3(root, join21(root, declaration)));
   if (path === "" || path === ".." || path.startsWith("../") || declaration !== `./${path}`) {
-    invalid4(`declared hook path must be a canonical file inside the plugin root: ${declaration}`);
+    invalid5(`declared hook path must be a canonical file inside the plugin root: ${declaration}`);
   }
   const absolute = join21(root, path);
   if (!existsSync16(absolute))
-    invalid4(`declared hook configuration does not exist: ${declaration}`);
+    invalid5(`declared hook configuration does not exist: ${declaration}`);
   const stat = lstatSync9(absolute);
   if (stat.isDirectory()) {
     const document = `${path}/hooks.json`;
     const documentPath = join21(root, document);
     if (!existsSync16(documentPath) || !lstatSync9(documentPath).isFile()) {
-      invalid4(`declared hook directory must contain hooks.json: ${declaration}`);
+      invalid5(`declared hook directory must contain hooks.json: ${declaration}`);
     }
     return { path: document, directory: true };
   }
   if (!stat.isFile()) {
-    invalid4(`declared hook configuration must be a regular file or native hook directory: ${declaration}`);
+    invalid5(`declared hook configuration must be a regular file or native hook directory: ${declaration}`);
   }
   return { path, directory: false };
 }
 function validateHookEventMap(value, label) {
   if (!isRecord4(value))
-    invalid4(`${label} must be a hook event object`);
+    invalid5(`${label} must be a hook event object`);
   const events = [];
   const handlerTypes = new Set;
   const groupDeclarations = [];
   const handlerFacets = new Set;
   for (const [event, groups] of Object.entries(value)) {
     if (event.trim() === "" || !Array.isArray(groups))
-      invalid4(`${label} event '${event}' must be an array`);
+      invalid5(`${label} event '${event}' must be an array`);
     events.push(event);
     for (const [groupIndex, group] of groups.entries()) {
       if (!isRecord4(group))
-        invalid4(`${label} event '${event}' group ${groupIndex} must be an object`);
+        invalid5(`${label} event '${event}' group ${groupIndex} must be an object`);
       if (group["matcher"] !== undefined && typeof group["matcher"] !== "string") {
-        invalid4(`${label} event '${event}' group ${groupIndex} matcher must be a string`);
+        invalid5(`${label} event '${event}' group ${groupIndex} matcher must be a string`);
       }
       const matcher = typeof group["matcher"] === "string" ? group["matcher"] : null;
       if (!Array.isArray(group["hooks"]))
-        invalid4(`${label} event '${event}' group ${groupIndex} hooks must be an array`);
+        invalid5(`${label} event '${event}' group ${groupIndex} hooks must be an array`);
       const groupHandlerTypes = new Set;
       const groupHandlerFacets = new Set;
       for (const [hookIndex, hook] of group["hooks"].entries()) {
         if (!isRecord4(hook) || typeof hook["type"] !== "string" || hook["type"].trim() === "") {
-          invalid4(`${label} event '${event}' group ${groupIndex} hook ${hookIndex} needs a non-empty type`);
+          invalid5(`${label} event '${event}' group ${groupIndex} hook ${hookIndex} needs a non-empty type`);
         }
         validateHookHandler(hook, `${label} event '${event}' group ${groupIndex} hook ${hookIndex}`);
         handlerTypes.add(hook["type"]);
@@ -13292,7 +13431,7 @@ function validateHookHandler(hook, label) {
     return;
   if ((hook["type"] === "prompt" || hook["type"] === "agent") && nonemptyString("prompt"))
     return;
-  invalid4(`${label} has an unknown type or is missing required fields`);
+  invalid5(`${label} has an unknown type or is missing required fields`);
 }
 function walkFiles(root) {
   const files = [];
@@ -13303,13 +13442,13 @@ function walkFiles(root) {
       const path = join21(dir, entry);
       const stat = lstatSync9(path);
       if (stat.isSymbolicLink())
-        invalid4(`package semantic inventory refuses symlink: ${portable(relative3(root, path))}`);
+        invalid5(`package semantic inventory refuses symlink: ${portable(relative3(root, path))}`);
       if (stat.isDirectory())
         walk(path);
       else if (stat.isFile())
         files.push(portable(relative3(root, path)));
       else
-        invalid4(`package semantic inventory refuses unsupported entry: ${portable(relative3(root, path))}`);
+        invalid5(`package semantic inventory refuses unsupported entry: ${portable(relative3(root, path))}`);
     }
   };
   walk(root);
@@ -13325,7 +13464,7 @@ var UNSUPPORTED_COMPONENT_ROOTS = [".codex/commands", ".codex/agents"];
 function inventoryComponentRoots(root) {
   for (const unsupported of UNSUPPORTED_COMPONENT_ROOTS) {
     if (existsSync16(join21(root, unsupported)))
-      invalid4(`unsupported component root: ${unsupported}`);
+      invalid5(`unsupported component root: ${unsupported}`);
   }
   const definitions = [];
   const invocationPolicies = [];
@@ -13336,26 +13475,26 @@ function inventoryComponentRoots(root) {
       continue;
     const rootStat = lstatSync9(directory);
     if (!rootStat.isDirectory())
-      invalid4(`component root must be a directory: ${spec.root}`);
+      invalid5(`component root must be a directory: ${spec.root}`);
     const entries = readdirSync10(directory).sort();
     if (entries.length === 0)
-      invalid4(`component root must not be empty: ${spec.root}`);
+      invalid5(`component root must not be empty: ${spec.root}`);
     const identities = new Set;
     for (const entry of entries) {
       const absolute = join21(directory, entry);
       const path = `${spec.root}/${entry}`;
       const stat = lstatSync9(absolute);
       if (!stat.isFile())
-        invalid4(`component root entries must be regular files: ${path}`);
+        invalid5(`component root entries must be regular files: ${path}`);
       const suffix = Object.keys(spec.dialects).find((candidate) => entry.endsWith(candidate));
       if (suffix === undefined)
-        invalid4(`unsupported ${spec.kind} dialect: ${path}`);
+        invalid5(`unsupported ${spec.kind} dialect: ${path}`);
       const dialect = spec.dialects[suffix];
       if (dialect === undefined)
-        invalid4(`unsupported ${spec.kind} dialect: ${path}`);
+        invalid5(`unsupported ${spec.kind} dialect: ${path}`);
       const parsed = parseComponentDefinition(absolute, path, spec.kind, dialect, entry.slice(0, -suffix.length));
       if (identities.has(parsed.definition.identity)) {
-        invalid4(`duplicate ${spec.kind} identity '${parsed.definition.identity}' within ${spec.root}`);
+        invalid5(`duplicate ${spec.kind} identity '${parsed.definition.identity}' within ${spec.root}`);
       }
       identities.add(parsed.definition.identity);
       definitions.push({ ...parsed.definition, root: spec.root });
@@ -13377,16 +13516,16 @@ function parseComponentDefinition(absolute, path, kind, dialect, filenameIdentit
   let body;
   if (dialect === "toml") {
     if (kind !== "command")
-      invalid4(`unsupported ${kind} dialect: ${path}`);
+      invalid5(`unsupported ${kind} dialect: ${path}`);
     record = parseTomlObject(raw, path);
     if (typeof record["description"] !== "string" || record["description"].trim() === "" || typeof record["prompt"] !== "string") {
-      invalid4(`command TOML needs description and prompt: ${path}`);
+      invalid5(`command TOML needs description and prompt: ${path}`);
     }
     body = record["prompt"];
   } else {
     const frontmatter = requiredOpeningFrontmatter(raw, path);
     if (typeof frontmatter["description"] !== "string" || frontmatter["description"].trim() === "") {
-      invalid4(`${kind} description is required: ${path}`);
+      invalid5(`${kind} description is required: ${path}`);
     }
     record = frontmatter;
     const match = OPENING_FRONTMATTER.exec(raw);
@@ -13394,9 +13533,9 @@ function parseComponentDefinition(absolute, path, kind, dialect, filenameIdentit
   }
   const identity = kind === "agent" ? record["name"] : filenameIdentity;
   if (typeof identity !== "string" || identity.trim() === "")
-    invalid4(`${kind} identity is required: ${path}`);
+    invalid5(`${kind} identity is required: ${path}`);
   if (kind === "command" && /@\{/u.test(body))
-    invalid4(`unsupported command preprocessing: ${path}`);
+    invalid5(`unsupported command preprocessing: ${path}`);
   const declarations = kind === "command" ? componentInvocationDeclarations(record, dialect, path) : [];
   const policy = {
     component: kind,
@@ -13419,7 +13558,7 @@ function componentInvocationDeclarations(record, dialect, path) {
       continue;
     const value = record[field];
     if (typeof value !== "boolean")
-      invalid4(`component invocation policy ${field} must be boolean: ${path}`);
+      invalid5(`component invocation policy ${field} must be boolean: ${path}`);
     declarations.push({ dialect: policyDialect, path, field, direction: "model", allowed: !value });
   }
   for (const field of USER_INVOCATION_ALIASES) {
@@ -13427,7 +13566,7 @@ function componentInvocationDeclarations(record, dialect, path) {
       continue;
     const value = record[field];
     if (typeof value !== "boolean")
-      invalid4(`component invocation policy ${field} must be boolean: ${path}`);
+      invalid5(`component invocation policy ${field} must be boolean: ${path}`);
     declarations.push({ dialect: policyDialect, path, field, direction: "user", allowed: value });
   }
   onePolicyValue(declarations, "model", path);
@@ -13449,7 +13588,7 @@ function hasAny(record, fields) {
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function invalid4(diagnostic) {
+function invalid5(diagnostic) {
   throw new SemanticInventoryError(createLifecycleReason("usage", "usage.invalid-argument", diagnostic));
 }
 function errorDiagnostic(error) {
@@ -13546,7 +13685,8 @@ var dcode0183Managed = createCapabilityEvidenceProfile({
   },
   evidence: [
     "docs/evidence/dcode-native-update-0.1.83-20261009.json",
-    "docs/research/dcode-session-findings-2026-10-09.md"
+    "docs/research/dcode-session-findings-2026-10-09.md",
+    "docs/evidence/dcode-managed-lifecycle-20261011.md"
   ]
 });
 var capabilityEvidenceProfiles = Object.freeze([
@@ -14206,6 +14346,32 @@ function createLifecycleHostAdapter(definition) {
       const result = await invokePhase("retire", () => definition.retire(prepared));
       return mutationReceipt(prepared.handle, result);
     },
+    async beginRecovery(handle) {
+      assertHandle(definition.id, handle);
+      if (definition.beginRecovery === undefined)
+        throw phaseError("rollback", "recovery.failed", new Error(`adapter '${definition.id}' cross-process native CAS fence is unverified; recovery remains pending`));
+      try {
+        await definition.beginRecovery(handle);
+        const version = await definition.probeVersion(handle.target);
+        if (version.kind !== "detected" || version.version !== handle.detectedVersion || version.probeId !== handle.versionProbeId)
+          throw new Error("recovery native version/probe differs from the sealed operation");
+        const observation = deepFreeze({ ...normalizeReadback(await definition.readback(handle)), phase: "observed" });
+        try {
+          assertReadbackMatch(handle.prior, observation, "recovery prior");
+          return { kind: "prior", observation };
+        } catch {
+          assertReadbackMatch(handle.expected, observation, "recovery candidate");
+          return { kind: "expected", observation };
+        }
+      } catch (error) {
+        try {
+          await definition.releaseRecovery?.(handle);
+        } catch (releaseError) {
+          throw phaseError("rollback", "recovery.failed", new Error(`${unknownErrorDiagnostic(error)}; releasing recovery fence failed: ${unknownErrorDiagnostic(releaseError)}`));
+        }
+        throw phaseError("rollback", "recovery.failed", error);
+      }
+    },
     async readback(handle) {
       assertHandle(definition.id, handle);
       const data = await invokePhase("readback", () => definition.readback(handle));
@@ -14228,6 +14394,12 @@ function createLifecycleHostAdapter(definition) {
       assertReadbackMatch(handle.prior, observation, "rollback");
       return deepFreeze({ phase: "rollback-verified", handle, observation });
     },
+    async releaseRecovery(handle) {
+      assertHandle(definition.id, handle);
+      await invokePhase("cleanup", async () => {
+        await definition.releaseRecovery?.(handle);
+      });
+    },
     async cleanup(target, disposition) {
       const reference = cleanupReference(definition.id, target);
       if (isPreparationProjection(target) && disposition !== "aborted-preparation") {
@@ -14255,6 +14427,68 @@ function assertMutationLeader(handle) {
     throw phaseError("apply-precondition", "internal.invariant", new Error(`operation '${handle.operationId}' is a grouped Native follower; '${handle.mutationInvocationOperationId}' owns the single mutation invocation`));
   }
 }
+function hydrateDurableLifecycleOperation(value) {
+  const input = record(value, "durable lifecycle operation");
+  exactFields4(input, [
+    "schemaVersion",
+    "adapterId",
+    "target",
+    "targetObservationId",
+    "operationId",
+    "attemptId",
+    "scopeId",
+    "packageName",
+    "nativeId",
+    "sourceType",
+    "sourceRevision",
+    "sourceLocator",
+    "packageVersion",
+    "action",
+    "route",
+    "detectedVersion",
+    "versionProbeId",
+    "evidenceId",
+    "mutationGroupId",
+    "mutationInvocationOperationId",
+    "artifactId",
+    "projectedFingerprint",
+    "affectedNativeIds",
+    "affectedOperationIds",
+    "prior",
+    "expected",
+    "rollbackReference"
+  ], "durable lifecycle operation");
+  if (input["schemaVersion"] !== 1)
+    invariant("durable lifecycle operation schemaVersion must be 1");
+  return durableHandle({
+    adapterId: stringField(input, "adapterId"),
+    target: input["target"],
+    targetObservationId: stringField(input, "targetObservationId"),
+    operationId: stringField(input, "operationId"),
+    attemptId: stringField(input, "attemptId"),
+    scopeId: stringField(input, "scopeId"),
+    packageName: stringField(input, "packageName"),
+    nativeId: stringField(input, "nativeId"),
+    sourceType: sourceTypeField(input["sourceType"]),
+    sourceRevision: stringField(input, "sourceRevision"),
+    sourceLocator: nullableString2(input["sourceLocator"], "sourceLocator"),
+    packageVersion: nullableString2(input["packageVersion"], "packageVersion"),
+    action: actionField(input["action"]),
+    route: routeField(input["route"]),
+    detectedVersion: stringField(input, "detectedVersion"),
+    versionProbeId: stringField(input, "versionProbeId"),
+    evidenceId: stringField(input, "evidenceId"),
+    mutationGroupId: stringField(input, "mutationGroupId"),
+    mutationInvocationOperationId: stringField(input, "mutationInvocationOperationId"),
+    affectedNativeIds: stringArrayField(input["affectedNativeIds"], "affectedNativeIds"),
+    affectedOperationIds: stringArrayField(input["affectedOperationIds"], "affectedOperationIds"),
+    artifactId: nullableString2(input["artifactId"], "artifactId"),
+    projectedFingerprint: nullableString2(input["projectedFingerprint"], "projectedFingerprint"),
+    prior: readbackField(input["prior"], "prior"),
+    expected: readbackField(input["expected"], "expected"),
+    rollbackReference: stringField(input, "rollbackReference")
+  });
+}
 function freezeNativeProjectionRequest(request) {
   if ("snapshot" in request) {
     const expectedOperation = request.snapshot.action === "install" ? "install" : "update";
@@ -15032,6 +15266,51 @@ function stringField(value, field) {
     invariant(`${field} must be a string`);
   return result;
 }
+function readbackField(value, label) {
+  const input = record(value, `${label} lifecycle readback`);
+  exactFields4(input, [
+    "adapterId",
+    "target",
+    "scopeId",
+    "packageName",
+    "nativeId",
+    "route",
+    "presence",
+    "enablement",
+    "activation",
+    "transition",
+    "installedFingerprint",
+    "contentRoots",
+    "retention"
+  ], `${label} lifecycle readback`);
+  return input;
+}
+function nullableString2(value, label) {
+  if (value !== null && typeof value !== "string")
+    invariant(`${label} must be a string or null`);
+  return value;
+}
+function stringArrayField(value, label) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string"))
+    invariant(`${label} must be a string array`);
+  return [...value];
+}
+function actionField(value) {
+  if (!["install", "update", "route-migrate", "disable-nonconforming", "retire-orphan", "remove"].includes(String(value))) {
+    invariant("durable lifecycle action is invalid");
+  }
+  return value;
+}
+function routeField(value) {
+  if (value !== "native" && value !== "managed")
+    invariant("durable lifecycle route is invalid");
+  return value;
+}
+function sourceTypeField(value) {
+  if (value !== "local" && value !== "git")
+    invariant("durable lifecycle Source type is invalid");
+  return value;
+}
 
 // src/hosts/claude-code-writer.ts
 var OWNERSHIP = ".plgnz-install.json";
@@ -19492,9 +19771,9 @@ var ompWriter = {
     const lockFile = join26(pluginsDir3(), "omp-plugins.lock.json");
     const registryFile = join26(pluginsDir3(), "installed_plugins.json");
     const lock = readDoc(lockFile, { plugins: {}, settings: {} }, "lockfile");
-    const lockPlugins = object2(lock.plugins, "lockfile plugins");
+    const lockPlugins = object3(lock.plugins, "lockfile plugins");
     const registry = readDoc(registryFile, { version: 2, plugins: {} }, "registry");
-    const registryPlugins = object2(registry.plugins, "registry plugins");
+    const registryPlugins = object3(registry.plugins, "registry plugins");
     const rows = userRows(registryPlugins[id]);
     if (rows.length > 0)
       validateLegacy(rows, id, plugin.name, version, opts?.adoptExisting === true);
@@ -19817,7 +20096,7 @@ function readDoc(path, fallback, label) {
     throw new Error(`invalid OMP ${label}: ${path} (${error.message})`);
   }
 }
-function object2(value, label) {
+function object3(value, label) {
   if (!isDoc(value))
     throw new Error(`invalid OMP ${label}`);
   return value;
@@ -20238,7 +20517,7 @@ async function applyManaged(handle, stagingRoot) {
   const link = managedLink(handle.nativeId);
   const file = lockPath();
   const lock = readDoc(file, { plugins: {}, settings: {} }, "lockfile");
-  const plugins = object2(lock.plugins, "lockfile plugins");
+  const plugins = object3(lock.plugins, "lockfile plugins");
   const before = snapshot(file);
   mkdirSafe(dirname9(target));
   mkdirSafe(dirname9(link));
@@ -20268,7 +20547,7 @@ function activationAlreadyCurrent(nativeId, stage, version) {
   if (!existsSync21(target) || !existsSync21(stage) || fingerprintTree(stage) !== fingerprintTree(target) || !linkPointsTo(managedLink(nativeId), target))
     return false;
   const lock = readDoc(lockPath(), { plugins: {}, settings: {} }, "lockfile");
-  const plugins = object2(lock.plugins, "lockfile plugins");
+  const plugins = object3(lock.plugins, "lockfile plugins");
   const row = entry(plugins[npmName(nativeId)]);
   return row.enabled === true && row.version === version;
 }
@@ -20276,7 +20555,7 @@ async function disableManaged(handle) {
   const receiptId = `disable:${handle.attemptId}:${handle.operationId}`;
   const file = lockPath();
   const lock = readDoc(file, { plugins: {}, settings: {} }, "lockfile");
-  const plugins = object2(lock.plugins, "lockfile plugins");
+  const plugins = object3(lock.plugins, "lockfile plugins");
   const npm = npmName(handle.nativeId);
   const previous = entry(plugins[npm]);
   if (previous.enabled === false)
@@ -20598,10 +20877,476 @@ function assertUnder(root, path) {
 import { cpSync as cpSync8, existsSync as existsSync23, lstatSync as lstatSync16, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync9, readFileSync as readFileSync22, readdirSync as readdirSync17, realpathSync as realpathSync3, renameSync as renameSync8, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "node:fs";
 import { basename as basename5, dirname as dirname11, join as join28, resolve as resolve17 } from "node:path";
 import { tmpdir as tmpdir7 } from "node:os";
+import { spawn as spawnChild } from "node:child_process";
 var MARKER7 = ".plgnz-install.json";
 var MANIFESTS = ["plugin.json", ".claude-plugin/plugin.json", ".codex-plugin/plugin.json"];
 var READBACK_FAULT = ".plgnz-dcode-readback-fault";
+var NATIVE_LOCK_SCRIPT = `import sys
+from importlib.metadata import version
+from filelock import FileLock
+if version('deepagents-code') != '0.1.83':
+ raise RuntimeError('unverified dcode lock runtime')
+with FileLock(sys.argv[1]).acquire(timeout=10):
+ print('DCODE_LOCK_0.1.83', flush=True)
+ sys.stdin.read()
+`;
+var nativeLocks = new Map;
+var recoveringNativeLocks = new Map;
+function nativePython() {
+  const override = process.env["OPEN_PLUGIN_DCODE_PYTHON_BIN"];
+  if (override) {
+    assertIdentity2(basename5(override), "Python binary");
+    return override;
+  }
+  const binary = dcodeBinary();
+  if (binary === undefined)
+    throw new Error("dcode native lock runtime is unavailable");
+  const shebang = readFileSync22(binary, "utf8").split(/\r?\n/, 1)[0] ?? "";
+  const match = /^#!(\/[^\s]+python(?:\d+(?:\.\d+)?)?)$/u.exec(shebang);
+  if (match?.[1] === undefined || !existsSync23(match[1]))
+    throw new Error("dcode native Python interpreter is unverified; set OPEN_PLUGIN_DCODE_PYTHON_BIN to its verified interpreter");
+  return match[1];
+}
+function probeLifecycleVersion() {
+  const observation = probeDcodeVersion();
+  if (observation.kind !== "detected" || observation.version !== "0.1.83")
+    return observation;
+  const result = spawnSync([nativePython(), "-c", "from importlib.metadata import version; import filelock; assert version('deepagents-code') == '0.1.83'; print('DCODE_LOCK_0.1.83')"], { stdout: "pipe", stderr: "pipe", timeout: 1e4 });
+  if (result.exitCode !== 0 || new TextDecoder().decode(result.stdout).trim() !== "DCODE_LOCK_0.1.83")
+    throw new Error(`dcode native lock runtime is unverified: ${new TextDecoder().decode(result.stderr).trim()}`);
+  return observation;
+}
+async function acquireNativeLock(attemptId, operationId) {
+  const key = `${attemptId}:${operationId}`;
+  const existing = nativeLocks.get(key);
+  if (existing !== undefined) {
+    if (!existing.isAlive())
+      throw new Error("dcode native lock was lost before verification");
+    return;
+  }
+  const file = join28(dcodeRoot(), "plugins", ".mutation.lock");
+  assertManagedPath4(file);
+  mkdirSync9(dirname11(file), { recursive: true });
+  const child = spawnChild(nativePython(), ["-c", NATIVE_LOCK_SCRIPT, file], { env: { ...process.env, HOME: process.env["OPEN_PLUGIN_HOME"] || process.env["HOME"], DEEPAGENTS_HOME: dcodeRoot() }, stdio: ["pipe", "pipe", "pipe"] });
+  let alive = true;
+  const exited = new Promise((resolveExit) => child.on("exit", (code) => {
+    alive = false;
+    resolveExit(code);
+  }));
+  await new Promise((resolveLock, rejectLock) => {
+    let output = "", diagnostic = "", settled = false;
+    const finish = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) {
+        child.kill("SIGKILL");
+        rejectLock(error);
+      } else
+        resolveLock();
+    };
+    const timer = setTimeout(() => finish(new Error("dcode native lock acquisition timed out")), 12000);
+    child.stdout.on("data", (data) => {
+      output += new TextDecoder().decode(data);
+      if (output.includes(`DCODE_LOCK_0.1.83
+`))
+        finish();
+    });
+    child.stderr.on("data", (data) => {
+      diagnostic += new TextDecoder().decode(data);
+    });
+    child.on("error", (error) => finish(new Error(`dcode native lock failed: ${error.message}`)));
+    child.on("exit", (code) => finish(new Error(`dcode native lock failed (${code}): ${diagnostic.trim()}`)));
+  });
+  nativeLocks.set(key, { child, exited, isAlive: () => alive });
+}
+async function releaseNativeLock(attemptId, operationId) {
+  const key = `${attemptId}:${operationId}`, held = nativeLocks.get(key);
+  recoveringNativeLocks.delete(key);
+  if (held === undefined)
+    return;
+  nativeLocks.delete(key);
+  held.child.stdin.end();
+  let timer;
+  try {
+    const code = await Promise.race([held.exited, new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        held.child.kill("SIGKILL");
+        reject(new Error("dcode native lock release timed out"));
+      }, 2000);
+    })]);
+    if (code !== 0)
+      throw new Error(`dcode native lock process failed during mutation (${code})`);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+function lifecycleDirectory(attemptId, operationId) {
+  const hash = new CryptoHasher("sha256");
+  hash.update(`${attemptId}\x00${operationId}`);
+  const dir = join28(dcodeCacheRoot(), "plgnz-operations", hash.digest("hex"));
+  assertCachePath(dir);
+  return dir;
+}
+function lifecycleSlot(nativeId, fingerprint) {
+  return managedSlot(nativeId, fingerprint);
+}
+function observeDcodeTarget(target) {
+  if (target.kind !== "dcode" || target.instance !== "default")
+    throw new Error("unsupported dcode target identity");
+  const registry = readRegistry3(dcodeRegistryFile());
+  const enabled = boolObject(readEnablement(dcodeEnablementFile()).enabledPlugins, "enabledPlugins");
+  return Object.entries(object4(registry.plugins, "registry plugins")).map(([nativeId, raw]) => {
+    const rows = rowsFor(raw);
+    if (rows.length !== 1)
+      throw new Error(`dcode install record ${nativeId} has duplicate rows`);
+    const path = rowInstall(rows[0], nativeId);
+    assertCachePath(path);
+    const present = existsSync23(path);
+    const marker = present ? ownership3(path) : null;
+    const body = present ? readDoc2(join28(path, MARKER7), {}, "ownership marker") : {};
+    const owned = marker?.pluginId === nativeId;
+    const fingerprint = present ? fingerprintTree(path) : null;
+    return {
+      nativeId,
+      packageName: nativeId.split("@")[0],
+      ownership: owned ? { kind: "owned", proof: body.proof === "adopted" ? "adopted" : "created", scopeId: typeof body.scopeId === "string" ? body.scopeId : "dcode:default", proofId: `dcode-marker:${nativeId}` } : { kind: "unmanaged" },
+      presence: present ? "present" : "absent",
+      enablement: enabled[nativeId] === true ? "enabled" : "disabled",
+      activation: enabled[nativeId] === true && present ? "active" : "inactive",
+      installedFingerprint: fingerprint,
+      installedVersion: present ? declaredManifest(path, nativeId.split("@")[0]).version : null,
+      source: owned ? { type: body.sourceType === "git" ? "git" : "local", immutableRevision: marker.kind === "current" ? marker.sourceRevision : marker.fingerprint, locator: body.sourceType === "git" ? marker.source : null } : null,
+      contentRoots: fingerprint === null ? [] : [{ label: "managed", path, fingerprint }]
+    };
+  });
+}
+function dcodeLifecycleReadback(binding) {
+  if (existsSync23(join28(dcodeStateDir(), READBACK_FAULT)))
+    throw new Error(`dcode readback failed for ${binding.nativeId}`);
+  const installations = observeDcodeTarget(binding.target);
+  const row = installations.find((item) => item.nativeId === binding.nativeId);
+  const present = row?.presence === "present";
+  const enabled = row?.enablement === "enabled" && present;
+  const dataRoot = join28(dcodeRoot(), "plugins", "data");
+  assertManagedPath4(dataRoot);
+  return {
+    adapterId: binding.adapterId,
+    target: binding.target,
+    scopeId: binding.scopeId,
+    packageName: binding.packageName,
+    nativeId: binding.nativeId,
+    route: binding.route ?? (present ? "managed" : "none"),
+    presence: present ? "present" : "absent",
+    enablement: enabled ? "enabled" : "disabled",
+    activation: enabled ? "active" : "inactive",
+    transition: { requirement: present ? "restart" : "none", status: "effective" },
+    installedFingerprint: present ? row.installedFingerprint : null,
+    contentRoots: present ? row.contentRoots : [],
+    retention: { pluginData: existsSync23(dataRoot) ? { state: "present", fingerprint: fingerprintTree(dataRoot) } : { state: "absent", fingerprint: null }, inactiveMetadata: { state: "absent", fingerprint: null } }
+  };
+}
+function captureDcodeRollback(binding, attemptId, operationId) {
+  const dir = join28(lifecycleDirectory(attemptId, operationId), "rollback");
+  mkdirSync9(dir, { recursive: true });
+  const registry = readRegistry3(dcodeRegistryFile());
+  const enabled = boolObject(readEnablement(dcodeEnablementFile()).enabledPlugins, "enabledPlugins");
+  const row = object4(registry.plugins, "registry plugins")[binding.nativeId];
+  const state = { row: row ?? null, enabled: enabled[binding.nativeId] ?? null, registryExisted: existsSync23(dcodeRegistryFile()), enablementExisted: existsSync23(dcodeEnablementFile()) };
+  writeFileSync9(join28(dir, "state.json"), JSON.stringify(state));
+  for (const [index, item] of rowsFor(row).entries()) {
+    const path = rowInstall(item, binding.nativeId);
+    assertCachePath(path);
+    assertNoSymlinks6(path);
+    if (existsSync23(path))
+      cpSync8(path, join28(dir, `content-${index}`), { recursive: true });
+  }
+  return dir;
+}
+function assertRecoveryRollbackMetadata(handle, state) {
+  const rows = rowsFor(state.row);
+  if (rows.length !== handle.prior.contentRoots.length || rows.some((row, index) => resolve17(rowInstall(row, handle.nativeId)) !== resolve17(handle.prior.contentRoots[index].path)) || handle.prior.presence === "present" && state.enabled === true !== (handle.prior.enablement === "enabled"))
+    throw new Error("dcode rollback registry snapshot differs from the sealed prior; recovery refused");
+}
+async function lockPreparation(binding, attemptId, operationId, expectedObservationId) {
+  await acquireNativeLock(attemptId, operationId);
+  const observed = createTargetInventoryObservation("dcode", { target: binding.target, installations: observeDcodeTarget(binding.target) });
+  if (observed.observationId !== expectedObservationId)
+    throw new Error("dcode native inventory changed before locked preparation; refusing stale rollback authority");
+}
+async function captureOwnedPreparation(binding, attemptId, operationId, expectedObservationId, capture) {
+  try {
+    await lockPreparation(binding, attemptId, operationId, expectedObservationId);
+    return capture();
+  } catch (error) {
+    try {
+      await releaseNativeLock(attemptId, operationId);
+    } catch (releaseError) {
+      throw new Error(`${error instanceof Error ? error.message : String(error)}; dcode preparation lock release failed: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`);
+    }
+    throw error;
+  }
+}
+function preflightAdoption(request) {
+  if (request.operation !== "install" && request.operation !== "update")
+    return;
+  const snapshot = request.snapshot;
+  const installed = request.targetObservation.installations.find((item) => item.nativeId === snapshot.nativeId);
+  if (installed?.ownership.kind !== "unmanaged" || installed.presence !== "present")
+    return;
+  const path = installed.contentRoots[0]?.path;
+  if (path === undefined)
+    throw new Error("dcode unmanaged adoption has no native root");
+  const manifest = declaredManifest(snapshot.packageRoot, snapshot.packageName);
+  assessPrior(object4(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[snapshot.nativeId], snapshot.nativeId, snapshot.nativeGit?.locator ?? `local:${snapshot.scopeId}`, true, snapshot.packageName, manifest.version, snapshot.packageRoot);
+  if (fingerprintTree(path) !== installed.installedFingerprint)
+    throw new Error("dcode unmanaged adoption changed during preflight");
+}
+function setDcodeRow(nativeId, row, enabled) {
+  assertManagedPath4(dcodeRegistryFile());
+  assertManagedPath4(dcodeEnablementFile());
+  const registry = readRegistry3(dcodeRegistryFile()), enablement = readEnablement(dcodeEnablementFile());
+  const plugins = { ...object4(registry.plugins, "registry plugins") }, flags = { ...boolObject(enablement.enabledPlugins, "enabledPlugins") };
+  if (row === null)
+    delete plugins[nativeId];
+  else
+    plugins[nativeId] = row;
+  if (enabled === null)
+    delete flags[nativeId];
+  else
+    flags[nativeId] = enabled;
+  writeDoc2(dcodeRegistryFile(), { ...registry, plugins });
+  writeDoc2(dcodeEnablementFile(), { ...enablement, enabledPlugins: flags });
+}
+var dcodeDefinition = {
+  id: "dcode",
+  evidenceProfiles: capabilityEvidenceProfiles.filter((profile) => profile.host === "dcode").flatMap((profile) => [profile, createCapabilityEvidenceProfile({ ...profile, operations: ["disable"], semantics: { ...profile.semantics, "reversible-disable": "supported" }, evidence: [...profile.evidence, "docs/evidence/dcode-managed-lifecycle-20261011.md"] })]),
+  probeVersion: async () => probeLifecycleVersion(),
+  observeTarget: async (target) => ({ target, installations: observeDcodeTarget(target) }),
+  observeNativeMutationScope: async () => ({ kind: "unavailable" }),
+  observeNativeProjection: async (request) => {
+    preflightAdoption(request);
+    return { kind: "requires-managed", reasonId: "dcode-frozen-projection-and-updater-isolation" };
+  },
+  revalidateTargetPrecondition: async (handle) => {
+    await acquireNativeLock(handle.attemptId, handle.operationId);
+    return { version: probeDcodeVersion(), targetObservationId: createTargetInventoryObservation("dcode", { target: handle.target, installations: observeDcodeTarget(handle.target) }).observationId };
+  },
+  stageActivation: async (request) => {
+    const dir = lifecycleDirectory(request.snapshot.attemptId, request.snapshot.operationId);
+    const stagingRoot = join28(dir, "stage");
+    if (existsSync23(stagingRoot))
+      throw new Error("dcode preparation stage already exists");
+    mkdirSync9(stagingRoot, { recursive: true });
+    const manifest = declaredManifest(request.snapshot.packageRoot, request.snapshot.packageName);
+    try {
+      stagePlugin5(request.snapshot.packageRoot, stagingRoot, request.snapshot.packageName, manifest.version);
+    } catch (error) {
+      rmSync9(dir, { recursive: true, force: true });
+      throw error;
+    }
+    return { stagingRoot, stagingId: `${request.snapshot.attemptId}:${request.snapshot.operationId}` };
+  },
+  applyLifecycleDirectives: async (projection) => {
+    forceAutoUpdateOff(projection.stagingRoot);
+    const prior = observeDcodeTarget(projection.target).find((item) => item.nativeId === projection.nativeId);
+    writeFileSync9(join28(projection.stagingRoot, MARKER7), JSON.stringify({ source: projection.sourceLocator ?? `local:${projection.scopeId}`, pluginId: projection.nativeId, fingerprint: projection.sourceRevision, sourceRevision: projection.sourceRevision, projectedFingerprint: projectionDigest(projection.stagingRoot), scopeId: projection.scopeId, sourceType: projection.sourceType, proof: prior?.ownership.kind === "unmanaged" ? "adopted" : "created" }));
+    return ["dcode.managed-unversioned-registry"];
+  },
+  applyPins: async (projection) => {
+    const found = new Set;
+    for (const candidate of dcodeMcpCandidates()) {
+      const file = join28(projection.stagingRoot, candidate.kind === "spec" ? candidate.file : candidate.manifest);
+      if (!existsSync23(file))
+        continue;
+      const body = readDoc2(file, {}, "MCP document");
+      if (typeof body.mcpServers !== "object" || body.mcpServers === null || Array.isArray(body.mcpServers))
+        continue;
+      let changed = false;
+      for (const pin of projection.pins) {
+        const server = body.mcpServers[pin.server];
+        if (typeof server !== "object" || server === null || Array.isArray(server))
+          continue;
+        server.command = pin.executable;
+        found.add(pin.server);
+        changed = true;
+      }
+      if (changed)
+        writeFileSync9(file, JSON.stringify(body, null, 2));
+    }
+    if (projection.pins.some((pin) => !found.has(pin.server)))
+      throw new Error("dcode resolved pin is absent from staged MCP configuration");
+    const marker = readDoc2(join28(projection.stagingRoot, MARKER7), {}, "ownership marker");
+    marker.projectedFingerprint = projectionDigest(projection.stagingRoot);
+    writeFileSync9(join28(projection.stagingRoot, MARKER7), JSON.stringify(marker));
+    return [...found];
+  },
+  captureActivationPreparation: async (projection, fingerprint) => {
+    await lockPreparation(projection, projection.attemptId, projection.operationId, projection.targetObservationId);
+    const prior = dcodeLifecycleReadback(projection);
+    const target = lifecycleSlot(projection.nativeId, fingerprint);
+    assertCachePath(target);
+    const installed = observeDcodeTarget(projection.target).find((item) => item.nativeId === projection.nativeId);
+    if (installed?.ownership.kind === "owned" && installed.ownership.scopeId !== projection.scopeId)
+      throw new Error("dcode scope ownership conflict");
+    if (installed?.ownership.kind === "unmanaged") {
+      const path = installed.contentRoots[0]?.path;
+      if (path === undefined || !sameTree7(projection.snapshot.packageRoot, path))
+        throw new Error("dcode legacy content differs; refusing adoption");
+      const manifest = declaredManifest(path, projection.packageName);
+      if (manifest.version !== projection.packageVersion)
+        throw new Error("dcode legacy version differs; refusing adoption");
+    }
+    if (existsSync23(target) && ownership3(target)?.pluginId !== projection.nativeId)
+      throw new Error("dcode lifecycle target is not owned");
+    const rollbackReference = captureDcodeRollback(projection, projection.attemptId, projection.operationId);
+    writeFileSync9(join28(rollbackReference, "next-path.json"), JSON.stringify({ target }));
+    return { prior, expected: { ...prior, route: "managed", presence: "present", enablement: "enabled", activation: "active", transition: { requirement: "restart", status: "effective" }, installedFingerprint: fingerprint, contentRoots: [{ label: "managed", path: target, fingerprint }] }, rollbackReference, rollbackCoverageOperationIds: projection.affectedOperationIds };
+  },
+  captureDisablePreparation: async (request) => {
+    const binding = { adapterId: "dcode", ...request.activation };
+    return captureOwnedPreparation(binding, request.attemptId, request.operationId, request.selection.targetObservationId, () => ({ prior: dcodeLifecycleReadback(binding), rollbackReference: captureDcodeRollback(binding, request.attemptId, request.operationId), rollbackCoverageOperationIds: request.selection.affectedOperationIds, transition: { requirement: "restart", status: "effective" } }));
+  },
+  captureRetirementPreparation: async (request) => {
+    const binding = { adapterId: "dcode", ...request.activation };
+    return captureOwnedPreparation(binding, request.attemptId, request.operationId, request.selection.targetObservationId, () => ({ prior: dcodeLifecycleReadback(binding), rollbackReference: captureDcodeRollback(binding, request.attemptId, request.operationId), rollbackCoverageOperationIds: request.selection.affectedOperationIds, transition: { requirement: "none", status: "effective" } }));
+  },
+  apply: async (prepared) => {
+    await acquireNativeLock(prepared.handle.attemptId, prepared.handle.operationId);
+    const target = lifecycleSlot(prepared.handle.nativeId, prepared.handle.projectedFingerprint);
+    assertCachePath(target);
+    mkdirSync9(dirname11(target), { recursive: true });
+    if (existsSync23(target)) {
+      const marker = ownership3(target);
+      if (marker?.pluginId !== prepared.handle.nativeId)
+        throw new Error("dcode lifecycle activation would overwrite foreign content");
+      if (fingerprintTree(target) !== prepared.handle.projectedFingerprint)
+        throw new Error("dcode immutable projection slot has diverged");
+    } else {
+      renameSync8(prepared.stagingRoot, target);
+    }
+    setDcodeRow(prepared.handle.nativeId, [{ installPath: target }], true);
+    return { receiptId: `dcode-apply:${prepared.handle.operationId}`, changed: true };
+  },
+  disable: async (prepared) => {
+    await acquireNativeLock(prepared.handle.attemptId, prepared.handle.operationId);
+    const row = object4(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[prepared.handle.nativeId];
+    setDcodeRow(prepared.handle.nativeId, row ?? null, false);
+    return { receiptId: `dcode-disable:${prepared.handle.operationId}`, changed: true };
+  },
+  retire: async (prepared) => {
+    await acquireNativeLock(prepared.handle.attemptId, prepared.handle.operationId);
+    const rows = rowsFor(object4(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[prepared.handle.nativeId]);
+    for (const row of rows) {
+      const path = rowInstall(row, prepared.handle.nativeId);
+      assertCachePath(path);
+      if (ownership3(path)?.pluginId !== prepared.handle.nativeId)
+        throw new Error("dcode retirement has no ownership proof");
+    }
+    setDcodeRow(prepared.handle.nativeId, null, null);
+    for (const row of rows)
+      rmSync9(rowInstall(row, prepared.handle.nativeId), { recursive: true, force: true });
+    return { receiptId: `dcode-retire:${prepared.handle.operationId}`, changed: true };
+  },
+  readback: async (handle) => {
+    const held = nativeLocks.get(`${handle.attemptId}:${handle.operationId}`);
+    if (held !== undefined && !held.isAlive())
+      throw new Error("dcode native lock was lost before readback");
+    return dcodeLifecycleReadback(handle);
+  },
+  rollback: async (handle) => {
+    await acquireNativeLock(handle.attemptId, handle.operationId);
+    if (!existsSync23(join28(handle.rollbackReference, "state.json")))
+      throw new Error("dcode rollback snapshot is missing; recovery refused");
+    const state = readDoc2(join28(handle.rollbackReference, "state.json"), {}, "rollback state");
+    if (recoveringNativeLocks.has(`${handle.attemptId}:${handle.operationId}`))
+      assertRecoveryRollbackMetadata(handle, state);
+    for (const [index, root] of handle.prior.contentRoots.entries()) {
+      const backup = join28(handle.rollbackReference, `content-${index}`);
+      if (!existsSync23(backup) || fingerprintTree(backup) !== root.fingerprint)
+        throw new Error("dcode rollback snapshot bytes do not match the sealed prior");
+      if (recoveringNativeLocks.has(`${handle.attemptId}:${handle.operationId}`) && existsSync23(root.path) && fingerprintTree(root.path) !== root.fingerprint)
+        throw new Error("dcode prior root changed outside the sealed operation; refusing stale overwrite");
+    }
+    const target = handle.projectedFingerprint === null ? undefined : lifecycleSlot(handle.nativeId, handle.projectedFingerprint);
+    if (target !== undefined)
+      assertCachePath(target);
+    if (target !== undefined && existsSync23(target) && !handle.prior.contentRoots.some((root) => resolve17(root.path) === resolve17(target))) {
+      if (ownership3(target)?.pluginId !== handle.nativeId || recoveringNativeLocks.has(`${handle.attemptId}:${handle.operationId}`) && fingerprintTree(target) !== handle.projectedFingerprint)
+        throw new Error("dcode rollback candidate differs from the sealed operation; refusing stale overwrite");
+      rmSync9(target, { recursive: true });
+    }
+    for (const [index, row] of rowsFor(state.row).entries()) {
+      const path = rowInstall(row, handle.nativeId);
+      assertCachePath(path);
+      const backup = join28(handle.rollbackReference, `content-${index}`);
+      if (existsSync23(backup)) {
+        mkdirSync9(dirname11(path), { recursive: true });
+        cpSync8(backup, path, { recursive: true });
+      }
+    }
+    setDcodeRow(handle.nativeId, state.row ?? null, typeof state.enabled === "boolean" ? state.enabled : null);
+    if (state.registryExisted === false && Object.keys(object4(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")).length === 0)
+      rmSync9(dcodeRegistryFile());
+    if (state.enablementExisted === false && Object.keys(boolObject(readEnablement(dcodeEnablementFile()).enabledPlugins, "enabledPlugins")).length === 0)
+      rmSync9(dcodeEnablementFile());
+    return { receiptId: `dcode-rollback:${handle.operationId}`, changed: true };
+  },
+  beginRecovery: async (handle) => {
+    const reference = join28(lifecycleDirectory(handle.attemptId, handle.operationId), "rollback");
+    if (resolve17(handle.rollbackReference) !== resolve17(reference))
+      throw new Error("dcode recovery reference escapes the operation-owned artifact directory");
+    assertManagedPath4(reference);
+    for (const root of [...handle.prior.contentRoots, ...handle.expected.contentRoots])
+      assertCachePath(root.path);
+    await acquireNativeLock(handle.attemptId, handle.operationId);
+    recoveringNativeLocks.set(`${handle.attemptId}:${handle.operationId}`, handle);
+  },
+  releaseRecovery: async (handle) => {
+    await releaseNativeLock(handle.attemptId, handle.operationId);
+  },
+  cleanup: async (reference, disposition) => {
+    try {
+      const dir = lifecycleDirectory(reference.attemptId, reference.operationId);
+      const recovering = recoveringNativeLocks.get(`${reference.attemptId}:${reference.operationId}`);
+      const nextFile = join28(dir, "rollback", "next-path.json");
+      const priorFile = join28(dir, "rollback", "state.json");
+      const next = readDoc2(nextFile, {}, "cleanup target");
+      if (disposition === "verified-commit" && recovering !== undefined) {
+        const retiredRoots = recovering.prior.contentRoots.filter((root) => !recovering.expected.contentRoots.some((next) => resolve17(next.path) === resolve17(root.path)));
+        if (existsSync23(priorFile))
+          assertRecoveryRollbackMetadata(recovering, readDoc2(priorFile, {}, "rollback state"));
+        else if (retiredRoots.some((root) => existsSync23(root.path)))
+          throw new Error("dcode cleanup prior metadata is missing; recovery refused");
+        if (existsSync23(nextFile) && (typeof next.target !== "string" || !recovering.expected.contentRoots.some((root) => resolve17(root.path) === resolve17(next.target))))
+          throw new Error("dcode cleanup target differs from the sealed expected root; recovery refused");
+        for (const root of retiredRoots) {
+          if (existsSync23(root.path) && fingerprintTree(root.path) !== root.fingerprint)
+            throw new Error("dcode cleanup prior root changed; refusing stale deletion");
+        }
+        for (const root of retiredRoots)
+          rmSync9(root.path, { recursive: true, force: true });
+      } else if (disposition === "verified-commit" && typeof next.target === "string") {
+        const prior = readDoc2(priorFile, {}, "rollback state");
+        for (const row of rowsFor(prior.row)) {
+          const path = rowInstall(row, reference.operationId);
+          assertCachePath(path);
+          if (resolve17(path) !== resolve17(next.target))
+            rmSync9(path, { recursive: true, force: true });
+        }
+      }
+      rmSync9(dir, { recursive: true, force: true });
+    } finally {
+      await releaseNativeLock(reference.attemptId, reference.operationId);
+    }
+    return { cleanupId: `dcode-cleanup:${reference.operationId}`, completed: true };
+  }
+};
+var dcodeLifecycle = createLifecycleHostAdapter(dcodeDefinition);
 var dcodeWriter = {
+  lifecyclePinAdapter: dcodeLifecycle,
   ...dcode,
   supportsAdoption: true,
   plannedNativeId: (plugin) => `${plugin.name}@${plugin.marketplace || "local"}`,
@@ -20620,7 +21365,7 @@ var dcodeWriter = {
     assertManagedPath4(enablementFile);
     const registry = readRegistry3(registryFile);
     const enablement = readEnablement(enablementFile);
-    const plugins = object3(registry.plugins, "registry plugins");
+    const plugins = object4(registry.plugins, "registry plugins");
     const enabled = boolObject(enablement.enabledPlugins, "enabledPlugins");
     const manifest = declaredManifest(plugin.dir, plugin.name);
     const observation = probeDcodeVersion();
@@ -20664,7 +21409,7 @@ var dcodeWriter = {
         throw new Error(`dcode cache target is unowned; refusing to replace it: ${target}`);
       const former = prior.kind === "none" ? undefined : prior.path;
       const unchanged = (former === undefined || resolve17(former) === resolve17(target)) && slot?.kind === "current" && slot.fingerprint === sourceFingerprint && slot.projectedFingerprint === projected && slot.sourceRevision === resolved.sha && sameTree7(stage, target);
-      const nextRegistry = { ...registry, plugins: { ...plugins, [id]: [{ installPath: target, version: manifest.version }] } };
+      const nextRegistry = { ...registry, plugins: { ...plugins, [id]: [{ installPath: target }] } };
       const nextEnablement = { ...enablement, enabledPlugins: { ...enabled, [id]: true } };
       if (opts?.dryRun) {
         console.log(`[dcode] would activate directory: ${target}`);
@@ -20715,6 +21460,8 @@ var dcodeWriter = {
     assertCachePath(plugin.path);
     if (ownership3(plugin.path)?.pluginId !== plugin.id)
       return { changes: [], refusals: [] };
+    if (opts?.dryRun !== true)
+      throw new Error("dcode pin requires the durable lifecycle pin workflow; direct in-place pinning is refused");
     return pinPluginMcpFiles(plugin.path, dcodeMcpCandidates(), opts);
   },
   async remove(id) {
@@ -20726,7 +21473,7 @@ var dcodeWriter = {
     assertManagedPath4(enablementFile);
     const registry = readRegistry3(registryFile);
     const enablement = readEnablement(enablementFile);
-    const plugins = object3(registry.plugins, "registry plugins");
+    const plugins = object4(registry.plugins, "registry plugins");
     const rows = rowsFor(plugins[id]);
     if (rows.length === 0)
       return;
@@ -20820,7 +21567,7 @@ function declaredManifest(dir, expectedName) {
     throw new Error("dcode stage has no supported plugin manifest");
   let parsed;
   try {
-    parsed = object3(JSON.parse(readFileSync22(manifest, "utf8")), "manifest");
+    parsed = object4(JSON.parse(readFileSync22(manifest, "utf8")), "manifest");
   } catch (error) {
     throw new Error(`invalid dcode manifest: ${manifest} (${error.message})`);
   }
@@ -20843,10 +21590,10 @@ function forceAutoUpdateOff(dir) {
   const manifest = MANIFESTS.map((relative) => join28(dir, relative)).find((file) => existsSync23(file));
   if (manifest === undefined)
     throw new Error("dcode stage has no supported plugin manifest");
-  const parsed = object3(JSON.parse(readFileSync22(manifest, "utf8")), "manifest");
-  const extensions = parsed.extensions === undefined ? {} : object3(parsed.extensions, "manifest extensions");
+  const parsed = object4(JSON.parse(readFileSync22(manifest, "utf8")), "manifest");
+  const extensions = parsed.extensions === undefined ? {} : object4(parsed.extensions, "manifest extensions");
   const current = extensions["com.langchain.deepagents.code"];
-  const dcodeExtension = current === undefined ? {} : object3(current, "dcode manifest extension");
+  const dcodeExtension = current === undefined ? {} : object4(current, "dcode manifest extension");
   dcodeExtension.autoUpdate = false;
   extensions["com.langchain.deepagents.code"] = dcodeExtension;
   parsed.extensions = extensions;
@@ -20858,15 +21605,17 @@ function assertReadback(id, registryFile, enablementFile, target, version, proje
     throw new Error(`dcode readback failed for ${id}`);
   const registry = readRegistry3(registryFile);
   const enablement = readEnablement(enablementFile);
-  const rows = rowsFor(object3(registry.plugins, "registry plugins")[id]);
+  const rows = rowsFor(object4(registry.plugins, "registry plugins")[id]);
   if (rows.length !== 1)
     throw new Error(`dcode readback failed for ${id}`);
   const install = rowInstall(rows[0], id);
   if (resolve17(install) !== resolve17(target))
     throw new Error(`dcode readback path mismatch for ${id}`);
-  if (rows[0].version !== version)
+  if (rows[0].version !== undefined && rows[0].version !== null)
+    throw new Error(`dcode managed install is eligible for native auto-update: ${id}`);
+  if (declaredManifest(target, id.split("@")[0]).version !== version)
     throw new Error(`dcode readback version mismatch for ${id}`);
-  if (boolObject(object3(enablement.enabledPlugins, "enabledPlugins"), "enabledPlugins")[id] !== true)
+  if (boolObject(object4(enablement.enabledPlugins, "enabledPlugins"), "enabledPlugins")[id] !== true)
     throw new Error(`dcode readback enablement mismatch for ${id}`);
   const marker = ownership3(target);
   if (marker?.kind !== "current" || marker.projectedFingerprint !== projected || marker.sourceRevision !== sourceRevision) {
@@ -20946,7 +21695,7 @@ function readRegistry3(file) {
   const registry = readDoc2(file, { version: 2, plugins: {} }, "registry");
   if (registry.version !== 1 && registry.version !== 2)
     throw new Error(`invalid dcode registry version: ${file}`);
-  const plugins = object3(registry.plugins, "registry plugins");
+  const plugins = object4(registry.plugins, "registry plugins");
   for (const [id, value] of Object.entries(plugins)) {
     if (!id || !Array.isArray(value) || value.length === 0)
       throw new Error(`invalid dcode registry record: ${id}`);
@@ -20965,13 +21714,13 @@ function readEnablement(file) {
   boolObject(enablement.enabledPlugins, "enabledPlugins");
   return enablement;
 }
-function object3(value, label) {
+function object4(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     throw new Error(`invalid dcode ${label}`);
   return value;
 }
 function boolObject(value, label) {
-  const result = object3(value, label);
+  const result = object4(value, label);
   if (Object.values(result).some((entry) => typeof entry !== "boolean"))
     throw new Error(`invalid dcode ${label}`);
   return result;
@@ -20994,7 +21743,7 @@ function ownership3(dir) {
   if (!existsSync23(file))
     return null;
   try {
-    const value = object3(JSON.parse(readFileSync22(file, "utf8")), "ownership marker");
+    const value = object4(JSON.parse(readFileSync22(file, "utf8")), "ownership marker");
     if (typeof value.source !== "string" || typeof value.pluginId !== "string" || typeof value.fingerprint !== "string")
       throw new Error("marker fields are invalid");
     const projected = value.projectedFingerprint;
@@ -21508,7 +22257,7 @@ import { cpSync as cpSync10, existsSync as existsSync25, lstatSync as lstatSync1
 import { dirname as dirname13, join as join30, resolve as resolve19 } from "node:path";
 import { tmpdir as tmpdir9 } from "node:os";
 var stableId = (plugin) => plugin.marketplace === undefined ? plugin.name : `${plugin.name}@${plugin.marketplace}`;
-var digest2 = (value) => {
+var digest3 = (value) => {
   const hash = new CryptoHasher("sha256");
   hash.update(value);
   return hash.digest("hex").slice(0, 16);
@@ -21529,7 +22278,7 @@ var grokWriter = {
     if (!registryIsReadable())
       throw new Error("Grok native registry is unreadable or unsupported; refusing mutation");
     const id = stableId(plugin);
-    const root = join30(marketplacesRoot(), `plgnz-${digest2(`${resolved.sourceUri}\x00${id}`)}`);
+    const root = join30(marketplacesRoot(), `plgnz-${digest3(`${resolved.sourceUri}\x00${id}`)}`);
     const parent = dirname13(root);
     const prior = canonical(root);
     const priorMarker = prior === undefined ? null : ownership(prior);
@@ -22016,7 +22765,7 @@ function probeGrokVersion() {
   return parseGrokVersionOutput(result.stdout ?? "", result.status);
 }
 function lifecycleMarketplace(scopeId, nativeId) {
-  return resolve19(join30(marketplacesRoot(), `plgnz-${digest2(`${scopeId}\x00${nativeId}`)}`));
+  return resolve19(join30(marketplacesRoot(), `plgnz-${digest3(`${scopeId}\x00${nativeId}`)}`));
 }
 function marketplacePluginPath(scopeId, nativeId, packageName) {
   return resolve19(join30(lifecycleMarketplace(scopeId, nativeId), "plugins", packageName));
@@ -24817,7 +25566,7 @@ class SyncManifestValidationError extends Error {
   }
 }
 function parseSyncManifest(value) {
-  const manifest = object4(value, "sync manifest");
+  const manifest = object5(value, "sync manifest");
   exactFields5(manifest, ["schemaVersion", "entries"], "sync manifest");
   if (manifest["schemaVersion"] !== SYNC_MANIFEST_SCHEMA_VERSION)
     invalidArgument2("sync manifest schemaVersion must be 1");
@@ -24851,7 +25600,7 @@ function selectManifestPackages(entry, discovered) {
   });
 }
 function parseEntry(value, index) {
-  const entry = object4(value, `sync manifest entry ${index}`);
+  const entry = object5(value, `sync manifest entry ${index}`);
   if (entry["operation"] === "sync") {
     exactFields5(entry, ["operation", "source", "target", "selectors"], `sync manifest entry ${index}`);
     const source = parseSourceBinding(entry["source"], `sync manifest entry ${index} source`);
@@ -24929,7 +25678,7 @@ function assertUniqueScopes(entries) {
   }
 }
 function parseSourceBinding(value, label) {
-  const binding = object4(value, label);
+  const binding = object5(value, label);
   if (binding["kind"] === "local") {
     exactFields5(binding, ["kind", "locator"], label);
     if (typeof binding["locator"] !== "string")
@@ -24955,7 +25704,7 @@ function parseTarget(value, label) {
 }
 function parseSelector(value, entryIndex, selectorIndex) {
   const label = `sync manifest entry ${entryIndex} selector ${selectorIndex}`;
-  const selector = object4(value, label);
+  const selector = object5(value, label);
   exactFields5(selector, ["package", "adoptExisting"], label);
   if (typeof selector["package"] !== "string" || !/^[a-z0-9][a-z0-9._-]*$/iu.test(selector["package"])) {
     invalidArgument2(`${label} package must be a valid package name`);
@@ -24973,7 +25722,7 @@ function validateBinding(source, label) {
   }
 }
 function targetProfile(value, label) {
-  const target = object4(value, label);
+  const target = object5(value, label);
   if (typeof target["kind"] !== "string")
     invalidArgument2(`${label} kind must be a string`);
   return targetProfileForKind(target["kind"], label);
@@ -24998,7 +25747,7 @@ function invokeTargetProfile(operation) {
     throw error;
   }
 }
-function object4(value, label) {
+function object5(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     invalidArgument2(`${label} must be an object`);
   return value;
@@ -25029,22 +25778,87 @@ async function planLifecycle(input) {
   if (duplicate !== null)
     return zeroWrite(command, input.dryRun, duplicate);
   const prepared = [];
-  const transportCache = new Map;
+  const transportCache = input.retainedSources ?? new Map;
+  const planningState = input.recoveryPreflight ? { ...loaded.state, activations: loaded.state.activations.map((row) => {
+    if (row.pending === undefined || !loaded.state.attempts.some((attempt) => attempt.command !== "legacy-recovery" && attempt.id === row.pending.attemptId && attempt.journal.some((entry) => entry.scopeId === row.scopeId && entry.packageId === row.packageId && entry.nativeId === row.nativeId && (entry.sealedOperation !== undefined || entry.state === "pending"))))
+      return row;
+    const { pending: _pending, ...kept } = row;
+    return kept;
+  }) } : loaded.state;
   for (const entry of input.manifest.entries) {
-    const result = await prepareEntry(entry, input.hosts, loaded.state, command, input.transportSource, transportCache);
+    const result = await prepareEntry(entry, input.hosts, planningState, command, input.transportSource, transportCache);
     if (result.kind === "defect")
       return zeroWrite(command, input.dryRun, result.reason, result.terminalPhase);
-    prepared.push(result);
+    if (input.removalSelection !== undefined) {
+      if (command !== "remove" || result.kind !== "retire-source") {
+        return zeroWrite(command, input.dryRun, createLifecycleReason("internal", "internal.invariant", "package retirement selection is valid only for manual removal"));
+      }
+      const selected = input.removalSelection.filter((row) => row.scopeId === result.scope.id);
+      if (selected.length === 0 || selected.some((row) => !loaded.state.activations.some((activation) => activation.scopeId === row.scopeId && activation.packageId === row.packageId && activation.nativeId === row.nativeId))) {
+        return zeroWrite(command, input.dryRun, createLifecycleReason("internal", "internal.invariant", "manual removal selection no longer matches recorded ownership"));
+      }
+      const retirementPackages = selected.map(({ packageId, nativeId }) => ({ packageId, nativeId })).sort((left, right) => left.packageId.localeCompare(right.packageId) || left.nativeId.localeCompare(right.nativeId));
+      prepared.push({
+        ...result,
+        retirementPackages,
+        identity: ["remove-packages", result.scope.id, ...retirementPackages.flatMap((row) => [row.packageId, row.nativeId])]
+      });
+    } else
+      prepared.push(result);
   }
   const attemptId = lifecycleAttemptId(loaded.state.stateGeneration, prepared.map((item) => item.identity));
+  const recovering = input.recoveryPreflight && loaded.state.attempts.some((attempt) => attempt.command !== "legacy-recovery" && attempt.journal.some((row) => prepared.some((item) => item.scope.id === row.scopeId) && ["pending", "applying", "applied", "readback-verified", "rollback", "cleanup-pending"].includes(row.state)));
   const scopes = [];
   const operations = [];
   for (const item of prepared) {
-    const planned = await planPrepared(item, attemptId, input.validatedAt, loaded.state, command);
+    const pendingJournals = recovering ? loaded.state.attempts.filter((attempt) => attempt.command !== "legacy-recovery").flatMap((attempt) => attempt.journal.filter((row) => row.scopeId === item.scope.id && ["pending", "applying", "applied", "readback-verified", "rollback", "cleanup-pending"].includes(row.state))) : [];
+    const pendingNativeIds = new Set(pendingJournals.map((row) => row.nativeId));
+    const transitional = [];
+    const transitionalDesired = [];
+    const blockedReason = createLifecycleReason("runtime", "runtime.operation-failed", "not attempted before pending lifecycle recovery settles");
+    let classifiable = item;
+    if (item.kind === "sync" && pendingNativeIds.size > 0) {
+      const selectedPackages = [];
+      for (const selected of item.selected) {
+        const nativeId = plannedNativeIdFor(item, selected.plugin);
+        if (nativeId instanceof Error)
+          return zeroWrite(command, input.dryRun, createLifecycleReason("internal", "internal.defect", unknownErrorDiagnostic(nativeId)));
+        if (!pendingNativeIds.has(nativeId)) {
+          selectedPackages.push(selected);
+          continue;
+        }
+        try {
+          const inventory = inventoryPackageSemantics(selected.plugin);
+          transitionalDesired.push({
+            packageId: selected.plugin.name,
+            nativeId,
+            sourceRelativeDir: selected.plugin.relativeDir || ".",
+            requiredCapabilities: [...requiredSemanticsForOperation(inventory, "install")].sort(),
+            adoptionRequested: selected.adoptionRequested
+          });
+        } catch (error) {
+          return zeroWrite(command, input.dryRun, error instanceof SemanticInventoryError ? error.reason : createLifecycleReason("internal", "internal.defect", unknownErrorDiagnostic(error)));
+        }
+        transitional.push(classified(operationIdentity("desired-pair", item.scope.id, selected.plugin.name, nativeId, `${item.frozen.snapshot.fingerprint}\x00${attemptId}`), "desired-pair", item.scope, sourceSnapshotId(item.frozen), selected.plugin.name, nativeId, "not-attempted", "none", blockedReason).operation);
+      }
+      classifiable = { ...item, selected: selectedPackages };
+    }
+    const classifiableState = pendingNativeIds.size === 0 ? loaded.state : { ...loaded.state, activations: loaded.state.activations.filter((row) => row.scopeId !== item.scope.id || !pendingNativeIds.has(row.nativeId)) };
+    const planned = await planPrepared(classifiable, attemptId, input.validatedAt, classifiableState, command);
     if (planned.kind === "defect")
       return zeroWrite(command, input.dryRun, planned.reason, planned.terminalPhase);
-    scopes.push(planned.scope);
-    operations.push(...planned.operations);
+    for (const journal of pendingJournals) {
+      if (journal.packageId === undefined || journal.nativeId === undefined || transitional.some((row) => row.operation.nativeId === journal.nativeId))
+        continue;
+      if (item.kind === "retire-source" && (item.retirementPackages === undefined || item.retirementPackages.some((row) => row.nativeId === journal.nativeId)) || item.kind === "sync" && command === "sync" && loaded.state.activations.some((row) => row.scopeId === item.scope.id && row.nativeId === journal.nativeId)) {
+        transitional.push(classified(operationIdentity("retirement", item.scope.id, journal.packageId, journal.nativeId, attemptId), "retirement", item.scope, item.kind === "sync" ? sourceSnapshotId(item.frozen) : null, journal.packageId, journal.nativeId, "not-attempted", "none", blockedReason).operation);
+      }
+    }
+    scopes.push(item.kind === "sync" && transitionalDesired.length > 0 ? {
+      ...planned.scope,
+      desired: desiredGeneration(loaded.state.scopes.find((row) => row.id === item.scope.id), item.frozen.snapshot.revision, item.frozen.snapshot.fingerprint, item.selected.map((selected) => [...planned.scope.desired.packages, ...transitionalDesired].find((row) => row.packageId === selected.plugin.name)), input.validatedAt)
+    } : planned.scope);
+    operations.push(...planned.operations, ...transitional);
   }
   return frozenPlan(input, command, attemptId, scopes, operations, prepared, loaded.state);
 }
@@ -25080,6 +25894,10 @@ async function prepareSync(entry, hosts, state, command, transportSource, transp
     throw error;
   }
   const scope = deploymentScopeForSyncManifestEntry(entry);
+  const recordedScope = state.scopes.find((row) => row.id === scope.id);
+  if (recordedScope?.target.context !== undefined && JSON.stringify(canonicalTargetContext(recordedScope.target.context)) !== JSON.stringify(entry.target.context === undefined ? undefined : canonicalTargetContext(entry.target.context))) {
+    return defect(createLifecycleReason("internal", "internal.invariant", `target context changed for recorded scope '${scope.id}'; use a distinct target instance or retire the recorded scope explicitly`));
+  }
   const pending = pendingDefect(state, scope.id, new Set(selected.map((item) => item.plugin.name)), command);
   if (pending !== null)
     return defect(pending);
@@ -25229,6 +26047,7 @@ async function planSync(item, attemptId, validatedAt, state, command) {
     kind: "planned",
     scope: {
       scope: item.scope,
+      target: item.observation?.target ?? item.entry.target,
       selectorMode: item.entry.selectors === undefined ? "all" : "explicit",
       desired: desiredGeneration(existing, item.frozen.snapshot.revision, item.frozen.snapshot.fingerprint, packages, validatedAt),
       prune: blocks || retirements.operations.some((row) => row.operation.action !== "retire-orphan") ? "blocked" : "planned"
@@ -25308,7 +26127,7 @@ async function planOmissions(item, attemptId, state, desired) {
   return { kind: "omissions", operations };
 }
 async function planRetire(item, attemptId, state) {
-  const activations = state.activations.filter((activation) => activation.scopeId === item.recorded.id).sort((left, right) => left.packageId < right.packageId ? -1 : left.packageId > right.packageId ? 1 : 0);
+  const activations = state.activations.filter((activation) => activation.scopeId === item.recorded.id && (item.retirementPackages === undefined || item.retirementPackages.some((row) => row.packageId === activation.packageId && row.nativeId === activation.nativeId))).sort((left, right) => left.packageId < right.packageId ? -1 : left.packageId > right.packageId ? 1 : 0);
   const operations = [];
   for (const activation of activations) {
     const installation = item.observation?.installations.find((row) => row.nativeId === activation.nativeId);
@@ -25328,8 +26147,10 @@ async function planRetire(item, attemptId, state) {
     kind: "planned",
     scope: {
       scope: item.scope,
+      target: item.observation?.target ?? item.recorded.target,
       selectorMode: "retired",
       desired: null,
+      ...item.retirementPackages === undefined ? {} : { retirementPackages: item.retirementPackages },
       prune: operations.length > 0 && operations.every((row) => row.operation.action === "retire-orphan") ? "planned" : "blocked"
     },
     operations
@@ -25816,7 +26637,7 @@ function lifecycleTarget(target) {
 }
 function sourceSnapshotId(frozen) {
   const binding = frozen.snapshot.binding;
-  return `snapshot-v1-${digest3([
+  return `snapshot-v1-${digest4([
     binding.kind,
     binding.locator,
     binding.kind === "git" ? binding.ref : "",
@@ -25824,20 +26645,20 @@ function sourceSnapshotId(frozen) {
   ])}`;
 }
 function operationIdentity(coverage, scopeId, packageName, nativeId, fingerprint) {
-  return `operation-v1-${digest3([coverage, scopeId, packageName, nativeId, fingerprint])}`;
+  return `operation-v1-${digest4([coverage, scopeId, packageName, nativeId, fingerprint])}`;
 }
 function lifecycleAttemptId(stateGeneration, identities) {
-  return `attempt-v1-${digest3([String(stateGeneration), ...identities.flat()])}`;
+  return `attempt-v1-${digest4([String(stateGeneration), ...identities.flat()])}`;
 }
 function lifecycleAttemptIdForPlannedScopes(stateGeneration, scopes) {
-  return lifecycleAttemptId(stateGeneration, scopes.map((planned) => plannedAttemptIdentity(planned.scope.id, planned.desired?.sourceFingerprint, planned.desired?.packages.map((pkg) => pkg.packageId), planned.selectorMode === "retired" || planned.desired === null)));
+  return lifecycleAttemptId(stateGeneration, scopes.map((planned) => planned.retirementPackages !== undefined ? ["remove-packages", planned.scope.id, ...planned.retirementPackages.flatMap((row) => [row.packageId, row.nativeId])] : plannedAttemptIdentity(planned.scope.id, planned.desired?.sourceFingerprint, planned.desired?.packages.map((pkg) => pkg.packageId), planned.selectorMode === "retired" || planned.desired === null)));
 }
 function plannedAttemptIdentity(scopeId, sourceFingerprint, packageIds, retired = false) {
   if (retired || sourceFingerprint === undefined || packageIds === undefined)
     return ["retire-source", scopeId];
   return ["sync", scopeId, sourceFingerprint, ...packageIds];
 }
-function digest3(parts) {
+function digest4(parts) {
   const hash = new CryptoHasher("sha256");
   for (const part of parts) {
     hash.update(String(part.length));
@@ -26093,8 +26914,9 @@ async function runOperation(plan, operation, hosts, ledger) {
       return succeeded(operation, false);
     case "retire-orphan":
       return runRetire(plan, operation, hosts, ledger);
-    case "route-migrate":
     case "disable-nonconforming":
+      return runDisable(plan, operation, hosts, ledger);
+    case "route-migrate":
     case "retain-prior":
     case "not-attempted":
       return stop(operation, createLifecycleReason("internal", "internal.invariant", `operation '${operation.operationId}' is not applied by this execution slice`));
@@ -26151,12 +26973,19 @@ async function runActivation(plan, operation, hosts, ledger, action) {
     const sealed = await host.adapter.sealActivation(pinned);
     preparation = sealed;
     handle = sealed.handle;
+    ledger.captureOperation(plan, operation, handle);
     ledger.markApplying(plan, operation);
     receipt = await host.adapter.apply(sealed);
     const observation = await host.adapter.readback(receipt.handle);
     verified = host.adapter.verify(receipt.handle, observation);
   } catch (error) {
     const reason = thrownReason(error);
+    if (receipt === undefined && ledger.journalState(plan.attemptId, operation.operationId) === "applying" && error instanceof LifecycleHostPhaseError && !error.mutationStarted) {
+      ledger.markNotApplied(plan, operation);
+      if (preparation !== undefined)
+        await abortPreparation(host, preparation);
+      return stop(operation, reason);
+    }
     if (handle !== undefined && ledger.journalState(plan.attemptId, operation.operationId) === "applying") {
       return recoverApplied(plan, operation, host, ledger, handle, reason);
     }
@@ -26230,7 +27059,7 @@ async function prepareActivation(plan, operation, host, nativeId, action, record
   if (plugin === undefined || packageFingerprint === undefined) {
     return refused(createLifecycleReason("internal", "internal.invariant", `${action} '${operation.package}' is missing from the frozen source`));
   }
-  const target = lifecycleTarget2(operation);
+  const target = lifecycleTarget2(plan, operation);
   const observation = await host.adapter.observeTarget(target);
   const version = await host.adapter.probeVersion(observation.target);
   if (version.kind !== "detected") {
@@ -26314,6 +27143,51 @@ function sealActivationSnapshot(operation, attemptId, nativeId, frozen, plugin,
     throw new Error(`frozen snapshot action '${snapshot.action}' is not ${action}`);
   return snapshot;
 }
+async function runDisable(plan, operation, hosts, ledger) {
+  const host = hosts.find((candidate) => candidate.kinds.includes(operation.scope.target.kind));
+  const reason = plan.report.outcomes.find((row) => row.operationId === operation.operationId)?.reason;
+  if (host === undefined || operation.nativeId === null || reason === undefined || reason === null) {
+    return stop(operation, createLifecycleReason("internal", "internal.invariant", "disable containment lost its adapter, identity or desired failure reason"));
+  }
+  let preparation;
+  let receipt;
+  try {
+    const prepared = await prepareOwnedMutation(plan, operation, host, operation.nativeId, ledger, "disable");
+    if (prepared.kind === "refused")
+      return stop(operation, prepared.reason);
+    if (prepared.selection.operation !== "disable")
+      throw new Error("disable containment selected the wrong operation");
+    ledger.acceptJournal(plan, operation, "disable-nonconforming");
+    preparation = await host.adapter.prepareDisable({ operationId: operation.operationId, attemptId: plan.attemptId, selection: { ...prepared.selection, operation: "disable" }, activation: prepared.activation });
+    ledger.captureOperation(plan, operation, preparation.handle);
+    ledger.markApplying(plan, operation);
+    receipt = await host.adapter.disable(preparation);
+    const observation = await host.adapter.readback(receipt.handle);
+    const verified = host.adapter.verify(receipt.handle, observation);
+    ledger.confirmDisable(plan, operation);
+    try {
+      await host.adapter.cleanup(verified.handle, "verified-commit");
+    } catch {
+      ledger.markCleanupPending(plan, operation, "disable-nonconforming");
+      return pendingCleanup(operation);
+    }
+    ledger.completeContainment(plan, operation);
+    return { stop: true, reason, outcome: { ...operation, result: "failed", resourceState: "retained", activationState: "inactive", changed: receipt.changed, reason } };
+  } catch (error) {
+    const failure = thrownReason(error);
+    if (receipt === undefined && error instanceof LifecycleHostPhaseError && !error.mutationStarted) {
+      if (ledger.journalState(plan.attemptId, operation.operationId) !== undefined)
+        ledger.markNotApplied(plan, operation);
+      if (preparation !== undefined)
+        await abortPreparation(host, preparation);
+      return stop(operation, failure);
+    }
+    if (preparation !== undefined && (receipt !== undefined || ledger.journalState(plan.attemptId, operation.operationId) === "applying")) {
+      return recoverApplied(plan, operation, host, ledger, preparation.handle, failure);
+    }
+    return stop(operation, failure);
+  }
+}
 async function runRetire(plan, operation, hosts, ledger) {
   if (ledger.journalState(plan.attemptId, operation.operationId) === "completed")
     return retired(operation, false);
@@ -26331,17 +27205,20 @@ async function runRetire(plan, operation, hosts, ledger) {
   }
   let prepared;
   try {
-    prepared = await prepareRetirement(plan, operation, host, nativeId, ledger);
+    prepared = await prepareOwnedMutation(plan, operation, host, nativeId, ledger);
   } catch (error) {
     return stop(operation, thrownReason(error));
   }
   if (prepared.kind === "refused")
     return stop(operation, prepared.reason);
+  if (prepared.selection.operation !== "retire")
+    return stop(operation, createLifecycleReason("internal", "internal.invariant", "retirement selected the wrong operation"));
   try {
     ledger.acceptJournal(plan, operation, "retire-orphan");
   } catch (error) {
     return stop(operation, thrownReason(error));
   }
+  let preparation;
   let receipt;
   let verified;
   try {
@@ -26349,17 +27226,30 @@ async function runRetire(plan, operation, hosts, ledger) {
       operationId: operation.operationId,
       attemptId: plan.attemptId,
       action: "retire-orphan",
-      selection: prepared.selection,
+      selection: { ...prepared.selection, operation: "retire" },
       activation: prepared.activation
     });
+    preparation = sealed;
+    ledger.captureOperation(plan, operation, sealed.handle);
     ledger.markPruning(plan, operation);
     receipt = await host.adapter.retire(sealed);
     const observation = await host.adapter.readback(receipt.handle);
     verified = host.adapter.verify(receipt.handle, observation);
   } catch (error) {
     const reason = thrownReason(error);
+    if (receipt === undefined && ledger.journalState(plan.attemptId, operation.operationId) === "applying" && error instanceof LifecycleHostPhaseError && !error.mutationStarted) {
+      ledger.markNotApplied(plan, operation);
+      if (preparation !== undefined)
+        await abortPreparation(host, preparation);
+      return stop(operation, reason);
+    }
     if (receipt !== undefined)
       return recoverApplied(plan, operation, host, ledger, receipt.handle, reason);
+    if (preparation !== undefined && ledger.journalState(plan.attemptId, operation.operationId) === "applying") {
+      return recoverApplied(plan, operation, host, ledger, preparation.handle, reason);
+    }
+    if (preparation === undefined)
+      ledger.markNotApplied(plan, operation);
     return stop(operation, reason);
   }
   if (receipt === undefined || verified === undefined) {
@@ -26379,12 +27269,13 @@ async function runRetire(plan, operation, hosts, ledger) {
   ledger.markCompleted(plan, operation);
   return retired(operation, receipt.changed);
 }
-async function prepareRetirement(plan, operation, host, nativeId, ledger) {
+async function prepareOwnedMutation(plan, operation, host, nativeId, ledger, capabilityOperation = "retire") {
+  const operationLabel = capabilityOperation === "disable" ? "disablement" : "retirement";
   const recorded = ledger.activation(operation.scope.id, operation.package, nativeId);
   if (recorded === undefined || recorded.route.kind === "legacy-unverified" || recorded.ownership.kind === "legacy-claim" || recorded.sourceRevision === undefined) {
     return refused(createLifecycleReason("internal", "internal.invariant", `ownership of '${operation.package}' was not revalidated`));
   }
-  const target = lifecycleTarget2(operation);
+  const target = lifecycleTarget2(plan, operation);
   const observation = await host.adapter.observeTarget(target);
   const installation = observation.installations.find((row) => row.nativeId === nativeId);
   if (installation === undefined || installation.presence !== "present" || installation.ownership.kind !== "owned" || installation.ownership.scopeId !== operation.scope.id) {
@@ -26392,10 +27283,10 @@ async function prepareRetirement(plan, operation, host, nativeId, ledger) {
   }
   const version = await host.adapter.probeVersion(observation.target);
   if (version.kind !== "detected") {
-    return refused(createLifecycleReason("runtime", "runtime.operation-failed", `retirement '${operation.package}' lost its detected target version`));
+    return refused(createLifecycleReason("runtime", "runtime.operation-failed", `${operationLabel} '${operation.package}' lost its detected target version`));
   }
   if (recorded.fingerprints.installed !== installation.installedFingerprint) {
-    return refused(createLifecycleReason("internal", "internal.invariant", `retirement '${operation.package}' fingerprint does not match the owned install`));
+    return refused(createLifecycleReason("internal", "internal.invariant", `${operationLabel} '${operation.package}' fingerprint does not match the owned install`));
   }
   const owned = ownedActivation(operation.scope, operation.scope.source, recorded, installation, observation.target);
   if (owned === null) {
@@ -26404,27 +27295,27 @@ async function prepareRetirement(plan, operation, host, nativeId, ledger) {
   const planCoverage = createLifecyclePlanCoverage(observation, [{
     nativeId,
     operationId: operation.operationId,
-    operation: "retire",
+    operation: capabilityOperation,
     mutationGroupId: operation.operationId,
     authorization: "observed-owned"
   }]);
   const nativeScope = await host.adapter.observeNativeMutationScope({
     targetObservation: observation,
-    operation: "retire",
+    operation: capabilityOperation,
     packageName: owned.packageName,
     nativeId,
     sourceType: owned.sourceType
   });
   const nativeProjection = await host.adapter.observeNativeProjection({
     targetObservation: observation,
-    operation: "retire",
+    operation: capabilityOperation,
     operationId: operation.operationId,
     attemptId: plan.attemptId,
     activation: owned
   });
   const decision = host.adapter.decideRoute({
     target: observation.target,
-    operation: "retire",
+    operation: capabilityOperation,
     operationId: operation.operationId,
     attemptId: plan.attemptId,
     scopeId: operation.scope.id,
@@ -26438,13 +27329,13 @@ async function prepareRetirement(plan, operation, host, nativeId, ledger) {
     planCoverage,
     activation: owned
   });
-  if (decision.kind !== "selected" || decision.operation !== "retire" || decision.route !== operation.route) {
-    return refused(createLifecycleReason("runtime", "runtime.operation-failed", `retirement '${operation.package}' kept frozen route '${operation.route}'`));
+  if (decision.kind !== "selected" || decision.operation !== capabilityOperation || decision.route !== operation.route) {
+    return refused(createLifecycleReason("runtime", "runtime.operation-failed", `${operationLabel} '${operation.package}' kept frozen route '${operation.route}'`));
   }
   return { kind: "ready", selection: decision, activation: owned, recorded };
 }
-function lifecycleTarget2(operation) {
-  return { kind: operation.scope.target.kind, instance: operation.scope.target.instance };
+function lifecycleTarget2(plan, operation) {
+  return plan.scopes.find((row) => row.scope.id === operation.scope.id)?.target ?? { kind: operation.scope.target.kind, instance: operation.scope.target.instance };
 }
 
 class Ledger {
@@ -26505,8 +27396,22 @@ class Ledger {
     return this.state.activations.find((row) => row.scopeId === scopeId && row.packageId === packageId && row.nativeId === nativeId);
   }
   markApplying(plan, operation) {
+    if (operation.action === "disable-nonconforming")
+      this.disablePending(plan, operation, "applying");
     this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "applying", "applying", true));
   }
+  captureOperation(plan, operation, handle) {
+    const sealedOperation = parseSerializedLifecycleOperation(JSON.parse(JSON.stringify(handle)));
+    this.replaceAttempt(plan, (attempt) => ({ ...attempt, journal: attempt.journal.map((row) => row.operationId === operation.operationId ? { ...row, sealedOperation } : row) }));
+  }
+  markNotApplied(plan, operation) {
+    if (operation.action === "disable-nonconforming")
+      this.clearDisablePending(operation);
+    this.replaceAttempt(plan, (attempt) => {
+      const next = this.journaled(attempt, operation.operationId, "not-attempted", "failed", false);
+      return { ...next, mutationStarted: next.journal.some((row) => mutationBegan(row.state)) };
+    });
+  }
   markPruning(plan, operation) {
     this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "applying", "pruning", true));
   }
@@ -26570,13 +27475,42 @@ class Ledger {
   }
   markRolledBack(plan, operation) {
     this.adoptMovedGeneration();
+    if (operation.action === "disable-nonconforming")
+      this.clearDisablePending(operation, true);
+    this.clearPending(operation);
     this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "rolled-back", "failed", true));
   }
+  markRollbackVerified(plan, operation) {
+    this.adoptMovedGeneration();
+    this.state = { ...this.state, activations: this.state.activations.map((row) => row.scopeId === operation.scope.id && row.packageId === operation.package ? { ...row, pending: { operation: operation.action, phase: "cleanup", attemptId: plan.attemptId, startedAt: this.now }, readbackState: "verified" } : row) };
+    this.replaceAttempt(plan, (attempt) => ({ ...this.journaled(attempt, operation.operationId, "cleanup-pending", "finalizing", true), journal: attempt.journal.map((row) => row.operationId === operation.operationId ? { ...row, state: "cleanup-pending", settlement: "rollback", updatedAt: this.now } : row) }));
+  }
+  confirmDisable(plan, operation) {
+    this.clearDisablePending(operation);
+    this.state = { ...this.state, activations: this.state.activations.map((row) => row.scopeId === operation.scope.id && row.packageId === operation.package ? { ...row, activationState: "inactive", readbackState: "verified", readbackAt: this.now, updatedAt: this.now } : row) };
+    this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "readback-verified", "readback", true));
+  }
+  completeContainment(plan, operation) {
+    this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "completed", "failed", true));
+  }
   markRollbackRequired(plan, operation) {
     this.adoptMovedGeneration();
     this.retargetBareAlias(plan, operation);
+    if (operation.action === "disable-nonconforming")
+      this.disablePending(plan, operation, "rollback");
     this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "rollback", "recovery-required", true));
   }
+  disablePending(plan, operation, phase) {
+    this.state = { ...this.state, activations: this.state.activations.map((row) => row.scopeId === operation.scope.id && row.packageId === operation.package ? { ...row, pending: { operation: "disable-nonconforming", phase, attemptId: plan.attemptId, startedAt: this.now } } : row) };
+  }
+  clearDisablePending(operation, rolledBack = false) {
+    this.state = { ...this.state, activations: this.state.activations.map((row) => {
+      if (row.scopeId !== operation.scope.id || row.packageId !== operation.package)
+        return row;
+      const { pending: _pending, ...prior } = row;
+      return rolledBack ? { ...prior, activationState: "nonconforming", readbackState: "unverified" } : prior;
+    }) };
+  }
   markCompleted(plan, operation) {
     const desiredPairs = plan.operations.filter((row) => row.operation.scope.id === operation.scope.id && row.operation.coverage === "desired-pair");
     const converged = desiredPairs.every((row) => row.operation.operationId === operation.operationId || row.operation.action === "unchanged" || this.journalState(plan.attemptId, row.operation.operationId) === "completed");
@@ -26595,7 +27529,13 @@ class Ledger {
     if (scope.authority !== "authoritative")
       return scope;
     const planned = plan.scopes.find((row) => row.scope.id === scope.id);
+    if (planned?.retirementPackages !== undefined)
+      return scope;
     if (planned?.selectorMode === "retired") {
+      if (this.state.activations.some((row) => row.scopeId === scope.id))
+        return scope;
+      if (plan.operations.some((row) => row.operation.scope.id === scope.id && row.operation.operationId !== operation.operationId && this.journalState(plan.attemptId, row.operation.operationId) !== "completed"))
+        return scope;
       const { desired: _desired, lastConverged: _converged, ...kept } = scope;
       return {
         ...kept,
@@ -26663,7 +27603,7 @@ class Ledger {
     if (existing !== undefined && existing.authority !== "authoritative")
       return existing;
     const selectorMode = planned.selectorMode;
-    const target = { kind: planned.scope.target.kind, instance: planned.scope.target.instance };
+    const target = planned.target ?? { kind: planned.scope.target.kind, instance: planned.scope.target.instance };
     if (existing === undefined) {
       return {
         id: planned.scope.id,
@@ -26829,19 +27769,44 @@ function succeeded(operation, changed, notices = []) {
   };
 }
 async function recoverApplied(plan, operation, host, ledger, handle, reason) {
+  let verified = false;
+  let diagnostic = "";
   try {
-    await host.adapter.rollback(handle);
-    const observation = await host.adapter.readback(handle);
-    host.adapter.verifyRollback(handle, observation);
-  } catch {
-    ledger.markRollbackRequired(plan, operation);
-    return pendingRecovery(operation);
+    try {
+      await host.adapter.rollback(handle);
+      const observation = await host.adapter.readback(handle);
+      host.adapter.verifyRollback(handle, observation);
+      verified = true;
+    } catch (error) {
+      diagnostic = `; rollback verification failed: ${unknownErrorDiagnostic(error)}`;
+    }
+    try {
+      if (verified)
+        ledger.markRollbackVerified(plan, operation);
+      else
+        ledger.markRollbackRequired(plan, operation);
+    } catch (error) {
+      verified = false;
+      diagnostic += `; recovery ledger could not be persisted: ${unknownErrorDiagnostic(error)}`;
+    }
+    if (verified) {
+      try {
+        await host.adapter.cleanup(handle, "verified-rollback");
+        ledger.markRolledBack(plan, operation);
+      } catch (error) {
+        verified = false;
+        diagnostic += `; rollback cleanup remains pending: ${unknownErrorDiagnostic(error)}`;
+      }
+    }
+  } finally {
+    try {
+      await host.adapter.releaseRecovery(handle);
+    } catch (error) {
+      verified = false;
+      diagnostic += `; recovery resources could not be released: ${unknownErrorDiagnostic(error)}`;
+    }
   }
-  ledger.markRolledBack(plan, operation);
-  try {
-    await host.adapter.cleanup(handle, "verified-rollback");
-  } catch {}
-  return reportedRollback(operation, reason);
+  return verified ? reportedRollback(operation, reason) : pendingRecovery(operation, `; original failure: ${reason.diagnostic}${diagnostic}`);
 }
 async function abortPreparation(host, preparation) {
   try {
@@ -26869,8 +27834,8 @@ function pendingReadback(operation, reason) {
     }
   };
 }
-function pendingRecovery(operation) {
-  const reason = createLifecycleReason("recovery", "recovery.required", `rollback for '${operation.operationId}' did not verify`);
+function pendingRecovery(operation, diagnostic = "") {
+  const reason = createLifecycleReason("recovery", "recovery.required", `rollback for '${operation.operationId}' did not verify${diagnostic}`);
   return {
     stop: true,
     reason,
@@ -26906,8 +27871,8 @@ function pendingCleanup(operation) {
     outcome: {
       ...operation,
       result: "pending",
-      resourceState: "present",
-      activationState: "active-conforming",
+      resourceState: operation.action === "disable-nonconforming" ? "retained" : "present",
+      activationState: operation.action === "disable-nonconforming" ? "inactive" : "active-conforming",
       changed: true,
       reason
     }
@@ -26986,7 +27951,7 @@ function summaryFor(outcomes) {
   const failed = outcomes.find((outcome) => outcome.result !== "succeeded");
   const changed = outcomes.some((outcome) => outcome.changed);
   const pending = outcomes.find((outcome) => outcome.result === "pending");
-  const readback = outcomes.find((outcome) => outcome.reason?.category === "readback");
+  const readback = outcomes.find((outcome) => outcome.reason?.category === "readback" || outcome.action === "disable-nonconforming" && outcome.changed);
   const reapplied = outcomes.some((outcome) => outcome.result === "succeeded" && outcome.action === "update");
   const mutationStarted = changed || pending !== undefined || reapplied;
   if (failed === undefined) {
@@ -27072,16 +28037,186 @@ function absolutePinExecutable(command) {
   return resolve22(found);
 }
 
+// src/lifecycle-recovery.ts
+var OPEN = new Set(["pending", "applying", "applied", "readback-verified", "rollback", "cleanup-pending"]);
+async function recoverLifecycleJournals(plan, hosts, now) {
+  let state = readLifecycleState().state;
+  const scopeIds = new Set(plan.scopes.map((row) => row.scope.id));
+  const journals = state.attempts.filter((attempt) => attempt.command !== "legacy-recovery").flatMap((attempt) => attempt.journal.filter((row) => scopeIds.has(row.scopeId) && OPEN.has(row.state)).map((row) => ({ attempt, row })));
+  if (journals.length === 0)
+    return false;
+  const incompatible = journals.find(({ attempt }) => attempt.command !== plan.report.command.name);
+  if (incompatible !== undefined)
+    return {
+      operation: null,
+      changed: false,
+      settled: [],
+      reason: createLifecycleReason("internal", "internal.invariant", `pending operation '${incompatible.row.operationId}' belongs to '${incompatible.attempt.command}' attempt '${incompatible.attempt.id}'; cross-verb recovery is unverified. Retry the original '${incompatible.attempt.command}' command for scope '${incompatible.row.scopeId}' before '${plan.report.command.name}'. Pending proof and native state were retained.`)
+    };
+  let pending = journals[0].row;
+  let changed = false;
+  const settled = [];
+  const operationFor = (row) => ({
+    operationId: row.operationId,
+    scope: plan.scopes.find((scope) => scope.scope.id === row.scopeId).scope,
+    sourceSnapshotId: null,
+    package: row.packageId ?? "unknown",
+    nativeId: row.nativeId ?? null,
+    coverage: row.action === "retire-orphan" || row.action === "remove" ? "retirement" : "desired-pair",
+    action: row.action === "remove" ? "retire-orphan" : row.action,
+    route: row.route?.kind === "native" ? "native" : "managed"
+  });
+  try {
+    for (const source of plan.frozenSources.values())
+      if (fingerprintTree(source.snapshotDir) !== source.snapshot.fingerprint)
+        throw new Error("retained Source drifted before recovery");
+    const prepared = journals.map(({ attempt, row }) => {
+      if (row.state === "pending" && row.sealedOperation === undefined)
+        return { row, attemptId: attempt.id, handle: null, host: null };
+      if (row.sealedOperation === undefined)
+        throw new Error(`journal '${row.operationId}' has no durable sealed operation; recovery remains unverified`);
+      const handle = hydrateDurableLifecycleOperation(row.sealedOperation);
+      const scope = state.scopes.find((scope) => scope.id === row.scopeId);
+      if (handle.attemptId !== attempt.id || handle.target.kind !== scope?.target.kind || handle.target.instance !== scope.target.instance || canonicalTargetContextBytes(handle.target.context) !== canonicalTargetContextBytes(scope.target.context))
+        throw new Error("recovery target/attempt differs from recorded authority");
+      const host = hosts.find((host) => host.adapter.id === handle.adapterId && host.kinds.includes(handle.target.kind));
+      if (host === undefined)
+        throw new Error(`recovery adapter '${handle.adapterId}' is unavailable`);
+      return { row, attemptId: attempt.id, handle, host };
+    });
+    const persist = (row, settled, finished) => {
+      if (readLifecycleState().state.stateGeneration !== state.stateGeneration)
+        throw new Error("recovery ledger changed concurrently; refusing stale commit");
+      const next = {
+        ...state,
+        stateGeneration: state.stateGeneration + 1,
+        activations: state.activations.map((activation) => {
+          if (activation.scopeId !== row.scopeId || activation.nativeId !== row.nativeId || activation.packageId !== row.packageId)
+            return activation;
+          const { pending: _pending, ...kept } = activation;
+          return finished ? { ...kept, readbackState: "verified", readbackAt: now, updatedAt: now } : { ...kept, pending: { operation: row.action, phase: "cleanup", attemptId: row.sealedOperation.attemptId, startedAt: now }, readbackState: "verified" };
+        }),
+        attempts: state.attempts.map((attempt) => {
+          if (attempt.id !== row.sealedOperation.attemptId)
+            return attempt;
+          const journal = attempt.journal.map((entry) => entry.operationId === row.operationId ? { ...entry, state: finished ? settled === "rollback" ? "rolled-back" : "completed" : "cleanup-pending", settlement: settled, updatedAt: now } : entry);
+          const unresolved = journal.some((entry) => OPEN.has(entry.state));
+          const failed = journal.some((entry) => entry.state === "rolled-back" || entry.state === "failed" || entry.state === "not-attempted" || entry.action === "disable-nonconforming");
+          return { ...attempt, phase: unresolved ? "finalizing" : failed ? "failed" : "completed", ...!unresolved && !failed ? { completedAt: now } : {}, updatedAt: now, journal };
+        })
+      };
+      if (finished && settled === "commit")
+        next.scopes = next.scopes.map((scope) => {
+          const requested = plan.scopes.find((item) => item.scope.id === scope.id);
+          if (scope.id !== row.scopeId || requested?.selectorMode !== "retired" || requested.retirementPackages !== undefined || next.activations.some((activation) => activation.scopeId === scope.id) || next.attempts.some((attempt) => attempt.journal.some((entry) => entry.scopeId === scope.id && OPEN.has(entry.state))))
+            return scope;
+          const { desired: _desired, lastConverged: _converged, ...kept } = scope;
+          return { ...kept, lifecycle: "retired", selectorMode: "retired", retiredAt: now, updatedAt: now };
+        });
+      writeLifecycleState(next, { globalPreflight: "succeeded" });
+      state = next;
+    };
+    for (const { row, attemptId, handle, host } of prepared) {
+      pending = row;
+      changed = false;
+      if (handle === null || host === null) {
+        if (readLifecycleState().state.stateGeneration !== state.stateGeneration)
+          throw new Error("recovery ledger changed concurrently; refusing stale accepted-intent settlement");
+        const next = {
+          ...state,
+          stateGeneration: state.stateGeneration + 1,
+          activations: state.activations.map((activation) => {
+            if (activation.pending?.attemptId !== attemptId || activation.scopeId !== row.scopeId || activation.packageId !== row.packageId || activation.nativeId !== row.nativeId)
+              return activation;
+            const { pending: _pending, ...kept } = activation;
+            return { ...kept, readbackState: activation.readbackState === "pending" ? "unverified" : activation.readbackState, updatedAt: now };
+          }),
+          attempts: state.attempts.map((attempt) => attempt.id !== attemptId ? attempt : { ...attempt, phase: "failed", updatedAt: now, journal: attempt.journal.map((entry) => entry.operationId !== row.operationId ? entry : { ...entry, state: "not-attempted", updatedAt: now }) })
+        };
+        writeLifecycleState(next, { globalPreflight: "succeeded" });
+        state = next;
+        settled.push({
+          ...operationFor(row),
+          action: "not-attempted",
+          route: "none",
+          result: "not-attempted",
+          resourceState: "unknown",
+          activationState: "unknown",
+          changed: false,
+          reason: createLifecycleReason("runtime", "runtime.operation-failed", `original accepted operation '${row.operationId}' settled without native apply; unsealed preparation remains retained`)
+        });
+        continue;
+      }
+      let receipt;
+      try {
+        const observed = await host.adapter.beginRecovery(handle);
+        const committed = row.settlement === "commit" || row.settlement === undefined && (row.state === "readback-verified" || row.state === "cleanup-pending");
+        let verifiedObservation = observed.observation;
+        if (committed) {
+          if (observed.kind !== "expected")
+            throw new Error("committed recovery candidate changed; refusing stale cleanup");
+        } else {
+          if (row.settlement !== "rollback")
+            changed = (await host.adapter.rollback(handle)).changed;
+          verifiedObservation = await host.adapter.readback(handle);
+          host.adapter.verifyRollback(handle, verifiedObservation);
+        }
+        const settlement = committed ? "commit" : "rollback";
+        persist(row, settlement, false);
+        await host.adapter.cleanup(handle, committed ? "verified-commit" : "verified-rollback");
+        persist(row, settlement, true);
+        const retired = committed && (row.action === "retire-orphan" || row.action === "remove");
+        receipt = {
+          ...operationFor(row),
+          result: retired ? "succeeded" : "failed",
+          resourceState: verifiedObservation.presence === "absent" ? "absent" : committed ? "present" : "retained",
+          activationState: verifiedObservation.presence === "absent" || verifiedObservation.activation === "inactive" ? "inactive" : verifiedObservation.activation === "active" ? "retained-prior" : "unknown",
+          changed,
+          reason: retired ? null : createLifecycleReason("runtime", "runtime.operation-failed", `original operation '${row.operationId}' settled by verified ${settlement}; current Desired has not been attempted`)
+        };
+      } finally {
+        await host.adapter.releaseRecovery(handle);
+      }
+      settled.push(receipt);
+    }
+    return true;
+  } catch (error) {
+    return { changed, settled, reason: createLifecycleReason("recovery", "recovery.required", `cross-process recovery of operation '${pending.operationId}' remains pending: ${unknownErrorDiagnostic(error)}`), operation: operationFor(pending) };
+  }
+}
+
 // src/lifecycle-command.ts
 async function runFrozenLifecycle(command) {
-  const plan = await planLifecycle({
+  const retainedSources = new Map;
+  const input = {
     manifest: command.manifest,
     dryRun: command.dryRun,
     validatedAt: command.now,
     hosts: command.hosts,
     ...command.command === undefined ? {} : { command: command.command },
-    ...command.transportSource === undefined ? {} : { transportSource: command.transportSource }
-  });
+    ...command.transportSource === undefined ? {} : { transportSource: command.transportSource },
+    ...command.removalSelection === undefined ? {} : { removalSelection: command.removalSelection },
+    retainedSources
+  };
+  let plan = await planLifecycle({ ...input, recoveryPreflight: !command.dryRun });
+  if (!command.dryRun && plan.kind === "frozen") {
+    const recovery = await recoverLifecycleJournals(plan, command.hosts, command.now);
+    if (typeof recovery !== "boolean") {
+      const { reason, operation, changed, settled } = recovery;
+      const blocked = createLifecycleReason("runtime", "runtime.operation-failed", `not attempted while recovery remains unresolved: ${reason.diagnostic}`);
+      const operations = plan.report.plan.filter((row) => ![...settled, ...operation === null ? [] : [operation]].some((recovered) => row.scope.id === recovered.scope.id && row.package === recovered.package && row.nativeId === recovered.nativeId && row.coverage === recovered.coverage)).map((row) => row.action === "retain-prior" ? { ...row, action: "not-attempted", route: "none" } : row);
+      const outcomes = operations.map((row) => ({ ...row, result: "not-attempted", resourceState: "unknown", activationState: "unknown", changed: false, reason: operation === null ? reason : blocked }));
+      if (operation === null) {
+        const report = parseLifecycleReport({ ...plan.report, plan: operations, outcomes, summary: { result: "incomplete", terminalPhase: "preflight", mutationStarted: false, changed: false, failureCategory: reason.category, reason, recoveryId: null, readbackId: null } });
+        return { report, exitCode: exitCodeForLifecycleReport(report) };
+      }
+      const recoveredOutcomes = [{ ...operation, result: "pending", resourceState: changed ? "potentially-changed" : "unknown", activationState: "unknown", changed, reason }, ...settled];
+      const report = parseLifecycleReport({ ...plan.report, plan: [operation, ...settled.map(({ result: _result, resourceState: _resource, activationState: _activation, changed: _changed, reason: _reason, ...row }) => row), ...operations], outcomes: [...recoveredOutcomes, ...outcomes], summary: { result: "incomplete", terminalPhase: "finalize", mutationStarted: true, changed: recoveredOutcomes.some((row) => row.changed), failureCategory: "recovery", reason, recoveryId: operation.operationId, readbackId: recoveredOutcomes.find((row) => row.changed && row.action === "disable-nonconforming")?.operationId ?? null } });
+      return { report, exitCode: exitCodeForLifecycleReport(report) };
+    }
+    if (recovery)
+      plan = await planLifecycle(input);
+  }
   const executed = await executeLifecycle({
     plan,
     hosts: command.hosts,
@@ -27103,6 +28238,7 @@ function plannerHost(kind, adapter, plannedNativeId, announceDryRun) {
 var lifecyclePlannerHostKinds = [
   "claude-code",
   "codex",
+  "dcode",
   "kimi",
   "cursor",
   "omp",
@@ -27114,6 +28250,7 @@ function createLifecyclePlannerHosts() {
   return [
     plannerHost("claude-code", createClaudeCodeLifecycleHost(), claudeCodeWriter.plannedNativeId),
     plannerHost("codex", codexLifecycle, codexWriter.plannedNativeId),
+    plannerHost("dcode", dcodeLifecycle, dcodeWriter.plannedNativeId),
     plannerHost("kimi", createLifecycleHostAdapter(kimiLifecycle), kimiWriter.plannedNativeId),
     plannerHost("cursor", cursorManagedLifecycle, cursorWriter.plannedNativeId, announceCursorDryRun),
     plannerHost("omp", ompLifecycle, ompWriter.plannedNativeId),
@@ -27123,6 +28260,164 @@ function createLifecyclePlannerHosts() {
   ];
 }
 
+// src/pin-lifecycle.ts
+import { cpSync as cpSync13, mkdtempSync as mkdtempSync14, rmSync as rmSync15 } from "node:fs";
+import { tmpdir as tmpdir12 } from "node:os";
+import { basename as basename9, join as join35, relative as relative8 } from "node:path";
+async function runOfflineLifecyclePin(host, plugin, dryRun) {
+  const adapter = host.lifecyclePinAdapter;
+  if (adapter === undefined || plugin.path === undefined)
+    throw new Error("offline lifecycle pin has no adapter or active root");
+  let state = readLifecycleState().state;
+  const matches = state.activations.filter((row) => row.nativeId === plugin.id && state.scopes.some((scope) => scope.id === row.scopeId && scope.target.kind === host.id));
+  if (matches.length !== 1)
+    throw new Error("offline lifecycle pin requires one recorded owned activation");
+  const activation = matches[0];
+  const scope = state.scopes.find((row) => row.id === activation.scopeId);
+  if (activation.ownership.kind === "legacy-claim" || activation.route.kind === "legacy-unverified" || activation.sourceRevision === undefined || activation.pending !== undefined)
+    throw new Error("offline lifecycle pin requires verified ownership with no pending recovery");
+  if (activation.activationState !== "active" || activation.readbackState !== "verified")
+    throw new Error("offline lifecycle pin requires a verified active installation");
+  const preview = await host.pin(plugin, { dryRun: true });
+  if (preview.refusals.length !== 0)
+    return { changes: [], refusals: preview.refusals };
+  if (preview.changes.length === 0)
+    return preview;
+  const now = new Date().toISOString();
+  const frozenRoot = mkdtempSync14(join35(tmpdir12(), "plgnz-offline-pin-"));
+  const attemptId = `pin-${basename9(frozenRoot)}`;
+  const operationId = `${attemptId}:${plugin.id}`;
+  let handle;
+  let preparation;
+  let accepted = false, applying = false, committed = false;
+  const attempt = { id: attemptId, command: "update", phase: "accepted", mutationStarted: false, scopeIds: [scope.id], journal: [{ operationId, scopeId: scope.id, packageId: activation.packageId, nativeId: activation.nativeId, action: "update", state: "pending", route: activation.route, startedAt: now, updatedAt: now }], startedAt: now, updatedAt: now };
+  const persist = (nextActivation) => {
+    if (readLifecycleState().state.stateGeneration !== state.stateGeneration)
+      throw new Error("pin ledger changed concurrently; refusing stale commit");
+    const next = { ...state, stateGeneration: state.stateGeneration + 1, activations: state.activations.map((row) => row.scopeId === activation.scopeId && row.nativeId === activation.nativeId ? nextActivation : row), attempts: [...state.attempts.filter((row) => row.id !== attemptId), { ...attempt, journal: attempt.journal.map((row) => ({ ...row })) }] };
+    writeLifecycleState(next, { globalPreflight: "succeeded" });
+    state = next;
+  };
+  const pending = (phase) => persist({ ...activation, pending: { operation: "update", phase, attemptId, startedAt: now }, readbackState: "pending" });
+  try {
+    cpSync13(plugin.path, frozenRoot, { recursive: true });
+    const packageFingerprint = fingerprintTree(frozenRoot);
+    if (packageFingerprint !== activation.fingerprints.installed)
+      throw new Error("pin active bytes differ from recorded readback");
+    const target = { kind: scope.target.kind, instance: scope.target.instance };
+    const observed = await adapter.observeTarget(target);
+    const installed = observed.installations.find((row) => row.nativeId === plugin.id);
+    if (installed?.ownership.kind !== "owned" || installed.ownership.scopeId !== scope.id || installed.installedFingerprint !== packageFingerprint || installed.enablement !== "enabled")
+      throw new Error("pin native identity or bytes differ from the recorded owned activation");
+    const version = await adapter.probeVersion(target);
+    const sourceType = scope.source.kind;
+    const inventory = inventoryPackageSemantics({ dir: frozenRoot, name: activation.packageId, ...plugin.version === undefined ? {} : { version: plugin.version }, contentFingerprint: packageFingerprint });
+    const snapshot = createFrozenPackageSnapshot({ operationId, attemptId, scopeId: scope.id, target, action: "update", packageName: activation.packageId, nativeId: plugin.id, sourceType, immutableRevision: activation.sourceRevision, snapshotRoot: frozenRoot, packageRoot: frozenRoot, relativePackagePath: ".", snapshotFingerprint: packageFingerprint, packageFingerprint, ...sourceType === "git" ? { nativeGit: { locator: scope.source.locator, resolvedRevision: activation.sourceRevision } } : {}, inventory });
+    const pins = createResolvedLifecyclePins(preview.changes.map((change) => ({ server: change.server, executable: change.to })).sort((left, right) => left.server < right.server ? -1 : left.server > right.server ? 1 : 0));
+    const nativeScope = await adapter.observeNativeMutationScope({ targetObservation: observed, operation: "update", packageName: activation.packageId, nativeId: plugin.id, sourceType });
+    const nativeProjection = await adapter.observeNativeProjection({ targetObservation: observed, operation: "update", snapshot, pins });
+    const selection = adapter.decideRoute({ target, operationId, attemptId, scopeId: scope.id, packageName: activation.packageId, nativeId: plugin.id, version, sourceType, targetObservation: observed, nativeScope, nativeProjection, planCoverage: createLifecyclePlanCoverage(observed, [{ nativeId: plugin.id, operationId, operation: "update", mutationGroupId: operationId, authorization: "observed-owned" }]), operation: "update", snapshot, pins });
+    if (selection.kind !== "selected")
+      throw new Error(`pin capability ${selection.status}: ${selection.gaps.map((gap) => gap.capabilityId).join(", ")}`);
+    if (selection.route !== "managed")
+      throw new Error("offline lifecycle pin requires a frozen Managed projection");
+    if (dryRun)
+      return preview;
+    pending("accepted");
+    accepted = true;
+    preparation = await adapter.stageActivation({ selection, snapshot, pins });
+    preparation = await adapter.applyLifecycleDirectives(preparation);
+    preparation = await adapter.applyPins(preparation);
+    const sealed = await adapter.sealActivation(preparation);
+    preparation = sealed;
+    handle = sealed.handle;
+    attempt.journal[0].sealedOperation = parseSerializedLifecycleOperation(JSON.parse(JSON.stringify(handle)));
+    attempt.phase = "applying";
+    attempt.mutationStarted = true;
+    attempt.journal[0].state = "applying";
+    pending("applying");
+    applying = true;
+    await adapter.apply(sealed);
+    const observation = await adapter.readback(handle);
+    adapter.verify(handle, observation);
+    if (observation.installedFingerprint === null || handle.projectedFingerprint === null)
+      throw new Error("pin readback lacks exact installed/projected fingerprint");
+    attempt.phase = "finalizing";
+    attempt.journal[0].state = "readback-verified";
+    attempt.journal[0].settlement = "commit";
+    const pinnedActivation = { ...activation, route: { kind: handle.route, evidenceKey: { kind: "capability-profile", key: handle.evidenceId } }, fingerprints: { ...activation.fingerprints, projected: handle.projectedFingerprint, installed: observation.installedFingerprint }, pins: [...new Set([...activation.pins, ...pins.map((pin) => pin.server)])].sort(), readbackState: "verified", readbackAt: now, updatedAt: now };
+    persist(pinnedActivation);
+    committed = true;
+    try {
+      await adapter.cleanup(handle, "verified-commit");
+    } catch (error) {
+      attempt.journal[0].state = "cleanup-pending";
+      persist({ ...pinnedActivation, pending: { operation: "update", phase: "cleanup", attemptId, startedAt: now } });
+      await adapter.releaseRecovery(handle);
+      throw error;
+    }
+    attempt.phase = "completed";
+    attempt.journal[0].state = "completed";
+    attempt.completedAt = now;
+    persist(pinnedActivation);
+    const activatedRoot = observation.contentRoots[0]?.path;
+    return { ...preview, changes: preview.changes.map((change) => ({ ...change, file: activatedRoot === undefined ? change.file : join35(activatedRoot, relative8(plugin.path, change.file)) })) };
+  } catch (error) {
+    if (!committed && handle !== undefined && applying) {
+      if (!(error instanceof LifecycleHostPhaseError && error.mutationStarted === false)) {
+        attempt.phase = "recovery-required";
+        attempt.journal[0].state = "rollback";
+        try {
+          let journalError;
+          try {
+            pending("rollback");
+          } catch (writeError) {
+            journalError = writeError;
+          }
+          await adapter.rollback(handle);
+          adapter.verifyRollback(handle, await adapter.readback(handle));
+          if (journalError !== undefined)
+            throw new Error(`rollback verified but its durable receipt is blocked: ${journalError.message}`);
+          attempt.phase = "finalizing";
+          attempt.journal[0].state = "cleanup-pending";
+          attempt.journal[0].settlement = "rollback";
+          persist({ ...activation, pending: { operation: "update", phase: "cleanup", attemptId, startedAt: now } });
+          await adapter.cleanup(handle, "verified-rollback");
+          attempt.phase = "failed";
+          attempt.journal[0].state = "rolled-back";
+          persist(activation);
+        } catch (recoveryError) {
+          await adapter.releaseRecovery(handle);
+          throw new Error(`pin failed: ${error.message}; recovery remains pending: ${recoveryError.message}`);
+        }
+      } else {
+        attempt.phase = "failed";
+        attempt.journal[0].state = "not-attempted";
+        attempt.mutationStarted = false;
+        persist(activation);
+        await adapter.cleanup(handle, "aborted-preparation");
+      }
+    } else if (!committed && accepted) {
+      try {
+        if (preparation !== undefined)
+          await adapter.cleanup(preparation, "aborted-preparation");
+      } finally {
+        attempt.phase = "failed";
+        attempt.journal[0].state = "not-attempted";
+        persist(activation);
+      }
+    }
+    throw error;
+  } finally {
+    try {
+      if (handle !== undefined)
+        await adapter.releaseRecovery(handle);
+    } finally {
+      rmSync15(frozenRoot, { recursive: true, force: true });
+    }
+  }
+}
+
 // src/pin.ts
 function defaultPinTargets(all = writers) {
   return all.filter((w) => w.gui);
@@ -27133,13 +28428,20 @@ async function runPin(options = {}) {
   const selected = selectTargets(candidates, options);
   const findings = [];
   let ledgerChanged = false;
+  const changedRecords = new Set;
   for (const host of selected) {
     if (!host.detect())
       continue;
     for (const plugin of host.listInstalled()) {
       if (plugin.path === undefined)
         continue;
-      const outcome = await host.pin(plugin, { dryRun: options.dryRun });
+      let outcome;
+      try {
+        outcome = host.lifecyclePinAdapter === undefined ? await host.pin(plugin, { dryRun: options.dryRun }) : await runOfflineLifecyclePin(host, plugin, options.dryRun === true);
+      } catch (error) {
+        findings.push({ host: host.id, mark: "✗", message: `plugin '${plugin.id}' pin failed — ${error.message}` });
+        continue;
+      }
       const prefix = options.dryRun === true ? "[dry-run] " : "";
       for (const change of outcome.changes) {
         findings.push({
@@ -27157,6 +28459,8 @@ async function runPin(options = {}) {
       }
       if (outcome.changes.length === 0)
         continue;
+      if (host.lifecyclePinAdapter !== undefined)
+        continue;
       const record = findRecord(state, host.id, plugin.id);
       if (record === undefined) {
         findings.push({
@@ -27168,6 +28472,7 @@ async function runPin(options = {}) {
       }
       if (options.dryRun === true)
         continue;
+      changedRecords.add(record);
       const pins = new Set(record.pins ?? []);
       for (const change of outcome.changes)
         pins.add(change.server);
@@ -27185,10 +28490,10 @@ async function runPin(options = {}) {
     }
   }
   if (ledgerChanged)
-    persistRecordedPins(state, options.state !== undefined);
+    persistRecordedPins(state, options.state !== undefined, changedRecords);
   return { findings, exitCode: findings.some((f) => f.mark === "✗") ? 1 : 0 };
 }
-function persistRecordedPins(records, legacyLedger) {
+function persistRecordedPins(records, legacyLedger, changedRecords) {
   const loaded = legacyLedger ? null : readLifecycleState();
   if (loaded === null || loaded.sourceVersion !== 2) {
     writeState(records);
@@ -27200,7 +28505,7 @@ function persistRecordedPins(records, legacyLedger) {
     stateGeneration: loaded.state.stateGeneration + 1,
     activations: loaded.state.activations.map((activation) => {
       const scope = scopes.get(activation.scopeId);
-      const record = records.find((candidate) => candidate.host === scope?.target.kind && candidate.id === activation.nativeId);
+      const record = records.find((candidate) => changedRecords.has(candidate) && candidate.host === scope?.target.kind && candidate.id === activation.nativeId);
       if (record === undefined)
         return activation;
       return {
@@ -27672,7 +28977,7 @@ function legacyCommandAction(command) {
 // package.json
 var package_default = {
   name: "plugnz",
-  version: "0.0.8",
+  version: "0.0.10",
   description: "Install, diagnose and update agent plugins (Agent Plugins spec) and MCP configs across Claude Code, Codex, Cursor, Kimi and more",
   license: "MIT",
   type: "module",
@@ -28681,19 +29986,13 @@ async function runRecordedLifecycleRemove(flags, target, state, selected) {
     const alias = writer?.persistedNativeIdMayAlias?.(activation.nativeId, target) === true;
     if (target !== activation.packageId && target !== activation.nativeId && !alias)
       return [];
-    return [{ scope }];
+    return [{ scope, activation }];
   });
   if (matches.length === 0 || matches.some((match) => !plannerKinds.has(match.scope.target.kind)))
     return null;
   const byScope = new Map;
   for (const match of matches)
     byScope.set(match.scope.id, match.scope);
-  for (const scopeId of byScope.keys()) {
-    const inScope = state.activations.filter((activation) => activation.scopeId === scopeId).length;
-    const selectedInScope = matches.filter((match) => match.scope.id === scopeId).length;
-    if (inScope !== selectedInScope)
-      return null;
-  }
   const perHost = new Map;
   for (const match of matches) {
     const count = (perHost.get(match.scope.target.kind) ?? 0) + 1;
@@ -28726,7 +30025,12 @@ async function runRecordedLifecycleRemove(flags, target, state, selected) {
     dryRun: flags.dryRun,
     hosts: createLifecyclePlannerHosts(),
     now: new Date().toISOString(),
-    command: "remove"
+    command: "remove",
+    removalSelection: matches.map(({ activation }) => ({
+      scopeId: activation.scopeId,
+      packageId: activation.packageId,
+      nativeId: activation.nativeId
+    }))
   });
   return executed.report;
 }
@@ -29103,18 +30407,22 @@ async function main(argv) {
       return 2;
     }
     const state = readState();
+    const recoveries = pendingLifecycleOperations();
     const all = [];
     for (const h of selection.selected) {
       const installed = h.listInstalled();
       const pending = state.filter((record) => record.host === h.id && record.pending !== undefined).map((record) => ({ id: record.id, action: record.pending }));
       if (json) {
-        all.push({ host: h.id, plugins: installed, ...pending.length > 0 ? { pending } : {} });
+        const recovery = recoveries.filter((row) => row.host === h.id);
+        all.push({ host: h.id, plugins: installed, ...pending.length > 0 ? { pending } : {}, ...recovery.length > 0 ? { recovery } : {} });
       } else {
         for (const p of installed) {
           console.log(`${h.id}	${p.id}	${p.version || p.sha || "unknown"}`);
         }
         for (const record of pending)
           console.log(`${h.id}	${record.id}	pending:${record.action}`);
+        for (const row of recoveries.filter((row) => row.host === h.id))
+          console.log(`${h.id}	${row.id}	recovery:${row.phase}	operation:${row.operationId}	retry:${row.command}	scope:${row.scopeId}`);
       }
     }
     if (json)