plugnz 0.0.9 → 0.0.10

package/dist/plugnz.mjs

@@ -10252,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"];
@@ -10319,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) {
@@ -10387,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"];
@@ -10403,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"];
@@ -10440,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,
@@ -10475,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,
@@ -10534,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`);
@@ -10545,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) {
@@ -10570,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;
   }
 }
@@ -10583,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;
@@ -10597,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) {
@@ -10612,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`);
@@ -10625,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) {
@@ -10691,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;
@@ -10724,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);
@@ -10738,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`);
@@ -10771,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;
@@ -10803,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) {
@@ -10826,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;
@@ -10835,7 +10936,7 @@ function validateCanonicalSourceBinding(source, label) {
   try {
     validateSourceBinding(source);
   } catch (error) {
-    invalid2(`${label}: ${error.message}`);
+    invalid3(`${label}: ${error.message}`);
   }
 }
 function compatibilitySourceUri(source) {
@@ -10848,7 +10949,7 @@ function canonicalScopeId(source, target) {
   try {
     return createDeploymentScopeIdentity(source, target).id;
   } catch (error) {
-    invalid2(error.message);
+    invalid3(error.message);
   }
 }
 function legacyRelativeDir(record) {
@@ -10861,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);
@@ -10877,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) {
@@ -10948,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();
@@ -10971,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);
   }
 }
@@ -10981,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";
@@ -11247,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` });
@@ -12448,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"];
@@ -12464,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);
   }
@@ -12485,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);
@@ -12516,7 +12636,7 @@ var PLAN_IDENTITY_FIELDS = [
   "action",
   "route"
 ];
-function invalid3(diagnostic) {
+function invalid4(diagnostic) {
   return protocol("protocol.invalid-report", diagnostic);
 }
 function contradiction(diagnostic) {
@@ -12528,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"]}'`);
   }
@@ -12568,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`);
@@ -12597,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)
@@ -12620,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`);
@@ -12692,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)
@@ -12780,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");
@@ -12802,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) {
@@ -12851,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);
@@ -12904,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,
@@ -12999,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");
@@ -13017,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) {
@@ -13025,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 });
     }
   }
@@ -13035,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,
@@ -13060,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) {
@@ -13072,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) {
@@ -13080,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) {
@@ -13091,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) {
@@ -13102,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) {
@@ -13130,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);
@@ -13146,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) => {
@@ -13154,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";
       }
@@ -13180,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 {
@@ -13195,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"]);
@@ -13311,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 = [];
@@ -13322,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);
@@ -13344,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 = [];
@@ -13355,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 });
@@ -13396,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);
@@ -13413,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,
@@ -13438,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) {
@@ -13446,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);
@@ -13468,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) {
@@ -14226,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));
@@ -14281,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";
@@ -15058,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";
@@ -19518,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);
@@ -19843,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;
@@ -20264,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));
@@ -20294,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;
 }
@@ -20302,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)
@@ -20638,6 +20891,7 @@ with FileLock(sys.argv[1]).acquire(timeout=10):
  sys.stdin.read()
 `;
 var nativeLocks = new Map;
+var recoveringNativeLocks = new Map;
 function nativePython() {
   const override = process.env["OPEN_PLUGIN_DCODE_PYTHON_BIN"];
   if (override) {
@@ -20709,6 +20963,7 @@ async function acquireNativeLock(attemptId, operationId) {
 }
 async function releaseNativeLock(attemptId, operationId) {
   const key = `${attemptId}:${operationId}`, held = nativeLocks.get(key);
+  recoveringNativeLocks.delete(key);
   if (held === undefined)
     return;
   nativeLocks.delete(key);
@@ -20743,7 +20998,7 @@ function observeDcodeTarget(target) {
     throw new Error("unsupported dcode target identity");
   const registry = readRegistry3(dcodeRegistryFile());
   const enabled = boolObject(readEnablement(dcodeEnablementFile()).enabledPlugins, "enabledPlugins");
-  return Object.entries(object3(registry.plugins, "registry plugins")).map(([nativeId, raw]) => {
+  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`);
@@ -20798,7 +21053,7 @@ function captureDcodeRollback(binding, attemptId, operationId) {
   mkdirSync9(dir, { recursive: true });
   const registry = readRegistry3(dcodeRegistryFile());
   const enabled = boolObject(readEnablement(dcodeEnablementFile()).enabledPlugins, "enabledPlugins");
-  const row = object3(registry.plugins, "registry plugins")[binding.nativeId];
+  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()) {
@@ -20810,6 +21065,11 @@ function captureDcodeRollback(binding, attemptId, operationId) {
   }
   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) });
@@ -20840,7 +21100,7 @@ function preflightAdoption(request) {
   if (path === undefined)
     throw new Error("dcode unmanaged adoption has no native root");
   const manifest = declaredManifest(snapshot.packageRoot, snapshot.packageName);
-  assessPrior(object3(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[snapshot.nativeId], snapshot.nativeId, snapshot.nativeGit?.locator ?? `local:${snapshot.scopeId}`, true, snapshot.packageName, manifest.version, snapshot.packageRoot);
+  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");
 }
@@ -20848,7 +21108,7 @@ function setDcodeRow(nativeId, row, enabled) {
   assertManagedPath4(dcodeRegistryFile());
   assertManagedPath4(dcodeEnablementFile());
   const registry = readRegistry3(dcodeRegistryFile()), enablement = readEnablement(dcodeEnablementFile());
-  const plugins = { ...object3(registry.plugins, "registry plugins") }, flags = { ...boolObject(enablement.enabledPlugins, "enabledPlugins") };
+  const plugins = { ...object4(registry.plugins, "registry plugins") }, flags = { ...boolObject(enablement.enabledPlugins, "enabledPlugins") };
   if (row === null)
     delete plugins[nativeId];
   else
@@ -20972,13 +21232,13 @@ var dcodeDefinition = {
   },
   disable: async (prepared) => {
     await acquireNativeLock(prepared.handle.attemptId, prepared.handle.operationId);
-    const row = object3(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[prepared.handle.nativeId];
+    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(object3(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[prepared.handle.nativeId]);
+    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);
@@ -20998,15 +21258,26 @@ var dcodeDefinition = {
   },
   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)
-        throw new Error("dcode rollback target is not owned");
+      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 });
     }
-    const state = readDoc2(join28(handle.rollbackReference, "state.json"), {}, "rollback state");
     for (const [index, row] of rowsFor(state.row).entries()) {
       const path = rowInstall(row, handle.nativeId);
       assertCachePath(path);
@@ -21017,21 +21288,48 @@ var dcodeDefinition = {
       }
     }
     setDcodeRow(handle.nativeId, state.row ?? null, typeof state.enabled === "boolean" ? state.enabled : null);
-    if (state.registryExisted === false && Object.keys(object3(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")).length === 0)
+    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 next = readDoc2(join28(dir, "rollback", "next-path.json"), {}, "cleanup target");
-      if (disposition === "verified-commit" && typeof next.target === "string") {
-        const prior = readDoc2(join28(dir, "rollback", "state.json"), {}, "rollback state");
+      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);
@@ -21067,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();
@@ -21175,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;
@@ -21269,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})`);
   }
@@ -21292,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;
@@ -21307,7 +21605,7 @@ 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);
@@ -21317,7 +21615,7 @@ function assertReadback(id, registryFile, enablementFile, target, version, proje
     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) {
@@ -21397,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}`);
@@ -21416,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;
@@ -21445,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;
@@ -21959,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);
@@ -21980,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);
@@ -22467,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));
@@ -25268,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");
@@ -25302,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`);
@@ -25380,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")
@@ -25406,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`);
@@ -25424,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);
@@ -25449,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;
@@ -25480,9 +25778,15 @@ 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);
     if (input.removalSelection !== undefined) {
@@ -25503,14 +25807,58 @@ async function planLifecycle(input) {
       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);
 }
@@ -26289,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 : "",
@@ -26297,10 +26645,10 @@ 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) => 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)));
@@ -26310,7 +26658,7 @@ function plannedAttemptIdentity(scopeId, sourceFingerprint, packageIds, retired
     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));
@@ -26625,6 +26973,7 @@ 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);
@@ -26810,6 +27159,7 @@ async function runDisable(plan, operation, hosts, ledger) {
       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);
@@ -26880,6 +27230,7 @@ async function runRetire(plan, operation, hosts, ledger) {
       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);
@@ -26897,6 +27248,8 @@ async function runRetire(plan, operation, hosts, ledger) {
     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) {
@@ -27047,6 +27400,10 @@ class Ledger {
       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);
@@ -27120,8 +27477,14 @@ class Ledger {
     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) };
@@ -27419,7 +27782,7 @@ async function recoverApplied(plan, operation, host, ledger, handle, reason) {
     }
     try {
       if (verified)
-        ledger.markRolledBack(plan, operation);
+        ledger.markRollbackVerified(plan, operation);
       else
         ledger.markRollbackRequired(plan, operation);
     } catch (error) {
@@ -27429,7 +27792,11 @@ async function recoverApplied(plan, operation, host, ledger, handle, reason) {
     if (verified) {
       try {
         await host.adapter.cleanup(handle, "verified-rollback");
-      } catch {}
+        ledger.markRolledBack(plan, operation);
+      } catch (error) {
+        verified = false;
+        diagnostic += `; rollback cleanup remains pending: ${unknownErrorDiagnostic(error)}`;
+      }
     }
   } finally {
     try {
@@ -27670,17 +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.removalSelection === undefined ? {} : { removalSelection: command.removalSelection }
-  });
+    ...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,
@@ -27795,6 +28331,7 @@ async function runOfflineLifecyclePin(host, plugin, dryRun) {
     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";
@@ -27807,6 +28344,7 @@ async function runOfflineLifecyclePin(host, plugin, dryRun) {
       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;
@@ -27842,6 +28380,7 @@ async function runOfflineLifecyclePin(host, plugin, dryRun) {
             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";
@@ -28438,7 +28977,7 @@ function legacyCommandAction(command) {
 // package.json
 var package_default = {
   name: "plugnz",
-  version: "0.0.9",
+  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",
@@ -29868,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)