plugnz 0.0.8 → 0.0.9

package/dist/plugnz.mjs

@@ -9339,10 +9339,23 @@ var dcode = {
         continue;
       const row = entry;
       const path = typeof row.installPath === "string" ? row.installPath : typeof row.install_path === "string" ? row.install_path : undefined;
+      let declaredVersion;
+      if (path && existsSync8(path)) {
+        for (const relative of ["plugin.json", ".claude-plugin/plugin.json", ".codex-plugin/plugin.json"]) {
+          try {
+            const manifest = JSON.parse(readFileSync6(join11(path, relative), "utf8"));
+            if (typeof manifest.version === "string") {
+              declaredVersion = manifest.version;
+              break;
+            }
+          } catch {}
+        }
+      }
       const at = id.indexOf("@");
       const name = at < 0 ? id : id.slice(0, at);
       const marketplace = at < 0 ? undefined : id.slice(at + 1);
-      const plugin = { id, name, ...marketplace ? { marketplace } : {}, ...path && existsSync8(path) ? { path } : {}, ...typeof row.version === "string" ? { version: row.version } : {}, ...enabled.enabledPlugins[id] === true ? { enabled: true } : { enabled: false } };
+      const version = typeof row.version === "string" ? row.version : declaredVersion;
+      const plugin = { id, name, ...marketplace ? { marketplace } : {}, ...path && existsSync8(path) ? { path } : {}, ...version === undefined ? {} : { version }, ...enabled.enabledPlugins[id] === true ? { enabled: true } : { enabled: false } };
       result.push(plugin);
     }
     return result;
@@ -12627,7 +12640,13 @@ function assertOutcome(outcome, snapshots, dryRun, command) {
   }
   const containment = outcome["action"] === "retain-prior" || outcome["action"] === "disable-nonconforming";
   const appliedDisablement = outcome["action"] === "disable-nonconforming" && outcome["changed"] === true;
-  if (containment && !dryRun) {
+  if (outcome["action"] === "disable-nonconforming" && outcome["result"] === "succeeded") {
+    throw contradiction(`disablement '${outcome["operationId"]}' cannot claim Desired convergence`);
+  }
+  if (!dryRun && outcome["action"] === "disable-nonconforming" && outcome["resourceState"] === "retained" && outcome["activationState"] === "inactive" && outcome["changed"] !== true) {
+    throw contradiction(`disablement '${outcome["operationId"]}' cannot claim inactive containment without a verified mutation`);
+  }
+  if (containment && !dryRun && (outcome["action"] === "retain-prior" || isObject2(reason) && reason["category"] === "capability")) {
     const expectedResourceState = "retained";
     const expectedActivationState = outcome["action"] === "retain-prior" ? "retained-prior" : appliedDisablement ? "inactive" : "active-nonconforming";
     if (outcome["result"] !== "failed" || outcome["resourceState"] !== expectedResourceState || outcome["activationState"] !== expectedActivationState) {
@@ -13546,7 +13565,8 @@ var dcode0183Managed = createCapabilityEvidenceProfile({
   },
   evidence: [
     "docs/evidence/dcode-native-update-0.1.83-20261009.json",
-    "docs/research/dcode-session-findings-2026-10-09.md"
+    "docs/research/dcode-session-findings-2026-10-09.md",
+    "docs/evidence/dcode-managed-lifecycle-20261011.md"
   ]
 });
 var capabilityEvidenceProfiles = Object.freeze([
@@ -14228,6 +14248,12 @@ function createLifecycleHostAdapter(definition) {
       assertReadbackMatch(handle.prior, observation, "rollback");
       return deepFreeze({ phase: "rollback-verified", handle, observation });
     },
+    async releaseRecovery(handle) {
+      assertHandle(definition.id, handle);
+      await invokePhase("cleanup", async () => {
+        await definition.releaseRecovery?.(handle);
+      });
+    },
     async cleanup(target, disposition) {
       const reference = cleanupReference(definition.id, target);
       if (isPreparationProjection(target) && disposition !== "aborted-preparation") {
@@ -20598,10 +20624,431 @@ function assertUnder(root, path) {
 import { cpSync as cpSync8, existsSync as existsSync23, lstatSync as lstatSync16, mkdirSync as mkdirSync9, mkdtempSync as mkdtempSync9, readFileSync as readFileSync22, readdirSync as readdirSync17, realpathSync as realpathSync3, renameSync as renameSync8, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "node:fs";
 import { basename as basename5, dirname as dirname11, join as join28, resolve as resolve17 } from "node:path";
 import { tmpdir as tmpdir7 } from "node:os";
+import { spawn as spawnChild } from "node:child_process";
 var MARKER7 = ".plgnz-install.json";
 var MANIFESTS = ["plugin.json", ".claude-plugin/plugin.json", ".codex-plugin/plugin.json"];
 var READBACK_FAULT = ".plgnz-dcode-readback-fault";
+var NATIVE_LOCK_SCRIPT = `import sys
+from importlib.metadata import version
+from filelock import FileLock
+if version('deepagents-code') != '0.1.83':
+ raise RuntimeError('unverified dcode lock runtime')
+with FileLock(sys.argv[1]).acquire(timeout=10):
+ print('DCODE_LOCK_0.1.83', flush=True)
+ sys.stdin.read()
+`;
+var nativeLocks = new Map;
+function nativePython() {
+  const override = process.env["OPEN_PLUGIN_DCODE_PYTHON_BIN"];
+  if (override) {
+    assertIdentity2(basename5(override), "Python binary");
+    return override;
+  }
+  const binary = dcodeBinary();
+  if (binary === undefined)
+    throw new Error("dcode native lock runtime is unavailable");
+  const shebang = readFileSync22(binary, "utf8").split(/\r?\n/, 1)[0] ?? "";
+  const match = /^#!(\/[^\s]+python(?:\d+(?:\.\d+)?)?)$/u.exec(shebang);
+  if (match?.[1] === undefined || !existsSync23(match[1]))
+    throw new Error("dcode native Python interpreter is unverified; set OPEN_PLUGIN_DCODE_PYTHON_BIN to its verified interpreter");
+  return match[1];
+}
+function probeLifecycleVersion() {
+  const observation = probeDcodeVersion();
+  if (observation.kind !== "detected" || observation.version !== "0.1.83")
+    return observation;
+  const result = spawnSync([nativePython(), "-c", "from importlib.metadata import version; import filelock; assert version('deepagents-code') == '0.1.83'; print('DCODE_LOCK_0.1.83')"], { stdout: "pipe", stderr: "pipe", timeout: 1e4 });
+  if (result.exitCode !== 0 || new TextDecoder().decode(result.stdout).trim() !== "DCODE_LOCK_0.1.83")
+    throw new Error(`dcode native lock runtime is unverified: ${new TextDecoder().decode(result.stderr).trim()}`);
+  return observation;
+}
+async function acquireNativeLock(attemptId, operationId) {
+  const key = `${attemptId}:${operationId}`;
+  const existing = nativeLocks.get(key);
+  if (existing !== undefined) {
+    if (!existing.isAlive())
+      throw new Error("dcode native lock was lost before verification");
+    return;
+  }
+  const file = join28(dcodeRoot(), "plugins", ".mutation.lock");
+  assertManagedPath4(file);
+  mkdirSync9(dirname11(file), { recursive: true });
+  const child = spawnChild(nativePython(), ["-c", NATIVE_LOCK_SCRIPT, file], { env: { ...process.env, HOME: process.env["OPEN_PLUGIN_HOME"] || process.env["HOME"], DEEPAGENTS_HOME: dcodeRoot() }, stdio: ["pipe", "pipe", "pipe"] });
+  let alive = true;
+  const exited = new Promise((resolveExit) => child.on("exit", (code) => {
+    alive = false;
+    resolveExit(code);
+  }));
+  await new Promise((resolveLock, rejectLock) => {
+    let output = "", diagnostic = "", settled = false;
+    const finish = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (error) {
+        child.kill("SIGKILL");
+        rejectLock(error);
+      } else
+        resolveLock();
+    };
+    const timer = setTimeout(() => finish(new Error("dcode native lock acquisition timed out")), 12000);
+    child.stdout.on("data", (data) => {
+      output += new TextDecoder().decode(data);
+      if (output.includes(`DCODE_LOCK_0.1.83
+`))
+        finish();
+    });
+    child.stderr.on("data", (data) => {
+      diagnostic += new TextDecoder().decode(data);
+    });
+    child.on("error", (error) => finish(new Error(`dcode native lock failed: ${error.message}`)));
+    child.on("exit", (code) => finish(new Error(`dcode native lock failed (${code}): ${diagnostic.trim()}`)));
+  });
+  nativeLocks.set(key, { child, exited, isAlive: () => alive });
+}
+async function releaseNativeLock(attemptId, operationId) {
+  const key = `${attemptId}:${operationId}`, held = nativeLocks.get(key);
+  if (held === undefined)
+    return;
+  nativeLocks.delete(key);
+  held.child.stdin.end();
+  let timer;
+  try {
+    const code = await Promise.race([held.exited, new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        held.child.kill("SIGKILL");
+        reject(new Error("dcode native lock release timed out"));
+      }, 2000);
+    })]);
+    if (code !== 0)
+      throw new Error(`dcode native lock process failed during mutation (${code})`);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+function lifecycleDirectory(attemptId, operationId) {
+  const hash = new CryptoHasher("sha256");
+  hash.update(`${attemptId}\x00${operationId}`);
+  const dir = join28(dcodeCacheRoot(), "plgnz-operations", hash.digest("hex"));
+  assertCachePath(dir);
+  return dir;
+}
+function lifecycleSlot(nativeId, fingerprint) {
+  return managedSlot(nativeId, fingerprint);
+}
+function observeDcodeTarget(target) {
+  if (target.kind !== "dcode" || target.instance !== "default")
+    throw new Error("unsupported dcode target identity");
+  const registry = readRegistry3(dcodeRegistryFile());
+  const enabled = boolObject(readEnablement(dcodeEnablementFile()).enabledPlugins, "enabledPlugins");
+  return Object.entries(object3(registry.plugins, "registry plugins")).map(([nativeId, raw]) => {
+    const rows = rowsFor(raw);
+    if (rows.length !== 1)
+      throw new Error(`dcode install record ${nativeId} has duplicate rows`);
+    const path = rowInstall(rows[0], nativeId);
+    assertCachePath(path);
+    const present = existsSync23(path);
+    const marker = present ? ownership3(path) : null;
+    const body = present ? readDoc2(join28(path, MARKER7), {}, "ownership marker") : {};
+    const owned = marker?.pluginId === nativeId;
+    const fingerprint = present ? fingerprintTree(path) : null;
+    return {
+      nativeId,
+      packageName: nativeId.split("@")[0],
+      ownership: owned ? { kind: "owned", proof: body.proof === "adopted" ? "adopted" : "created", scopeId: typeof body.scopeId === "string" ? body.scopeId : "dcode:default", proofId: `dcode-marker:${nativeId}` } : { kind: "unmanaged" },
+      presence: present ? "present" : "absent",
+      enablement: enabled[nativeId] === true ? "enabled" : "disabled",
+      activation: enabled[nativeId] === true && present ? "active" : "inactive",
+      installedFingerprint: fingerprint,
+      installedVersion: present ? declaredManifest(path, nativeId.split("@")[0]).version : null,
+      source: owned ? { type: body.sourceType === "git" ? "git" : "local", immutableRevision: marker.kind === "current" ? marker.sourceRevision : marker.fingerprint, locator: body.sourceType === "git" ? marker.source : null } : null,
+      contentRoots: fingerprint === null ? [] : [{ label: "managed", path, fingerprint }]
+    };
+  });
+}
+function dcodeLifecycleReadback(binding) {
+  if (existsSync23(join28(dcodeStateDir(), READBACK_FAULT)))
+    throw new Error(`dcode readback failed for ${binding.nativeId}`);
+  const installations = observeDcodeTarget(binding.target);
+  const row = installations.find((item) => item.nativeId === binding.nativeId);
+  const present = row?.presence === "present";
+  const enabled = row?.enablement === "enabled" && present;
+  const dataRoot = join28(dcodeRoot(), "plugins", "data");
+  assertManagedPath4(dataRoot);
+  return {
+    adapterId: binding.adapterId,
+    target: binding.target,
+    scopeId: binding.scopeId,
+    packageName: binding.packageName,
+    nativeId: binding.nativeId,
+    route: binding.route ?? (present ? "managed" : "none"),
+    presence: present ? "present" : "absent",
+    enablement: enabled ? "enabled" : "disabled",
+    activation: enabled ? "active" : "inactive",
+    transition: { requirement: present ? "restart" : "none", status: "effective" },
+    installedFingerprint: present ? row.installedFingerprint : null,
+    contentRoots: present ? row.contentRoots : [],
+    retention: { pluginData: existsSync23(dataRoot) ? { state: "present", fingerprint: fingerprintTree(dataRoot) } : { state: "absent", fingerprint: null }, inactiveMetadata: { state: "absent", fingerprint: null } }
+  };
+}
+function captureDcodeRollback(binding, attemptId, operationId) {
+  const dir = join28(lifecycleDirectory(attemptId, operationId), "rollback");
+  mkdirSync9(dir, { recursive: true });
+  const registry = readRegistry3(dcodeRegistryFile());
+  const enabled = boolObject(readEnablement(dcodeEnablementFile()).enabledPlugins, "enabledPlugins");
+  const row = object3(registry.plugins, "registry plugins")[binding.nativeId];
+  const state = { row: row ?? null, enabled: enabled[binding.nativeId] ?? null, registryExisted: existsSync23(dcodeRegistryFile()), enablementExisted: existsSync23(dcodeEnablementFile()) };
+  writeFileSync9(join28(dir, "state.json"), JSON.stringify(state));
+  for (const [index, item] of rowsFor(row).entries()) {
+    const path = rowInstall(item, binding.nativeId);
+    assertCachePath(path);
+    assertNoSymlinks6(path);
+    if (existsSync23(path))
+      cpSync8(path, join28(dir, `content-${index}`), { recursive: true });
+  }
+  return dir;
+}
+async function lockPreparation(binding, attemptId, operationId, expectedObservationId) {
+  await acquireNativeLock(attemptId, operationId);
+  const observed = createTargetInventoryObservation("dcode", { target: binding.target, installations: observeDcodeTarget(binding.target) });
+  if (observed.observationId !== expectedObservationId)
+    throw new Error("dcode native inventory changed before locked preparation; refusing stale rollback authority");
+}
+async function captureOwnedPreparation(binding, attemptId, operationId, expectedObservationId, capture) {
+  try {
+    await lockPreparation(binding, attemptId, operationId, expectedObservationId);
+    return capture();
+  } catch (error) {
+    try {
+      await releaseNativeLock(attemptId, operationId);
+    } catch (releaseError) {
+      throw new Error(`${error instanceof Error ? error.message : String(error)}; dcode preparation lock release failed: ${releaseError instanceof Error ? releaseError.message : String(releaseError)}`);
+    }
+    throw error;
+  }
+}
+function preflightAdoption(request) {
+  if (request.operation !== "install" && request.operation !== "update")
+    return;
+  const snapshot = request.snapshot;
+  const installed = request.targetObservation.installations.find((item) => item.nativeId === snapshot.nativeId);
+  if (installed?.ownership.kind !== "unmanaged" || installed.presence !== "present")
+    return;
+  const path = installed.contentRoots[0]?.path;
+  if (path === undefined)
+    throw new Error("dcode unmanaged adoption has no native root");
+  const manifest = declaredManifest(snapshot.packageRoot, snapshot.packageName);
+  assessPrior(object3(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[snapshot.nativeId], snapshot.nativeId, snapshot.nativeGit?.locator ?? `local:${snapshot.scopeId}`, true, snapshot.packageName, manifest.version, snapshot.packageRoot);
+  if (fingerprintTree(path) !== installed.installedFingerprint)
+    throw new Error("dcode unmanaged adoption changed during preflight");
+}
+function setDcodeRow(nativeId, row, enabled) {
+  assertManagedPath4(dcodeRegistryFile());
+  assertManagedPath4(dcodeEnablementFile());
+  const registry = readRegistry3(dcodeRegistryFile()), enablement = readEnablement(dcodeEnablementFile());
+  const plugins = { ...object3(registry.plugins, "registry plugins") }, flags = { ...boolObject(enablement.enabledPlugins, "enabledPlugins") };
+  if (row === null)
+    delete plugins[nativeId];
+  else
+    plugins[nativeId] = row;
+  if (enabled === null)
+    delete flags[nativeId];
+  else
+    flags[nativeId] = enabled;
+  writeDoc2(dcodeRegistryFile(), { ...registry, plugins });
+  writeDoc2(dcodeEnablementFile(), { ...enablement, enabledPlugins: flags });
+}
+var dcodeDefinition = {
+  id: "dcode",
+  evidenceProfiles: capabilityEvidenceProfiles.filter((profile) => profile.host === "dcode").flatMap((profile) => [profile, createCapabilityEvidenceProfile({ ...profile, operations: ["disable"], semantics: { ...profile.semantics, "reversible-disable": "supported" }, evidence: [...profile.evidence, "docs/evidence/dcode-managed-lifecycle-20261011.md"] })]),
+  probeVersion: async () => probeLifecycleVersion(),
+  observeTarget: async (target) => ({ target, installations: observeDcodeTarget(target) }),
+  observeNativeMutationScope: async () => ({ kind: "unavailable" }),
+  observeNativeProjection: async (request) => {
+    preflightAdoption(request);
+    return { kind: "requires-managed", reasonId: "dcode-frozen-projection-and-updater-isolation" };
+  },
+  revalidateTargetPrecondition: async (handle) => {
+    await acquireNativeLock(handle.attemptId, handle.operationId);
+    return { version: probeDcodeVersion(), targetObservationId: createTargetInventoryObservation("dcode", { target: handle.target, installations: observeDcodeTarget(handle.target) }).observationId };
+  },
+  stageActivation: async (request) => {
+    const dir = lifecycleDirectory(request.snapshot.attemptId, request.snapshot.operationId);
+    const stagingRoot = join28(dir, "stage");
+    if (existsSync23(stagingRoot))
+      throw new Error("dcode preparation stage already exists");
+    mkdirSync9(stagingRoot, { recursive: true });
+    const manifest = declaredManifest(request.snapshot.packageRoot, request.snapshot.packageName);
+    try {
+      stagePlugin5(request.snapshot.packageRoot, stagingRoot, request.snapshot.packageName, manifest.version);
+    } catch (error) {
+      rmSync9(dir, { recursive: true, force: true });
+      throw error;
+    }
+    return { stagingRoot, stagingId: `${request.snapshot.attemptId}:${request.snapshot.operationId}` };
+  },
+  applyLifecycleDirectives: async (projection) => {
+    forceAutoUpdateOff(projection.stagingRoot);
+    const prior = observeDcodeTarget(projection.target).find((item) => item.nativeId === projection.nativeId);
+    writeFileSync9(join28(projection.stagingRoot, MARKER7), JSON.stringify({ source: projection.sourceLocator ?? `local:${projection.scopeId}`, pluginId: projection.nativeId, fingerprint: projection.sourceRevision, sourceRevision: projection.sourceRevision, projectedFingerprint: projectionDigest(projection.stagingRoot), scopeId: projection.scopeId, sourceType: projection.sourceType, proof: prior?.ownership.kind === "unmanaged" ? "adopted" : "created" }));
+    return ["dcode.managed-unversioned-registry"];
+  },
+  applyPins: async (projection) => {
+    const found = new Set;
+    for (const candidate of dcodeMcpCandidates()) {
+      const file = join28(projection.stagingRoot, candidate.kind === "spec" ? candidate.file : candidate.manifest);
+      if (!existsSync23(file))
+        continue;
+      const body = readDoc2(file, {}, "MCP document");
+      if (typeof body.mcpServers !== "object" || body.mcpServers === null || Array.isArray(body.mcpServers))
+        continue;
+      let changed = false;
+      for (const pin of projection.pins) {
+        const server = body.mcpServers[pin.server];
+        if (typeof server !== "object" || server === null || Array.isArray(server))
+          continue;
+        server.command = pin.executable;
+        found.add(pin.server);
+        changed = true;
+      }
+      if (changed)
+        writeFileSync9(file, JSON.stringify(body, null, 2));
+    }
+    if (projection.pins.some((pin) => !found.has(pin.server)))
+      throw new Error("dcode resolved pin is absent from staged MCP configuration");
+    const marker = readDoc2(join28(projection.stagingRoot, MARKER7), {}, "ownership marker");
+    marker.projectedFingerprint = projectionDigest(projection.stagingRoot);
+    writeFileSync9(join28(projection.stagingRoot, MARKER7), JSON.stringify(marker));
+    return [...found];
+  },
+  captureActivationPreparation: async (projection, fingerprint) => {
+    await lockPreparation(projection, projection.attemptId, projection.operationId, projection.targetObservationId);
+    const prior = dcodeLifecycleReadback(projection);
+    const target = lifecycleSlot(projection.nativeId, fingerprint);
+    assertCachePath(target);
+    const installed = observeDcodeTarget(projection.target).find((item) => item.nativeId === projection.nativeId);
+    if (installed?.ownership.kind === "owned" && installed.ownership.scopeId !== projection.scopeId)
+      throw new Error("dcode scope ownership conflict");
+    if (installed?.ownership.kind === "unmanaged") {
+      const path = installed.contentRoots[0]?.path;
+      if (path === undefined || !sameTree7(projection.snapshot.packageRoot, path))
+        throw new Error("dcode legacy content differs; refusing adoption");
+      const manifest = declaredManifest(path, projection.packageName);
+      if (manifest.version !== projection.packageVersion)
+        throw new Error("dcode legacy version differs; refusing adoption");
+    }
+    if (existsSync23(target) && ownership3(target)?.pluginId !== projection.nativeId)
+      throw new Error("dcode lifecycle target is not owned");
+    const rollbackReference = captureDcodeRollback(projection, projection.attemptId, projection.operationId);
+    writeFileSync9(join28(rollbackReference, "next-path.json"), JSON.stringify({ target }));
+    return { prior, expected: { ...prior, route: "managed", presence: "present", enablement: "enabled", activation: "active", transition: { requirement: "restart", status: "effective" }, installedFingerprint: fingerprint, contentRoots: [{ label: "managed", path: target, fingerprint }] }, rollbackReference, rollbackCoverageOperationIds: projection.affectedOperationIds };
+  },
+  captureDisablePreparation: async (request) => {
+    const binding = { adapterId: "dcode", ...request.activation };
+    return captureOwnedPreparation(binding, request.attemptId, request.operationId, request.selection.targetObservationId, () => ({ prior: dcodeLifecycleReadback(binding), rollbackReference: captureDcodeRollback(binding, request.attemptId, request.operationId), rollbackCoverageOperationIds: request.selection.affectedOperationIds, transition: { requirement: "restart", status: "effective" } }));
+  },
+  captureRetirementPreparation: async (request) => {
+    const binding = { adapterId: "dcode", ...request.activation };
+    return captureOwnedPreparation(binding, request.attemptId, request.operationId, request.selection.targetObservationId, () => ({ prior: dcodeLifecycleReadback(binding), rollbackReference: captureDcodeRollback(binding, request.attemptId, request.operationId), rollbackCoverageOperationIds: request.selection.affectedOperationIds, transition: { requirement: "none", status: "effective" } }));
+  },
+  apply: async (prepared) => {
+    await acquireNativeLock(prepared.handle.attemptId, prepared.handle.operationId);
+    const target = lifecycleSlot(prepared.handle.nativeId, prepared.handle.projectedFingerprint);
+    assertCachePath(target);
+    mkdirSync9(dirname11(target), { recursive: true });
+    if (existsSync23(target)) {
+      const marker = ownership3(target);
+      if (marker?.pluginId !== prepared.handle.nativeId)
+        throw new Error("dcode lifecycle activation would overwrite foreign content");
+      if (fingerprintTree(target) !== prepared.handle.projectedFingerprint)
+        throw new Error("dcode immutable projection slot has diverged");
+    } else {
+      renameSync8(prepared.stagingRoot, target);
+    }
+    setDcodeRow(prepared.handle.nativeId, [{ installPath: target }], true);
+    return { receiptId: `dcode-apply:${prepared.handle.operationId}`, changed: true };
+  },
+  disable: async (prepared) => {
+    await acquireNativeLock(prepared.handle.attemptId, prepared.handle.operationId);
+    const row = object3(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]);
+    for (const row of rows) {
+      const path = rowInstall(row, prepared.handle.nativeId);
+      assertCachePath(path);
+      if (ownership3(path)?.pluginId !== prepared.handle.nativeId)
+        throw new Error("dcode retirement has no ownership proof");
+    }
+    setDcodeRow(prepared.handle.nativeId, null, null);
+    for (const row of rows)
+      rmSync9(rowInstall(row, prepared.handle.nativeId), { recursive: true, force: true });
+    return { receiptId: `dcode-retire:${prepared.handle.operationId}`, changed: true };
+  },
+  readback: async (handle) => {
+    const held = nativeLocks.get(`${handle.attemptId}:${handle.operationId}`);
+    if (held !== undefined && !held.isAlive())
+      throw new Error("dcode native lock was lost before readback");
+    return dcodeLifecycleReadback(handle);
+  },
+  rollback: async (handle) => {
+    await acquireNativeLock(handle.attemptId, handle.operationId);
+    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");
+      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);
+      const backup = join28(handle.rollbackReference, `content-${index}`);
+      if (existsSync23(backup)) {
+        mkdirSync9(dirname11(path), { recursive: true });
+        cpSync8(backup, path, { recursive: true });
+      }
+    }
+    setDcodeRow(handle.nativeId, state.row ?? null, typeof state.enabled === "boolean" ? state.enabled : null);
+    if (state.registryExisted === false && Object.keys(object3(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 };
+  },
+  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");
+        for (const row of rowsFor(prior.row)) {
+          const path = rowInstall(row, reference.operationId);
+          assertCachePath(path);
+          if (resolve17(path) !== resolve17(next.target))
+            rmSync9(path, { recursive: true, force: true });
+        }
+      }
+      rmSync9(dir, { recursive: true, force: true });
+    } finally {
+      await releaseNativeLock(reference.attemptId, reference.operationId);
+    }
+    return { cleanupId: `dcode-cleanup:${reference.operationId}`, completed: true };
+  }
+};
+var dcodeLifecycle = createLifecycleHostAdapter(dcodeDefinition);
 var dcodeWriter = {
+  lifecyclePinAdapter: dcodeLifecycle,
   ...dcode,
   supportsAdoption: true,
   plannedNativeId: (plugin) => `${plugin.name}@${plugin.marketplace || "local"}`,
@@ -20664,7 +21111,7 @@ var dcodeWriter = {
         throw new Error(`dcode cache target is unowned; refusing to replace it: ${target}`);
       const former = prior.kind === "none" ? undefined : prior.path;
       const unchanged = (former === undefined || resolve17(former) === resolve17(target)) && slot?.kind === "current" && slot.fingerprint === sourceFingerprint && slot.projectedFingerprint === projected && slot.sourceRevision === resolved.sha && sameTree7(stage, target);
-      const nextRegistry = { ...registry, plugins: { ...plugins, [id]: [{ installPath: target, version: manifest.version }] } };
+      const nextRegistry = { ...registry, plugins: { ...plugins, [id]: [{ installPath: target }] } };
       const nextEnablement = { ...enablement, enabledPlugins: { ...enabled, [id]: true } };
       if (opts?.dryRun) {
         console.log(`[dcode] would activate directory: ${target}`);
@@ -20715,6 +21162,8 @@ var dcodeWriter = {
     assertCachePath(plugin.path);
     if (ownership3(plugin.path)?.pluginId !== plugin.id)
       return { changes: [], refusals: [] };
+    if (opts?.dryRun !== true)
+      throw new Error("dcode pin requires the durable lifecycle pin workflow; direct in-place pinning is refused");
     return pinPluginMcpFiles(plugin.path, dcodeMcpCandidates(), opts);
   },
   async remove(id) {
@@ -20864,7 +21313,9 @@ function assertReadback(id, registryFile, enablementFile, target, version, proje
   const install = rowInstall(rows[0], id);
   if (resolve17(install) !== resolve17(target))
     throw new Error(`dcode readback path mismatch for ${id}`);
-  if (rows[0].version !== version)
+  if (rows[0].version !== undefined && rows[0].version !== null)
+    throw new Error(`dcode managed install is eligible for native auto-update: ${id}`);
+  if (declaredManifest(target, id.split("@")[0]).version !== version)
     throw new Error(`dcode readback version mismatch for ${id}`);
   if (boolObject(object3(enablement.enabledPlugins, "enabledPlugins"), "enabledPlugins")[id] !== true)
     throw new Error(`dcode readback enablement mismatch for ${id}`);
@@ -25034,7 +25485,22 @@ async function planLifecycle(input) {
     const result = await prepareEntry(entry, input.hosts, loaded.state, command, input.transportSource, transportCache);
     if (result.kind === "defect")
       return zeroWrite(command, input.dryRun, result.reason, result.terminalPhase);
-    prepared.push(result);
+    if (input.removalSelection !== undefined) {
+      if (command !== "remove" || result.kind !== "retire-source") {
+        return zeroWrite(command, input.dryRun, createLifecycleReason("internal", "internal.invariant", "package retirement selection is valid only for manual removal"));
+      }
+      const selected = input.removalSelection.filter((row) => row.scopeId === result.scope.id);
+      if (selected.length === 0 || selected.some((row) => !loaded.state.activations.some((activation) => activation.scopeId === row.scopeId && activation.packageId === row.packageId && activation.nativeId === row.nativeId))) {
+        return zeroWrite(command, input.dryRun, createLifecycleReason("internal", "internal.invariant", "manual removal selection no longer matches recorded ownership"));
+      }
+      const retirementPackages = selected.map(({ packageId, nativeId }) => ({ packageId, nativeId })).sort((left, right) => left.packageId.localeCompare(right.packageId) || left.nativeId.localeCompare(right.nativeId));
+      prepared.push({
+        ...result,
+        retirementPackages,
+        identity: ["remove-packages", result.scope.id, ...retirementPackages.flatMap((row) => [row.packageId, row.nativeId])]
+      });
+    } else
+      prepared.push(result);
   }
   const attemptId = lifecycleAttemptId(loaded.state.stateGeneration, prepared.map((item) => item.identity));
   const scopes = [];
@@ -25080,6 +25546,10 @@ async function prepareSync(entry, hosts, state, command, transportSource, transp
     throw error;
   }
   const scope = deploymentScopeForSyncManifestEntry(entry);
+  const recordedScope = state.scopes.find((row) => row.id === scope.id);
+  if (recordedScope?.target.context !== undefined && JSON.stringify(canonicalTargetContext(recordedScope.target.context)) !== JSON.stringify(entry.target.context === undefined ? undefined : canonicalTargetContext(entry.target.context))) {
+    return defect(createLifecycleReason("internal", "internal.invariant", `target context changed for recorded scope '${scope.id}'; use a distinct target instance or retire the recorded scope explicitly`));
+  }
   const pending = pendingDefect(state, scope.id, new Set(selected.map((item) => item.plugin.name)), command);
   if (pending !== null)
     return defect(pending);
@@ -25229,6 +25699,7 @@ async function planSync(item, attemptId, validatedAt, state, command) {
     kind: "planned",
     scope: {
       scope: item.scope,
+      target: item.observation?.target ?? item.entry.target,
       selectorMode: item.entry.selectors === undefined ? "all" : "explicit",
       desired: desiredGeneration(existing, item.frozen.snapshot.revision, item.frozen.snapshot.fingerprint, packages, validatedAt),
       prune: blocks || retirements.operations.some((row) => row.operation.action !== "retire-orphan") ? "blocked" : "planned"
@@ -25308,7 +25779,7 @@ async function planOmissions(item, attemptId, state, desired) {
   return { kind: "omissions", operations };
 }
 async function planRetire(item, attemptId, state) {
-  const activations = state.activations.filter((activation) => activation.scopeId === item.recorded.id).sort((left, right) => left.packageId < right.packageId ? -1 : left.packageId > right.packageId ? 1 : 0);
+  const activations = state.activations.filter((activation) => activation.scopeId === item.recorded.id && (item.retirementPackages === undefined || item.retirementPackages.some((row) => row.packageId === activation.packageId && row.nativeId === activation.nativeId))).sort((left, right) => left.packageId < right.packageId ? -1 : left.packageId > right.packageId ? 1 : 0);
   const operations = [];
   for (const activation of activations) {
     const installation = item.observation?.installations.find((row) => row.nativeId === activation.nativeId);
@@ -25328,8 +25799,10 @@ async function planRetire(item, attemptId, state) {
     kind: "planned",
     scope: {
       scope: item.scope,
+      target: item.observation?.target ?? item.recorded.target,
       selectorMode: "retired",
       desired: null,
+      ...item.retirementPackages === undefined ? {} : { retirementPackages: item.retirementPackages },
       prune: operations.length > 0 && operations.every((row) => row.operation.action === "retire-orphan") ? "planned" : "blocked"
     },
     operations
@@ -25830,7 +26303,7 @@ function lifecycleAttemptId(stateGeneration, identities) {
   return `attempt-v1-${digest3([String(stateGeneration), ...identities.flat()])}`;
 }
 function lifecycleAttemptIdForPlannedScopes(stateGeneration, scopes) {
-  return lifecycleAttemptId(stateGeneration, scopes.map((planned) => plannedAttemptIdentity(planned.scope.id, planned.desired?.sourceFingerprint, planned.desired?.packages.map((pkg) => pkg.packageId), planned.selectorMode === "retired" || planned.desired === null)));
+  return lifecycleAttemptId(stateGeneration, scopes.map((planned) => planned.retirementPackages !== undefined ? ["remove-packages", planned.scope.id, ...planned.retirementPackages.flatMap((row) => [row.packageId, row.nativeId])] : plannedAttemptIdentity(planned.scope.id, planned.desired?.sourceFingerprint, planned.desired?.packages.map((pkg) => pkg.packageId), planned.selectorMode === "retired" || planned.desired === null)));
 }
 function plannedAttemptIdentity(scopeId, sourceFingerprint, packageIds, retired = false) {
   if (retired || sourceFingerprint === undefined || packageIds === undefined)
@@ -26093,8 +26566,9 @@ async function runOperation(plan, operation, hosts, ledger) {
       return succeeded(operation, false);
     case "retire-orphan":
       return runRetire(plan, operation, hosts, ledger);
-    case "route-migrate":
     case "disable-nonconforming":
+      return runDisable(plan, operation, hosts, ledger);
+    case "route-migrate":
     case "retain-prior":
     case "not-attempted":
       return stop(operation, createLifecycleReason("internal", "internal.invariant", `operation '${operation.operationId}' is not applied by this execution slice`));
@@ -26157,6 +26631,12 @@ async function runActivation(plan, operation, hosts, ledger, action) {
     verified = host.adapter.verify(receipt.handle, observation);
   } catch (error) {
     const reason = thrownReason(error);
+    if (receipt === undefined && ledger.journalState(plan.attemptId, operation.operationId) === "applying" && error instanceof LifecycleHostPhaseError && !error.mutationStarted) {
+      ledger.markNotApplied(plan, operation);
+      if (preparation !== undefined)
+        await abortPreparation(host, preparation);
+      return stop(operation, reason);
+    }
     if (handle !== undefined && ledger.journalState(plan.attemptId, operation.operationId) === "applying") {
       return recoverApplied(plan, operation, host, ledger, handle, reason);
     }
@@ -26230,7 +26710,7 @@ async function prepareActivation(plan, operation, host, nativeId, action, record
   if (plugin === undefined || packageFingerprint === undefined) {
     return refused(createLifecycleReason("internal", "internal.invariant", `${action} '${operation.package}' is missing from the frozen source`));
   }
-  const target = lifecycleTarget2(operation);
+  const target = lifecycleTarget2(plan, operation);
   const observation = await host.adapter.observeTarget(target);
   const version = await host.adapter.probeVersion(observation.target);
   if (version.kind !== "detected") {
@@ -26314,6 +26794,50 @@ function sealActivationSnapshot(operation, attemptId, nativeId, frozen, plugin,
     throw new Error(`frozen snapshot action '${snapshot.action}' is not ${action}`);
   return snapshot;
 }
+async function runDisable(plan, operation, hosts, ledger) {
+  const host = hosts.find((candidate) => candidate.kinds.includes(operation.scope.target.kind));
+  const reason = plan.report.outcomes.find((row) => row.operationId === operation.operationId)?.reason;
+  if (host === undefined || operation.nativeId === null || reason === undefined || reason === null) {
+    return stop(operation, createLifecycleReason("internal", "internal.invariant", "disable containment lost its adapter, identity or desired failure reason"));
+  }
+  let preparation;
+  let receipt;
+  try {
+    const prepared = await prepareOwnedMutation(plan, operation, host, operation.nativeId, ledger, "disable");
+    if (prepared.kind === "refused")
+      return stop(operation, prepared.reason);
+    if (prepared.selection.operation !== "disable")
+      throw new Error("disable containment selected the wrong operation");
+    ledger.acceptJournal(plan, operation, "disable-nonconforming");
+    preparation = await host.adapter.prepareDisable({ operationId: operation.operationId, attemptId: plan.attemptId, selection: { ...prepared.selection, operation: "disable" }, activation: prepared.activation });
+    ledger.markApplying(plan, operation);
+    receipt = await host.adapter.disable(preparation);
+    const observation = await host.adapter.readback(receipt.handle);
+    const verified = host.adapter.verify(receipt.handle, observation);
+    ledger.confirmDisable(plan, operation);
+    try {
+      await host.adapter.cleanup(verified.handle, "verified-commit");
+    } catch {
+      ledger.markCleanupPending(plan, operation, "disable-nonconforming");
+      return pendingCleanup(operation);
+    }
+    ledger.completeContainment(plan, operation);
+    return { stop: true, reason, outcome: { ...operation, result: "failed", resourceState: "retained", activationState: "inactive", changed: receipt.changed, reason } };
+  } catch (error) {
+    const failure = thrownReason(error);
+    if (receipt === undefined && error instanceof LifecycleHostPhaseError && !error.mutationStarted) {
+      if (ledger.journalState(plan.attemptId, operation.operationId) !== undefined)
+        ledger.markNotApplied(plan, operation);
+      if (preparation !== undefined)
+        await abortPreparation(host, preparation);
+      return stop(operation, failure);
+    }
+    if (preparation !== undefined && (receipt !== undefined || ledger.journalState(plan.attemptId, operation.operationId) === "applying")) {
+      return recoverApplied(plan, operation, host, ledger, preparation.handle, failure);
+    }
+    return stop(operation, failure);
+  }
+}
 async function runRetire(plan, operation, hosts, ledger) {
   if (ledger.journalState(plan.attemptId, operation.operationId) === "completed")
     return retired(operation, false);
@@ -26331,17 +26855,20 @@ async function runRetire(plan, operation, hosts, ledger) {
   }
   let prepared;
   try {
-    prepared = await prepareRetirement(plan, operation, host, nativeId, ledger);
+    prepared = await prepareOwnedMutation(plan, operation, host, nativeId, ledger);
   } catch (error) {
     return stop(operation, thrownReason(error));
   }
   if (prepared.kind === "refused")
     return stop(operation, prepared.reason);
+  if (prepared.selection.operation !== "retire")
+    return stop(operation, createLifecycleReason("internal", "internal.invariant", "retirement selected the wrong operation"));
   try {
     ledger.acceptJournal(plan, operation, "retire-orphan");
   } catch (error) {
     return stop(operation, thrownReason(error));
   }
+  let preparation;
   let receipt;
   let verified;
   try {
@@ -26349,17 +26876,27 @@ async function runRetire(plan, operation, hosts, ledger) {
       operationId: operation.operationId,
       attemptId: plan.attemptId,
       action: "retire-orphan",
-      selection: prepared.selection,
+      selection: { ...prepared.selection, operation: "retire" },
       activation: prepared.activation
     });
+    preparation = sealed;
     ledger.markPruning(plan, operation);
     receipt = await host.adapter.retire(sealed);
     const observation = await host.adapter.readback(receipt.handle);
     verified = host.adapter.verify(receipt.handle, observation);
   } catch (error) {
     const reason = thrownReason(error);
+    if (receipt === undefined && ledger.journalState(plan.attemptId, operation.operationId) === "applying" && error instanceof LifecycleHostPhaseError && !error.mutationStarted) {
+      ledger.markNotApplied(plan, operation);
+      if (preparation !== undefined)
+        await abortPreparation(host, preparation);
+      return stop(operation, reason);
+    }
     if (receipt !== undefined)
       return recoverApplied(plan, operation, host, ledger, receipt.handle, reason);
+    if (preparation !== undefined && ledger.journalState(plan.attemptId, operation.operationId) === "applying") {
+      return recoverApplied(plan, operation, host, ledger, preparation.handle, reason);
+    }
     return stop(operation, reason);
   }
   if (receipt === undefined || verified === undefined) {
@@ -26379,12 +26916,13 @@ async function runRetire(plan, operation, hosts, ledger) {
   ledger.markCompleted(plan, operation);
   return retired(operation, receipt.changed);
 }
-async function prepareRetirement(plan, operation, host, nativeId, ledger) {
+async function prepareOwnedMutation(plan, operation, host, nativeId, ledger, capabilityOperation = "retire") {
+  const operationLabel = capabilityOperation === "disable" ? "disablement" : "retirement";
   const recorded = ledger.activation(operation.scope.id, operation.package, nativeId);
   if (recorded === undefined || recorded.route.kind === "legacy-unverified" || recorded.ownership.kind === "legacy-claim" || recorded.sourceRevision === undefined) {
     return refused(createLifecycleReason("internal", "internal.invariant", `ownership of '${operation.package}' was not revalidated`));
   }
-  const target = lifecycleTarget2(operation);
+  const target = lifecycleTarget2(plan, operation);
   const observation = await host.adapter.observeTarget(target);
   const installation = observation.installations.find((row) => row.nativeId === nativeId);
   if (installation === undefined || installation.presence !== "present" || installation.ownership.kind !== "owned" || installation.ownership.scopeId !== operation.scope.id) {
@@ -26392,10 +26930,10 @@ async function prepareRetirement(plan, operation, host, nativeId, ledger) {
   }
   const version = await host.adapter.probeVersion(observation.target);
   if (version.kind !== "detected") {
-    return refused(createLifecycleReason("runtime", "runtime.operation-failed", `retirement '${operation.package}' lost its detected target version`));
+    return refused(createLifecycleReason("runtime", "runtime.operation-failed", `${operationLabel} '${operation.package}' lost its detected target version`));
   }
   if (recorded.fingerprints.installed !== installation.installedFingerprint) {
-    return refused(createLifecycleReason("internal", "internal.invariant", `retirement '${operation.package}' fingerprint does not match the owned install`));
+    return refused(createLifecycleReason("internal", "internal.invariant", `${operationLabel} '${operation.package}' fingerprint does not match the owned install`));
   }
   const owned = ownedActivation(operation.scope, operation.scope.source, recorded, installation, observation.target);
   if (owned === null) {
@@ -26404,27 +26942,27 @@ async function prepareRetirement(plan, operation, host, nativeId, ledger) {
   const planCoverage = createLifecyclePlanCoverage(observation, [{
     nativeId,
     operationId: operation.operationId,
-    operation: "retire",
+    operation: capabilityOperation,
     mutationGroupId: operation.operationId,
     authorization: "observed-owned"
   }]);
   const nativeScope = await host.adapter.observeNativeMutationScope({
     targetObservation: observation,
-    operation: "retire",
+    operation: capabilityOperation,
     packageName: owned.packageName,
     nativeId,
     sourceType: owned.sourceType
   });
   const nativeProjection = await host.adapter.observeNativeProjection({
     targetObservation: observation,
-    operation: "retire",
+    operation: capabilityOperation,
     operationId: operation.operationId,
     attemptId: plan.attemptId,
     activation: owned
   });
   const decision = host.adapter.decideRoute({
     target: observation.target,
-    operation: "retire",
+    operation: capabilityOperation,
     operationId: operation.operationId,
     attemptId: plan.attemptId,
     scopeId: operation.scope.id,
@@ -26438,13 +26976,13 @@ async function prepareRetirement(plan, operation, host, nativeId, ledger) {
     planCoverage,
     activation: owned
   });
-  if (decision.kind !== "selected" || decision.operation !== "retire" || decision.route !== operation.route) {
-    return refused(createLifecycleReason("runtime", "runtime.operation-failed", `retirement '${operation.package}' kept frozen route '${operation.route}'`));
+  if (decision.kind !== "selected" || decision.operation !== capabilityOperation || decision.route !== operation.route) {
+    return refused(createLifecycleReason("runtime", "runtime.operation-failed", `${operationLabel} '${operation.package}' kept frozen route '${operation.route}'`));
   }
   return { kind: "ready", selection: decision, activation: owned, recorded };
 }
-function lifecycleTarget2(operation) {
-  return { kind: operation.scope.target.kind, instance: operation.scope.target.instance };
+function lifecycleTarget2(plan, operation) {
+  return plan.scopes.find((row) => row.scope.id === operation.scope.id)?.target ?? { kind: operation.scope.target.kind, instance: operation.scope.target.instance };
 }
 
 class Ledger {
@@ -26505,8 +27043,18 @@ class Ledger {
     return this.state.activations.find((row) => row.scopeId === scopeId && row.packageId === packageId && row.nativeId === nativeId);
   }
   markApplying(plan, operation) {
+    if (operation.action === "disable-nonconforming")
+      this.disablePending(plan, operation, "applying");
     this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "applying", "applying", true));
   }
+  markNotApplied(plan, operation) {
+    if (operation.action === "disable-nonconforming")
+      this.clearDisablePending(operation);
+    this.replaceAttempt(plan, (attempt) => {
+      const next = this.journaled(attempt, operation.operationId, "not-attempted", "failed", false);
+      return { ...next, mutationStarted: next.journal.some((row) => mutationBegan(row.state)) };
+    });
+  }
   markPruning(plan, operation) {
     this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "applying", "pruning", true));
   }
@@ -26570,13 +27118,36 @@ class Ledger {
   }
   markRolledBack(plan, operation) {
     this.adoptMovedGeneration();
+    if (operation.action === "disable-nonconforming")
+      this.clearDisablePending(operation, true);
     this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "rolled-back", "failed", true));
   }
+  confirmDisable(plan, operation) {
+    this.clearDisablePending(operation);
+    this.state = { ...this.state, activations: this.state.activations.map((row) => row.scopeId === operation.scope.id && row.packageId === operation.package ? { ...row, activationState: "inactive", readbackState: "verified", readbackAt: this.now, updatedAt: this.now } : row) };
+    this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "readback-verified", "readback", true));
+  }
+  completeContainment(plan, operation) {
+    this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "completed", "failed", true));
+  }
   markRollbackRequired(plan, operation) {
     this.adoptMovedGeneration();
     this.retargetBareAlias(plan, operation);
+    if (operation.action === "disable-nonconforming")
+      this.disablePending(plan, operation, "rollback");
     this.replaceAttempt(plan, (attempt) => this.journaled(attempt, operation.operationId, "rollback", "recovery-required", true));
   }
+  disablePending(plan, operation, phase) {
+    this.state = { ...this.state, activations: this.state.activations.map((row) => row.scopeId === operation.scope.id && row.packageId === operation.package ? { ...row, pending: { operation: "disable-nonconforming", phase, attemptId: plan.attemptId, startedAt: this.now } } : row) };
+  }
+  clearDisablePending(operation, rolledBack = false) {
+    this.state = { ...this.state, activations: this.state.activations.map((row) => {
+      if (row.scopeId !== operation.scope.id || row.packageId !== operation.package)
+        return row;
+      const { pending: _pending, ...prior } = row;
+      return rolledBack ? { ...prior, activationState: "nonconforming", readbackState: "unverified" } : prior;
+    }) };
+  }
   markCompleted(plan, operation) {
     const desiredPairs = plan.operations.filter((row) => row.operation.scope.id === operation.scope.id && row.operation.coverage === "desired-pair");
     const converged = desiredPairs.every((row) => row.operation.operationId === operation.operationId || row.operation.action === "unchanged" || this.journalState(plan.attemptId, row.operation.operationId) === "completed");
@@ -26595,7 +27166,13 @@ class Ledger {
     if (scope.authority !== "authoritative")
       return scope;
     const planned = plan.scopes.find((row) => row.scope.id === scope.id);
+    if (planned?.retirementPackages !== undefined)
+      return scope;
     if (planned?.selectorMode === "retired") {
+      if (this.state.activations.some((row) => row.scopeId === scope.id))
+        return scope;
+      if (plan.operations.some((row) => row.operation.scope.id === scope.id && row.operation.operationId !== operation.operationId && this.journalState(plan.attemptId, row.operation.operationId) !== "completed"))
+        return scope;
       const { desired: _desired, lastConverged: _converged, ...kept } = scope;
       return {
         ...kept,
@@ -26663,7 +27240,7 @@ class Ledger {
     if (existing !== undefined && existing.authority !== "authoritative")
       return existing;
     const selectorMode = planned.selectorMode;
-    const target = { kind: planned.scope.target.kind, instance: planned.scope.target.instance };
+    const target = planned.target ?? { kind: planned.scope.target.kind, instance: planned.scope.target.instance };
     if (existing === undefined) {
       return {
         id: planned.scope.id,
@@ -26829,19 +27406,40 @@ function succeeded(operation, changed, notices = []) {
   };
 }
 async function recoverApplied(plan, operation, host, ledger, handle, reason) {
+  let verified = false;
+  let diagnostic = "";
   try {
-    await host.adapter.rollback(handle);
-    const observation = await host.adapter.readback(handle);
-    host.adapter.verifyRollback(handle, observation);
-  } catch {
-    ledger.markRollbackRequired(plan, operation);
-    return pendingRecovery(operation);
+    try {
+      await host.adapter.rollback(handle);
+      const observation = await host.adapter.readback(handle);
+      host.adapter.verifyRollback(handle, observation);
+      verified = true;
+    } catch (error) {
+      diagnostic = `; rollback verification failed: ${unknownErrorDiagnostic(error)}`;
+    }
+    try {
+      if (verified)
+        ledger.markRolledBack(plan, operation);
+      else
+        ledger.markRollbackRequired(plan, operation);
+    } catch (error) {
+      verified = false;
+      diagnostic += `; recovery ledger could not be persisted: ${unknownErrorDiagnostic(error)}`;
+    }
+    if (verified) {
+      try {
+        await host.adapter.cleanup(handle, "verified-rollback");
+      } catch {}
+    }
+  } finally {
+    try {
+      await host.adapter.releaseRecovery(handle);
+    } catch (error) {
+      verified = false;
+      diagnostic += `; recovery resources could not be released: ${unknownErrorDiagnostic(error)}`;
+    }
   }
-  ledger.markRolledBack(plan, operation);
-  try {
-    await host.adapter.cleanup(handle, "verified-rollback");
-  } catch {}
-  return reportedRollback(operation, reason);
+  return verified ? reportedRollback(operation, reason) : pendingRecovery(operation, `; original failure: ${reason.diagnostic}${diagnostic}`);
 }
 async function abortPreparation(host, preparation) {
   try {
@@ -26869,8 +27467,8 @@ function pendingReadback(operation, reason) {
     }
   };
 }
-function pendingRecovery(operation) {
-  const reason = createLifecycleReason("recovery", "recovery.required", `rollback for '${operation.operationId}' did not verify`);
+function pendingRecovery(operation, diagnostic = "") {
+  const reason = createLifecycleReason("recovery", "recovery.required", `rollback for '${operation.operationId}' did not verify${diagnostic}`);
   return {
     stop: true,
     reason,
@@ -26906,8 +27504,8 @@ function pendingCleanup(operation) {
     outcome: {
       ...operation,
       result: "pending",
-      resourceState: "present",
-      activationState: "active-conforming",
+      resourceState: operation.action === "disable-nonconforming" ? "retained" : "present",
+      activationState: operation.action === "disable-nonconforming" ? "inactive" : "active-conforming",
       changed: true,
       reason
     }
@@ -26986,7 +27584,7 @@ function summaryFor(outcomes) {
   const failed = outcomes.find((outcome) => outcome.result !== "succeeded");
   const changed = outcomes.some((outcome) => outcome.changed);
   const pending = outcomes.find((outcome) => outcome.result === "pending");
-  const readback = outcomes.find((outcome) => outcome.reason?.category === "readback");
+  const readback = outcomes.find((outcome) => outcome.reason?.category === "readback" || outcome.action === "disable-nonconforming" && outcome.changed);
   const reapplied = outcomes.some((outcome) => outcome.result === "succeeded" && outcome.action === "update");
   const mutationStarted = changed || pending !== undefined || reapplied;
   if (failed === undefined) {
@@ -27080,7 +27678,8 @@ async function runFrozenLifecycle(command) {
     validatedAt: command.now,
     hosts: command.hosts,
     ...command.command === undefined ? {} : { command: command.command },
-    ...command.transportSource === undefined ? {} : { transportSource: command.transportSource }
+    ...command.transportSource === undefined ? {} : { transportSource: command.transportSource },
+    ...command.removalSelection === undefined ? {} : { removalSelection: command.removalSelection }
   });
   const executed = await executeLifecycle({
     plan,
@@ -27103,6 +27702,7 @@ function plannerHost(kind, adapter, plannedNativeId, announceDryRun) {
 var lifecyclePlannerHostKinds = [
   "claude-code",
   "codex",
+  "dcode",
   "kimi",
   "cursor",
   "omp",
@@ -27114,6 +27714,7 @@ function createLifecyclePlannerHosts() {
   return [
     plannerHost("claude-code", createClaudeCodeLifecycleHost(), claudeCodeWriter.plannedNativeId),
     plannerHost("codex", codexLifecycle, codexWriter.plannedNativeId),
+    plannerHost("dcode", dcodeLifecycle, dcodeWriter.plannedNativeId),
     plannerHost("kimi", createLifecycleHostAdapter(kimiLifecycle), kimiWriter.plannedNativeId),
     plannerHost("cursor", cursorManagedLifecycle, cursorWriter.plannedNativeId, announceCursorDryRun),
     plannerHost("omp", ompLifecycle, ompWriter.plannedNativeId),
@@ -27123,6 +27724,161 @@ function createLifecyclePlannerHosts() {
   ];
 }
 
+// src/pin-lifecycle.ts
+import { cpSync as cpSync13, mkdtempSync as mkdtempSync14, rmSync as rmSync15 } from "node:fs";
+import { tmpdir as tmpdir12 } from "node:os";
+import { basename as basename9, join as join35, relative as relative8 } from "node:path";
+async function runOfflineLifecyclePin(host, plugin, dryRun) {
+  const adapter = host.lifecyclePinAdapter;
+  if (adapter === undefined || plugin.path === undefined)
+    throw new Error("offline lifecycle pin has no adapter or active root");
+  let state = readLifecycleState().state;
+  const matches = state.activations.filter((row) => row.nativeId === plugin.id && state.scopes.some((scope) => scope.id === row.scopeId && scope.target.kind === host.id));
+  if (matches.length !== 1)
+    throw new Error("offline lifecycle pin requires one recorded owned activation");
+  const activation = matches[0];
+  const scope = state.scopes.find((row) => row.id === activation.scopeId);
+  if (activation.ownership.kind === "legacy-claim" || activation.route.kind === "legacy-unverified" || activation.sourceRevision === undefined || activation.pending !== undefined)
+    throw new Error("offline lifecycle pin requires verified ownership with no pending recovery");
+  if (activation.activationState !== "active" || activation.readbackState !== "verified")
+    throw new Error("offline lifecycle pin requires a verified active installation");
+  const preview = await host.pin(plugin, { dryRun: true });
+  if (preview.refusals.length !== 0)
+    return { changes: [], refusals: preview.refusals };
+  if (preview.changes.length === 0)
+    return preview;
+  const now = new Date().toISOString();
+  const frozenRoot = mkdtempSync14(join35(tmpdir12(), "plgnz-offline-pin-"));
+  const attemptId = `pin-${basename9(frozenRoot)}`;
+  const operationId = `${attemptId}:${plugin.id}`;
+  let handle;
+  let preparation;
+  let accepted = false, applying = false, committed = false;
+  const attempt = { id: attemptId, command: "update", phase: "accepted", mutationStarted: false, scopeIds: [scope.id], journal: [{ operationId, scopeId: scope.id, packageId: activation.packageId, nativeId: activation.nativeId, action: "update", state: "pending", route: activation.route, startedAt: now, updatedAt: now }], startedAt: now, updatedAt: now };
+  const persist = (nextActivation) => {
+    if (readLifecycleState().state.stateGeneration !== state.stateGeneration)
+      throw new Error("pin ledger changed concurrently; refusing stale commit");
+    const next = { ...state, stateGeneration: state.stateGeneration + 1, activations: state.activations.map((row) => row.scopeId === activation.scopeId && row.nativeId === activation.nativeId ? nextActivation : row), attempts: [...state.attempts.filter((row) => row.id !== attemptId), { ...attempt, journal: attempt.journal.map((row) => ({ ...row })) }] };
+    writeLifecycleState(next, { globalPreflight: "succeeded" });
+    state = next;
+  };
+  const pending = (phase) => persist({ ...activation, pending: { operation: "update", phase, attemptId, startedAt: now }, readbackState: "pending" });
+  try {
+    cpSync13(plugin.path, frozenRoot, { recursive: true });
+    const packageFingerprint = fingerprintTree(frozenRoot);
+    if (packageFingerprint !== activation.fingerprints.installed)
+      throw new Error("pin active bytes differ from recorded readback");
+    const target = { kind: scope.target.kind, instance: scope.target.instance };
+    const observed = await adapter.observeTarget(target);
+    const installed = observed.installations.find((row) => row.nativeId === plugin.id);
+    if (installed?.ownership.kind !== "owned" || installed.ownership.scopeId !== scope.id || installed.installedFingerprint !== packageFingerprint || installed.enablement !== "enabled")
+      throw new Error("pin native identity or bytes differ from the recorded owned activation");
+    const version = await adapter.probeVersion(target);
+    const sourceType = scope.source.kind;
+    const inventory = inventoryPackageSemantics({ dir: frozenRoot, name: activation.packageId, ...plugin.version === undefined ? {} : { version: plugin.version }, contentFingerprint: packageFingerprint });
+    const snapshot = createFrozenPackageSnapshot({ operationId, attemptId, scopeId: scope.id, target, action: "update", packageName: activation.packageId, nativeId: plugin.id, sourceType, immutableRevision: activation.sourceRevision, snapshotRoot: frozenRoot, packageRoot: frozenRoot, relativePackagePath: ".", snapshotFingerprint: packageFingerprint, packageFingerprint, ...sourceType === "git" ? { nativeGit: { locator: scope.source.locator, resolvedRevision: activation.sourceRevision } } : {}, inventory });
+    const pins = createResolvedLifecyclePins(preview.changes.map((change) => ({ server: change.server, executable: change.to })).sort((left, right) => left.server < right.server ? -1 : left.server > right.server ? 1 : 0));
+    const nativeScope = await adapter.observeNativeMutationScope({ targetObservation: observed, operation: "update", packageName: activation.packageId, nativeId: plugin.id, sourceType });
+    const nativeProjection = await adapter.observeNativeProjection({ targetObservation: observed, operation: "update", snapshot, pins });
+    const selection = adapter.decideRoute({ target, operationId, attemptId, scopeId: scope.id, packageName: activation.packageId, nativeId: plugin.id, version, sourceType, targetObservation: observed, nativeScope, nativeProjection, planCoverage: createLifecyclePlanCoverage(observed, [{ nativeId: plugin.id, operationId, operation: "update", mutationGroupId: operationId, authorization: "observed-owned" }]), operation: "update", snapshot, pins });
+    if (selection.kind !== "selected")
+      throw new Error(`pin capability ${selection.status}: ${selection.gaps.map((gap) => gap.capabilityId).join(", ")}`);
+    if (selection.route !== "managed")
+      throw new Error("offline lifecycle pin requires a frozen Managed projection");
+    if (dryRun)
+      return preview;
+    pending("accepted");
+    accepted = true;
+    preparation = await adapter.stageActivation({ selection, snapshot, pins });
+    preparation = await adapter.applyLifecycleDirectives(preparation);
+    preparation = await adapter.applyPins(preparation);
+    const sealed = await adapter.sealActivation(preparation);
+    preparation = sealed;
+    handle = sealed.handle;
+    attempt.phase = "applying";
+    attempt.mutationStarted = true;
+    attempt.journal[0].state = "applying";
+    pending("applying");
+    applying = true;
+    await adapter.apply(sealed);
+    const observation = await adapter.readback(handle);
+    adapter.verify(handle, observation);
+    if (observation.installedFingerprint === null || handle.projectedFingerprint === null)
+      throw new Error("pin readback lacks exact installed/projected fingerprint");
+    attempt.phase = "finalizing";
+    attempt.journal[0].state = "readback-verified";
+    const pinnedActivation = { ...activation, route: { kind: handle.route, evidenceKey: { kind: "capability-profile", key: handle.evidenceId } }, fingerprints: { ...activation.fingerprints, projected: handle.projectedFingerprint, installed: observation.installedFingerprint }, pins: [...new Set([...activation.pins, ...pins.map((pin) => pin.server)])].sort(), readbackState: "verified", readbackAt: now, updatedAt: now };
+    persist(pinnedActivation);
+    committed = true;
+    try {
+      await adapter.cleanup(handle, "verified-commit");
+    } catch (error) {
+      attempt.journal[0].state = "cleanup-pending";
+      persist({ ...pinnedActivation, pending: { operation: "update", phase: "cleanup", attemptId, startedAt: now } });
+      await adapter.releaseRecovery(handle);
+      throw error;
+    }
+    attempt.phase = "completed";
+    attempt.journal[0].state = "completed";
+    attempt.completedAt = now;
+    persist(pinnedActivation);
+    const activatedRoot = observation.contentRoots[0]?.path;
+    return { ...preview, changes: preview.changes.map((change) => ({ ...change, file: activatedRoot === undefined ? change.file : join35(activatedRoot, relative8(plugin.path, change.file)) })) };
+  } catch (error) {
+    if (!committed && handle !== undefined && applying) {
+      if (!(error instanceof LifecycleHostPhaseError && error.mutationStarted === false)) {
+        attempt.phase = "recovery-required";
+        attempt.journal[0].state = "rollback";
+        try {
+          let journalError;
+          try {
+            pending("rollback");
+          } catch (writeError) {
+            journalError = writeError;
+          }
+          await adapter.rollback(handle);
+          adapter.verifyRollback(handle, await adapter.readback(handle));
+          if (journalError !== undefined)
+            throw new Error(`rollback verified but its durable receipt is blocked: ${journalError.message}`);
+          attempt.phase = "finalizing";
+          attempt.journal[0].state = "cleanup-pending";
+          persist({ ...activation, pending: { operation: "update", phase: "cleanup", attemptId, startedAt: now } });
+          await adapter.cleanup(handle, "verified-rollback");
+          attempt.phase = "failed";
+          attempt.journal[0].state = "rolled-back";
+          persist(activation);
+        } catch (recoveryError) {
+          await adapter.releaseRecovery(handle);
+          throw new Error(`pin failed: ${error.message}; recovery remains pending: ${recoveryError.message}`);
+        }
+      } else {
+        attempt.phase = "failed";
+        attempt.journal[0].state = "not-attempted";
+        attempt.mutationStarted = false;
+        persist(activation);
+        await adapter.cleanup(handle, "aborted-preparation");
+      }
+    } else if (!committed && accepted) {
+      try {
+        if (preparation !== undefined)
+          await adapter.cleanup(preparation, "aborted-preparation");
+      } finally {
+        attempt.phase = "failed";
+        attempt.journal[0].state = "not-attempted";
+        persist(activation);
+      }
+    }
+    throw error;
+  } finally {
+    try {
+      if (handle !== undefined)
+        await adapter.releaseRecovery(handle);
+    } finally {
+      rmSync15(frozenRoot, { recursive: true, force: true });
+    }
+  }
+}
+
 // src/pin.ts
 function defaultPinTargets(all = writers) {
   return all.filter((w) => w.gui);
@@ -27133,13 +27889,20 @@ async function runPin(options = {}) {
   const selected = selectTargets(candidates, options);
   const findings = [];
   let ledgerChanged = false;
+  const changedRecords = new Set;
   for (const host of selected) {
     if (!host.detect())
       continue;
     for (const plugin of host.listInstalled()) {
       if (plugin.path === undefined)
         continue;
-      const outcome = await host.pin(plugin, { dryRun: options.dryRun });
+      let outcome;
+      try {
+        outcome = host.lifecyclePinAdapter === undefined ? await host.pin(plugin, { dryRun: options.dryRun }) : await runOfflineLifecyclePin(host, plugin, options.dryRun === true);
+      } catch (error) {
+        findings.push({ host: host.id, mark: "✗", message: `plugin '${plugin.id}' pin failed — ${error.message}` });
+        continue;
+      }
       const prefix = options.dryRun === true ? "[dry-run] " : "";
       for (const change of outcome.changes) {
         findings.push({
@@ -27157,6 +27920,8 @@ async function runPin(options = {}) {
       }
       if (outcome.changes.length === 0)
         continue;
+      if (host.lifecyclePinAdapter !== undefined)
+        continue;
       const record = findRecord(state, host.id, plugin.id);
       if (record === undefined) {
         findings.push({
@@ -27168,6 +27933,7 @@ async function runPin(options = {}) {
       }
       if (options.dryRun === true)
         continue;
+      changedRecords.add(record);
       const pins = new Set(record.pins ?? []);
       for (const change of outcome.changes)
         pins.add(change.server);
@@ -27185,10 +27951,10 @@ async function runPin(options = {}) {
     }
   }
   if (ledgerChanged)
-    persistRecordedPins(state, options.state !== undefined);
+    persistRecordedPins(state, options.state !== undefined, changedRecords);
   return { findings, exitCode: findings.some((f) => f.mark === "✗") ? 1 : 0 };
 }
-function persistRecordedPins(records, legacyLedger) {
+function persistRecordedPins(records, legacyLedger, changedRecords) {
   const loaded = legacyLedger ? null : readLifecycleState();
   if (loaded === null || loaded.sourceVersion !== 2) {
     writeState(records);
@@ -27200,7 +27966,7 @@ function persistRecordedPins(records, legacyLedger) {
     stateGeneration: loaded.state.stateGeneration + 1,
     activations: loaded.state.activations.map((activation) => {
       const scope = scopes.get(activation.scopeId);
-      const record = records.find((candidate) => candidate.host === scope?.target.kind && candidate.id === activation.nativeId);
+      const record = records.find((candidate) => changedRecords.has(candidate) && candidate.host === scope?.target.kind && candidate.id === activation.nativeId);
       if (record === undefined)
         return activation;
       return {
@@ -27672,7 +28438,7 @@ function legacyCommandAction(command) {
 // package.json
 var package_default = {
   name: "plugnz",
-  version: "0.0.8",
+  version: "0.0.9",
   description: "Install, diagnose and update agent plugins (Agent Plugins spec) and MCP configs across Claude Code, Codex, Cursor, Kimi and more",
   license: "MIT",
   type: "module",
@@ -28681,19 +29447,13 @@ async function runRecordedLifecycleRemove(flags, target, state, selected) {
     const alias = writer?.persistedNativeIdMayAlias?.(activation.nativeId, target) === true;
     if (target !== activation.packageId && target !== activation.nativeId && !alias)
       return [];
-    return [{ scope }];
+    return [{ scope, activation }];
   });
   if (matches.length === 0 || matches.some((match) => !plannerKinds.has(match.scope.target.kind)))
     return null;
   const byScope = new Map;
   for (const match of matches)
     byScope.set(match.scope.id, match.scope);
-  for (const scopeId of byScope.keys()) {
-    const inScope = state.activations.filter((activation) => activation.scopeId === scopeId).length;
-    const selectedInScope = matches.filter((match) => match.scope.id === scopeId).length;
-    if (inScope !== selectedInScope)
-      return null;
-  }
   const perHost = new Map;
   for (const match of matches) {
     const count = (perHost.get(match.scope.target.kind) ?? 0) + 1;
@@ -28726,7 +29486,12 @@ async function runRecordedLifecycleRemove(flags, target, state, selected) {
     dryRun: flags.dryRun,
     hosts: createLifecyclePlannerHosts(),
     now: new Date().toISOString(),
-    command: "remove"
+    command: "remove",
+    removalSelection: matches.map(({ activation }) => ({
+      scopeId: activation.scopeId,
+      packageId: activation.packageId,
+      nativeId: activation.nativeId
+    }))
   });
   return executed.report;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plugnz",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "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",