create-agdf 0.14.5 → 0.20.1

package/lib/installers/local-marketplace.js

@@ -1,9 +1,15 @@
+import { CODEX_REGISTRATION_REVISION, codexLocalInstallVersion, isCodexLocalInstallVersion, marketplaceEntries as codexMarketplaceEntries } from "../host-adapters/codex/identity.js";
+import { marketplaceEntries as claudeMarketplaceEntries } from "../host-adapters/claude/marketplace.js";
+export { CODEX_REGISTRATION_REVISION, codexLocalInstallVersion, isCodexLocalInstallVersion } from "../host-adapters/codex/identity.js";
 import {
   cpSync,
   existsSync,
+  lstatSync,
   mkdirSync,
   mkdtempSync,
   readFileSync,
+  readdirSync,
+  realpathSync,
   rmSync,
   writeFileSync,
 } from "node:fs";
@@ -11,28 +17,58 @@ import { homedir, tmpdir } from "node:os";
 import { dirname, isAbsolute, join, posix, relative, resolve, sep, win32 } from "node:path";
 import process from "node:process";
 import { generatedRoot, packageRoot, pluginDefinition } from "../cli/runtime-context.js";
-import { renameSyncWithRetry } from "../fs-swap.js";
-import { classifyHistoricalDistributionProfile } from "../runtime/distribution-profile-history.js";
+import { renameSyncWithRetry } from "#agdf-core/fs-swap.js";
+import { atomicWrite, withOwnedFileLock } from "#agdf-core/control-state/run-state-writer.js";
+import { validateCockpitTransitionEvidence } from "../mcp-lifecycle/evidence.js";
+import { inspectMcpExecutableRoot } from '../mcp-lifecycle/package.js';
+import { pluginMcpRuntimeIdentity } from '../mcp-lifecycle/plugin-runtime.js';
+import { createHash } from "node:crypto";
+import { resolveControlCommandTarget } from "#agdf-core/control-state/approval-command-contract.js";
+import { buildCopilotMarketplaceTransport, copilotMarketplaceSpec, COPILOT_TRANSPORT_REVISION, verifyCopilotMarketplaceTransport } from "./copilot-marketplace-transport.js";
+import { classifyHistoricalDistributionProfile } from "#agdf-core/runtime/distribution-profile-history.js";
 import {
+  CODEX_PLUGIN_MCP_FILE,
   INSTALLATION_PROVENANCE_FILE,
   LEGACY_LOCAL_INSTALL_FILE,
   digestDirectory,
+  renderCodexPluginMcpConfig,
   inspectCopilotPayloadInventory,
   digestNormalizedPluginSource,
   inspectInstallationProvenance,
   validateDistributionProfiles,
-} from "../runtime/plugin-provenance.js";
+} from "#agdf-core/runtime/plugin-provenance.js";
 
 const MARKETPLACE_ID = "agdf";
 const OWNERSHIP_FILE = ".agdf-owned.json";
 const LEGACY_REPOSITORY = "arndtgold/ai-native-governance-delivery-framework";
-export const CODEX_REGISTRATION_REVISION = 1;
 
 function pathInside(root, candidate) {
   const rel = relative(root, candidate);
   return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
 }
 
+function rootIdentity(path) {
+  if (!existsSync(path)) return null;
+  const type = lstatSync(path);
+  if (type.isSymbolicLink() || !type.isDirectory()) throw new Error(`Unsafe AGDF marketplace root: ${path}`);
+  return `${type.dev}:${type.ino}`;
+}
+
+function assertTransactionBackupIdentity(path, transaction) {
+  if (rootIdentity(path) !== transaction.previous_root_identity || !transaction.previous_root_identity) {
+    throw new Error(`AGDF marketplace backup identity changed: ${path}`);
+  }
+}
+
+function assertTransactionStablePayload(path, transaction) {
+  const stable = ownership(path);
+  if (stable.plugin_digest !== transaction.plugin_digest || stable.version !== transaction.version
+      || stable.profile_id !== transaction.profile_id
+      || digestDirectory(join(path, "plugins", MARKETPLACE_ID)) !== stable.plugin_digest) {
+    throw new Error(`AGDF marketplace stable payload changed: ${path}`);
+  }
+}
+
 function readOptionalJson(path) {
   try {
     return JSON.parse(readFileSync(path, "utf8"));
@@ -47,27 +83,11 @@ export function digestPluginSource(root, canonicalVersion = pluginDefinition.ver
 
 export { digestDirectory };
 
-function semverBase(version) {
-  return version.split("+")[0];
-}
-
 function isSemanticVersion(version) {
   return typeof version === "string"
     && /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(version);
 }
 
-export function codexLocalInstallVersion(version, sourceDigest) {
-  if (!/^[a-f0-9]{64}$/.test(sourceDigest)) throw new Error("AGDF local source digest must be a deterministic SHA-256 value.");
-  return `${semverBase(version)}+codex.local-${sourceDigest.slice(0, 12)}`;
-}
-
-export function isCodexLocalInstallVersion(version, candidate, sourceDigest = "") {
-  if (typeof candidate !== "string") return false;
-  if (sourceDigest) return candidate === codexLocalInstallVersion(version, sourceDigest);
-  const escaped = semverBase(version).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return new RegExp(`^${escaped}\\+codex\\.local-[a-f0-9]{12}$`).test(candidate);
-}
-
 function localInstallSourceUnstable(detail) {
   const error = new Error(`AGDF local plugin source changed during snapshot capture: ${detail}`);
   error.code = "local_install_source_unstable";
@@ -146,6 +166,7 @@ export function localMarketplaceRoot(options = {}) {
 }
 
 function ownership(root, { allowBuilding = false } = {}) {
+  rootIdentity(root);
   if (!existsSync(join(root, OWNERSHIP_FILE))) {
     throw new Error(`Refusing marketplace path without AGDF ownership marker: ${root}`);
   }
@@ -234,6 +255,8 @@ function validateBuiltPlugin(pluginRoot, expectedVersion, expectedCodexInstallVe
   const codex = copilotProfile ? null : readJson(join(pluginRoot, ".codex-plugin", "plugin.json"), "built Codex plugin manifest");
   const claude = copilotProfile ? null : readJson(join(pluginRoot, ".claude-plugin", "plugin.json"), "built Claude plugin manifest");
   const copilot = copilotProfile ? readJson(join(pluginRoot, "plugin.json"), "built Copilot plugin manifest") : null;
+  const portablePath = join(pluginRoot, "plugin.json");
+  const portable = !copilotProfile && existsSync(portablePath) ? readJson(portablePath, "built portable plugin manifest") : null;
   for (const required of [
     ...(copilotProfile ? [join(pluginRoot, "plugin.json"), join(pluginRoot, ".agdf-payload-inventory.json")] : [
       join(pluginRoot, ".codex-plugin", "plugin.json"),
@@ -275,6 +298,9 @@ function validateBuiltPlugin(pluginRoot, expectedVersion, expectedCodexInstallVe
   if (!copilotProfile && codex.version !== expectedCodexInstallVersion) {
     throw new Error(`Built Codex plugin version mismatch: expected ${expectedCodexInstallVersion}, observed ${codex.version}`);
   }
+  if (portable && portable.version !== expectedCodexInstallVersion) {
+    throw new Error(`Built portable plugin version mismatch: expected ${expectedCodexInstallVersion}, observed ${portable.version}`);
+  }
   if (!copilotProfile && claude.version !== expectedVersion) {
     throw new Error(`Built Claude plugin version mismatch: expected ${expectedVersion}, observed ${claude.version}`);
   }
@@ -417,20 +443,60 @@ function invalidExistingMarketplace(error) {
   return error;
 }
 
-function recoverInterruptedTransaction(stableRoot, stageRoot, backupRoot, failedRoot) {
+function recoverInterruptedTransaction(stableRoot, stageRoot, backupRoot, failedRoot, transactionPath) {
   const parent = dirname(stableRoot);
+  const transaction = existsSync(transactionPath)
+    ? readOptionalJson(transactionPath) : null;
+  if (existsSync(transactionPath) && (transaction?.schema_version !== 1
+      || transaction.owner !== "create-agdf" || !["prepared", "committed", "cockpit_qualification_pending"].includes(transaction.phase)
+      || typeof transaction.plugin_digest !== "string" || typeof transaction.version !== "string"
+      || typeof transaction.profile_id !== "string"
+      || (transaction.previous_root_identity !== null && typeof transaction.previous_root_identity !== "string"))) {
+    throw new Error(`Invalid AGDF marketplace transaction marker: ${transactionPath}`);
+  }
+  if (transaction?.phase === 'cockpit_qualification_pending') {
+    assertTransactionStablePayload(stableRoot, transaction);
+    if (transaction.previous_root_identity !== null) assertTransactionBackupIdentity(backupRoot, transaction);
+    throw new Error('AGDF_COCKPIT_QUALIFICATION_PENDING: finish or roll back the recorded Cockpit transition before another installation.');
+  }
+  if (transaction?.phase === "committed") {
+    assertTransactionStablePayload(stableRoot, transaction);
+    if (existsSync(backupRoot)) {
+      assertTransactionBackupIdentity(backupRoot, transaction);
+      removeOwnedRoot(backupRoot, parent);
+    }
+    if (existsSync(stageRoot)) removeOwnedRoot(stageRoot, parent, { allowBuilding: true });
+    if (existsSync(failedRoot)) removeOwnedRoot(failedRoot, parent);
+    rmSync(transactionPath);
+    return;
+  }
   if (existsSync(backupRoot)) {
+    if (!transaction && existsSync(stableRoot)) {
+      throw new Error(`Ambiguous AGDF marketplace backup without transaction marker: ${backupRoot}`);
+    }
+    if (transaction) assertTransactionBackupIdentity(backupRoot, transaction);
     ownership(backupRoot);
     if (existsSync(failedRoot)) removeOwnedRoot(failedRoot, parent);
     if (existsSync(stableRoot)) {
-      ownership(stableRoot);
+      assertTransactionStablePayload(stableRoot, transaction);
       renameSyncWithRetry(stableRoot, failedRoot);
     }
     renameSyncWithRetry(backupRoot, stableRoot);
     if (existsSync(failedRoot)) removeOwnedRoot(failedRoot, parent);
+  } else if (transaction?.phase === "prepared" && existsSync(stableRoot)) {
+    if (rootIdentity(stableRoot) !== transaction.previous_root_identity) {
+      if (transaction.previous_root_identity !== null) {
+        throw new Error(`AGDF marketplace prior backup missing: ${backupRoot}`);
+      }
+      assertTransactionStablePayload(stableRoot, transaction);
+      removeOwnedRoot(stableRoot, parent);
+    }
+  } else if (transaction?.phase === "prepared" && transaction.previous_root_identity !== null) {
+    throw new Error(`AGDF marketplace prior backup missing: ${backupRoot}`);
   }
   if (existsSync(stageRoot)) removeOwnedRoot(stageRoot, parent, { allowBuilding: true });
   if (existsSync(failedRoot)) removeOwnedRoot(failedRoot, parent);
+  if (transaction) rmSync(transactionPath);
 }
 
 function prepareLocalMarketplaceFromSource({
@@ -442,6 +508,8 @@ function prepareLocalMarketplaceFromSource({
   profileId = "runtime-plugin",
   knownSourceDigest = "",
   sourceStaged = () => {},
+  transportAdapters = {},
+  cleanupBackup = removeOwnedRoot,
 } = {}) {
   dataRoot = resolve(dataRoot);
   const copilotProfile = profileId === "copilot-runtime-plugin";
@@ -454,6 +522,7 @@ function prepareLocalMarketplaceFromSource({
   const stageRoot = `${stableRoot}.stage`;
   const backupRoot = `${stableRoot}.backup`;
   const failedRoot = `${stableRoot}.failed`;
+  const transactionPath = `${stableRoot}.transaction.json`;
   if (!pathInside(dataRoot, stableRoot) || dirname(stableRoot) !== parent) throw new Error(`Unsafe AGDF marketplace root: ${stableRoot}`);
   const sourceDigest = knownSourceDigest || digestPluginSource(builtPluginRoot, expectedVersion);
   if (!copilotProfile && codexInstallVersion !== expectedVersion
@@ -465,7 +534,7 @@ function prepareLocalMarketplaceFromSource({
     join(builtPluginRoot, "meta", "distribution-profile-history.json"),
   );
   mkdirSync(parent, { recursive: true });
-  recoverInterruptedTransaction(stableRoot, stageRoot, backupRoot, failedRoot);
+  recoverInterruptedTransaction(stableRoot, stageRoot, backupRoot, failedRoot, transactionPath);
 
   let existing = null;
   if (existsSync(stableRoot)) {
@@ -482,16 +551,22 @@ function prepareLocalMarketplaceFromSource({
   let existingMarketplace = null;
   let existingClassification = "none";
   let historicalEvidence = null;
+  let damagedReason = null;
   if (existing) {
-    let classified;
     try {
-      classified = classifyExistingMarketplace(stableRoot, existing, { profileId, distributionProfileHistory });
+      const classified = classifyExistingMarketplace(stableRoot, existing, { profileId, distributionProfileHistory });
+      existingClassification = classified.classification;
+      existingMarketplace = classified.marketplace;
+      historicalEvidence = classified.historicalEvidence;
     } catch (error) {
-      throw invalidExistingMarketplace(error);
+      // An invalid profile history belongs to the incoming build, not to the existing root.
+      if (/profile_history_invalid/.test(error.message)) throw invalidExistingMarketplace(error);
+      // The ownership marker proves AGDF created this root, but its payload no longer validates
+      // (for example a half-replaced update). Nothing from it is reused: it becomes the transaction
+      // backup, is restored on rollback and removed only after the fresh build committed.
+      existingClassification = "owned_damaged_rebuild";
+      damagedReason = error.message;
     }
-    existingClassification = classified.classification;
-    existingMarketplace = classified.marketplace;
-    historicalEvidence = classified.historicalEvidence;
   }
   mkdirSync(stageRoot, { recursive: false });
   try {
@@ -510,11 +585,25 @@ function prepareLocalMarketplaceFromSource({
     });
     const stagedPluginRoot = join(stageRoot, "plugins", MARKETPLACE_ID);
     cpSync(builtPluginRoot, stagedPluginRoot, { recursive: true });
+    // Codex starts plugin MCP servers only from absolute paths and passes no plugin data directory,
+    // so the installed declaration names the final marketplace plugin root and an AGDF-owned data root.
+    const codexMcpPath = join(stagedPluginRoot, CODEX_PLUGIN_MCP_FILE);
+    if (!copilotProfile && existsSync(codexMcpPath)) {
+      writeFileSync(codexMcpPath, renderCodexPluginMcpConfig({
+        pluginRoot: join(stableRoot, "plugins", MARKETPLACE_ID),
+        dataRoot: join(dataRoot, "mcp", "codex-plugin"),
+        cockpit: Object.hasOwn(readJson(codexMcpPath, 'built MCP declaration').mcpServers, 'agdf-cockpit'),
+      }), "utf8");
+    }
     sourceStaged();
     validateBuiltPlugin(stagedPluginRoot, expectedVersion, expectedVersion, "", { profileId });
     if (!copilotProfile && codexInstallVersion !== expectedVersion) {
       const codexManifestPath = join(stagedPluginRoot, ".codex-plugin", "plugin.json");
       writeJson(codexManifestPath, { ...readJson(codexManifestPath, "built Codex plugin manifest"), version: codexInstallVersion });
+      const portableManifestPath = join(stagedPluginRoot, "plugin.json");
+      if (existsSync(portableManifestPath)) {
+        writeJson(portableManifestPath, { ...readJson(portableManifestPath, "built portable plugin manifest"), version: codexInstallVersion });
+      }
     }
     const runtimeManifest = readJson(join(stagedPluginRoot, "runtime", "runtime-manifest.json"), "built runtime manifest");
     writeJson(join(stagedPluginRoot, INSTALLATION_PROVENANCE_FILE), {
@@ -552,13 +641,18 @@ function prepareLocalMarketplaceFromSource({
       plugin_digest: pluginDigest,
       source_package_version: readJson(join(packageRoot, "package.json"), "create-agdf package manifest").version,
       staging_state: "ready",
+      ...(copilotProfile ? { copilot_transport_revision: COPILOT_TRANSPORT_REVISION } : {}),
     };
     writeJson(join(stageRoot, OWNERSHIP_FILE), marker);
 
+    if (copilotProfile) buildCopilotMarketplaceTransport(stageRoot, sourceDigest, transportAdapters);
+
     if (existing?.version === expectedVersion
         && existing?.plugin_digest === pluginDigest
         && existing?.codex_registration_revision === targetCodexRegistrationRevision
-        && existingMarketplace?.codexShape === "current") {
+        && existingMarketplace?.codexShape === "current"
+        && (!copilotProfile || existing.copilot_transport_revision === COPILOT_TRANSPORT_REVISION)) {
+      if (copilotProfile) verifyCopilotMarketplaceTransport(stableRoot, sourceDigest, transportAdapters);
       removeOwnedRoot(stageRoot, parent);
       return Object.freeze({
         root: stableRoot,
@@ -570,17 +664,33 @@ function prepareLocalMarketplaceFromSource({
         runtimeDigest: runtimeManifest.digest,
         existingClassification,
         historicalEvidence,
+        damagedReason,
+        ...(copilotProfile ? { marketplaceSpec: copilotMarketplaceSpec(stableRoot, sourceDigest) } : {}),
         changed: false,
         commit() {},
         rollback() {},
       });
     }
 
+    const transaction = {
+      schema_version: 1,
+      owner: "create-agdf",
+      phase: "prepared",
+      profile_id: profileId,
+      version: expectedVersion,
+      plugin_digest: pluginDigest,
+      previous_root_identity: rootIdentity(stableRoot),
+    };
+    atomicWrite(transactionPath, `${JSON.stringify(transaction)}\n`);
     if (existsSync(stableRoot)) renameSyncWithRetry(stableRoot, backupRoot);
     try {
       renameSyncWithRetry(stageRoot, stableRoot);
     } catch (error) {
-      if (existsSync(backupRoot) && !existsSync(stableRoot)) renameSyncWithRetry(backupRoot, stableRoot);
+      if (existsSync(backupRoot) && !existsSync(stableRoot)) {
+        assertTransactionBackupIdentity(backupRoot, transaction);
+        renameSyncWithRetry(backupRoot, stableRoot);
+      }
+      if (existsSync(transactionPath)) rmSync(transactionPath);
       throw error;
     }
     let closed = false;
@@ -594,22 +704,55 @@ function prepareLocalMarketplaceFromSource({
       runtimeDigest: runtimeManifest.digest,
       existingClassification,
       historicalEvidence,
+      damagedReason,
+      ...(copilotProfile ? { marketplaceSpec: copilotMarketplaceSpec(stableRoot, sourceDigest) } : {}),
       changed: true,
-      commit() {
-        if (closed) return;
-        if (existsSync(backupRoot)) removeOwnedRoot(backupRoot, parent);
+      // The committed marker is the commit point. A host that already serves the new root may opt in to
+      // report a failed backup cleanup instead of throwing; the marker stays for the next run's recovery.
+      commit({ tolerateCleanupFailure = false, retainCockpitRollbackFor } = {}) {
+        if (closed) return Object.freeze({ cleanup: "none" });
+        if (retainCockpitRollbackFor !== undefined) {
+          if (profileId !== 'runtime-plugin' || !isAbsolute(retainCockpitRollbackFor)
+            || realpathSync(retainCockpitRollbackFor) !== retainCockpitRollbackFor) throw Error('AGDF_COCKPIT_ROLLBACK_TARGET_INVALID');
+          atomicWrite(transactionPath, `${JSON.stringify({ ...transaction, phase: 'cockpit_qualification_pending',
+            cockpit_target: retainCockpitRollbackFor, source_digest: sourceDigest,
+            previous_source_digest: existing?.source_digest ?? null, previous_version: existing?.version ?? null })}\n`);
+          closed = true;
+          return Object.freeze({ cleanup: 'retained_for_cockpit', transactionPath });
+        }
+        atomicWrite(transactionPath, `${JSON.stringify({ ...transaction, phase: "committed" })}\n`);
         closed = true;
+        try {
+          if (existsSync(backupRoot)) {
+            assertTransactionBackupIdentity(backupRoot, transaction);
+            cleanupBackup(backupRoot, parent);
+          }
+          rmSync(transactionPath);
+        } catch (error) {
+          if (!tolerateCleanupFailure) throw error;
+          return Object.freeze({ cleanup: "pending", reason: error?.code || "cleanup_failed" });
+        }
+        return Object.freeze({ cleanup: "done" });
       },
       rollback() {
-        if (closed) return;
+        if (closed) return "already_closed";
+        if (existsSync(backupRoot)) assertTransactionBackupIdentity(backupRoot, transaction);
         if (existsSync(backupRoot)) {
           if (existsSync(failedRoot)) removeOwnedRoot(failedRoot, parent);
-          if (existsSync(stableRoot)) renameSyncWithRetry(stableRoot, failedRoot);
+          if (existsSync(stableRoot)) {
+            assertTransactionStablePayload(stableRoot, transaction);
+            renameSyncWithRetry(stableRoot, failedRoot);
+          }
           renameSyncWithRetry(backupRoot, stableRoot);
           if (existsSync(failedRoot)) removeOwnedRoot(failedRoot, parent);
         } else if (existsSync(stableRoot)) {
+          if (transaction.previous_root_identity !== null) {
+            throw new Error(`AGDF marketplace prior backup missing: ${backupRoot}`);
+          }
+          assertTransactionStablePayload(stableRoot, transaction);
           removeOwnedRoot(stableRoot, parent);
         }
+        if (existsSync(transactionPath)) rmSync(transactionPath);
         closed = true;
       },
     });
@@ -687,6 +830,58 @@ export function inspectLocalMarketplaceProjection({
   });
 }
 
+// Repair admission is narrower than normal provenance: exactly the runtime
+// manifest may be stale, and restoring a fully verified native cache copy must
+// reproduce the pre-existing owner's complete payload hash. Nothing is reused
+// or written back here; the existing transaction still publishes a fresh build.
+export function inspectCodexOwnedManifestRepair({ dataRoot = defaultAgdfDataRoot(), env = process.env,
+  expectedVersion = pluginDefinition.version } = {}) {
+  try {
+    const root = join(resolve(dataRoot), 'marketplaces', MARKETPLACE_ID), marker = ownership(root);
+    if (marker.version !== expectedVersion || (marker.profile_id ?? 'runtime-plugin') !== 'runtime-plugin'
+      || !/^[a-f0-9]{64}$/u.test(marker.source_digest ?? '') || !/^[a-f0-9]{64}$/u.test(marker.plugin_digest ?? '')) return null;
+    const installVersion = marker.codex_install_version ?? marker.version;
+    if (installVersion !== marker.version && !isCodexLocalInstallVersion(marker.version, installVersion, marker.source_digest)) return null;
+    const pluginRoot = join(root, 'plugins', MARKETPLACE_ID);
+    const cache = join(env.CODEX_HOME || join(homedir(), '.codex'), 'plugins/cache/agdf/agdf', marker.codex_install_version ?? marker.version);
+    if (realpathSync(cache) !== resolve(cache) || realpathSync(pluginRoot) !== resolve(pluginRoot)) return null;
+    const noLinks = base => { let count = 0, bytes = 0;
+      const visit = path => { const stat = lstatSync(path); if (stat.isSymbolicLink()) throw Error('repair_symlink');
+        if (++count > 10000 || (bytes += stat.size) > 32 * 1024 * 1024) throw Error('repair_bounds');
+        if (stat.isDirectory()) for (const name of readdirSync(path)) visit(join(path, name));
+      }; visit(base);
+    };
+    noLinks(pluginRoot); noLinks(cache);
+    validateBuiltPlugin(cache, marker.version, marker.codex_install_version ?? marker.version, marker.source_digest,
+      { requireInstallationProvenance: true });
+    const manifest = join('runtime', 'runtime-manifest.json'), original = readFileSync(join(cache, manifest));
+    if (readFileSync(join(pluginRoot, manifest)).equals(original)) return null;
+    const observed = digestDirectory(pluginRoot), markerBytes = readFileSync(join(root, OWNERSHIP_FILE));
+    const temporary = mkdtempSync(join(tmpdir(), 'agdf-owned-repair-'));
+    let declaration;
+    try {
+      cpSync(pluginRoot, join(temporary, 'plugin'), { recursive: true, filter: path => {
+        if (lstatSync(path).isSymbolicLink()) throw Error('repair_symlink'); return true;
+      } });
+      writeFileSync(join(temporary, 'plugin', manifest), original);
+      if (digestDirectory(join(temporary, 'plugin')) !== marker.plugin_digest) return null;
+      validateBuiltPlugin(join(temporary, 'plugin'), marker.version, marker.codex_install_version ?? marker.version,
+        marker.source_digest, { requireInstallationProvenance: true });
+      declaration = readJson(join(temporary, 'plugin/mcp.json'), 'verified repair declaration');
+    } finally { rmSync(temporary, { recursive: true, force: true }); }
+    const assertCurrent = () => {
+      ownership(root); noLinks(pluginRoot); noLinks(cache);
+      if (!readFileSync(join(root, OWNERSHIP_FILE)).equals(markerBytes) || digestDirectory(pluginRoot) !== observed
+        || !readFileSync(join(cache, manifest)).equals(original)) throw Error('repair_source_changed');
+    };
+    return Object.freeze({ assertCurrent, inspect(candidateRoot) {
+      assertCurrent();
+      if (resolve(candidateRoot) !== pluginRoot || realpathSync(candidateRoot) !== pluginRoot) return { status: 'unconfirmed' };
+      return { status: 'matched', repair: true, version: marker.version, digest: 'sha256:' + marker.source_digest, declaration };
+    } });
+  } catch { return null; }
+}
+
 export function inspectOwnedSharedMarketplaceForCopilotMigration({
   dataRoot = defaultAgdfDataRoot(),
   expectedVersion = pluginDefinition.version,
@@ -745,7 +940,7 @@ export function classifyMarketplaceList(surface, output, stableRoot) {
   } catch {
     return { state: "unknown", source: "", reason: "invalid_json" };
   }
-  const entries = surface === "codex" ? parsed?.marketplaces : parsed;
+  const entries = surface === "codex" ? codexMarketplaceEntries(parsed) : claudeMarketplaceEntries(parsed);
   if (!Array.isArray(entries)) return { state: "unknown", source: "", reason: "invalid_shape" };
   const matches = entries.filter((entry) => entry?.name === MARKETPLACE_ID);
   if (matches.length === 0) return { state: "absent", source: "" };
@@ -767,3 +962,84 @@ export const localMarketplaceConstants = Object.freeze({
   legacyLocalInstallFile: LEGACY_LOCAL_INSTALL_FILE,
   legacyRepository: LEGACY_REPOSITORY,
 });
+
+// Existing marketplace journal/backup remains the single publication owner. Native observers
+// call this only after qualification or to compensate a failed Cockpit cutover.
+export function settleCodexCockpitPublication({ pluginRoot, target, sourceDigest, previousSourceDigest, action, finalEvidence } = {}) {
+  if (!['commit', 'rollback'].includes(action) || !isAbsolute(pluginRoot ?? '') || !isAbsolute(target ?? ''))
+    throw Error('AGDF_COCKPIT_SETTLEMENT_INPUT_INVALID');
+  const stableRoot = dirname(dirname(pluginRoot)), parent = dirname(stableRoot);
+  if (join(stableRoot, 'plugins', MARKETPLACE_ID) !== pluginRoot || realpathSync(target) !== target)
+    throw Error('AGDF_COCKPIT_SETTLEMENT_INPUT_INVALID');
+  const transactionPath = `${stableRoot}.transaction.json`, backupRoot = `${stableRoot}.backup`, failedRoot = `${stableRoot}.failed`;
+  return withOwnedFileLock(`${stableRoot}.cockpit-settle`, () => {
+  const transaction = readOptionalJson(transactionPath);
+  if (transaction?.schema_version !== 1 || transaction.owner !== 'create-agdf' || transaction.profile_id !== 'runtime-plugin'
+    || transaction.phase !== 'cockpit_qualification_pending' || transaction.cockpit_target !== target
+    || transaction.source_digest !== sourceDigest) throw Error('AGDF_COCKPIT_SETTLEMENT_CONFLICT');
+  if (action === 'rollback' && transaction.previous_source_digest !== previousSourceDigest
+    || transaction.previous_root_identity === null && existsSync(backupRoot)) throw Error('AGDF_COCKPIT_SETTLEMENT_CONFLICT');
+  assertTransactionStablePayload(stableRoot, transaction);
+  if (transaction.previous_root_identity !== null) {
+    assertTransactionBackupIdentity(backupRoot, transaction);
+    const previous = ownership(backupRoot);
+    if (previous.source_digest !== transaction.previous_source_digest
+      || digestDirectory(join(backupRoot, 'plugins', MARKETPLACE_ID)) !== previous.plugin_digest)
+      throw Error('AGDF_COCKPIT_SETTLEMENT_CONFLICT');
+  }
+  if (action === 'commit') {
+    const checked = validateCockpitTransitionEvidence(finalEvidence, { expected: { plugin_root: pluginRoot,
+      target_id: resolveControlCommandTarget(target).target_id, version: transaction.version,
+      previous_plugin_digest: transaction.previous_source_digest ? `sha256:${transaction.previous_source_digest}` : null,
+      previous_plugin_version: transaction.previous_version } });
+    const digest = path => {
+      if (realpathSync(path) !== path || !lstatSync(path).isFile() || lstatSync(path).size > 4 * 1024 ** 2)
+        throw Error('AGDF_COCKPIT_FINAL_EVIDENCE_REQUIRED');
+      return 'sha256:' + createHash('sha256').update(readFileSync(path)).digest('hex');
+    };
+    if (!checked.valid || finalEvidence.config_path !== join(target, '.codex/config.toml')
+      || digest(finalEvidence.config_path) !== finalEvidence.config_digest) throw Error('AGDF_COCKPIT_FINAL_EVIDENCE_REQUIRED');
+    for (const origin of finalEvidence.inventory.origins) {
+      if (!isAbsolute(origin.path) || (existsSync(origin.path) ? digest(origin.path)
+        : 'sha256:' + createHash('sha256').update('').digest('hex')) !== origin.digest)
+        throw Error('AGDF_COCKPIT_FINAL_EVIDENCE_REQUIRED');
+    }
+    if (![finalEvidence.config_path, join(pluginRoot, 'mcp.json')]
+      .every(path => finalEvidence.inventory.origins.some(origin => origin.path === path)))
+      throw Error('AGDF_COCKPIT_FINAL_EVIDENCE_REQUIRED');
+    for (const ref of finalEvidence.evidence) {
+      const path = resolve(target, ref.path);
+      if (!pathInside(join(target, '.agdf/control/artefacts'), path) || digest(path) !== ref.digest)
+        throw Error('AGDF_COCKPIT_FINAL_EVIDENCE_REQUIRED');
+    }
+    const runtime = inspectMcpExecutableRoot({ root: finalEvidence.runtime_root, expectedVersion: transaction.version });
+    const shipped = pluginMcpRuntimeIdentity(pluginRoot);
+    if (runtime.status !== 'matched' || `sha256:${runtime.digest}` !== finalEvidence.server_digest
+      || `sha256:${runtime.dispatcherDigest}` !== finalEvidence.dispatcher_digest
+      || `sha256:${runtime.sdkDigest}` !== finalEvidence.sdk_digest
+      || digest(join(runtime.packageRoot, 'ui/cockpit.html')) !== finalEvidence.ui_digest
+      || runtime.version !== shipped.version || runtime.digest !== shipped.digest
+      || runtime.dispatcherDigest !== shipped.dispatcherDigest || runtime.sdkDigest !== shipped.sdkDigest
+      || finalEvidence.host.os !== process.platform || finalEvidence.host.arch !== process.arch
+      || finalEvidence.providers.some(provider => provider.origin !== pluginRoot
+        && [finalEvidence.legacy_id, 'agdf-cockpit'].some(id => id.replaceAll('-', '_').toLowerCase()
+          === provider.server_id.replaceAll('-', '_').toLowerCase())))
+      throw Error('AGDF_COCKPIT_FINAL_EVIDENCE_REQUIRED');
+    if (finalEvidence?.authorizes !== false || finalEvidence?.kind !== 'cockpit_transition'
+      || finalEvidence.plugin_digest !== `sha256:${sourceDigest}`
+      || finalEvidence.result !== 'qualified' || finalEvidence.native_final !== true
+      || !['normal_context', 'legacy_absent', 'render', 'interaction', 'legacy_views_closed', 'legacy_context_clear']
+        .every(key => finalEvidence.observations?.includes(key)))
+      throw Error('AGDF_COCKPIT_FINAL_EVIDENCE_REQUIRED');
+    atomicWrite(transactionPath, `${JSON.stringify({ ...transaction, phase: 'committed' })}\n`);
+    recoverInterruptedTransaction(stableRoot, `${stableRoot}.stage`, backupRoot, failedRoot, transactionPath);
+    return { status: 'committed', source_digest: sourceDigest };
+  }
+  if (existsSync(failedRoot)) throw Error('AGDF_COCKPIT_SETTLEMENT_CONFLICT');
+  // Persist explicit rollback intent before filesystem changes; the existing recovery owner
+  // can resume every interrupted rename/cleanup without inventing another journal.
+  atomicWrite(transactionPath, `${JSON.stringify({ ...transaction, phase: 'prepared' })}\n`);
+  recoverInterruptedTransaction(stableRoot, `${stableRoot}.stage`, backupRoot, failedRoot, transactionPath);
+  return { status: 'restored', source_digest: transaction.previous_source_digest };
+  });
+}

package/lib/installers/npm-invocation.js

@@ -0,0 +1,2 @@
+// npm invocation is shared with the plugin-local MCP runtime, which must not ship installer modules.
+export { defaultNpmInstallRoot, npmExecutable, npmInvocation } from "../npm-invocation.js";

package/lib/installers/opencode-activation.js

@@ -1,8 +1,8 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { pluginDefinition } from "../cli/runtime-context.js";
 
-const requiredConfigFields = ["artifact_language", "chat_language", "runtime_language"];
+import { inspectControlConfiguration } from "#agdf-core/control-state/control-configuration.js";
 
 export function isOpenCodeLegacySurfacePresent(targetDir) {
   return existsSync(join(targetDir, ".opencode", pluginDefinition.opencode.instructionsFileName))
@@ -10,34 +10,8 @@ export function isOpenCodeLegacySurfacePresent(targetDir) {
 }
 
 export function evaluateOpenCodeRepositoryActivation(targetDir) {
-  const controlDir = join(targetDir, ".agdf", "control");
-  const configPath = join(controlDir, "config.json");
+  const observation = inspectControlConfiguration(targetDir);
   const legacySurface = isOpenCodeLegacySurfacePresent(targetDir);
-  const base = {
-    control_dir: controlDir,
-    config_path: configPath,
-    legacy_surface: legacySurface,
-  };
-
-  if (!existsSync(configPath)) {
-    return { ...base, state: "inactive", active: false, diagnostic: "missing_control_config" };
-  }
-
-  try {
-    const config = JSON.parse(readFileSync(configPath, "utf8"));
-    const valid = config
-      && typeof config === "object"
-      && !Array.isArray(config)
-      && requiredConfigFields.every((field) => typeof config[field] === "string" && config[field].trim());
-    if (!valid) return { ...base, state: "invalid_control", active: false, diagnostic: "invalid_control_config" };
-  } catch (error) {
-    return { ...base, state: "invalid_control", active: false, diagnostic: "invalid_control_json", error: error.message };
-  }
-
-  return {
-    ...base,
-    state: legacySurface ? "legacy_compatible" : "active",
-    active: true,
-    diagnostic: "valid_control_config",
-  };
+  return { ...observation, legacy_surface: legacySurface,
+    state: observation.active && legacySurface ? "legacy_compatible" : observation.state };
 }