plugnz 0.0.10 → 0.0.12

package/dist/plugnz.mjs

@@ -9795,8 +9795,6 @@ import { existsSync as existsSync12, lstatSync as lstatSync5, readFileSync as re
 import { isAbsolute as isAbsolute3, join as join15, resolve as resolve7 } from "node:path";
 
 // src/hermes-identity.ts
-var HERMES_PORTABLE_SURFACE = "portable-surface";
-var HERMES_PORTABLE_SURFACE_PROBE = "hermes-portable-surface";
 function hermesCommandCompanionId(pluginId) {
   return `${pluginId}.plgnz-commands`;
 }
@@ -10038,6 +10036,10 @@ function yamlStringify(value) {
 }
 
 // src/hosts/hermes.ts
+var hermesProvenManagedRevisions = [
+  "c0d7294769a38c17ceae51d8f7995e66e1dcae27",
+  "dce1e9b37581dd62e480a9064dc04a709c2940d3"
+];
 var hermesTargetProfile = {
   kind: "hermes",
   parseSyncTarget(value, label) {
@@ -12393,6 +12395,203 @@ function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// src/hosts/claude-native-schema.ts
+var control = /[\p{Cc}\u200E\u200F\u202A-\u202E\u2066-\u2069]/u;
+var reserved = new Set(["inline", "builtin", "skills-dir", "synced", "claude-plugin-test"]);
+var official275 = new Set(["claude-community", "claude-plugins-community", "healthcare", "claude-code-marketplace", "claude-code-plugins", "claude-plugins-official", "anthropic-marketplace", "anthropic-plugins", "agent-skills", "anthropic-agent-skills", "life-sciences", "knowledge-work-plugins", "claude-for-legal", "claude-for-financial-services", "financial-services-plugins", "first-party-plugins", "claude-tag-plugins"]);
+var metadataHosts = new Set(["metadata.google.internal", "metadata.goog", "metadata", "instance-data", "instance-data.ec2.internal", "ip6-localhost", "ip6-loopback", "localhost.localdomain", "localhost4", "localhost4.localdomain4", "localhost6", "localhost6.localdomain6"]);
+var metadataIps = new Set(["100.100.100.200", "168.63.129.16", "192.0.0.192"]);
+function object3(value, path, invalid) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return invalid(path, "object");
+  return value;
+}
+function string2(value, path, invalid) {
+  if (typeof value !== "string")
+    return invalid(path, "string");
+  return value;
+}
+function optionalStrings(value, keys, path, invalid) {
+  for (const key of keys)
+    if (value[key] !== undefined)
+      string2(value[key], `${path}.${key}`, invalid);
+}
+function optionalBoolean(value, key, path, invalid) {
+  if (value[key] !== undefined && typeof value[key] !== "boolean")
+    invalid(`${path}.${key}`, "boolean");
+}
+function headers(value, path, invalid) {
+  if (value.headers !== undefined)
+    for (const [key, entry] of Object.entries(object3(value.headers, `${path}.headers`, invalid)))
+      string2(entry, `${path}.headers.${key}`, invalid);
+  if (value.headersHelper !== undefined)
+    printable(value.headersHelper, `${path}.headersHelper`, false, invalid);
+}
+function printable(value, path, nonempty, invalid) {
+  const text = string2(value, path, invalid);
+  if (nonempty && text.length === 0 || text.length > 500 || /[^\x20-\x7E]| {4,}/u.test(text))
+    invalid(path, "printable ASCII, at most 500 characters, no four-space runs");
+}
+function url(value, path, invalid) {
+  const text = string2(value, path, invalid);
+  try {
+    return new URL(text);
+  } catch {
+    return invalid(path, "URL");
+  }
+}
+function registry2(value, path, invalid) {
+  if (value.registry === undefined)
+    return;
+  const text = string2(value.registry, `${path}.registry`, invalid), parsed = url(text, `${path}.registry`, invalid);
+  if (!/^https?:\/\/[^/\\]/iu.test(text) || !["http:", "https:"].includes(parsed.protocol))
+    invalid(`${path}.registry`, "http(s) registry URL");
+}
+function name(value, path, marketplace, version, invalid) {
+  const text = string2(value, path, invalid), lower = text.toLowerCase();
+  if (text.length === 0 || text.includes(" ") || control.test(text))
+    invalid(path, "nonempty name without spaces, control or bidirectional-formatting characters");
+  if (!marketplace)
+    return;
+  if (/[\\/]/u.test(text) || text.includes("..") || text === "." || reserved.has(lower))
+    invalid(path, "native marketplace name");
+  if (version === "2.1.275" && (official275.has(lower) || /[^\u0020-\u007E]/u.test(text) || /(?:official[^a-z0-9]*(anthropic|claude)|(?:anthropic|claude)[^a-z0-9]*official|^(?:anthropic|claude)[^a-z0-9]*(marketplace|plugins|official))/iu.test(text)))
+    invalid(path, "2.1.275 settings marketplace name without reserved/official impersonation");
+}
+function blockedIpv4(bytes) {
+  return bytes[0] === 127 || bytes[0] === 0 || bytes[0] === 169 && bytes[1] === 254 || metadataIps.has(bytes.join("."));
+}
+function ipv6Bytes(host) {
+  const parts = host.split("::"), left = parts[0] ? parts[0].split(":") : [], right = parts.length === 2 && parts[1] ? parts[1].split(":") : [];
+  const numbers = (values) => values.flatMap((value) => {
+    const n = Number.parseInt(value, 16);
+    return [n >> 8, n & 255];
+  });
+  const start = numbers(left), end = numbers(right);
+  return [...start, ...Array(16 - start.length - end.length).fill(0), ...end];
+}
+function archiveHostBlocked(hostname) {
+  let host = hostname.toLowerCase().replace(/^\[|\]$/gu, "");
+  if (host.endsWith("."))
+    host = host.slice(0, -1);
+  if (host === "" || host === "localhost" || host.endsWith(".localhost") || metadataHosts.has(host) || host.startsWith("instance-data.") && host.endsWith(".compute.internal"))
+    return true;
+  if (/^\d+\.\d+\.\d+\.\d+$/u.test(host))
+    return blockedIpv4(host.split(".").map(Number));
+  if (!host.includes(":"))
+    return false;
+  const b = ipv6Bytes(host);
+  const nat64 = b[0] === 0 && b[1] === 100 && b[2] === 255 && b[3] === 155;
+  if (nat64 && b[4] === 0 && b[5] === 1 || b.every((n) => n === 0) || b.slice(0, 15).every((n) => n === 0) && b[15] === 1 || host === "fd00:ec2::254" || b[0] === 254 && b[1] >= 128 && b[1] <= 191)
+    return true;
+  const embedded = [];
+  if (b[0] === 32 && b[1] === 2)
+    embedded.push(b.slice(2, 6));
+  if (b.slice(0, 10).every((n) => n === 0) && (b[10] === 255 && b[11] === 255 || b[10] === 0 && b[11] === 0) || nat64 && b.slice(4, 12).every((n) => n === 0) || (b[8] === 0 || b[8] === 2) && b[9] === 0 && b[10] === 94 && b[11] === 254)
+    embedded.push(b.slice(12, 16));
+  return embedded.some(blockedIpv4);
+}
+function pluginSource(value, path, invalid) {
+  const source = object3(value, path, invalid), kind = string2(source.source, `${path}.source`, invalid);
+  switch (kind) {
+    case "npm": {
+      const pkg = string2(source.package, `${path}.package`, invalid);
+      if (!/^(?:file|https?|git(?:\+https?|\+ssh)?|ssh|github|gitlab|bitbucket):/iu.test(pkg) && pkg.includes(".."))
+        invalid(`${path}.package`, "npm reference without path traversal");
+      optionalStrings(source, ["version"], path, invalid);
+      registry2(source, path, invalid);
+      break;
+    }
+    case "url":
+    case "github":
+    case "git-subdir":
+      string2(source[kind === "github" ? "repo" : "url"], `${path}.${kind === "github" ? "repo" : "url"}`, invalid);
+      optionalStrings(source, ["ref", "sha"], path, invalid);
+      if (source.sha !== undefined && !/^[a-f0-9]{40}$/u.test(source.sha))
+        invalid(`${path}.sha`, "40-character lowercase commit SHA");
+      if (kind === "git-subdir" && string2(source.path, `${path}.path`, invalid).length === 0)
+        invalid(`${path}.path`, "nonempty string");
+      break;
+    case "archive": {
+      const parsed = url(source.url, `${path}.url`, invalid);
+      if (parsed.protocol !== "https:" || archiveHostBlocked(parsed.hostname))
+        invalid(`${path}.url`, "HTTPS archive URL without loopback/link-local/metadata host");
+      optionalStrings(source, ["sha256"], path, invalid);
+      if (source.sha256 !== undefined && !/^[a-f0-9]{64}$/iu.test(source.sha256))
+        invalid(`${path}.sha256`, "64-character hex SHA-256");
+      break;
+    }
+    case "command":
+      printable(source.command, `${path}.command`, true, invalid);
+      if (source.timeout !== undefined && (typeof source.timeout !== "number" || !Number.isInteger(source.timeout) || source.timeout <= 0 || source.timeout > 600))
+        invalid(`${path}.timeout`, "positive integer at most 600");
+      if (source.mode !== undefined && source.mode !== "copy" && source.mode !== "link")
+        invalid(`${path}.mode`, "copy or link");
+      break;
+    default:
+      invalid(`${path}.source`, "native remote inline plugin source");
+  }
+}
+function assertClaudeMarketplaceSource(value, path, version, invalid) {
+  const source = object3(value, path, invalid), kind = string2(source.source, `${path}.source`, invalid);
+  switch (kind) {
+    case "url":
+      url(source.url, `${path}.url`, invalid);
+      headers(source, path, invalid);
+      break;
+    case "github":
+    case "git":
+      string2(source[kind === "github" ? "repo" : "url"], `${path}.${kind === "github" ? "repo" : "url"}`, invalid);
+      optionalStrings(source, ["ref", "path"], path, invalid);
+      optionalBoolean(source, "skipLfs", path, invalid);
+      if (source.sparsePaths !== undefined && (!Array.isArray(source.sparsePaths) || source.sparsePaths.some((v) => typeof v !== "string")))
+        invalid(`${path}.sparsePaths`, "array of strings");
+      break;
+    case "npm": {
+      const pkg = string2(source.package, `${path}.package`, invalid);
+      if (!(/^@[a-z0-9][a-z0-9._-]*\/\*$/u.test(pkg) || !pkg.includes("..") && !pkg.includes("//") && /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/u.test(pkg)))
+        invalid(`${path}.package`, "native npm package name or scope wildcard");
+      optionalStrings(source, ["version"], path, invalid);
+      registry2(source, path, invalid);
+      break;
+    }
+    case "file":
+    case "directory":
+      string2(source.path, `${path}.path`, invalid);
+      break;
+    case "skills-dir":
+      break;
+    case "hostPattern":
+      string2(source.hostPattern, `${path}.hostPattern`, invalid);
+      break;
+    case "pathPattern":
+      string2(source.pathPattern, `${path}.pathPattern`, invalid);
+      break;
+    case "settings": {
+      name(source.name, `${path}.name`, true, version, invalid);
+      if (!Array.isArray(source.plugins))
+        return invalid(`${path}.plugins`, "array of inline plugins");
+      for (const [index, value] of source.plugins.entries()) {
+        const pluginPath = `${path}.plugins[${index}]`, plugin = object3(value, pluginPath, invalid);
+        name(plugin.name, `${pluginPath}.name`, false, version, invalid);
+        pluginSource(plugin.source, `${pluginPath}.source`, invalid);
+        optionalStrings(plugin, ["description", "version"], pluginPath, invalid);
+        optionalBoolean(plugin, "strict", pluginPath, invalid);
+        headers(plugin, pluginPath, invalid);
+      }
+      if (source.owner !== undefined) {
+        const owner = object3(source.owner, `${path}.owner`, invalid);
+        if (string2(owner.name, `${path}.owner.name`, invalid).length === 0)
+          invalid(`${path}.owner.name`, "nonempty string");
+        optionalStrings(owner, ["email", "url"], `${path}.owner`, invalid);
+      }
+      break;
+    }
+    default:
+      invalid(`${path}.source`, "native marketplace source discriminator");
+  }
+}
+
 // src/mcp-write.ts
 import { writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join20 } from "node:path";
@@ -14010,7 +14209,8 @@ function selectLifecycleRoute(adapterId, profiles, request) {
     if (detectedVersion !== undefined && managedAdmission.status === "admitted") {
       return selectedDecision(adapterId, target, request, detectedVersion, "managed", managedAdmission);
     }
-    const gaps = dedupeGaps([...nativeGaps, ...managedAdmission.gaps]);
+    const versionDiagnostic = request.version.kind === "detected" ? undefined : request.version.diagnostic;
+    const gaps = dedupeGaps([...nativeGaps, ...managedAdmission.gaps].map((gap) => versionDiagnostic === undefined ? gap : { ...gap, diagnostic: `${gap.diagnostic}. ${versionDiagnostic}` }));
     if (gaps.length === 0)
       invariant("a refused route decision must retain at least one capability gap");
     return deepFreeze({
@@ -15127,7 +15327,9 @@ function normalizeVersionObservation(input) {
     });
   if (input.kind !== "unknown" && input.kind !== "unparseable")
     invariant("target version observation is invalid");
-  return Object.freeze({ kind: input.kind });
+  return Object.freeze({ kind: input.kind, ...input.diagnostic === undefined ? {} : {
+    diagnostic: stableCopy(input.diagnostic, "version probe diagnostic")
+  } });
 }
 function frozenTarget(input) {
   const parsed = parsePersistedTargetIdentity(input, "lifecycle target");
@@ -15624,6 +15826,22 @@ function readMarketplaces(file) {
     throw new Error(`Invalid Claude Code marketplace registry: ${file}`);
   return value;
 }
+function assertLifecycleMarketplaceEnvelope(version) {
+  const file = join22(pluginsDir(), "known_marketplaces.json");
+  for (const [name, entry] of Object.entries(readMarketplaces(file))) {
+    const invalid = (field, expectation) => {
+      throw new Error(`Invalid Claude Code marketplace registry: ${file}: ${name}.${field}: expected ${expectation}; repair the native configuration before retrying (no automatic edits)`);
+    };
+    if (!isRecord6(entry))
+      return invalid("entry", "object");
+    assertClaudeMarketplaceSource(entry["source"], "source", version, invalid);
+    for (const field of ["installLocation", "lastUpdated"])
+      if (typeof entry[field] !== "string")
+        invalid(field, "string");
+    if (entry["autoUpdate"] !== undefined && typeof entry["autoUpdate"] !== "boolean")
+      invalid("autoUpdate", "boolean");
+  }
+}
 function marketplacesWithLocalSource(marketplaces, name, sourcePath, sourceIdentity, plugin, forceWrapper) {
   const manifest = join22(sourcePath, ".claude-plugin", "marketplace.json");
   const catalog = validateMarketplaceRegistration(marketplaces, name, sourcePath, sourceIdentity, plugin, forceWrapper);
@@ -16088,18 +16306,30 @@ function claudeCodeLifecycleDefinition(contracts) {
     id: "claude-code",
     evidenceProfiles: claudeEvidenceProfiles(detectedVersion, contracts),
     probeVersion: async () => version,
-    observeTarget: async (target) => ({ target, installations: observeClaudeInstallations() }),
+    observeTarget: async (target) => ({ target, installations: observeClaudeInstallations(target, detectedVersion) }),
     observeNativeMutationScope: async (request) => ({
       kind: "bounded",
       mode: "exact-package",
       affectedNativeIds: [request.nativeId]
     }),
-    observeNativeProjection: async (request) => nativeProjection(contracts, request, detectedVersion),
+    observeNativeProjection: async (request) => {
+      const result = nativeProjection(contracts, request, detectedVersion);
+      if ("snapshot" in request && result.kind === "requires-managed") {
+        for (const path of ["known_marketplaces.json", "installed_plugins.json", "../settings.json"])
+          assertManagedPath(resolve11(join22(pluginsDir(), path)));
+        assertManagedPath(cacheSlot(request.snapshot.nativeId, slotVersion(request.snapshot.inventory.package.version, request.snapshot.immutableRevision)));
+        if (!matchingForeignLifecycleCatalog(request.snapshot.nativeId, request.snapshot.scopeId, request.snapshot.target, request.snapshot.packageRoot, request.snapshot.inventory.package.version ?? request.snapshot.immutableRevision))
+          validateLifecycleCatalog(request.snapshot.nativeId, request.snapshot.scopeId);
+      }
+      if (!("snapshot" in request) && request.operation === "retire")
+        validateLifecycleCatalogRetirement(request.activation.nativeId, request.activation.scopeId);
+      return result;
+    },
     revalidateTargetPrecondition: async (handle) => ({
       version: claudeVersionObservation(observeClaudeCodeVersion()),
       targetObservationId: createTargetInventoryObservation("claude-code", {
         target: handle.target,
-        installations: observeClaudeInstallations()
+        installations: observeClaudeInstallations(handle.target, detectedVersion)
       }).observationId
     }),
     stageActivation: async (request) => {
@@ -16125,7 +16355,8 @@ function claudeCodeLifecycleDefinition(contracts) {
     },
     captureActivationPreparation: async (projection, projectedFingerprint) => {
       const installPath = cacheSlot(projection.nativeId, slotVersion(projection.packageVersion, projection.sourceRevision));
-      const prior = claudeReadback(projection, "none");
+      const prior = claudeReadback(projection, "none", detectedVersion);
+      const nativeCatalog = matchingForeignLifecycleCatalog(projection.nativeId, projection.scopeId, projection.target, projection.stagingRoot, slotVersion(projection.packageVersion, projection.sourceRevision));
       return {
         prior,
         expected: {
@@ -16136,20 +16367,24 @@ function claudeCodeLifecycleDefinition(contracts) {
           activation: "active",
           transition: sessionRestart(),
           installedFingerprint: projectedFingerprint,
-          contentRoots: [{ label: "plugin", path: installPath, fingerprint: projectedFingerprint }]
+          contentRoots: [
+            { label: "plugin", path: installPath, fingerprint: projectedFingerprint },
+            { label: "catalog-plugin", path: nativeCatalog ?? lifecycleCatalogCopy(projection.nativeId), fingerprint: nativeCatalog === null ? projectedFingerprint : fingerprintTree(nativeCatalog) },
+            ...nativeCatalog === null ? [{ label: "selected-catalog-entry", path: join22(lifecycleCatalogRoot(projection.nativeId), ".claude-plugin", "marketplace.json"), fingerprint: catalogEntryFingerprint(ownedLifecycleCatalogEntry(projection.nativeId)) }] : lifecycleCatalogEntryObservation(projection.nativeId)
+          ]
         },
         rollbackReference: captureRollback(projection.attemptId, projection.operationId, projection.nativeId),
         rollbackCoverageOperationIds: [...projection.affectedOperationIds]
       };
     },
     captureDisablePreparation: async (request) => ({
-      prior: claudeReadback(activationIdentity(request.activation), "none"),
+      prior: claudeReadback(activationIdentity(request.activation), "none", detectedVersion),
       rollbackReference: captureRollback(request.attemptId, request.operationId, request.activation.nativeId),
       rollbackCoverageOperationIds: [...request.selection.affectedOperationIds],
       transition: sessionRestart()
     }),
     captureRetirementPreparation: async (request) => ({
-      prior: claudeReadback(activationIdentity(request.activation), "none"),
+      prior: claudeReadback(activationIdentity(request.activation), "none", detectedVersion),
       rollbackReference: captureRollback(request.attemptId, request.operationId, request.activation.nativeId),
       rollbackCoverageOperationIds: [...request.selection.affectedOperationIds],
       transition: settledTransition()
@@ -16161,6 +16396,7 @@ function claudeCodeLifecycleDefinition(contracts) {
     },
     disable: async (prepared) => setEnabled(prepared.handle, false, `claude-disable-${prepared.handle.operationId}`),
     retire: async (prepared) => {
+      retireLifecycleCatalog(prepared.handle.nativeId, prepared.handle.scopeId);
       const installPath = recordedInstallPath(prepared.handle.nativeId);
       const existed = installPath !== undefined && existsSync17(installPath);
       if (installPath !== undefined)
@@ -16170,7 +16406,7 @@ function claudeCodeLifecycleDefinition(contracts) {
       return { receiptId: `claude-retire-${prepared.handle.operationId}`, changed: existed };
     },
     readback: async (handle) => {
-      const observed = claudeReadback(handle, handle.action === "remove" || handle.action === "retire-orphan" ? handle.route : "none");
+      const observed = claudeReadback(handle, handle.action === "remove" || handle.action === "retire-orphan" ? handle.route : "none", detectedVersion);
       return { ...observed, transition: readbackTransition(handle, observed) };
     },
     rollback: async (handle) => restoreRollback(handle),
@@ -16227,14 +16463,15 @@ function claudeVersionObservation(observed) {
     return { kind: "detected", version: observed.version, probeId: observed.probeId };
   return { kind: observed.kind };
 }
+var CLAUDE_MANAGED_RELEASES = new Set(["2.1.275", "2.1.295"]);
 function claudeEvidenceProfiles(version, contracts) {
   if (version === undefined)
     return [];
-  const managed = claudeProfile(version, "managed", ["local", "git"], ["install", "update", "disable", "retire"]);
+  const managed = CLAUDE_MANAGED_RELEASES.has(version) ? [claudeProfile(version, "managed", ["local", "git"], ["install", "update", "disable", "retire"])] : [];
   const native = contracts.filter((contract) => contract.version === version && sandboxPasses(contract));
   if (native.length > 1)
     throw new Error(`ambiguous Claude Code native update contract for ${version}`);
-  return native.length === 0 ? [managed] : [managed, claudeProfile(version, "native", ["git"], ["update"])];
+  return native.length === 0 ? managed : [...managed, claudeProfile(version, "native", ["git"], ["update"])];
 }
 function sandboxPasses(contract) {
   return contract.source === "git" && contract.action === "update" && contract.consumesExactSnapshot && contract.forcesSameVersionBytes && contract.rollbackProven && contract.readbackProven;
@@ -16273,7 +16510,8 @@ function claudeSemantics() {
     CLAUDE_PROJECTED_SEMANTICS.has(semantic) ? "supported" : "unsupported"
   ]));
 }
-function observeClaudeInstallations() {
+function observeClaudeInstallations(target, version) {
+  assertLifecycleMarketplaceEnvelope(version);
   const registry = readRegistry(join22(pluginsDir(), "installed_plugins.json"));
   const settings = readSettings(join22(pluginsDir(), "..", "settings.json"));
   const enabled = settings["enabledPlugins"];
@@ -16315,11 +16553,11 @@ function observeClaudeInstallations() {
       } : { kind: "unmanaged" },
       presence: "present",
       enablement: on ? "enabled" : "disabled",
-      activation: on ? "active" : "inactive",
+      activation: on ? lifecycleCatalogConforms(id, installPath, target) ? "active" : "nonconforming" : "inactive",
       installedFingerprint: digest,
       installedVersion: typeof row["version"] === "string" ? row["version"] : null,
       source: revision !== undefined && locator !== undefined ? { type: "git", immutableRevision: revision, locator } : null,
-      contentRoots: [{ label: "plugin", path: installPath, fingerprint: digest }]
+      contentRoots: lifecycleContentRoots(id, installPath, digest)
     });
   }
   return installations;
@@ -16367,7 +16605,8 @@ function sameReadbackState(observed, target) {
 function activationIdentity(activation) {
   return { adapterId: "claude-code", ...activation };
 }
-function claudeReadback(identity, absentRoute) {
+function claudeReadback(identity, absentRoute, version) {
+  assertLifecycleMarketplaceEnvelope(version);
   const installPath = recordedInstallPath(identity.nativeId);
   const present = installPath !== undefined && existsSync17(installPath);
   const retention = {
@@ -16394,10 +16633,10 @@ function claudeReadback(identity, absentRoute) {
     route: installedRoute(installPath),
     presence: "present",
     enablement: enabled ? "enabled" : "disabled",
-    activation: enabled ? "active" : "inactive",
+    activation: enabled ? lifecycleCatalogConforms(identity.nativeId, installPath, identity.target) ? "active" : "unknown" : "inactive",
     transition: settledTransition(),
     installedFingerprint: digest,
-    contentRoots: [{ label: "plugin", path: installPath, fingerprint: digest }],
+    contentRoots: lifecycleContentRoots(identity.nativeId, installPath, digest),
     retention
   };
 }
@@ -16442,6 +16681,306 @@ function cacheSlot(nativeId, version) {
   const market = at === -1 ? "local" : nativeId.slice(at + 1);
   return resolve11(join22(pluginsDir(), "cache", market, name, version));
 }
+function lifecycleCatalogRoot(nativeId) {
+  const market = marketplaceName(nativeId);
+  if (market === undefined || market.includes("/") || market.includes("\\"))
+    throw new Error("Claude Code lifecycle native identity has no safe marketplace");
+  return resolve11(join22(pluginsDir(), "marketplaces", `.plgnz-${market}`));
+}
+function lifecycleCatalogCopy(nativeId) {
+  const name = nativeId.slice(0, nativeId.indexOf("@"));
+  if (!name || name.includes("/") || name.includes("\\"))
+    throw new Error("Claude Code lifecycle native identity has no safe package name");
+  return join22(lifecycleCatalogRoot(nativeId), "plugins", name);
+}
+function registeredLifecycleCatalogMember(nativeId) {
+  const market = marketplaceName(nativeId);
+  if (market === undefined)
+    return null;
+  const entry = readMarketplaces(join22(pluginsDir(), "known_marketplaces.json"))[market];
+  if (!isRecord6(entry) || !isRecord6(entry["source"]) || entry["source"]["source"] !== "directory" || typeof entry["source"]["path"] !== "string" || entry["installLocation"] !== entry["source"]["path"])
+    return null;
+  const root = entry["source"]["path"];
+  if (!root.startsWith("/") || resolve11(root) !== root || !existsSync17(root))
+    return null;
+  assertCatalogPath(root, join22(root, ".claude-plugin", "marketplace.json"));
+  const selected = catalogEntries(lifecycleCatalogDocument(root, market)).filter((item) => isCatalogMember(item, nativeId));
+  if (selected.length !== 1 || !isRecord6(selected[0]) || typeof selected[0]["source"] !== "string" || !selected[0]["source"].startsWith("./"))
+    return null;
+  const member = resolve11(root, selected[0]["source"]);
+  if (!containedPath(root, member) || root === member || !existsSync17(member))
+    return null;
+  assertCatalogPath(root, member);
+  assertNoSymlinks2(member);
+  return { root, member, entry: selected[0] };
+}
+function matchingForeignLifecycleCatalog(nativeId, scopeId, target, packageRoot, version) {
+  const catalog = registeredLifecycleCatalogMember(nativeId);
+  if (catalog === null || catalog.root === lifecycleCatalogRoot(nativeId))
+    return null;
+  if (createDeploymentScopeIdentity({ kind: "local", locator: catalog.root }, target).id !== scopeId)
+    return null;
+  if (!foreignLifecycleEntryEquivalent(catalog.entry))
+    return null;
+  if (!existsSync17(join22(catalog.member, ".claude-plugin", "plugin.json")))
+    return null;
+  const proof = mkdtempSync3(join22(tmpdir(), "plgnz-claude-native-member-"));
+  try {
+    stagePlugin(packageRoot, join22(proof, "incoming"), nativeId.slice(0, nativeId.indexOf("@")), version);
+    cpSync3(catalog.member, join22(proof, "native"), { recursive: true });
+    for (const path of [join22(proof, "incoming"), join22(proof, "native")]) {
+      rmSync3(join22(path, ".plgnz-lifecycle.json"), { force: true });
+      rmSync3(join22(path, OWNERSHIP), { force: true });
+    }
+    return fingerprintTree(join22(proof, "incoming")) === fingerprintTree(join22(proof, "native")) ? catalog.member : null;
+  } finally {
+    rmSync3(proof, { recursive: true, force: true });
+  }
+}
+function lifecycleCatalogDocument(root, market) {
+  const file = join22(root, ".claude-plugin", "marketplace.json");
+  if (!existsSync17(file))
+    return null;
+  const parsed = JSON.parse(readFileSync16(file, "utf8"));
+  if (!isRecord6(parsed) || parsed["name"] !== market || !Array.isArray(parsed["plugins"]))
+    throw new Error(`Invalid Claude Code lifecycle catalog identity: ${file}`);
+  return parsed;
+}
+function catalogEntries(document) {
+  return document === null ? [] : document["plugins"];
+}
+function isCatalogMember(entry, nativeId) {
+  return isRecord6(entry) && entry["name"] === nativeId.slice(0, nativeId.indexOf("@"));
+}
+function ownedLifecycleCatalogEntry(nativeId) {
+  const name = nativeId.slice(0, nativeId.indexOf("@"));
+  return { name, source: `./plugins/${name}` };
+}
+function catalogEntryFingerprint(entry) {
+  const canonical = (value) => Array.isArray(value) ? `[${value.map(canonical).join(",")}]` : isRecord6(value) ? `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}` : JSON.stringify(value);
+  const hash = new CryptoHasher("sha256");
+  hash.update(canonical(entry));
+  return hash.digest("hex");
+}
+function foreignLifecycleEntryEquivalent(entry) {
+  if (["commands", "agents", "skills", "hooks", "outputStyles", "themes"].some((key) => Object.hasOwn(entry, key)))
+    return false;
+  if (entry["strict"] !== undefined && typeof entry["strict"] !== "boolean")
+    return false;
+  if (entry["dependencies"] !== undefined && (!Array.isArray(entry["dependencies"]) || entry["dependencies"].length !== 0))
+    return false;
+  if (entry["defaultEnabled"] !== undefined && typeof entry["defaultEnabled"] !== "boolean")
+    return false;
+  return true;
+}
+function lifecycleCatalogEntryObservation(nativeId) {
+  const root = registeredLifecycleCatalogMember(nativeId)?.root ?? lifecycleCatalogRoot(nativeId);
+  const document = lifecycleCatalogDocument(root, marketplaceName(nativeId));
+  const entries = catalogEntries(document).filter((entry) => isCatalogMember(entry, nativeId));
+  return entries.length === 1 ? [{ label: "selected-catalog-entry", path: join22(root, ".claude-plugin", "marketplace.json"), fingerprint: catalogEntryFingerprint(entries[0]) }] : [];
+}
+function validateLifecycleCatalog(nativeId, scopeId) {
+  const root = lifecycleCatalogRoot(nativeId);
+  const copy = lifecycleCatalogCopy(nativeId);
+  const market = marketplaceName(nativeId);
+  assertManagedPath(root);
+  assertManagedPath(join22(root, ".claude-plugin", "marketplace.json"));
+  assertManagedPath(join22(root, OWNERSHIP));
+  assertManagedPath(copy);
+  if (existsSync17(root)) {
+    const owner = readOwnership(root);
+    if (owner?.source !== "plgnz-wrapper" || owner.pluginId !== `marketplace@${market}`)
+      throw new Error(`Claude Code marketplace wrapper ${root} is foreign; refusing to replace it`);
+  }
+  const document = lifecycleCatalogDocument(root, market);
+  const selected = catalogEntries(document).filter((entry) => isCatalogMember(entry, nativeId));
+  if (selected.length > 1 || selected.some((entry) => !isRecord6(entry) || entry["source"] !== `./plugins/${nativeId.slice(0, nativeId.indexOf("@"))}`))
+    throw new Error(`Claude Code marketplace member ${nativeId} is foreign or ambiguous; refusing to replace it`);
+  if (existsSync17(copy)) {
+    assertNoSymlinks2(copy);
+    const owner = readOwnership(copy);
+    if (owner?.pluginId !== nativeId || owner.scopeId !== scopeId)
+      throw new Error(`Claude Code marketplace member ${copy} has a different owned scope; refusing to replace it`);
+  } else if (selected.length > 0) {
+    const installed = recordedInstallPath(nativeId);
+    const owner = installed === undefined ? null : readOwnership(installed);
+    if (owner?.pluginId !== nativeId || owner.scopeId !== scopeId)
+      throw new Error(`Claude Code marketplace member ${nativeId} has no ownership proof; refusing to replace it`);
+  }
+  const known = readMarketplaces(join22(pluginsDir(), "known_marketplaces.json"));
+  const extra = readSettings(join22(pluginsDir(), "..", "settings.json"))["extraKnownMarketplaces"];
+  for (const entry of [known[market], isRecord6(extra) ? extra[market] : undefined]) {
+    if (entry === undefined)
+      continue;
+    if (!isRecord6(entry) || !isRecord6(entry["source"]) || entry["source"]["source"] !== "directory" || entry["source"]["path"] !== root || entry["installLocation"] !== undefined && entry["installLocation"] !== root)
+      throw new Error(`Claude Code marketplace ${market} is registered from a different source; refusing to replace it`);
+  }
+}
+function installLifecycleCatalog(nativeId, scopeId, stagingRoot) {
+  validateLifecycleCatalog(nativeId, scopeId);
+  const root = lifecycleCatalogRoot(nativeId);
+  const copy = lifecycleCatalogCopy(nativeId);
+  const market = marketplaceName(nativeId);
+  const document = lifecycleCatalogDocument(root, market) ?? { name: market, owner: { name: "plgnz" }, plugins: [] };
+  rmSync3(copy, { recursive: true, force: true });
+  mkdirSync3(dirname6(copy), { recursive: true });
+  cpSync3(stagingRoot, copy, { recursive: true });
+  mkdirSync3(join22(root, ".claude-plugin"), { recursive: true });
+  writeFileSync3(join22(root, ".claude-plugin", "marketplace.json"), JSON.stringify({ ...document, plugins: [...catalogEntries(document).filter((entry) => !isCatalogMember(entry, nativeId)), ownedLifecycleCatalogEntry(nativeId)] }));
+  writeFileSync3(join22(root, OWNERSHIP), JSON.stringify({ source: "plgnz-wrapper", pluginId: `marketplace@${market}`, fingerprint: "" }));
+  const file = join22(pluginsDir(), "known_marketplaces.json");
+  const known = readMarketplaces(file);
+  const previous = isRecord6(known[market]) ? known[market] : {};
+  writeMarketplaces(file, { ...known, [market]: { ...previous, source: { source: "directory", path: root }, installLocation: root, lastUpdated: new Date().toISOString() } });
+}
+function lifecycleCatalogConforms(nativeId, installPath, target) {
+  const market = marketplaceName(nativeId);
+  if (market === undefined)
+    return false;
+  const registered = registeredLifecycleCatalogMember(nativeId);
+  const owner = readOwnership(installPath);
+  if (registered !== null && registered.root !== lifecycleCatalogRoot(nativeId)) {
+    if (owner?.scopeId === undefined)
+      return false;
+    const manifest = existsSync17(join22(installPath, ".plugin", "plugin.json")) ? join22(installPath, ".plugin", "plugin.json") : join22(installPath, "plugin.json");
+    return matchingForeignLifecycleCatalog(nativeId, owner.scopeId, target, installPath, parseManifest(manifest, "canonical").version ?? "") !== null;
+  }
+  const known = readMarketplaces(join22(pluginsDir(), "known_marketplaces.json"))[market];
+  if (!isRecord6(known) || !isRecord6(known["source"]) || known["source"]["source"] !== "directory" || known["source"]["path"] !== lifecycleCatalogRoot(nativeId) || known["installLocation"] !== lifecycleCatalogRoot(nativeId))
+    return false;
+  const entries = catalogEntries(lifecycleCatalogDocument(lifecycleCatalogRoot(nativeId), market)).filter((entry) => isCatalogMember(entry, nativeId));
+  if (entries.length !== 1 || catalogEntryFingerprint(entries[0]) !== catalogEntryFingerprint(ownedLifecycleCatalogEntry(nativeId)))
+    return false;
+  const copy = lifecycleCatalogCopy(nativeId);
+  if (!existsSync17(copy))
+    return false;
+  assertManagedPath(copy);
+  assertNoSymlinks2(copy);
+  const catalogOwner = readOwnership(copy);
+  return owner?.pluginId === nativeId && catalogOwner?.pluginId === nativeId && owner.scopeId === catalogOwner.scopeId && fingerprintTree(copy) === fingerprintTree(installPath);
+}
+function lifecycleContentRoots(nativeId, installPath, digest) {
+  const copy = registeredLifecycleCatalogMember(nativeId)?.member ?? lifecycleCatalogCopy(nativeId);
+  return [{ label: "plugin", path: installPath, fingerprint: digest }, ...existsSync17(copy) ? [{ label: "catalog-plugin", path: copy, fingerprint: fingerprintTree(copy) }] : [], ...lifecycleCatalogEntryObservation(nativeId)];
+}
+function retireLifecycleCatalog(nativeId, scopeId) {
+  validateLifecycleCatalogRetirement(nativeId, scopeId);
+  const root = lifecycleCatalogRoot(nativeId);
+  const copy = lifecycleCatalogCopy(nativeId);
+  if (!existsSync17(root))
+    return;
+  assertManagedPath(root);
+  const market = marketplaceName(nativeId);
+  const owner = readOwnership(root);
+  if (owner?.source !== "plgnz-wrapper" || owner.pluginId !== `marketplace@${market}`)
+    return;
+  const document = lifecycleCatalogDocument(root, market);
+  if (existsSync17(copy)) {
+    const member = readOwnership(copy);
+    if (member?.pluginId !== nativeId || member.scopeId !== scopeId)
+      throw new Error(`Claude Code catalog retirement cannot prove ownership: ${copy}`);
+    rmSync3(copy, { recursive: true, force: true });
+  }
+  const entries = catalogEntries(document).filter((entry) => !isCatalogMember(entry, nativeId));
+  if (document !== null)
+    writeFileSync3(join22(root, ".claude-plugin", "marketplace.json"), JSON.stringify({ ...document, plugins: entries }));
+  if (entries.length === 0 && emptyOwnedCatalogContainer(root)) {
+    rmSync3(root, { recursive: true, force: true });
+    const file = join22(pluginsDir(), "known_marketplaces.json");
+    const known = readMarketplaces(file);
+    const entry = known[market];
+    if (isRecord6(entry) && isRecord6(entry["source"]) && entry["source"]["path"] === root) {
+      const next = { ...known };
+      delete next[market];
+      writeMarketplaces(file, next);
+    }
+  }
+}
+function emptyOwnedCatalogContainer(root) {
+  if (!existsSync17(root))
+    return true;
+  if (readdirSync11(root).some((name) => ![OWNERSHIP, ".claude-plugin", "plugins"].includes(name)))
+    return false;
+  if (existsSync17(join22(root, ".claude-plugin")) && readdirSync11(join22(root, ".claude-plugin")).some((name) => name !== "marketplace.json"))
+    return false;
+  return !existsSync17(join22(root, "plugins")) || readdirSync11(join22(root, "plugins")).length === 0;
+}
+function validateLifecycleCatalogRetirement(nativeId, scopeId) {
+  const root = lifecycleCatalogRoot(nativeId);
+  if (!existsSync17(root))
+    return;
+  assertManagedPath(root);
+  assertManagedPath(join22(root, OWNERSHIP));
+  const owner = readOwnership(root);
+  if (owner?.source !== "plgnz-wrapper" || owner.pluginId !== `marketplace@${marketplaceName(nativeId)}`) {
+    const member = readOwnership(lifecycleCatalogCopy(nativeId));
+    if (member?.pluginId === nativeId && member.scopeId === scopeId)
+      throw new Error(`Claude Code catalog retirement lost its container ownership proof: ${root}`);
+    return;
+  }
+  assertManagedPath(join22(root, ".claude-plugin", "marketplace.json"));
+  const copy = lifecycleCatalogCopy(nativeId);
+  assertManagedPath(copy);
+  const selected = catalogEntries(lifecycleCatalogDocument(root, marketplaceName(nativeId))).filter((entry) => isCatalogMember(entry, nativeId));
+  if (selected.length > 1 || selected.some((entry) => !isRecord6(entry) || entry["source"] !== `./plugins/${nativeId.slice(0, nativeId.indexOf("@"))}`))
+    throw new Error(`Claude Code catalog retirement found a foreign or ambiguous member: ${nativeId}`);
+  if (existsSync17(copy)) {
+    assertNoSymlinks2(copy);
+    const member = readOwnership(copy);
+    if (member?.pluginId !== nativeId || member.scopeId !== scopeId)
+      throw new Error(`Claude Code catalog retirement cannot prove ownership: ${copy}`);
+  }
+}
+function captureLifecycleCatalog(reference, nativeId) {
+  const root = lifecycleCatalogRoot(nativeId);
+  const market = marketplaceName(nativeId);
+  const document = lifecycleCatalogDocument(root, market);
+  writeFileSync3(join22(reference, "catalog.json"), JSON.stringify({ document, selected: catalogEntries(document).filter((entry) => isCatalogMember(entry, nativeId)), marker: existsSync17(join22(root, OWNERSHIP)) ? readFileSync16(join22(root, OWNERSHIP), "utf8") : null }));
+  const copy = lifecycleCatalogCopy(nativeId);
+  if (existsSync17(copy)) {
+    assertNoSymlinks2(copy);
+    cpSync3(copy, join22(reference, "catalog-plugin"), { recursive: true });
+  }
+}
+function restoreLifecycleCatalog(reference, nativeId, scopeId) {
+  const saved = JSON.parse(readFileSync16(join22(reference, "catalog.json"), "utf8"));
+  const root = lifecycleCatalogRoot(nativeId);
+  assertManagedPath(root);
+  if (existsSync17(root)) {
+    assertManagedPath(join22(root, OWNERSHIP));
+    const owner = readOwnership(root);
+    if (owner?.source !== "plgnz-wrapper" || owner.pluginId !== `marketplace@${marketplaceName(nativeId)}`)
+      throw new Error(`Claude Code rollback refuses a foreign catalog: ${root}`);
+  }
+  assertManagedPath(join22(root, ".claude-plugin", "marketplace.json"));
+  const market = marketplaceName(nativeId);
+  const current = lifecycleCatalogDocument(root, market);
+  const siblings = catalogEntries(current).filter((entry) => !isCatalogMember(entry, nativeId));
+  const copy = lifecycleCatalogCopy(nativeId);
+  assertManagedPath(copy);
+  if (existsSync17(copy)) {
+    assertNoSymlinks2(copy);
+    const owner = readOwnership(copy);
+    if (owner?.pluginId !== nativeId || owner.scopeId !== scopeId)
+      throw new Error(`Claude Code rollback refuses a foreign catalog member: ${copy}`);
+  }
+  rmSync3(copy, { recursive: true, force: true });
+  if (existsSync17(join22(reference, "catalog-plugin"))) {
+    mkdirSync3(dirname6(copy), { recursive: true });
+    cpSync3(join22(reference, "catalog-plugin"), copy, { recursive: true });
+  }
+  if (saved.document === null && siblings.length === 0 && emptyOwnedCatalogContainer(root)) {
+    rmSync3(root, { recursive: true, force: true });
+    return;
+  }
+  const document = current ?? saved.document;
+  if (document === null)
+    throw new Error("Claude Code catalog rollback has no manifest");
+  mkdirSync3(join22(root, ".claude-plugin"), { recursive: true });
+  writeFileSync3(join22(root, ".claude-plugin", "marketplace.json"), JSON.stringify({ ...document, plugins: [...siblings, ...saved.selected] }));
+  if (saved.marker !== null)
+    writeFileSync3(join22(root, OWNERSHIP), saved.marker);
+}
 function slotVersion(version, revision) {
   const selected = version ?? revision;
   if (selected.length === 0 || selected.includes("/") || selected.includes("\\")) {
@@ -16467,6 +17006,7 @@ function captureRollback(attemptId, operationId, nativeId) {
   const known = readMarketplaces(join22(pluginsDir(), "known_marketplaces.json"));
   const knownEntry = marketplace !== undefined && Object.hasOwn(known, marketplace) ? known[marketplace] ?? null : null;
   writeFileSync3(join22(reference, "known-marketplace.json"), JSON.stringify({ marketplace: marketplace ?? null, entry: knownEntry }));
+  captureLifecycleCatalog(reference, nativeId);
   const installPath = recordedInstallPath(nativeId);
   if (installPath !== undefined && existsSync17(installPath)) {
     cpSync3(installPath, join22(reference, "install"), { recursive: true });
@@ -16477,6 +17017,18 @@ function captureRollback(attemptId, operationId, nativeId) {
 function mutateInstall(handle, stagingRoot) {
   if (handle.projectedFingerprint === null)
     throw new Error("claude-code activation is missing its sealed fingerprint");
+  const nativeCatalog = matchingForeignLifecycleCatalog(handle.nativeId, handle.scopeId, handle.target, stagingRoot, slotVersion(handle.packageVersion, handle.sourceRevision));
+  if (nativeCatalog === null)
+    validateLifecycleCatalog(handle.nativeId, handle.scopeId);
+  const capturedEntry = handle.expected.contentRoots.find((root) => root.label === "selected-catalog-entry");
+  const ownedEntryPath = join22(lifecycleCatalogRoot(handle.nativeId), ".claude-plugin", "marketplace.json");
+  if (nativeCatalog !== null || capturedEntry !== undefined && capturedEntry.path !== ownedEntryPath) {
+    const liveEntry = lifecycleCatalogEntryObservation(handle.nativeId)[0];
+    if (nativeCatalog === null || capturedEntry === undefined || capturedEntry.path === ownedEntryPath || liveEntry?.path !== capturedEntry.path || liveEntry.fingerprint !== capturedEntry.fingerprint) {
+      throw new Error("claude-code selected foreign catalog entry changed after preparation; re-plan before applying");
+    }
+  }
+  const beforeCatalog = lifecycleSelectedMutationState(handle.nativeId);
   const installPath = cacheSlot(handle.nativeId, slotVersion(handle.packageVersion, handle.sourceRevision));
   const before = existsSync17(installPath) ? fingerprintTree(installPath) : null;
   rmSync3(installPath, { recursive: true, force: true });
@@ -16491,6 +17043,8 @@ function mutateInstall(handle, stagingRoot) {
     plugins: []
   };
   try {
+    if (nativeCatalog === null)
+      installLifecycleCatalog(handle.nativeId, handle.scopeId, stagingRoot);
     writeRegistry(registryFile, registryWithEntry(readRegistry(registryFile), handle.nativeId, installPath, slotVersion(handle.packageVersion, handle.sourceRevision), source));
     writeSettings(settingsFile, settingsWithEnabled(readSettings(settingsFile), handle.nativeId, true));
     disableMarketplaceAutoUpdate(handle.nativeId);
@@ -16500,9 +17054,24 @@ function mutateInstall(handle, stagingRoot) {
   }
   return {
     receiptId: `claude-apply-${handle.operationId}`,
-    changed: before !== handle.projectedFingerprint
+    changed: before !== handle.projectedFingerprint || beforeCatalog !== lifecycleSelectedMutationState(handle.nativeId)
   };
 }
+function lifecycleSelectedMutationState(nativeId) {
+  const market = marketplaceName(nativeId);
+  const known = readMarketplaces(join22(pluginsDir(), "known_marketplaces.json"));
+  const settings = readSettings(join22(pluginsDir(), "..", "settings.json"));
+  const extra = settings["extraKnownMarketplaces"];
+  const member = registeredLifecycleCatalogMember(nativeId)?.member ?? lifecycleCatalogCopy(nativeId);
+  return catalogEntryFingerprint({
+    catalogEntry: lifecycleCatalogEntryObservation(nativeId),
+    member: existsSync17(member) ? fingerprintTree(member) : null,
+    registration: known[market] ?? null,
+    extraRegistration: isRecord6(extra) ? extra[market] ?? null : null,
+    installedRows: readRegistry(join22(pluginsDir(), "installed_plugins.json")).plugins[nativeId] ?? null,
+    enabled: enabledPlugins()[nativeId] ?? null
+  });
+}
 function setEnabled(handle, enabled, receiptId) {
   const settingsFile = join22(pluginsDir(), "..", "settings.json");
   const was = enabledPlugins()[handle.nativeId] === true;
@@ -16537,6 +17106,7 @@ function restoreRollback(handle) {
   const beforeMarkets = existsSync17(join22(pluginsDir(), "known_marketplaces.json")) ? readFileSync16(join22(pluginsDir(), "known_marketplaces.json"), "utf8") : "";
   const beforeApplied = existsSync17(appliedSlot) ? fingerprintTree(appliedSlot) : null;
   const beforePrevious = previousSlot !== undefined && existsSync17(previousSlot) ? fingerprintTree(previousSlot) : null;
+  restoreLifecycleCatalog(reference, handle.nativeId, handle.scopeId);
   restorePluginSlice(handle.nativeId, reference);
   if (previousSlot !== undefined && resolve11(previousSlot) !== appliedSlot)
     rmSync3(appliedSlot, { recursive: true, force: true });
@@ -16604,6 +17174,9 @@ function restoreKnownMarketplace(reference) {
   if (saved.entry === null) {
     if (!hadFile || !Object.hasOwn(current, saved.marketplace))
       return;
+    const root = lifecycleCatalogRoot(`rollback@${saved.marketplace}`);
+    if (existsSync17(root) && (catalogEntries(lifecycleCatalogDocument(root, saved.marketplace)).length > 0 || !emptyOwnedCatalogContainer(root)))
+      return;
     const next = { ...current };
     delete next[saved.marketplace];
     writeMarketplaces(file, next);
@@ -16648,10 +17221,29 @@ function marketplaceAutoUpdateRecords(marketplace) {
 }
 function hasForeignMarketplaceSibling(nativeId, marketplace) {
   const registry = readRegistry(join22(pluginsDir(), "installed_plugins.json"));
-  return Object.entries(registry.plugins).some(([id, rows]) => {
+  if (Object.entries(registry.plugins).some(([id, rows]) => {
     if (id === nativeId || marketplaceName(id) !== marketplace || !Array.isArray(rows))
       return false;
     return rows.some((row) => isRecord6(row) && row["scope"] === "user" && !plgnzOwnedInstall(id, row["installPath"]));
+  }))
+    return true;
+  const registration = readMarketplaces(join22(pluginsDir(), "known_marketplaces.json"))[marketplace];
+  if (!isRecord6(registration) || !isRecord6(registration["source"]) || registration["source"]["source"] !== "directory" || typeof registration["source"]["path"] !== "string")
+    return false;
+  const root = registration["source"]["path"];
+  if (!root.startsWith("/") || !existsSync17(root))
+    return false;
+  const document = lifecycleCatalogDocument(root, marketplace);
+  return catalogEntries(document).some((entry) => {
+    if (isCatalogMember(entry, nativeId))
+      return false;
+    if (!isRecord6(entry) || typeof entry["name"] !== "string" || typeof entry["source"] !== "string" || !entry["source"].startsWith("./"))
+      return true;
+    const member = resolve11(root, entry["source"]);
+    if (!containedPath(root, member) || member === root || !existsSync17(member))
+      return true;
+    assertCatalogPath(root, member);
+    return readOwnership(member)?.pluginId !== `${entry["name"]}@${marketplace}`;
   });
 }
 function plgnzOwnedInstall(id, installPath) {
@@ -19771,9 +20363,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 = object3(lock.plugins, "lockfile plugins");
+    const lockPlugins = object4(lock.plugins, "lockfile plugins");
     const registry = readDoc(registryFile, { version: 2, plugins: {} }, "registry");
-    const registryPlugins = object3(registry.plugins, "registry plugins");
+    const registryPlugins = object4(registry.plugins, "registry plugins");
     const rows = userRows(registryPlugins[id]);
     if (rows.length > 0)
       validateLegacy(rows, id, plugin.name, version, opts?.adoptExisting === true);
@@ -20096,7 +20688,7 @@ function readDoc(path, fallback, label) {
     throw new Error(`invalid OMP ${label}: ${path} (${error.message})`);
   }
 }
-function object3(value, label) {
+function object4(value, label) {
   if (!isDoc(value))
     throw new Error(`invalid OMP ${label}`);
   return value;
@@ -20517,7 +21109,7 @@ async function applyManaged(handle, stagingRoot) {
   const link = managedLink(handle.nativeId);
   const file = lockPath();
   const lock = readDoc(file, { plugins: {}, settings: {} }, "lockfile");
-  const plugins = object3(lock.plugins, "lockfile plugins");
+  const plugins = object4(lock.plugins, "lockfile plugins");
   const before = snapshot(file);
   mkdirSafe(dirname9(target));
   mkdirSafe(dirname9(link));
@@ -20547,7 +21139,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 = object3(lock.plugins, "lockfile plugins");
+  const plugins = object4(lock.plugins, "lockfile plugins");
   const row = entry(plugins[npmName(nativeId)]);
   return row.enabled === true && row.version === version;
 }
@@ -20555,7 +21147,7 @@ async function disableManaged(handle) {
   const receiptId = `disable:${handle.attemptId}:${handle.operationId}`;
   const file = lockPath();
   const lock = readDoc(file, { plugins: {}, settings: {} }, "lockfile");
-  const plugins = object3(lock.plugins, "lockfile plugins");
+  const plugins = object4(lock.plugins, "lockfile plugins");
   const npm = npmName(handle.nativeId);
   const previous = entry(plugins[npm]);
   if (previous.enabled === false)
@@ -20998,7 +21590,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(object4(registry.plugins, "registry plugins")).map(([nativeId, raw]) => {
+  return Object.entries(object5(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`);
@@ -21053,7 +21645,7 @@ function captureDcodeRollback(binding, attemptId, operationId) {
   mkdirSync9(dir, { recursive: true });
   const registry = readRegistry3(dcodeRegistryFile());
   const enabled = boolObject(readEnablement(dcodeEnablementFile()).enabledPlugins, "enabledPlugins");
-  const row = object4(registry.plugins, "registry plugins")[binding.nativeId];
+  const row = object5(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()) {
@@ -21100,7 +21692,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(object4(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[snapshot.nativeId], snapshot.nativeId, snapshot.nativeGit?.locator ?? `local:${snapshot.scopeId}`, true, snapshot.packageName, manifest.version, snapshot.packageRoot);
+  assessPrior(object5(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");
 }
@@ -21108,7 +21700,7 @@ function setDcodeRow(nativeId, row, enabled) {
   assertManagedPath4(dcodeRegistryFile());
   assertManagedPath4(dcodeEnablementFile());
   const registry = readRegistry3(dcodeRegistryFile()), enablement = readEnablement(dcodeEnablementFile());
-  const plugins = { ...object4(registry.plugins, "registry plugins") }, flags = { ...boolObject(enablement.enabledPlugins, "enabledPlugins") };
+  const plugins = { ...object5(registry.plugins, "registry plugins") }, flags = { ...boolObject(enablement.enabledPlugins, "enabledPlugins") };
   if (row === null)
     delete plugins[nativeId];
   else
@@ -21232,13 +21824,13 @@ var dcodeDefinition = {
   },
   disable: async (prepared) => {
     await acquireNativeLock(prepared.handle.attemptId, prepared.handle.operationId);
-    const row = object4(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[prepared.handle.nativeId];
+    const row = object5(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[prepared.handle.nativeId];
     setDcodeRow(prepared.handle.nativeId, row ?? null, false);
     return { receiptId: `dcode-disable:${prepared.handle.operationId}`, changed: true };
   },
   retire: async (prepared) => {
     await acquireNativeLock(prepared.handle.attemptId, prepared.handle.operationId);
-    const rows = rowsFor(object4(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[prepared.handle.nativeId]);
+    const rows = rowsFor(object5(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")[prepared.handle.nativeId]);
     for (const row of rows) {
       const path = rowInstall(row, prepared.handle.nativeId);
       assertCachePath(path);
@@ -21288,7 +21880,7 @@ var dcodeDefinition = {
       }
     }
     setDcodeRow(handle.nativeId, state.row ?? null, typeof state.enabled === "boolean" ? state.enabled : null);
-    if (state.registryExisted === false && Object.keys(object4(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")).length === 0)
+    if (state.registryExisted === false && Object.keys(object5(readRegistry3(dcodeRegistryFile()).plugins, "registry plugins")).length === 0)
       rmSync9(dcodeRegistryFile());
     if (state.enablementExisted === false && Object.keys(boolObject(readEnablement(dcodeEnablementFile()).enabledPlugins, "enabledPlugins")).length === 0)
       rmSync9(dcodeEnablementFile());
@@ -21365,7 +21957,7 @@ var dcodeWriter = {
     assertManagedPath4(enablementFile);
     const registry = readRegistry3(registryFile);
     const enablement = readEnablement(enablementFile);
-    const plugins = object4(registry.plugins, "registry plugins");
+    const plugins = object5(registry.plugins, "registry plugins");
     const enabled = boolObject(enablement.enabledPlugins, "enabledPlugins");
     const manifest = declaredManifest(plugin.dir, plugin.name);
     const observation = probeDcodeVersion();
@@ -21473,7 +22065,7 @@ var dcodeWriter = {
     assertManagedPath4(enablementFile);
     const registry = readRegistry3(registryFile);
     const enablement = readEnablement(enablementFile);
-    const plugins = object4(registry.plugins, "registry plugins");
+    const plugins = object5(registry.plugins, "registry plugins");
     const rows = rowsFor(plugins[id]);
     if (rows.length === 0)
       return;
@@ -21567,7 +22159,7 @@ function declaredManifest(dir, expectedName) {
     throw new Error("dcode stage has no supported plugin manifest");
   let parsed;
   try {
-    parsed = object4(JSON.parse(readFileSync22(manifest, "utf8")), "manifest");
+    parsed = object5(JSON.parse(readFileSync22(manifest, "utf8")), "manifest");
   } catch (error) {
     throw new Error(`invalid dcode manifest: ${manifest} (${error.message})`);
   }
@@ -21590,10 +22182,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 = object4(JSON.parse(readFileSync22(manifest, "utf8")), "manifest");
-  const extensions = parsed.extensions === undefined ? {} : object4(parsed.extensions, "manifest extensions");
+  const parsed = object5(JSON.parse(readFileSync22(manifest, "utf8")), "manifest");
+  const extensions = parsed.extensions === undefined ? {} : object5(parsed.extensions, "manifest extensions");
   const current = extensions["com.langchain.deepagents.code"];
-  const dcodeExtension = current === undefined ? {} : object4(current, "dcode manifest extension");
+  const dcodeExtension = current === undefined ? {} : object5(current, "dcode manifest extension");
   dcodeExtension.autoUpdate = false;
   extensions["com.langchain.deepagents.code"] = dcodeExtension;
   parsed.extensions = extensions;
@@ -21605,7 +22197,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(object4(registry.plugins, "registry plugins")[id]);
+  const rows = rowsFor(object5(registry.plugins, "registry plugins")[id]);
   if (rows.length !== 1)
     throw new Error(`dcode readback failed for ${id}`);
   const install = rowInstall(rows[0], id);
@@ -21615,7 +22207,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(object4(enablement.enabledPlugins, "enabledPlugins"), "enabledPlugins")[id] !== true)
+  if (boolObject(object5(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) {
@@ -21695,7 +22287,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 = object4(registry.plugins, "registry plugins");
+  const plugins = object5(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}`);
@@ -21714,13 +22306,13 @@ function readEnablement(file) {
   boolObject(enablement.enabledPlugins, "enabledPlugins");
   return enablement;
 }
-function object4(value, label) {
+function object5(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 = object4(value, label);
+  const result = object5(value, label);
   if (Object.values(result).some((entry) => typeof entry !== "boolean"))
     throw new Error(`invalid dcode ${label}`);
   return result;
@@ -21743,7 +22335,7 @@ function ownership3(dir) {
   if (!existsSync23(file))
     return null;
   try {
-    const value = object4(JSON.parse(readFileSync22(file, "utf8")), "ownership marker");
+    const value = object5(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;
@@ -24456,8 +25048,240 @@ var zcodeCliLifecycle = createLifecycleHostAdapter(zcodeCliLifecycleDefinition);
 
 // src/hosts/hermes-writer.ts
 import { chmodSync, cpSync as cpSync12, existsSync as existsSync27, lstatSync as lstatSync20, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync13, readFileSync as readFileSync26, readdirSync as readdirSync21, realpathSync as realpathSync5, renameSync as renameSync12, rmSync as rmSync13, statSync as statSync14, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname15, join as join32, resolve as resolve21 } from "node:path";
+import { basename as basename8, dirname as dirname15, isAbsolute as isAbsolute9, join as join32, resolve as resolve21 } from "node:path";
 import { tmpdir as tmpdir11 } from "node:os";
+
+// src/hosts/hermes-launcher-templates.ts
+var hermesNativeBootstrap = `import os, re, sys
+import contextlib, hashlib, io, pathlib, shutil, subprocess
+os.environ.pop('PYTHONHOME', None)
+os.environ.pop('PYTHONPATH', None)
+sys.path.insert(0, '/__PLUGNZ_HERMES_ROOT__')
+def _hermes_closure_repair():
+    import contextlib, hashlib, io, shutil, subprocess
+    from pathlib import Path
+    root = Path('/__PLUGNZ_HERMES_ROOT__')
+    git = root / '.git'
+    try:
+        if git.is_file():
+            text = git.read_text(encoding='utf-8-sig').strip()
+            git = root / text[7:].strip() if text.startswith('gitdir:') else git
+        fields = dict(line.partition('=')[::2] for line in (git / 'hermes-update-pull').read_text(encoding='utf-8-sig').splitlines())
+    except OSError:
+        return
+    pre = fields.get('pre', '').strip()
+    if not re.fullmatch('[0-9a-f]{40}|[0-9a-f]{64}', pre):
+        return
+    closure = git / 'hermes-update-recovery' / pre
+    files = (*('hermes_cli/_early_recovery.py', 'hermes_cli/update_lock.py', 'hermes_cli/update_custody.py'), 'hermes_cli/__init__.py')
+
+    def blob_id(data):
+        return hashlib.new('sha1' if len(pre) == 40 else 'sha256', b'blob %d\\0' % len(data) + data).hexdigest()
+
+    def verified():
+        try:
+            listed = dict(line.split(' ', 1)[::-1] for line in (closure / 'MANIFEST').read_text(encoding='utf-8-sig').splitlines())
+            return (set(listed) == set(files) and listed['hermes_cli/__init__.py'] == blob_id(b'')
+                    and all(blob_id((closure / rel).read_bytes()) == oid for rel, oid in listed.items()))
+        except (OSError, ValueError):
+            return False
+
+    if not verified():
+        exe = fields.get('git', '').strip()
+        if not (os.path.isabs(exe) and os.path.isfile(exe)):
+            names = ('git.exe',) if os.name == 'nt' else ('git',)
+            exe = next((os.path.join(d, n) for d in os.environ.get('PATH', '').split(os.pathsep) if os.path.isabs(d)
+                        for n in names if os.path.isfile(os.path.join(d, n))), '')
+        if not exe:
+            return
+
+        def git_out(*args):
+            done = subprocess.run([exe, '--no-replace-objects', '-C', str(root), *args], capture_output=True, timeout=60,
+                                  stdin=subprocess.DEVNULL, creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0))
+            if done.returncode != 0:
+                raise OSError(done.stderr)
+            return done.stdout
+
+        staging = closure.with_name('.%s.%d.launch' % (pre, os.getpid()))
+        try:
+            ids = {}
+            for entry in git_out('ls-tree', '-z', '--full-tree', pre, '--', *('hermes_cli/_early_recovery.py', 'hermes_cli/update_lock.py', 'hermes_cli/update_custody.py')).split(b'\\0'):
+                meta, _, rel = entry.decode('utf-8', 'replace').partition('\\t')
+                if meta.split()[1:2] == ['blob']:
+                    ids[rel] = meta.split()[2]
+            blobs = {'hermes_cli/__init__.py': b''}
+            for rel in ('hermes_cli/_early_recovery.py', 'hermes_cli/update_lock.py', 'hermes_cli/update_custody.py'):
+                blobs[rel] = git_out('cat-file', 'blob', ids[rel])
+                if blob_id(blobs[rel]) != ids[rel]:  # an object that inflates to bytes pre never had
+                    raise OSError('%s does not hash to %s' % (rel, ids[rel]))
+            blobs['MANIFEST'] = ''.join('%s %s\\n' % (blob_id(data), rel) for rel, data in blobs.items()).encode('utf-8')
+            for rel, data in blobs.items():
+                (staging / rel).parent.mkdir(parents=True, exist_ok=True)
+                (staging / rel).write_bytes(data)
+            shutil.rmtree(closure, ignore_errors=True)
+            os.replace(staging, closure)
+        except (OSError, KeyError, subprocess.SubprocessError):
+            pass
+        finally:
+            shutil.rmtree(staging, ignore_errors=True)
+        if not verified():
+            return
+    for name in [n for n in sys.modules if n.split('.')[0] in ('hermes_cli', 'hermes_bootstrap', 'hermes_constants', 'pm')]:
+        del sys.modules[name]
+    tree = os.path.normcase(os.path.realpath(root))
+    sys.path[:] = [str(closure)] + [p for p in sys.path if p and os.path.normcase(os.path.realpath(p)) != tree
+                                    and not os.path.normcase(os.path.realpath(p)).startswith(tree + os.sep)]
+    sys.dont_write_bytecode = True
+    said = io.StringIO()
+    restored = False
+    try:
+        with contextlib.redirect_stderr(said):
+            from hermes_cli import _early_recovery
+            restored = _early_recovery.restore_interrupted_pull(root)
+    except Exception as exc:
+        said.write('hermes: the checkout cannot start after an interrupted \`hermes update\`, and it was not '
+                   'repaired: %s\\n' % (exc,))
+    if restored:
+        sys.stderr.write('hermes: the checkout could not start after an interrupted \`hermes update\`; '
+                         'repaired it with the recovery code saved before the update.\\n' + said.getvalue())
+        _early_recovery.relaunch_after_restore()
+    sys.stderr.write(said.getvalue() or 'hermes: the checkout cannot start after an interrupted \`hermes update\`; '
+                     'launch again once the update that owns it finishes.\\n')
+    raise SystemExit(1)
+if sys.argv[1:2] == ['--print-runtime-command']:
+    sys.dont_write_bytecode = True
+    from pathlib import Path
+    try:
+        from hermes_cli import _early_recovery
+    except Exception as exc:
+        if _hermes_closure_repair() or not isinstance(exc, ImportError):
+            raise
+        _early_recovery = None  # a tree without the repair: the imports below report real damage
+    if _early_recovery is not None and _early_recovery.restore_interrupted_pull(Path('/__PLUGNZ_HERMES_ROOT__')):
+        _early_recovery.relaunch_after_restore()
+    from hermes_constants import get_default_hermes_root
+    os.environ['HERMES_HOME'] = os.environ.get('HERMES_HOME') or str(get_default_hermes_root())
+    from hermes_cli._launchers import print_runtime_command
+    print_runtime_command(Path('/__PLUGNZ_HERMES_ROOT__'), sys.argv[2:])
+    sys.exit(0)
+sys._hermes_pin_default_home = True
+try:
+    import hermes_bootstrap
+except Exception:
+    _hermes_closure_repair()
+    raise
+if not os.environ.get('HERMES_HOME'):
+    from hermes_constants import get_default_hermes_root
+    os.environ['HERMES_HOME'] = str(get_default_hermes_root())
+if sys.argv[1:2] == ['--run-module']:
+    import runpy
+    if len(sys.argv) < 3: sys.exit('hermes: --run-module needs a module')
+    module = sys.argv.pop(2)
+    del sys.argv[1]
+    runpy.run_module(module, run_name='__main__', alter_sys=True)
+    sys.exit(0)
+from hermes_cli.main import main
+sys.argv[0] = re.sub(r'(-script\\.pyw|\\.exe)?$', '', sys.argv[0])
+sys.exit(main())
+`;
+var hermesEditableFinderBody = `from __future__ import annotations
+import sys
+from importlib.machinery import ModuleSpec, PathFinder
+from importlib.machinery import all_suffixes as module_suffixes
+from importlib.util import spec_from_file_location
+from itertools import chain
+from pathlib import Path
+
+__MAPPING__
+__NAMESPACES__
+PATH_PLACEHOLDER = '__EDITABLE_NAME__' + ".__path_hook__"
+
+
+class _EditableFinder:  # MetaPathFinder
+    @classmethod
+    def find_spec(cls, fullname: str, path=None, target=None) -> ModuleSpec | None:  # type: ignore
+        # Top-level packages and modules (we know these exist in the FS)
+        if fullname in MAPPING:
+            pkg_path = MAPPING[fullname]
+            return cls._find_spec(fullname, Path(pkg_path))
+
+        # Handle immediate children modules (required for namespaces to work)
+        # To avoid problems with case sensitivity in the file system we delegate
+        # to the importlib.machinery implementation.
+        parent, _, child = fullname.rpartition(".")
+        if parent and parent in MAPPING:
+            return PathFinder.find_spec(fullname, path=[MAPPING[parent]])
+
+        # Other levels of nesting should be handled automatically by importlib
+        # using the parent path.
+        return None
+
+    @classmethod
+    def _find_spec(cls, fullname: str, candidate_path: Path) -> ModuleSpec | None:
+        init = candidate_path / "__init__.py"
+        candidates = (candidate_path.with_suffix(x) for x in module_suffixes())
+        for candidate in chain([init], candidates):
+            if candidate.exists():
+                return spec_from_file_location(fullname, candidate)
+        return None
+
+
+class _EditableNamespaceFinder:  # PathEntryFinder
+    @classmethod
+    def _path_hook(cls, path) -> type[_EditableNamespaceFinder]:
+        if path == PATH_PLACEHOLDER:
+            return cls
+        raise ImportError
+
+    @classmethod
+    def _paths(cls, fullname: str) -> list[str]:
+        paths = NAMESPACES[fullname]
+        if not paths and fullname in MAPPING:
+            paths = [MAPPING[fullname]]
+        # Always add placeholder, for 2 reasons:
+        # 1. __path__ cannot be empty for the spec to be considered namespace.
+        # 2. In the case of nested namespaces, we need to force
+        #    import machinery to query _EditableNamespaceFinder again.
+        return [*paths, PATH_PLACEHOLDER]
+
+    @classmethod
+    def find_spec(cls, fullname: str, target=None) -> ModuleSpec | None:  # type: ignore
+        if fullname in NAMESPACES:
+            spec = ModuleSpec(fullname, None, is_package=True)
+            spec.submodule_search_locations = cls._paths(fullname)
+            return spec
+        return None
+
+    @classmethod
+    def find_module(cls, _fullname) -> None:
+        return None
+
+
+def install():
+    if not any(finder == _EditableFinder for finder in sys.meta_path):
+        sys.meta_path.append(_EditableFinder)
+
+    if not NAMESPACES:
+        return
+
+    if not any(hook == _EditableNamespaceFinder._path_hook for hook in sys.path_hooks):
+        # PathEntryFinder is needed to create NamespaceSpec without private APIS
+        sys.path_hooks.append(_EditableNamespaceFinder._path_hook)
+    if PATH_PLACEHOLDER not in sys.path:
+        sys.path.append(PATH_PLACEHOLDER)  # Used just to trigger the path hook
+`;
+var hermesUvConsoleBody = `# -*- coding: utf-8 -*-
+import sys
+from hermes_cli.main import main
+if __name__ == "__main__":
+    if sys.argv[0].endswith("-script.pyw"):
+        sys.argv[0] = sys.argv[0][:-11]
+    elif sys.argv[0].endswith(".exe"):
+        sys.argv[0] = sys.argv[0][:-4]
+    sys.exit(main())
+`;
+
+// src/hosts/hermes-writer.ts
 var MARKER10 = ".plgnz-install.json";
 var hermesWriter = {
   ...hermes,
@@ -24799,6 +25623,278 @@ function matches(marker, id, ownership) {
   return marker === id || marker === ownership;
 }
 var EFFECTIVE = { requirement: "none", status: "effective" };
+function launcherWords(body) {
+  const words = [];
+  let word = "", active = false, quote = "";
+  for (let at = 0;at < body.length; at++) {
+    const ch = body[at];
+    if (quote === "'") {
+      if (ch === "'")
+        quote = "";
+      else
+        word += ch;
+    } else if (quote === '"') {
+      if (ch === '"')
+        quote = "";
+      else if (ch === "\\") {
+        if (++at >= body.length)
+          return;
+        word += body[at];
+      } else if (ch === "$" && !(word === "" && body.slice(at, at + 3) === '$@"'))
+        return;
+      else if (ch === "`")
+        return;
+      else
+        word += ch;
+    } else if (ch === "'" || ch === '"') {
+      quote = ch;
+      active = true;
+    } else if (/\s/u.test(ch)) {
+      if (active) {
+        words.push(word);
+        word = "";
+        active = false;
+      }
+    } else if (ch === "\\") {
+      if (++at >= body.length)
+        return;
+      word += body[at];
+      active = true;
+    } else if (/[;$`|&<>]/u.test(ch))
+      return;
+    else {
+      word += ch;
+      active = true;
+    }
+  }
+  if (quote !== "")
+    return;
+  if (active)
+    words.push(word);
+  return words;
+}
+function literalPythonPath(literal) {
+  if (literal.startsWith('"')) {
+    try {
+      const value = JSON.parse(literal);
+      return typeof value === "string" ? value : undefined;
+    } catch {
+      return;
+    }
+  }
+  if (!/^'(?:[^'\\]|\\['\\])*'$/u.test(literal))
+    return;
+  return literal.slice(1, -1).replace(/\\(['\\])/gu, "$1");
+}
+function verifiedEditableFinder(text, root, version) {
+  const literal = String.raw`(?:'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*")`;
+  const mapping = /^MAPPING: dict\[str, str\] = (.*)$/mu.exec(text);
+  const namespaces = /^NAMESPACES: dict\[str, list\[str\]\] = (.*)$/mu.exec(text);
+  if (mapping?.[1] === undefined || namespaces?.[1] === undefined)
+    return false;
+  const entry = `${literal}:\\s*${literal}`;
+  const list = `\\[(?:${literal}(?:,\\s*${literal})*)?\\]`;
+  const namespace = `${literal}:\\s*${list}`;
+  if (!new RegExp(`^\\{(?:${entry}(?:,\\s*${entry})*)?\\}$`, "u").test(mapping[1]) || !new RegExp(`^\\{(?:${namespace}(?:,\\s*${namespace})*)?\\}$`, "u").test(namespaces[1]))
+    return false;
+  const data = [...mapping[1].matchAll(new RegExp(`(${literal}):\\s*(${literal})`, "gu"))];
+  if (!data.some((row) => literalPythonPath(row[1]) === "hermes_cli" && literalPythonPath(row[2]) === join32(root, "hermes_cli")))
+    return false;
+  const canonical = (keyLiteral, pathLiteral) => {
+    const key = literalPythonPath(keyLiteral), path = literalPythonPath(pathLiteral);
+    return key !== undefined && /^[a-zA-Z0-9_.-]+$/u.test(key) && path === join32(root, ...key.split("."));
+  };
+  if (data.some((row) => !canonical(row[1], row[2])))
+    return false;
+  for (const row of namespaces[1].matchAll(new RegExp(`(${literal}):\\s*\\[([^\\]]*)\\]`, "gu"))) {
+    if ([...row[2].matchAll(new RegExp(literal, "gu"))].some((path) => !canonical(row[1], path[0])))
+      return false;
+  }
+  return text.replace(mapping[0], "__MAPPING__").replace(namespaces[0], "__NAMESPACES__").replaceAll(`__editable__.hermes_agent-${version}.finder`, "__EDITABLE_NAME__") === hermesEditableFinderBody;
+}
+function isolatedVenvConfig(text) {
+  const values = new Map;
+  for (const line of text.split(/\r?\n/u)) {
+    if (line.trim() === "" || line.trimStart().startsWith("#"))
+      continue;
+    const row = /^\s*([^=]+?)\s*=\s*(.*?)\s*$/u.exec(line);
+    if (row === null)
+      return false;
+    const key = row[1].trim().toLowerCase();
+    if (key === "" || values.has(key))
+      return false;
+    values.set(key, row[2].toLowerCase());
+  }
+  return values.get("include-system-site-packages") === "false";
+}
+function hasImportShadow(directory, modules, allowed = []) {
+  return readdirSync21(directory).some((entry) => !allowed.includes(entry) && modules.some((module) => entry === module || entry === `${module}_d.pyd` || entry.startsWith(`${module}.`) && /\.(?:py|pyc|so|pyd)$/u.test(entry)));
+}
+function verifiedSourceImportClosure(root) {
+  let remaining = 20000;
+  const visit = (directory, top) => {
+    const entries = readdirSync21(directory);
+    remaining -= entries.length;
+    if (remaining < 0)
+      return false;
+    const packages = entries.filter((entry) => /^[a-zA-Z_]\w*$/u.test(entry) && entry !== "__pycache__" && statSync14(join32(directory, entry)).isDirectory());
+    const modules = ["__init__", ...packages, ...entries.filter((entry) => entry.endsWith(".py")).map((entry) => entry.slice(0, -3))];
+    if (top)
+      modules.push("hermes_cli", "hermes_bootstrap", "hermes_constants", "pm");
+    const allowed = entries.filter((entry) => entry.endsWith(".py"));
+    allowed.push(...packages.filter((module) => !entries.includes(`${module}.py`)));
+    if (hasImportShadow(directory, modules, allowed))
+      return false;
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "__pycache__")
+        continue;
+      const path = join32(directory, entry);
+      const stat = lstatSync20(path);
+      if (stat.isSymbolicLink()) {
+        if (entry.endsWith(".py") || statSync14(path).isDirectory())
+          return false;
+      } else if (stat.isDirectory() && !visit(path, false))
+        return false;
+    }
+    return true;
+  };
+  return visit(root, true);
+}
+function hermesExecutableSource(binary, depth = 0) {
+  if (depth > 4 || !isAbsolute9(binary) || !existsSync27(binary))
+    return;
+  const executable = realpathSync5(binary);
+  if (!statSync14(executable).isFile())
+    return;
+  const text = readFileSync26(executable, "utf8");
+  if (text.startsWith(`#!/bin/sh
+exec `)) {
+    const args = launcherWords(text.slice(`#!/bin/sh
+exec `.length));
+    if (args?.length === 2 && args[1] === "$@")
+      return hermesExecutableSource(args[0], depth + 1);
+    if (args?.length !== 5 || args[1] !== "-I" || args[2] !== "-c" || args[4] !== "$@" || !isAbsolute9(args[0]) || !/^python(?:\d+(?:\.\d+)*)?$/u.test(basename8(args[0])) || !existsSync27(args[0]))
+      return;
+    const code = args[3];
+    if (!code.startsWith(`import os, re, sys
+`) || !/\nfrom hermes_cli\.main import main\n/u.test(code) || !/\nsys\.exit\(main\(\)\)\s*$/u.test(code))
+      return;
+    const bindings = [...code.matchAll(/^sys\.path\.insert\(0, ('(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*")\)$/gmu)];
+    if (bindings.length !== 1)
+      return;
+    const root = literalPythonPath(bindings[0][1]);
+    if (root === undefined || code.replaceAll(bindings[0][1], "'/__PLUGNZ_HERMES_ROOT__'") !== hermesNativeBootstrap)
+      return;
+    return root !== undefined && isAbsolute9(root) && existsSync27(join32(root, "hermes_cli", "main.py")) && realpathSync5(join32(root, "hermes_cli", "main.py")).startsWith(`${realpathSync5(root)}/`) && verifiedSourceImportClosure(realpathSync5(root)) ? realpathSync5(root) : undefined;
+  }
+  const interpreter = /^#!([^\n]+)\n/u.exec(text)?.[1];
+  if (interpreter === undefined || !isAbsolute9(interpreter) || !existsSync27(interpreter) || !/^python(?:\d+(?:\.\d+)*)?$/u.test(basename8(interpreter)) || text.slice(text.indexOf(`
+`) + 1) !== hermesUvConsoleBody)
+    return;
+  const venv = dirname15(dirname15(executable));
+  if (dirname15(interpreter) !== join32(venv, "bin") || !existsSync27(join32(venv, "pyvenv.cfg")))
+    return;
+  if (existsSync27(join32(venv, "bin", "pyvenv.cfg")) || !isolatedVenvConfig(readFileSync26(join32(venv, "pyvenv.cfg"), "utf8")) || process.env["PYTHONHOME"] || process.env["PYTHONPATH"])
+    return;
+  if (hasImportShadow(join32(venv, "bin"), ["hermes_cli", "sitecustomize", "usercustomize", "_virtualenv"]))
+    return;
+  const lib = join32(venv, "lib");
+  if (!existsSync27(lib))
+    return;
+  const roots = [];
+  for (const python of readdirSync21(lib).filter((name) => /^python\d+\.\d+$/u.test(name))) {
+    const packages = join32(lib, python, "site-packages");
+    if (!existsSync27(packages))
+      continue;
+    if (hasImportShadow(packages, ["hermes_cli", "sitecustomize", "usercustomize", "_virtualenv"], ["_virtualenv.py"]))
+      return;
+    for (const name of readdirSync21(packages).filter((name) => /^hermes_agent-[^/]+\.dist-info$/u.test(name))) {
+      const distribution = join32(packages, name);
+      const metadata = join32(distribution, "direct_url.json");
+      const entry = join32(distribution, "entry_points.txt");
+      if (!existsSync27(metadata) || !existsSync27(entry) || !/^hermes\s*=\s*hermes_cli\.main:main$/mu.test(readFileSync26(entry, "utf8")))
+        continue;
+      const direct = JSON.parse(readFileSync26(metadata, "utf8"));
+      if (typeof direct !== "object" || direct === null || !("url" in direct) || typeof direct.url !== "string" || !("dir_info" in direct) || typeof direct.dir_info !== "object" || direct.dir_info === null || !("editable" in direct.dir_info) || direct.dir_info.editable !== true || !direct.url.startsWith("file:///"))
+        continue;
+      const root = decodeURIComponent(direct.url.slice("file://".length));
+      if (!isAbsolute9(root) || !existsSync27(join32(root, "hermes_cli", "main.py")))
+        continue;
+      const sourceModules = [
+        "hermes_cli",
+        "hermes_bootstrap",
+        "hermes_constants",
+        "pm",
+        ...readdirSync21(root).filter((name) => name.endsWith(".py")).map((name) => name.slice(0, -3)),
+        ...readdirSync21(root).filter((name) => existsSync27(join32(root, name, "__init__.py")))
+      ];
+      if (hasImportShadow(packages, sourceModules) || hasImportShadow(join32(venv, "bin"), sourceModules))
+        return;
+      if (hasImportShadow(root, ["hermes_cli", "sitecustomize", "usercustomize", "_virtualenv"], ["hermes_cli"]))
+        return;
+      const version = name.slice("hermes_agent-".length, -".dist-info".length);
+      const finder = `__editable___hermes_agent_${version.replace(/[^a-zA-Z0-9]/gu, "_")}_finder`;
+      if (hasImportShadow(packages, [finder], [`${finder}.py`]) || hasImportShadow(join32(venv, "bin"), [finder]) || hasImportShadow(root, [finder]))
+        return;
+      let binding = false;
+      for (const pthName of readdirSync21(packages).filter((name) => name.endsWith(".pth"))) {
+        const pth = readFileSync26(join32(packages, pthName), "utf8").trim();
+        if (pthName === `_virtualenv.pth` && pth === "import _virtualenv") {
+          const helper = join32(packages, "_virtualenv.py");
+          if (!existsSync27(helper) || new CryptoHasher("sha256").update(readFileSync26(helper, "utf8")).digest("hex") !== "cfb3db86aaa53bb62b5ff764970bec2d71c9228590a0ebec57f6ec926cc0bf1a")
+            return;
+        } else if (pthName === `__editable__.hermes_agent-${version}.pth` && pth === root)
+          binding = true;
+        else if (pthName === `__editable__.hermes_agent-${version}.pth` && pth === `import ${finder}; ${finder}.install()` && existsSync27(join32(packages, `${finder}.py`)) && verifiedEditableFinder(readFileSync26(join32(packages, `${finder}.py`), "utf8"), root, version))
+          binding = true;
+        else
+          return;
+      }
+      if (binding && realpathSync5(join32(root, "hermes_cli", "main.py")).startsWith(`${realpathSync5(root)}/`) && verifiedSourceImportClosure(realpathSync5(root)))
+        roots.push(realpathSync5(root));
+    }
+  }
+  return roots.length === 1 ? roots[0] : undefined;
+}
+function observeHermesRevision() {
+  const binary = process.env["OPEN_PLUGIN_HERMES_BIN"] ?? which("hermes");
+  if (!binary || !existsSync27(binary))
+    return { kind: "unknown", diagnostic: "Select an existing Hermes launcher with OPEN_PLUGIN_HERMES_BIN; a profile config does not identify its runtime" };
+  try {
+    const root = hermesExecutableSource(binary);
+    if (root === undefined)
+      return { kind: "unparseable", diagnostic: "Hermes launcher source binding is unverified; select its actual executable with OPEN_PLUGIN_HERMES_BIN and prove its whole native/uv body and editable import closure against docs/hosts/hermes.md before admission. Hermes was not executed" };
+    const git = which("git");
+    if (git === null)
+      return { kind: "unknown" };
+    const env = {
+      ...process.env,
+      GIT_NO_LAZY_FETCH: "1",
+      GIT_OPTIONAL_LOCKS: "0",
+      GIT_CONFIG_NOSYSTEM: "1",
+      GIT_CONFIG_GLOBAL: "/dev/null"
+    };
+    for (const key of ["GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE"])
+      delete env[key];
+    const output = (args) => {
+      const result = spawnSync([git, "-C", root, ...args], { env, stdout: "pipe", stderr: "pipe", timeout: 1e4 });
+      return result.exitCode === 0 ? new TextDecoder().decode(result.stdout) : undefined;
+    };
+    const lines = output(["rev-parse", "--show-toplevel", "HEAD"])?.trim().split(`
+`);
+    if (lines?.length !== 2 || lines[0] === undefined || lines[1] === undefined || !/^[a-f0-9]{40}$/u.test(lines[1]))
+      return { kind: "unknown" };
+    if (realpathSync5(lines[0]) !== root)
+      return { kind: "unparseable" };
+    const dirty = output(["-c", "core.fsmonitor=false", "status", "--porcelain=v1", "--untracked-files=no"]);
+    if (dirty === undefined)
+      return { kind: "unknown" };
+    const revision = dirty.trim() === "" ? lines[1] : `${lines[1]}+dirty`;
+    return { kind: "detected", version: revision, probeId: `hermes-launcher-git-${revision}` };
+  } catch {
+    return { kind: "unknown" };
+  }
+}
 var HERMES_SUPPORTED = new Set([
   "ordinary-skills",
   "mcp",
@@ -24813,20 +25909,20 @@ var HERMES_SUPPORTED = new Set([
   "activation-reload",
   "reversible-disable"
 ]);
-var hermesManagedProfile = createCapabilityEvidenceProfile({
+var hermesManagedProfiles = hermesProvenManagedRevisions.map((detectedVersion) => createCapabilityEvidenceProfile({
   host: "hermes",
-  detectedVersion: HERMES_PORTABLE_SURFACE,
+  detectedVersion,
   sourceTypes: ["local", "git"],
   operations: ["install", "update", "disable", "retire"],
   route: "managed",
   operationStatus: "supported",
   semantics: Object.fromEntries(PACKAGE_SEMANTICS.map((semantic) => [semantic, HERMES_SUPPORTED.has(semantic) ? "supported" : "unsupported"])),
   evidence: [
-    "docs/evidence/hermes-native-loader-c0d7294-20260923.json",
+    detectedVersion === "c0d7294769a38c17ceae51d8f7995e66e1dcae27" ? "docs/evidence/hermes-native-loader-c0d7294-20260923.json" : "docs/evidence/hermes-native-loader-dce1e9b-20261011.json",
     "docs/hosts/hermes.md",
     "docs/research/native-plugin-update-capabilities-2026-10-09.md"
   ]
-});
+}));
 function storeFor(target) {
   const identity = hermesInstanceIdentity({ kind: target.kind, instance: target.instance, ...target.context === undefined ? {} : { context: { ...target.context } } });
   return { root: identity.root, configPath: resolveInstanceConfig(identity.root, identity.configPath), pluginsDir: join32(identity.root, "plugins") };
@@ -25176,7 +26272,7 @@ function markerBody2(input) {
 }
 var hermesLifecycleDefinition = {
   id: "hermes",
-  evidenceProfiles: [hermesManagedProfile],
+  evidenceProfiles: hermesManagedProfiles,
   async probeVersion(target) {
     try {
       const store = storeFor(target);
@@ -25194,7 +26290,7 @@ var hermesLifecycleDefinition = {
         if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
           return { kind: "unparseable" };
       }
-      return { kind: "detected", version: HERMES_PORTABLE_SURFACE, probeId: HERMES_PORTABLE_SURFACE_PROBE };
+      return observeHermesRevision();
     } catch {
       return { kind: "unknown" };
     }
@@ -25419,7 +26515,7 @@ var cleanupWriters = [...writers, piWriter, opencodeWriter];
 
 // src/executor.ts
 import { existsSync as existsSync28, readFileSync as readFileSync27 } from "node:fs";
-import { isAbsolute as isAbsolute10, join as join34, resolve as resolve22 } from "node:path";
+import { isAbsolute as isAbsolute11, join as join34, resolve as resolve22 } from "node:path";
 
 // src/owned-activation.ts
 function ownedActivation(scope, source, activation, installation, target) {
@@ -25566,7 +26662,7 @@ class SyncManifestValidationError extends Error {
   }
 }
 function parseSyncManifest(value) {
-  const manifest = object5(value, "sync manifest");
+  const manifest = object6(value, "sync manifest");
   exactFields5(manifest, ["schemaVersion", "entries"], "sync manifest");
   if (manifest["schemaVersion"] !== SYNC_MANIFEST_SCHEMA_VERSION)
     invalidArgument2("sync manifest schemaVersion must be 1");
@@ -25600,7 +26696,7 @@ function selectManifestPackages(entry, discovered) {
   });
 }
 function parseEntry(value, index) {
-  const entry = object5(value, `sync manifest entry ${index}`);
+  const entry = object6(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`);
@@ -25678,7 +26774,7 @@ function assertUniqueScopes(entries) {
   }
 }
 function parseSourceBinding(value, label) {
-  const binding = object5(value, label);
+  const binding = object6(value, label);
   if (binding["kind"] === "local") {
     exactFields5(binding, ["kind", "locator"], label);
     if (typeof binding["locator"] !== "string")
@@ -25704,7 +26800,7 @@ function parseTarget(value, label) {
 }
 function parseSelector(value, entryIndex, selectorIndex) {
   const label = `sync manifest entry ${entryIndex} selector ${selectorIndex}`;
-  const selector = object5(value, label);
+  const selector = object6(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`);
@@ -25722,7 +26818,7 @@ function validateBinding(source, label) {
   }
 }
 function targetProfile(value, label) {
-  const target = object5(value, label);
+  const target = object6(value, label);
   if (typeof target["kind"] !== "string")
     invalidArgument2(`${label} kind must be a string`);
   return targetProfileForKind(target["kind"], label);
@@ -25747,7 +26843,7 @@ function invokeTargetProfile(operation) {
     throw error;
   }
 }
-function object5(value, label) {
+function object6(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     invalidArgument2(`${label} must be an object`);
   return value;
@@ -26675,7 +27771,7 @@ function defect(reason, terminalPhase) {
 // src/state-write.ts
 import { mkdirSync as mkdirSync14, rmSync as rmSync14, writeFileSync as writeFileSync14 } from "node:fs";
 import * as fs from "node:fs";
-import { basename as basename8, dirname as dirname16, isAbsolute as isAbsolute9, join as join33, relative as relative7 } from "node:path";
+import { basename as basename9, dirname as dirname16, isAbsolute as isAbsolute10, join as join33, relative as relative7 } from "node:path";
 function writeState(records, file = stateFile()) {
   const existing = readLifecycleState(file);
   if (existing.sourceVersion === 2)
@@ -26765,12 +27861,12 @@ function persistedSource(binding) {
   }
 }
 function legacyRelativeDir2(record) {
-  if (record.sourceDir === undefined || !isAbsolute9(record.source) || !isAbsolute9(record.sourceDir))
+  if (record.sourceDir === undefined || !isAbsolute10(record.source) || !isAbsolute10(record.sourceDir))
     return;
   const candidate = relative7(record.source, record.sourceDir).replaceAll("\\", "/");
   if (candidate === "")
     return ".";
-  if (candidate === ".." || candidate.startsWith("../") || isAbsolute9(candidate))
+  if (candidate === ".." || candidate.startsWith("../") || isAbsolute10(candidate))
     return;
   return candidate;
 }
@@ -26830,7 +27926,7 @@ function legacyScopes(state, scopeId, source, host, attemptId, retiredAttemptId)
 function atomicWrite(file, contents) {
   const parent = dirname16(file);
   mkdirSync14(parent, { recursive: true });
-  const temporary = join33(parent, `.${basename8(file)}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
+  const temporary = join33(parent, `.${basename9(file)}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
   try {
     writeFileSync14(temporary, contents);
     fs.renameSync(temporary, file);
@@ -28026,7 +29122,7 @@ function recordedPinCommand(packageRoot, server) {
 }
 function absolutePinExecutable(command) {
   if (command.includes("/")) {
-    if (!isAbsolute10(command))
+    if (!isAbsolute11(command))
       return null;
     const canonical = resolve22(command);
     return canonical === command ? command : null;
@@ -28263,7 +29359,7 @@ 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";
+import { basename as basename10, 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)
@@ -28285,7 +29381,7 @@ async function runOfflineLifecyclePin(host, plugin, dryRun) {
     return preview;
   const now = new Date().toISOString();
   const frozenRoot = mkdtempSync14(join35(tmpdir12(), "plgnz-offline-pin-"));
-  const attemptId = `pin-${basename9(frozenRoot)}`;
+  const attemptId = `pin-${basename10(frozenRoot)}`;
   const operationId = `${attemptId}:${plugin.id}`;
   let handle;
   let preparation;
@@ -28977,7 +30073,7 @@ function legacyCommandAction(command) {
 // package.json
 var package_default = {
   name: "plugnz",
-  version: "0.0.10",
+  version: "0.0.12",
   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",