@lesliechan721/aw 0.1.0-beta.10 → 0.1.0-beta.12

package/dist/src/commands/rebuild-integration.js

@@ -1,5 +1,4 @@
 import crypto from 'node:crypto';
-import os from 'node:os';
 import path from 'node:path';
 import fs from 'fs-extra';
 import { generateAgentArtifacts } from '../generators/agents.js';
@@ -7,19 +6,20 @@ import { generateInstructionArtifacts, renderCodexManagedInstructionBlock, } fro
 import { generateCodexPermissionArtifacts, mergeClaudePermissions, } from '../generators/permissions.js';
 import { buildGeneratedName } from '../generators/shared.js';
 import { applyConditionalCodexConfigTransactionFile, applyCodexConfigTransactionFile, composeManagedDeveloperInstructionsBlock, readCodexConfigFile, } from '../utils/codex-config.js';
-import { canonicalizePathThroughExistingAncestor } from '../utils/state-paths.js';
+import { canonicalizePathThroughExistingAncestor, resolveClaudeProjectKey, resolveCodexProjectKey, } from '../utils/state-paths.js';
 import { createCodexSkillExpectedTree, createCodexSkillStagingTreeContentDigest, } from '../utils/codex-skill-staging.js';
-import { createDynamicSkillExpectedTree, createDynamicSkillTreeContentDigest, readDynamicSkillTree, validateSkillDirectory, writeDynamicSkillTree, } from '../utils/dynamic-skill-tree.js';
+import { AW_PLUGIN_REQUIREMENTS_RECEIPT_PATH, createDynamicSkillExpectedTree, createDynamicSkillTreeContentDigest, readDynamicSkillTree, validateSkillDirectory, writeDynamicSkillTree, } from '../utils/dynamic-skill-tree.js';
 import { parseCodexSharedHooksFile, serializeTrackedHookGroupIdentity, } from '../utils/hooks-contract.js';
-import { buildCodexMarketplaceAddInvocation, buildCodexMarketplaceListInvocation, buildCodexPluginAddInvocation, buildCodexPluginListInvocation, buildCodexPluginListJsonInvocation, buildCodexProjectPluginListInvocations, buildCodexPluginRemoveInvocation, CodexProjectConfigNotEffectiveError, parseCodexPluginListJson, postcheckCodexProjectPluginActivation, runNativeCli, runNativeCliChecked, SYSTEM_CODEX_MANAGER, } from '../utils/native-cli.js';
+import { buildCodexMarketplaceAddInvocation, buildCodexMarketplaceRemoveInvocation, buildCodexPluginAddInvocation, buildCodexPluginRemoveInvocation, CodexProjectConfigNotEffectiveError, runNativeCliChecked, SYSTEM_CODEX_MANAGER, } from '../utils/native-cli.js';
 import { OWNED_TEXT_HEADER_PREFIX, createSharedOwnerToken, createSkillOwnerMarkerContent, parseSharedOwnerToken, parseOwnedTextHeader, readSkillOwnerMarker, renderOwnedTextFile, inspectOwnedComponents, writeOwnedTextFile, } from '../utils/ownership.js';
 import { resolveArtifactRenderConfig, resolveArtifactRendererTarget, runArtifactRenderer, } from '../utils/artifact-renderer.js';
 import { createArtifactConfigDigest, validateArtifactPlan, } from '../utils/artifact-plan.js';
-import { resolveAwDeliveredArtifactIds } from '../utils/artifact-request.js';
-import { createAwPluginRequirementsReceipt, } from '../utils/manifest.js';
+import { resolveAwDeliveredArtifactRequestBatches } from '../utils/artifact-request.js';
+import { createAwPluginRequirementsReceipt, parseAwPluginRequirementsReceipt, } from '../utils/manifest.js';
 import { resolvePlatformEntries } from '../utils/platform-entries.js';
 import { resolveAwHome, resolveClaudePaths, resolveCodexPaths, resolveRepoRoot, getCodexHome, } from '../utils/paths.js';
-import { runPostApplyScript } from '../utils/plugin-scripts.js';
+import { assertNoSensitiveConfigInFiles, collectSensitivePluginConfigValues, runPreApplyScript, } from '../utils/plugin-scripts.js';
+import { findSensitiveTokenPath } from '../utils/sensitive-content.js';
 import { atomicRemoveConfigFile, atomicReplaceConfigFile, withConfigFileMutation, } from '../utils/plugin-config.js';
 import { readCatalogSourcesConfigSnapshot } from '../utils/catalog-sources.js';
 import { getNamespacedMarketplaceName, projectMarketplaceManifestForPlatform, readStrictNamespacedMarketplaceRoot, replayNamespacedCodexSkillOverlays, } from '../utils/local-marketplace.js';
@@ -28,8 +28,8 @@ import { readClaudeSettings, writeClaudeSettings } from '../adapters/helpers.js'
 import { analyzeCodexSurface } from '../utils/codex-surface-analysis.js';
 import { CODEX_NATIVE_RENDER_RECEIPT_PATH, codexNativeRenderProjectionsEqual, createCodexNativeRenderProjection, createCodexNativeRenderReceipt, parseCodexNativeRenderReceipt, serializeCodexNativeRenderReceipt, } from '../utils/codex-native-render-receipt.js';
 import { inspectCodexSharedNative, } from '../utils/codex-shared-native.js';
-import { calculateCodexNativeRenderPayloadDigest, calculateCodexSharedNativePayloadDigest, } from '../utils/catalog-digests.js';
-import { combineCodexNativePluginObservations, observeCodexNativePlugin, } from '../utils/codex-native-observation.js';
+import { calculateCodexNativeRenderPayloadDigest } from '../utils/catalog-digests.js';
+import { createCodexNativeObservationSession, } from '../utils/codex-native-observation.js';
 import { isSafeCodexMarketplaceRoot } from '../utils/codex-marketplace-path.js';
 import { assertCanonicalProjectManagedRoots } from '../utils/project-boundary.js';
 import { findCodexRoleNameConflict, resolveCodexRoleNamespace, } from '../utils/codex-roles.js';
@@ -39,6 +39,26 @@ function requirementsReceipt(plugin) {
     const receipt = createAwPluginRequirementsReceipt({ name: plugin.manifest.name, version: plugin.manifest.version }, plugin.manifest.requires?.aw.capabilities ?? []);
     return Buffer.from(`${JSON.stringify(receipt, null, 2)}\n`, 'utf8');
 }
+function withoutVerifiedRequirementsReceipt(plugin, files) {
+    const receipt = files[AW_PLUGIN_REQUIREMENTS_RECEIPT_PATH];
+    if (!receipt)
+        return { ...files };
+    let actual;
+    let expected;
+    try {
+        actual = parseAwPluginRequirementsReceipt(JSON.parse(receipt.toString('utf8')));
+        expected = parseAwPluginRequirementsReceipt(JSON.parse(requirementsReceipt(plugin).toString('utf8')));
+    }
+    catch {
+        return { ...files };
+    }
+    if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+        return { ...files };
+    }
+    const output = { ...files };
+    delete output[AW_PLUGIN_REQUIREMENTS_RECEIPT_PATH];
+    return output;
+}
 export class CodexActivationPostcheckError extends Error {
     code = 'codexActivationPostcheckFailed';
     codexPluginIds;
@@ -48,13 +68,34 @@ export class CodexActivationPostcheckError extends Error {
         this.codexPluginIds = [...new Set(typeof codexPluginIds === 'string' ? [codexPluginIds] : codexPluginIds)];
     }
 }
+function codexObservationScope(context, marketplaceName, fallbackScope) {
+    return context.codexObservationScopeByMarketplace?.get(marketplaceName)
+        ?? (fallbackScope === 'user' ? 'user' : 'both');
+}
+function codexMarketplaceFromPluginId(pluginId) {
+    return pluginId.slice(pluginId.lastIndexOf('@') + 1);
+}
+function requireCodexObservationCoverage(registration, scope, operation) {
+    if (!registration.observations.user
+        || (scope === 'both' && !registration.observations.project)) {
+        throw new Error(`codexNativeObservationUnavailable: ${operation} requires ${scope === 'user' ? 'neutral' : 'exact and neutral'} Codex plugin list evidence.`);
+    }
+}
 function requireCodexManager(manager) {
     if (!manager) {
         throw new Error('codexManagerRequired: Codex native operation has no resolved manager.');
     }
     return manager;
 }
-export async function executeCodexReconcileActivations(options) {
+async function runCodexMutationWithInvalidation(options) {
+    try {
+        return await options.mutation();
+    }
+    finally {
+        options.observationSession?.invalidate(options.marketplaceName);
+    }
+}
+async function executeCodexReconcileActivationsInSession(options) {
     const byScope = {
         user: { upserts: {}, removals: new Set() },
         project: { upserts: {}, removals: new Set() },
@@ -87,23 +128,35 @@ export async function executeCodexReconcileActivations(options) {
             }
         }
     }
+    const recordActivationMutations = (pluginIds) => {
+        if (!options.mutationMarketplaces)
+            return;
+        for (const pluginId of pluginIds) {
+            options.mutationMarketplaces.add(pluginId.slice(pluginId.lastIndexOf('@') + 1));
+        }
+    };
     const observedActivationPluginIds = [...new Set(options.plans.flatMap((plan) => plan.postcheck.support === 'observed'
             ? plan.postcheck.plugins.map((plugin) => plugin.codexPluginId)
             : []))];
-    if (observedActivationPluginIds.length > 0) {
+    if (!options.preflightCompleted && observedActivationPluginIds.length > 0) {
         const manager = requireCodexManager(options.manager);
         for (const pluginId of observedActivationPluginIds) {
+            const marketplaceName = codexMarketplaceFromPluginId(pluginId);
+            const observationScope = options.observationScopeByMarketplace?.get(marketplaceName)
+                ?? (options.plans.some((plan) => plan.requirement.requiresProjectPluginContract)
+                    ? 'both'
+                    : 'user');
             const registration = await inspectCodexPluginRegistrationLive({
                 pluginId,
                 cwd: options.cwd,
                 env: options.env,
                 nativeCliRunner: options.runner,
                 manager,
+                scope: observationScope,
+                observationSession: options.observationSession,
             });
             const observedState = requireObservedCodexNativeState(registration.observation, 'activation precheck');
-            if (!registration.observations.user || !registration.observations.project) {
-                throw new Error('codexNativeObservationUnavailable: activation precheck requires exact and neutral Codex plugin list evidence.');
-            }
+            requireCodexObservationCoverage(registration, observationScope, 'activation precheck');
             if (observedState !== 'installed') {
                 throw new Error('codexNativeObservationFailed: activation precheck did not observe the installed Codex plugin.');
             }
@@ -115,7 +168,9 @@ export async function executeCodexReconcileActivations(options) {
         if (Object.keys(enables).length === 0)
             continue;
         const configPath = resolveCodexPaths(options.cwd, scope, options.env).configTomlPath;
-        await applyCodexConfigTransactionFile(configPath, { upsertPluginActivations: enables });
+        const update = await applyCodexConfigTransactionFile(configPath, { upsertPluginActivations: enables });
+        if (update.wrote)
+            recordActivationMutations(Object.keys(enables));
         const enabledConfig = await readCodexConfigFile(configPath);
         const missingEnables = Object.keys(enables).filter((pluginId) => enabledConfig.snapshot.plugins[pluginId]?.enabled !== true);
         if (missingEnables.length > 0) {
@@ -128,7 +183,7 @@ export async function executeCodexReconcileActivations(options) {
             .filter(([, desired]) => !desired));
         if (Object.keys(disables).length === 0 && transaction.removals.size === 0)
             continue;
-        await applyCodexConfigTransactionFile(resolveCodexPaths(options.cwd, scope, options.env).configTomlPath, {
+        const update = await applyCodexConfigTransactionFile(resolveCodexPaths(options.cwd, scope, options.env).configTomlPath, {
             ...(transaction.removals.size > 0
                 ? { removePluginActivations: [...transaction.removals].sort() }
                 : {}),
@@ -136,6 +191,12 @@ export async function executeCodexReconcileActivations(options) {
                 ? { upsertPluginActivations: disables }
                 : {}),
         });
+        if (update.wrote) {
+            recordActivationMutations([
+                ...Object.keys(disables),
+                ...transaction.removals,
+            ]);
+        }
     }
     const [userConfig, projectConfig] = await Promise.all([
         readCodexConfigFile(resolveCodexPaths(options.cwd, 'user', options.env).configTomlPath),
@@ -172,45 +233,87 @@ export async function executeCodexReconcileActivations(options) {
         : []);
     if (observedActivationChecks.length === 0)
         return;
-    const manager = requireCodexManager(options.manager);
-    const neutralCwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aw-codex-postcheck-'));
+    const ineffectivePlugins = [];
+    const ineffectiveDetails = [];
+    for (const plugin of observedActivationChecks) {
+        const userActive = userConfig.snapshot.plugins[plugin.codexPluginId]?.enabled === true;
+        const projectActive = projectConfig.snapshot.plugins[plugin.codexPluginId]?.enabled === true;
+        if ((userActive || projectActive) !== (plugin.expectedUserEnabled || plugin.expectedProjectEnabled)
+            || userActive !== plugin.expectedUserEnabled) {
+            ineffectivePlugins.push(plugin.codexPluginId);
+            ineffectiveDetails.push(new CodexProjectConfigNotEffectiveError(plugin.codexPluginId).message);
+        }
+    }
+    if (ineffectivePlugins.length > 0) {
+        throw new CodexActivationPostcheckError(ineffectivePlugins, ineffectiveDetails.join(' '));
+    }
+}
+export async function executeCodexReconcileActivations(options) {
+    const ownedSession = options.observationSession ? undefined
+        : await createCodexNativeObservationSession({
+            exactCwd: options.cwd,
+            env: options.env,
+            runner: options.runner,
+            manager: options.manager,
+        });
     try {
-        const invocations = buildCodexProjectPluginListInvocations(manager, {
+        await executeCodexReconcileActivationsInSession({
+            ...options,
+            observationSession: options.observationSession ?? ownedSession,
+        });
+    }
+    finally {
+        await ownedSession?.dispose();
+    }
+}
+export async function postcheckCodexReconcileActivations(options) {
+    const checks = options.plans.flatMap((plan) => plan.postcheck.support === 'observed' ? plan.postcheck.plugins : []);
+    if (checks.length === 0)
+        return;
+    const ownedSession = options.observationSession ? undefined
+        : await createCodexNativeObservationSession({
             exactCwd: options.cwd,
-            neutralCwd,
             env: options.env,
+            runner: options.runner,
+            manager: options.manager,
         });
-        const [exactResult, neutralResult] = await Promise.all([
-            runNativeCliChecked(invocations.exact, options.runner),
-            runNativeCliChecked(invocations.neutral, options.runner),
-        ]);
-        const ineffectivePlugins = [];
-        const ineffectiveDetails = [];
-        for (const plugin of observedActivationChecks) {
+    const session = options.observationSession ?? ownedSession;
+    try {
+        const failedPluginIds = [];
+        const failureDetails = [];
+        for (const check of checks) {
             try {
-                postcheckCodexProjectPluginActivation({
-                    pluginId: plugin.codexPluginId,
-                    userEnabled: plugin.expectedUserEnabled,
-                    projectEnabled: plugin.expectedProjectEnabled,
-                    exactResult,
-                    neutralResult,
+                const marketplaceName = codexMarketplaceFromPluginId(check.codexPluginId);
+                const observationScope = options.observationScopeByMarketplace?.get(marketplaceName)
+                    ?? (options.plans.some((plan) => plan.requirement.requiresProjectPluginContract)
+                        ? 'both'
+                        : 'user');
+                const registration = await inspectCodexPluginRegistrationLive({
+                    pluginId: check.codexPluginId,
+                    cwd: options.cwd,
+                    env: options.env,
+                    nativeCliRunner: options.runner,
+                    manager: options.manager,
+                    scope: observationScope,
+                    observationSession: session,
                 });
+                const state = requireObservedCodexNativeState(registration.observation, 'activation postcheck');
+                requireCodexObservationCoverage(registration, observationScope, 'activation postcheck');
+                if (state !== 'installed') {
+                    throw new Error(`codexNativeObservationFailed: ${check.codexPluginId} was not observed after Codex activation mutation.`);
+                }
             }
             catch (error) {
-                if (error instanceof CodexProjectConfigNotEffectiveError) {
-                    ineffectivePlugins.push(plugin.codexPluginId);
-                    ineffectiveDetails.push(error.message);
-                    continue;
-                }
-                throw error;
+                failedPluginIds.push(check.codexPluginId);
+                failureDetails.push(error instanceof Error ? error.message : String(error));
             }
         }
-        if (ineffectivePlugins.length > 0) {
-            throw new CodexActivationPostcheckError(ineffectivePlugins, ineffectiveDetails.join(' '));
+        if (failedPluginIds.length > 0) {
+            throw new CodexActivationPostcheckError(failedPluginIds, failureDetails.join(' '));
         }
     }
     finally {
-        await fs.remove(neutralCwd);
+        await ownedSession?.dispose();
     }
 }
 const CODEX_REMOVE_RECOVERY = 'Codex residue was retained. Retry cleanup or uninstall, upgrade AW, or install a compatible official Codex CLI.';
@@ -718,7 +821,8 @@ async function scanOwnedSkills(options) {
                 }));
                 continue;
             }
-            pending.push(skillRoot);
+            if (options.recursive !== false)
+                pending.push(skillRoot);
         }
     }
     return output;
@@ -840,46 +944,60 @@ function renderCodexRole(options) {
     ].join('\n');
 }
 async function resolveDynamicArtifacts(options) {
-    const requestedArtifactIds = resolveAwDeliveredArtifactIds({
+    const requestBatches = resolveAwDeliveredArtifactRequestBatches({
         manifest: options.plugin.manifest,
         platform: options.platform,
         scope: options.scope,
     });
-    if (requestedArtifactIds.length === 0)
-        return { artifacts: [], sourceDirs: () => [] };
-    const render = await runArtifactRenderer({
-        event: options.event,
-        plugin: options.plugin,
-        platform: options.platform,
-        scope: options.scope,
-        cwd: options.cwd,
-        commandEnv: options.env,
-        previousArtifacts: [...options.previousArtifacts],
-        requestedArtifactIds,
-        scriptTimeoutMs: options.scriptTimeoutMs,
-    });
+    if (requestBatches.length === 0) {
+        return { artifacts: [], sourceDirs: () => [], sensitiveValues: [] };
+    }
+    const previousArtifacts = [...options.previousArtifacts];
+    const renders = [];
+    for (const requestedArtifactIds of requestBatches) {
+        renders.push(await runArtifactRenderer({
+            event: options.event,
+            plugin: options.plugin,
+            platform: options.platform,
+            scope: options.scope,
+            cwd: options.cwd,
+            commandEnv: options.env,
+            previousArtifacts,
+            requestedArtifactIds,
+            scriptTimeoutMs: options.scriptTimeoutMs,
+        }));
+    }
     const config = await resolveArtifactRenderConfig({
         sourceId: options.plugin.sourceId,
         sourceIdentity: options.plugin.sourceIdentity,
+        logicalIdentity: options.plugin.catalogLogicalIdentity,
         pluginName: options.plugin.manifest.name,
         manifest: options.plugin.manifest,
         scope: options.scope,
         cwd: options.cwd,
         env: options.env,
     });
-    const artifacts = validateArtifactPlan({
-        manifest: options.plugin.manifest,
-        plan: render.plan,
-        platform: options.platform,
-        scope: options.scope,
-        requestedArtifactIds: render.context.requestedArtifactIds,
-        renderConfig: config,
-        rendererDigest: render.target.rendererDigest,
-        manifestDigest: render.target.manifestDigest,
-    }).artifacts;
+    const artifacts = [];
+    const sourceDirsByArtifact = new Map();
+    for (const render of renders) {
+        artifacts.push(...validateArtifactPlan({
+            manifest: options.plugin.manifest,
+            plan: render.plan,
+            platform: options.platform,
+            scope: options.scope,
+            requestedArtifactIds: render.context.requestedArtifactIds,
+            renderConfig: config,
+            rendererDigest: render.target.rendererDigest,
+            manifestDigest: render.target.manifestDigest,
+        }).artifacts);
+        for (const source of render.context.artifactSources) {
+            sourceDirsByArtifact.set(`${source.id}\0${source.target}`, source.sourceDirs);
+        }
+    }
     return {
         artifacts,
-        sourceDirs: (artifact) => render.context.artifactSources.find((entry) => entry.id === artifact.id && entry.target === artifact.target)?.sourceDirs ?? [],
+        sourceDirs: (artifact) => sourceDirsByArtifact.get(`${artifact.id}\0${artifact.target}`) ?? [],
+        sensitiveValues: collectSensitivePluginConfigValues(options.plugin.manifest, config.values),
     };
 }
 function dynamicSkillWrite(options) {
@@ -1053,6 +1171,7 @@ async function buildClaudeWrites(options) {
             requirementsReceipt: requirementsReceipt(options.plugin),
             sourceRequirementsReceiptPolicy: 'allow',
         });
+        assertNoSensitiveConfigInFiles(withoutVerifiedRequirementsReceipt(options.plugin, tree.files), dynamic.sensitiveValues, 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
         writes.push(dynamicSkillWrite({
             ...options,
             platform: 'claude',
@@ -1129,6 +1248,7 @@ async function buildCodexWrites(options) {
             requirementsReceipt: requirementsReceipt(options.plugin),
             sourceRequirementsReceiptPolicy: 'allow',
         });
+        assertNoSensitiveConfigInFiles(withoutVerifiedRequirementsReceipt(options.plugin, tree.files), dynamic.sensitiveValues, 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
         writes.push(dynamicSkillWrite({
             ...options,
             platform: 'codex',
@@ -1636,119 +1756,43 @@ async function buildHistoricalComponents(options) {
     }
     return components;
 }
-function isAbsentCodexResiduePath(error) {
+function isAbsentPath(error) {
     const code = error.code;
     return code === 'ENOENT';
 }
-async function lstatCodexResidueIfPresent(filePath) {
+async function lstatIfPresent(filePath) {
     return fs.lstat(filePath).catch((error) => {
-        if (isAbsentCodexResiduePath(error))
+        if (isAbsentPath(error))
             return null;
         throw error;
     });
 }
-async function readdirCodexResidueIfPresent(directory) {
-    const stats = await lstatCodexResidueIfPresent(directory);
-    if (!stats)
-        return [];
-    if (!stats.isDirectory() || stats.isSymbolicLink()) {
-        throw new Error(`Codex residue root is not a canonical directory: ${directory}`);
-    }
-    return fs.readdir(directory, { withFileTypes: true });
-}
-export async function inspectCodexNativeResidue(options) {
-    const marketplaceName = options.marketplaceName ?? MARKETPLACE_NAME;
-    const marketplaceRoot = options.marketplaceRoot ?? resolveAwHome(options.env);
-    const pluginId = `${options.pluginName}@${marketplaceName}`;
-    const configPath = resolveCodexPaths(options.cwd, 'user', options.env).configTomlPath;
-    const config = await readCodexConfigFile(configPath);
-    const marketplace = config.snapshot.marketplaces[marketplaceName];
-    const canonicalMarketplace = marketplace?.sourceType === 'local'
-        && !marketplace.sourcePointsToManifest
-        && path.normalize(marketplace.source ?? '') === path.normalize(marketplaceRoot);
-    const cacheRoot = path.join(getCodexHome(options.env), 'plugins', 'cache', marketplaceName, options.pluginName);
-    const installedRoot = path.join(getCodexHome(options.env), 'plugins', pluginId);
-    const installedManifest = path.join(installedRoot, 'manifest.json');
-    const labels = [];
-    const foreignLabels = [];
-    const versions = new Set();
-    const installedVersions = new Set();
-    const cacheVersions = new Set();
-    const configEntry = config.snapshot.plugins[pluginId];
-    if (configEntry) {
-        (canonicalMarketplace ? labels : foreignLabels).push(`${configPath}#plugins.${pluginId}`);
-    }
-    const inspectManifest = async (manifestPath, kind, directoryVersion) => {
-        const stats = await lstatCodexResidueIfPresent(manifestPath);
-        if (!stats)
-            return;
-        if (!stats.isFile() || stats.isSymbolicLink()) {
-            foreignLabels.push(manifestPath);
-            return;
-        }
-        const manifest = await fs.readJson(manifestPath);
-        const identity = manifest?.id ?? manifest?.name;
-        const version = typeof manifest?.version === 'string' ? manifest.version : null;
-        if (!canonicalMarketplace
-            || (identity !== options.pluginName && identity !== pluginId)
-            || !version
-            || (directoryVersion !== undefined && version !== directoryVersion)) {
-            foreignLabels.push(manifestPath);
-            return;
-        }
-        labels.push(manifestPath);
-        versions.add(version);
-        (kind === 'installed' ? installedVersions : cacheVersions).add(version);
-    };
-    for (const entry of await readdirCodexResidueIfPresent(cacheRoot)) {
-        if (!entry.isDirectory() || entry.isSymbolicLink()) {
-            foreignLabels.push(path.join(cacheRoot, entry.name));
-            continue;
-        }
-        const versionRoot = path.join(cacheRoot, entry.name);
-        const candidates = [
-            path.join(versionRoot, 'plugin.json'),
-            path.join(versionRoot, '.codex-plugin', 'plugin.json'),
-        ];
-        const existing = [];
-        for (const candidate of candidates) {
-            if (await lstatCodexResidueIfPresent(candidate))
-                existing.push(candidate);
-        }
-        if (existing.length === 0)
-            foreignLabels.push(versionRoot);
-        for (const candidate of existing)
-            await inspectManifest(candidate, 'cache', entry.name);
-    }
-    const installedStats = await lstatCodexResidueIfPresent(installedRoot);
-    if (installedStats && (!installedStats.isDirectory() || installedStats.isSymbolicLink())) {
-        foreignLabels.push(installedRoot);
-    }
-    else if (installedStats) {
-        await inspectManifest(installedManifest, 'installed');
-    }
-    return foreignLabels.length > 0
-        ? {
-            state: 'foreign', labels: [...labels, ...foreignLabels], versions: [...versions],
-            installedVersions: [...installedVersions], cacheVersions: [...cacheVersions],
-            enabled: configEntry?.enabled === true,
-        }
-        : labels.length > 0
-            ? {
-                state: 'present', labels, versions: [...versions],
-                installedVersions: [...installedVersions], cacheVersions: [...cacheVersions],
-                enabled: configEntry?.enabled === true,
-            }
-            : {
-                state: 'absent', labels: [], versions: [],
-                installedVersions: [], cacheVersions: [], enabled: false,
-            };
+async function lstatCodexResidueIfPresent(filePath) {
+    return fs.lstat(filePath).catch((error) => {
+        if (isAbsentPath(error))
+            return null;
+        throw error;
+    });
 }
 function isPathWithin(root, candidate) {
     const relative = path.relative(path.resolve(root), path.resolve(candidate));
     return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
 }
-async function codexPayloadPathSafe(payloadRoot) {
+async function codexReadPathSafe(root, candidate) {
+    if (!isPathWithin(root, candidate))
+        return false;
+    const rootStats = await lstatCodexResidueIfPresent(root);
+    if (rootStats && (!rootStats.isDirectory() || rootStats.isSymbolicLink()))
+        return false;
+    const [physicalRoot, physicalCandidate] = await Promise.all([
+        canonicalizePathThroughExistingAncestor(root),
+        canonicalizePathThroughExistingAncestor(candidate),
+    ]);
+    return isPathWithin(physicalRoot, physicalCandidate);
+}
+async function codexPayloadPathSafe(payloadRoot, allowedRoot = payloadRoot) {
+    if (!await codexReadPathSafe(allowedRoot, payloadRoot))
+        return false;
     const rootStats = await lstatCodexResidueIfPresent(payloadRoot);
     if (!rootStats?.isDirectory() || rootStats.isSymbolicLink())
         return false;
@@ -1757,12 +1801,9 @@ async function codexPayloadPathSafe(payloadRoot) {
         const current = pending.pop();
         for (const entry of await fs.readdir(current, { withFileTypes: true })) {
             const entryPath = path.join(current, entry.name);
-            if (entry.isSymbolicLink()) {
-                const target = path.resolve(path.dirname(entryPath), await fs.readlink(entryPath));
-                if (!isPathWithin(payloadRoot, target))
-                    return false;
-            }
-            else if (entry.isDirectory()) {
+            if (entry.isSymbolicLink())
+                return false;
+            if (entry.isDirectory()) {
                 pending.push(entryPath);
             }
             else if (!entry.isFile()) {
@@ -1772,6 +1813,23 @@ async function codexPayloadPathSafe(payloadRoot) {
     }
     return true;
 }
+async function resolveCodexSkillsRoot(payloadRoot, rawSkillsRoot) {
+    const normalizedSeparators = rawSkillsRoot.replace(/\\/gu, '/');
+    const relativeRoot = path.posix.normalize(normalizedSeparators.replace(/^\.\//u, ''));
+    if (!relativeRoot
+        || relativeRoot === '.'
+        || relativeRoot === '..'
+        || relativeRoot.startsWith('../')
+        || path.posix.isAbsolute(normalizedSeparators)
+        || path.win32.isAbsolute(rawSkillsRoot)) {
+        throw new Error('codexNativeSkillsRootInvalid: Codex native Skills root is invalid.');
+    }
+    const root = path.join(payloadRoot, ...relativeRoot.split('/'));
+    if (!await codexReadPathSafe(payloadRoot, root)) {
+        throw new Error('codexNativeSkillsRootInvalid: Codex native Skills root is unsafe.');
+    }
+    return { relativeRoot, root };
+}
 function codexNativeRenderTargets(plugin) {
     return (plugin.manifest.artifacts?.targets ?? []).filter((target) => target.platform === 'codex'
         && target.target === 'codex.skill'
@@ -1779,11 +1837,11 @@ function codexNativeRenderTargets(plugin) {
 }
 async function readCodexNativeRenderReceiptEvidence(payloadRoot) {
     const receiptPath = path.join(payloadRoot, CODEX_NATIVE_RENDER_RECEIPT_PATH);
-    const stats = await lstatCodexResidueIfPresent(receiptPath);
+    const stats = await lstatIfPresent(receiptPath);
     if (!stats)
         return { state: 'absent' };
     if (!stats.isFile() || stats.isSymbolicLink())
-        return { state: 'unreadable' };
+        return { state: 'unsafe' };
     try {
         return {
             state: 'present',
@@ -1791,7 +1849,7 @@ async function readCodexNativeRenderReceiptEvidence(payloadRoot) {
         };
     }
     catch {
-        return { state: 'unreadable' };
+        return { state: 'invalid' };
     }
 }
 async function resolveCodexNativeRenderExpectedEvidence(options) {
@@ -1801,6 +1859,7 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
         throw new Error('Codex native render projection requires namespaced source identity.');
     }
     const marketplace = await readStrictNamespacedMarketplaceRoot({
+        trustedMarketplaceRoot: path.join(resolveAwHome(options.env), 'marketplaces'),
         rootDir: options.marketplaceRoot,
         sourceId: options.plugin.sourceId,
         marketplaceName: options.marketplaceName,
@@ -1808,7 +1867,13 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
     if (!marketplace) {
         throw new Error('Codex native render canonical marketplace generation is missing.');
     }
+    if (marketplace.config.sourceIdentity !== options.plugin.sourceIdentity) {
+        return { state: 'foreign' };
+    }
     const payloadRoot = path.join(options.marketplaceRoot, 'plugins', options.plugin.manifest.name);
+    if (!await codexPayloadPathSafe(payloadRoot, options.marketplaceRoot)) {
+        throw new Error('Codex native render canonical marketplace payload path is unsafe.');
+    }
     const receiptEvidence = await readCodexNativeRenderReceiptEvidence(payloadRoot);
     if (receiptEvidence.state !== 'present') {
         throw new Error('Codex native render canonical marketplace receipt is missing or unreadable.');
@@ -1824,7 +1889,7 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
         throw new Error('Codex native render canonical marketplace payload does not match its receipt.');
     }
     const sourceManifestPath = path.join(payloadRoot, '.agents-plugin', 'plugin.json');
-    const sourceManifestStats = await lstatCodexResidueIfPresent(sourceManifestPath);
+    const sourceManifestStats = await lstatIfPresent(sourceManifestPath);
     const sourceManifest = sourceManifestStats?.isFile() && !sourceManifestStats.isSymbolicLink()
         ? await fs.readJson(sourceManifestPath).catch(() => null)
         : null;
@@ -1833,7 +1898,7 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
         throw new Error('Codex native render canonical marketplace plugin identity is invalid.');
     }
     const codexManifestPath = path.join(payloadRoot, '.codex-plugin', 'plugin.json');
-    const codexManifestStats = await lstatCodexResidueIfPresent(codexManifestPath);
+    const codexManifestStats = await lstatIfPresent(codexManifestPath);
     const codexManifest = codexManifestStats?.isFile() && !codexManifestStats.isSymbolicLink()
         ? await fs.readJson(codexManifestPath).catch(() => null)
         : null;
@@ -1843,19 +1908,14 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
     const rawSkillsRoot = typeof codexManifest.skills === 'string' && codexManifest.skills.trim() !== ''
         ? codexManifest.skills
         : './codex/skills';
-    const skillsRelativeRoot = path.posix.normalize(rawSkillsRoot.replace(/^\.\//u, ''));
-    if (skillsRelativeRoot === '..'
-        || skillsRelativeRoot.startsWith('../')
-        || path.posix.isAbsolute(skillsRelativeRoot)) {
-        throw new Error('Codex native render canonical marketplace skills root is invalid.');
-    }
+    const { relativeRoot: skillsRelativeRoot } = await resolveCodexSkillsRoot(payloadRoot, rawSkillsRoot);
     const emptyArtifactDigest = createCodexSkillStagingTreeContentDigest({
         skillKey: 'empty',
         files: {},
     });
     for (const receiptTarget of receipt.targets) {
         const skillRoot = path.join(payloadRoot, ...skillsRelativeRoot.split('/'), receiptTarget.skillKey);
-        if (await lstatCodexResidueIfPresent(path.join(skillRoot, '.agent-workflows-owner.json'))) {
+        if (await lstatIfPresent(path.join(skillRoot, '.agent-workflows-owner.json'))) {
             throw new Error('Codex native render canonical marketplace Skill has an AW owner marker.');
         }
         const tree = await readDynamicSkillTree(skillRoot, 'codex.skill');
@@ -1871,7 +1931,7 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
     if (targets.length === 0
         || targets.length !== receipt.targets.length
         || targets.some((target) => receiptTargets.get(target.id)?.skillKey !== target.skillKey)) {
-        return { payloadDigest };
+        return { state: 'present', payloadDigest, receipt, sourceProjection: 'drifted' };
     }
     const renderer = await resolveArtifactRendererTarget(options.plugin);
     if (renderer.noOp || !renderer.rendererDigest) {
@@ -1880,6 +1940,7 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
     const config = await resolveArtifactRenderConfig({
         sourceId: options.plugin.sourceId,
         sourceIdentity: options.plugin.sourceIdentity,
+        logicalIdentity: options.plugin.catalogLogicalIdentity,
         pluginName: options.plugin.manifest.name,
         manifest: options.plugin.manifest,
         scope: 'user',
@@ -1904,17 +1965,66 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
                     target: 'codex.skill',
                     refreshKeys: target.refreshKeys,
                 },
-                configValues: config.values,
+                renderConfig: config,
                 digestSalt: renderer.rendererDigest,
             }),
             artifactDigest: receiptTargets.get(target.id).artifactDigest,
         })),
     });
     return {
+        state: 'present',
+        receipt,
         projection,
         payloadDigest,
+        sourceProjection: codexNativeRenderProjectionsEqual(receipt, projection)
+            ? 'current'
+            : 'drifted',
     };
 }
+async function assertNoSensitiveValuesInCanonicalCodexNativePayload(options) {
+    if (options.sensitiveValues.length === 0
+        || !pluginHasCodexNativeSkillSurface(options.plugin))
+        return;
+    const sourceId = options.plugin.sourceId;
+    if (!sourceId) {
+        throw new Error('Codex native sensitive scan requires namespaced source identity.');
+    }
+    const awHome = resolveAwHome(options.env);
+    if (!await isSafeCodexMarketplaceRoot({
+        awHome,
+        sourceId,
+        marketplaceRoot: options.marketplaceRoot,
+    })) {
+        throw new Error('Codex native sensitive scan canonical marketplace path is unsafe.');
+    }
+    const payloadRoot = path.join(options.marketplaceRoot, 'plugins', options.plugin.manifest.name);
+    if (!await codexPayloadPathSafe(payloadRoot, options.marketplaceRoot)) {
+        throw new Error('Codex native sensitive scan payload path is unsafe.');
+    }
+    const receiptEvidence = await readCodexNativeRenderReceiptEvidence(payloadRoot);
+    if (receiptEvidence.state === 'unsafe') {
+        throw new Error('codexNativeRenderReceiptInvalid: Codex native render receipt path is unsafe.');
+    }
+    let verifiedRenderReceipt;
+    if (receiptEvidence.state === 'present') {
+        const expected = await resolveCodexNativeRenderExpectedEvidence({
+            plugin: options.plugin,
+            marketplaceRoot: options.marketplaceRoot,
+            marketplaceName: options.marketplaceName,
+            env: options.env,
+        }).catch(() => undefined);
+        if (expected?.state === 'present' && expected.sourceProjection === 'current') {
+            verifiedRenderReceipt = expected.receipt;
+        }
+    }
+    await assertNoSensitiveValuesInCodexNativePayload({
+        plugin: options.plugin,
+        payloadRoot,
+        allowedRoot: options.marketplaceRoot,
+        sensitiveValues: options.sensitiveValues,
+        verifiedRenderReceipt,
+    });
+}
 function observedCodexNativeState(observation, operation) {
     if (observation.state === 'observed') {
         return observation.value === 'installed' ? 'present' : 'absent';
@@ -1939,47 +2049,32 @@ export async function inspectCodexPluginRegistrationLive(options) {
             activations: {},
         };
     }
-    const manager = options.manager ?? SYSTEM_CODEX_MANAGER;
-    const readEntries = async (cwd) => {
-        try {
-            const result = await runNativeCli(buildCodexPluginListJsonInvocation(manager, cwd, options.env), options.nativeCliRunner);
-            if (result.exitCode !== 0) {
-                return { observation: { state: 'failed', reason: 'unavailable' } };
-            }
-            const entries = parseCodexPluginListJson(result.stdout);
-            return { entries, observation: observeCodexNativePlugin(options.pluginId, entries) };
-        }
-        catch (error) {
-            return {
-                observation: error.code === 'ENOENT'
-                    ? { state: 'unobserved' }
-                    : { state: 'failed', reason: 'unavailable' },
-            };
-        }
-    };
-    const [exactEntries, neutralEntries] = await Promise.all([
-        readEntries(options.cwd),
-        readEntries(os.tmpdir()),
-    ]);
-    const enabled = (values) => values?.find((entry) => entry.pluginId === options.pluginId)?.enabled;
-    return {
-        observation: combineCodexNativePluginObservations([
-            exactEntries.observation,
-            neutralEntries.observation,
-        ]),
-        observations: {
-            user: neutralEntries.entries !== undefined,
-            project: exactEntries.entries !== undefined,
-        },
-        activations: {
-            user: enabled(neutralEntries.entries),
-            project: enabled(exactEntries.entries),
-        },
-    };
+    const ownedSession = options.observationSession ? undefined
+        : await createCodexNativeObservationSession({
+            exactCwd: options.cwd,
+            env: options.env,
+            runner: options.nativeCliRunner,
+            manager: options.manager ?? SYSTEM_CODEX_MANAGER,
+        });
+    const session = options.observationSession ?? ownedSession;
+    try {
+        const inspected = await session.inspectPlugin({
+            pluginId: options.pluginId,
+            scope: options.scope ?? 'both',
+        });
+        return {
+            observation: inspected.observation,
+            observations: inspected.observations,
+            activations: inspected.activations,
+        };
+    }
+    finally {
+        await ownedSession?.dispose();
+    }
 }
 /**
- * Read-only filesystem projection for the payload-aware shared-native classifier.
- * It does not invoke Codex or create native/config state.
+ * Read-only shared-native inspection. Official Codex list evidence owns installation
+ * state. Filesystem validation is limited to the AW-owned marketplace source.
  */
 export async function inspectCodexSharedNativeLive(options) {
     const inspectionMode = options.inspectionMode ?? 'payload';
@@ -1992,151 +2087,28 @@ export async function inspectCodexSharedNativeLive(options) {
     }
     const marketplaceName = options.marketplaceName ?? MARKETPLACE_NAME;
     const marketplaceRoot = options.marketplaceRoot ?? path.join(resolveAwHome(options.env), 'marketplaces', options.sourceId);
+    const marketplacePathSafe = await isSafeCodexMarketplaceRoot({
+        awHome: resolveAwHome(options.env),
+        sourceId: options.sourceId,
+        marketplaceRoot,
+    });
     const pluginId = `${options.pluginName}@${marketplaceName}`;
     const config = await readCodexConfigFile(resolveCodexPaths(options.cwd, 'user', options.env).configTomlPath);
-    const cacheRoot = path.join(getCodexHome(options.env), 'plugins', 'cache', marketplaceName, options.pluginName);
-    const installedManifestPath = path.join(getCodexHome(options.env), 'plugins', pluginId, 'manifest.json');
-    const cacheRootStats = await lstatCodexResidueIfPresent(cacheRoot);
-    let unsafeCachePath = Boolean(cacheRootStats
-        && (!cacheRootStats.isDirectory() || cacheRootStats.isSymbolicLink()));
-    const candidates = [];
-    if (cacheRootStats?.isDirectory() && !cacheRootStats.isSymbolicLink()) {
-        for (const entry of await fs.readdir(cacheRoot, { withFileTypes: true })) {
-            const payloadPath = path.join(cacheRoot, entry.name);
-            if (!entry.isDirectory() || entry.isSymbolicLink()) {
-                unsafeCachePath = true;
-                continue;
-            }
-            const manifestPaths = [
-                path.join(payloadPath, 'plugin.json'),
-                path.join(payloadPath, '.codex-plugin', 'plugin.json'),
-            ];
-            const existingManifestPaths = [];
-            for (const manifestPath of manifestPaths) {
-                const stats = await lstatCodexResidueIfPresent(manifestPath);
-                if (stats)
-                    existingManifestPaths.push(manifestPath);
-            }
-            if (existingManifestPaths.length !== 1) {
-                candidates.push({
-                    version: entry.name,
-                    manifest: existingManifestPaths.length === 0 ? { state: 'absent' } : { state: 'unreadable' },
-                    payloadPath,
-                    projectionReceipt: { state: 'absent' },
-                });
-                continue;
-            }
-            const manifestPath = existingManifestPaths[0];
-            const manifestStats = await lstatCodexResidueIfPresent(manifestPath);
-            if (!manifestStats?.isFile() || manifestStats.isSymbolicLink()) {
-                candidates.push({
-                    version: entry.name,
-                    manifest: { state: 'unreadable' },
-                    payloadPath,
-                    projectionReceipt: { state: 'absent' },
-                });
-                continue;
-            }
-            let manifest;
-            try {
-                const value = await fs.readJson(manifestPath);
-                if (!value || typeof value !== 'object' || Array.isArray(value))
-                    throw new Error('invalid manifest');
-                manifest = value;
-            }
-            catch {
-                candidates.push({
-                    version: entry.name,
-                    manifest: { state: 'unreadable' },
-                    payloadPath,
-                    projectionReceipt: { state: 'absent' },
-                });
-                continue;
-            }
-            const projectionReceipt = await readCodexNativeRenderReceiptEvidence(payloadPath);
-            const pathSafe = inspectionMode === 'shallow'
-                ? true
-                : await codexPayloadPathSafe(payloadPath);
-            let payloadDigest;
-            if (pathSafe && inspectionMode === 'payload') {
-                try {
-                    payloadDigest = dynamicProjectionExpected || projectionReceipt.state !== 'absent'
-                        ? await calculateCodexNativeRenderPayloadDigest(payloadPath)
-                        : await calculateCodexSharedNativePayloadDigest(payloadPath);
-                }
-                catch {
-                    candidates.push({
-                        version: entry.name,
-                        manifest: { state: 'unreadable' },
-                        payloadPath,
-                        projectionReceipt,
-                    });
-                    continue;
-                }
-            }
-            candidates.push({
-                version: typeof manifest.version === 'string' ? manifest.version : entry.name,
-                payloadPath,
-                projectionReceipt,
-                manifest: {
-                    state: 'present',
-                    identity: typeof manifest.id === 'string'
-                        ? manifest.id
-                        : typeof manifest.name === 'string' ? manifest.name : '',
-                    version: typeof manifest.version === 'string' ? manifest.version : '',
-                    payloadDigest,
-                    payloadPath,
-                    pathSafe,
-                },
-            });
-        }
-    }
-    let installedVersion;
-    const installedStats = await lstatCodexResidueIfPresent(installedManifestPath);
-    if (installedStats?.isFile() && !installedStats.isSymbolicLink()) {
-        try {
-            const installed = await fs.readJson(installedManifestPath);
-            if (typeof installed.version === 'string')
-                installedVersion = installed.version;
-        }
-        catch {
-            installedVersion = undefined;
-        }
-    }
-    const selected = candidates.find((candidate) => candidate.version === installedVersion)
-        ?? candidates.find((candidate) => candidate.version === options.desiredVersion)
-        ?? (candidates.length === 1 ? candidates[0] : undefined);
     const pluginList = options.pluginRegistration ?? await inspectCodexPluginRegistrationLive({
         pluginId,
         cwd: options.cwd,
         env: options.env,
         nativeCliRunner: options.nativeCliRunner,
         manager: options.manager,
+        scope: options.observationScope,
+        observationSession: options.observationSession,
     });
-    const manifest = unsafeCachePath
-        ? {
-            state: 'present',
-            identity: pluginId,
-            version: options.desiredVersion,
-            ...(options.expectedPayloadDigest ? { payloadDigest: options.expectedPayloadDigest } : {}),
-            payloadPath: cacheRoot,
-            pathSafe: false,
-        }
-        : selected?.manifest ?? { state: 'absent' };
-    const projectionReceipt = selected?.projectionReceipt;
-    let expectedProjection;
     let expectedPayloadDigest = dynamicProjectionExpected ? undefined : options.expectedPayloadDigest;
-    const expectedLogicalPluginId = options.nativeRenderPlugin?.pluginId
-        ?? (options.nativeRenderPlugin?.sourceId
-            ? `${options.nativeRenderPlugin.sourceId}/${options.nativeRenderPlugin.manifest.name}`
-            : undefined);
-    const expectedProjectionIdentity = dynamicProjectionExpected && expectedLogicalPluginId
-        ? {
-            logicalPluginId: expectedLogicalPluginId,
-            strategy: 'shared-user',
-        }
-        : undefined;
-    if (dynamicProjectionExpected && options.nativeRenderPlugin) {
+    let sourceProjection;
+    let expectedMarketplaceForeign = false;
+    const installed = pluginList.observation.state === 'observed'
+        && pluginList.observation.value === 'installed';
+    if (installed && dynamicProjectionExpected && options.nativeRenderPlugin) {
         try {
             const expected = await resolveCodexNativeRenderExpectedEvidence({
                 plugin: options.nativeRenderPlugin,
@@ -2144,181 +2116,36 @@ export async function inspectCodexSharedNativeLive(options) {
                 marketplaceName,
                 env: options.env,
             });
-            expectedProjection = expected.projection;
-            expectedPayloadDigest = expected.payloadDigest;
+            if (expected.state === 'foreign') {
+                expectedMarketplaceForeign = true;
+            }
+            else {
+                expectedPayloadDigest = expected.payloadDigest;
+                sourceProjection = expected.sourceProjection;
+            }
         }
         catch {
-            // Canonical marketplace evidence is weak state. Missing evidence is replaceable damage.
+            sourceProjection = 'drifted';
         }
     }
-    const sharedNative = inspectCodexSharedNative({
-        pluginName: options.pluginName,
-        pluginId,
-        marketplaceName,
-        canonicalMarketplaceRoot: marketplaceRoot,
-        desiredVersion: options.desiredVersion,
-        expectedPayloadDigest,
-        marketplaceRegistration: config.snapshot.marketplaces[marketplaceName],
-        marketplacePathSafe: await isSafeCodexMarketplaceRoot({
-            awHome: resolveAwHome(options.env),
-            sourceId: options.sourceId,
-            marketplaceRoot,
-        }),
-        observation: pluginList.observation,
-        manifest,
-        ...(dynamicProjectionExpected ? { expectedProjectionRequired: true } : {}),
-        ...(expectedProjectionIdentity ? { expectedProjectionIdentity } : {}),
-        ...(expectedProjection ? { expectedProjection } : {}),
-        ...(projectionReceipt ? { projectionReceipt } : {}),
-    });
+    const sharedNative = expectedMarketplaceForeign
+        ? { state: 'blocked', reason: 'foreign', diagnostic: 'marketplaceRegistrationForeign' }
+        : inspectCodexSharedNative({
+            pluginName: options.pluginName,
+            pluginId,
+            marketplaceName,
+            canonicalMarketplaceRoot: marketplaceRoot,
+            desiredVersion: options.desiredVersion,
+            expectedPayloadDigest,
+            marketplaceRegistration: config.snapshot.marketplaces[marketplaceName],
+            marketplacePathSafe,
+            observation: pluginList.observation,
+            ...(sourceProjection ? { sourceProjection } : {}),
+        });
     return {
         sharedNative,
         ...(expectedPayloadDigest ? { expectedPayloadDigest } : {}),
-        ...(expectedProjection ? { expectedProjection } : {}),
-        activationObservations: pluginList.observations,
-        activations: pluginList.activations,
-        ...((sharedNative.state === 'missing' || sharedNative.state === 'unobserved')
-            && sharedNative.staleCacheObserved
-            ? { staleCacheObserved: true }
-            : {}),
-        ...(manifest.state === 'present' ? {
-            ...(manifest.payloadDigest ? { actualPayloadDigest: manifest.payloadDigest } : {}),
-            payloadPath: manifest.payloadPath,
-        } : {}),
-    };
-}
-export async function codexNativeRemovalRequired(options) {
-    const residue = await inspectCodexNativeResidue(options);
-    if (residue.state === 'present')
-        return true;
-    if (residue.state === 'foreign')
-        return false;
-    const marketplaceName = options.marketplaceName ?? MARKETPLACE_NAME;
-    const marketplaceRoot = options.marketplaceRoot ?? resolveAwHome(options.env);
-    const config = await readCodexConfigFile(resolveCodexPaths(options.cwd, 'user', options.env).configTomlPath);
-    const marketplace = config.snapshot.marketplaces[marketplaceName];
-    const canonical = marketplace?.sourceType === 'local'
-        && !marketplace.sourcePointsToManifest
-        && path.normalize(marketplace.source ?? '') === path.normalize(marketplaceRoot);
-    if (!canonical)
-        return false;
-    return (await discoverCodexNativeResidueNames(options)).length === 0;
-}
-export async function discoverCodexNativeResidueNames(options) {
-    const marketplaceName = options.marketplaceName ?? MARKETPLACE_NAME;
-    const marketplaceRoot = options.marketplaceRoot ?? resolveAwHome(options.env);
-    const names = new Set();
-    const config = await readCodexConfigFile(resolveCodexPaths(options.cwd, 'user', options.env).configTomlPath);
-    const marketplace = config.snapshot.marketplaces[marketplaceName];
-    const canonicalMarketplace = marketplace?.sourceType === 'local'
-        && !marketplace.sourcePointsToManifest
-        && path.normalize(marketplace.source ?? '') === path.normalize(marketplaceRoot);
-    const probeFailure = (location, cause, pluginName) => {
-        if (cause instanceof CodexNativeResidueProbeError)
-            throw cause;
-        throw new CodexNativeResidueProbeError(location, cause, pluginName);
     };
-    for (const pluginId of canonicalMarketplace ? Object.keys(config.snapshot.plugins) : []) {
-        const suffix = `@${marketplaceName}`;
-        const match = pluginId.endsWith(suffix)
-            ? /^([a-z0-9]+(?:-[a-z0-9]+)*)$/u.exec(pluginId.slice(0, -suffix.length))
-            : null;
-        if (match)
-            names.add(match[1]);
-    }
-    const cacheRoot = path.join(getCodexHome(options.env), 'plugins', 'cache', marketplaceName);
-    const cacheEntries = await readdirCodexResidueIfPresent(cacheRoot).catch((error) => probeFailure(cacheRoot, error));
-    for (const entry of cacheEntries) {
-        if (entry.isFile())
-            continue;
-        const entryPath = path.join(cacheRoot, entry.name);
-        const pluginName = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(entry.name)
-            ? entry.name
-            : probeFailure(entryPath, new Error('Codex cache residue has an invalid plugin identity.'));
-        if (!entry.isDirectory() || entry.isSymbolicLink()) {
-            probeFailure(entryPath, new Error('Codex cache residue is not a canonical plugin directory.'), pluginName);
-        }
-        let versionEntries;
-        try {
-            versionEntries = await fs.readdir(entryPath, { withFileTypes: true });
-        }
-        catch (error) {
-            throw new CodexNativeResidueProbeError(entryPath, error, pluginName);
-        }
-        if (versionEntries.length === 0) {
-            if (names.has(pluginName)) {
-                probeFailure(entryPath, new Error('Codex cache residue manifest is missing.'), pluginName);
-            }
-            continue;
-        }
-        let residue;
-        try {
-            residue = await inspectCodexNativeResidue({ ...options, pluginName: entry.name });
-        }
-        catch (error) {
-            throw new CodexNativeResidueProbeError(entryPath, error, pluginName);
-        }
-        if (residue.state !== 'present') {
-            probeFailure(entryPath, new Error('Codex cache residue has foreign or incomplete manifest evidence.'), pluginName);
-        }
-        names.add(pluginName);
-    }
-    const pluginsRoot = path.join(getCodexHome(options.env), 'plugins');
-    const pluginEntries = await readdirCodexResidueIfPresent(pluginsRoot).catch((error) => probeFailure(pluginsRoot, error));
-    for (const entry of pluginEntries) {
-        const suffix = `@${marketplaceName}`;
-        const match = entry.name.endsWith(suffix)
-            ? /^([a-z0-9]+(?:-[a-z0-9]+)*)$/u.exec(entry.name.slice(0, -suffix.length))
-            : null;
-        if (!match)
-            continue;
-        const installedRoot = path.join(pluginsRoot, entry.name);
-        if (!entry.isDirectory() || entry.isSymbolicLink()) {
-            probeFailure(installedRoot, new Error('Codex installed residue is not a canonical plugin directory.'), match[1]);
-        }
-        const installedStats = await lstatCodexResidueIfPresent(installedRoot);
-        if (!installedStats || !installedStats.isDirectory() || installedStats.isSymbolicLink()) {
-            probeFailure(installedRoot, new Error('Codex installed residue is not a canonical plugin directory.'), match[1]);
-        }
-        const manifestPath = path.join(pluginsRoot, entry.name, 'manifest.json');
-        const stats = await lstatCodexResidueIfPresent(manifestPath);
-        if (!stats?.isFile() || stats.isSymbolicLink()) {
-            probeFailure(manifestPath, new Error('Codex installed residue manifest is missing or nonregular.'), match[1]);
-        }
-        let rawManifest;
-        try {
-            rawManifest = await fs.readJson(manifestPath);
-        }
-        catch (error) {
-            throw new CodexNativeResidueProbeError(manifestPath, error, match[1]);
-        }
-        if (!rawManifest || typeof rawManifest !== 'object' || Array.isArray(rawManifest)) {
-            probeFailure(manifestPath, new Error('Codex installed residue manifest must be an object.'), match[1]);
-        }
-        const manifest = rawManifest;
-        const identity = manifest.id ?? manifest.name;
-        if (!canonicalMarketplace
-            || (identity !== match[1] && identity !== entry.name)
-            || typeof manifest.version !== 'string'
-            || manifest.version.trim() === '') {
-            probeFailure(manifestPath, new Error('Codex installed residue manifest has foreign identity or version.'), match[1]);
-        }
-        names.add(match[1]);
-    }
-    return [...names];
-}
-export class CodexNativeResidueProbeError extends Error {
-    code = 'codexNativeResidueProbeFailed';
-    location;
-    pluginName;
-    constructor(location, cause, pluginName) {
-        super(`codexNativeResidueProbeFailed: cannot classify Codex native residue at ${location}.`, {
-            cause,
-        });
-        this.name = 'CodexNativeResidueProbeError';
-        this.location = location;
-        this.pluginName = pluginName;
-    }
 }
 async function ensureCodexActiveSkillsManifest(options) {
     const relativeSkillsRoot = await resolveCodexSkillsRelativeRoot(options.plugin);
@@ -2358,124 +2185,6 @@ function createCodexMarketplaceComponent(options) {
         },
     };
 }
-async function assertCodexNativeInstallState(options) {
-    const marketplaceName = options.marketplaceName ?? MARKETPLACE_NAME;
-    const pluginId = `${options.pluginName}@${marketplaceName}`;
-    const configPath = resolveCodexPaths(options.cwd, 'user', options.env).configTomlPath;
-    const config = await readCodexConfigFile(configPath);
-    const marketplace = config.snapshot.marketplaces[marketplaceName];
-    if (marketplace?.sourceType !== 'local'
-        || marketplace.sourcePointsToManifest
-        || path.normalize(marketplace.source ?? '') !== path.normalize(options.marketplaceRoot)) {
-        throw new Error(`Codex marketplace aw 未指向当前 AW_HOME：${options.marketplaceRoot}`);
-    }
-    if (config.snapshot.plugins[pluginId]?.enabled !== true) {
-        throw new Error(`Codex enabled config 缺少 ${pluginId}。`);
-    }
-    const cacheRoot = path.join(getCodexHome(options.env), 'plugins', 'cache', marketplaceName, options.pluginName, options.pluginVersion);
-    const candidates = [
-        path.join(cacheRoot, 'plugin.json'),
-        path.join(cacheRoot, '.codex-plugin', 'plugin.json'),
-    ];
-    const expectedRoot = path.join(options.marketplaceRoot, 'plugins', options.pluginName);
-    const assertExpectedPayload = async () => {
-        const collectFiles = async (root) => {
-            const output = [];
-            const pending = [''];
-            while (pending.length > 0) {
-                const relativeRoot = pending.pop();
-                for (const entry of await fs.readdir(path.join(root, relativeRoot), { withFileTypes: true })) {
-                    const relativePath = path.join(relativeRoot, entry.name);
-                    if (entry.isSymbolicLink()) {
-                        throw new Error(`Codex native payload 不能包含符号链接：${path.join(root, relativePath)}`);
-                    }
-                    if (entry.isDirectory())
-                        pending.push(relativePath);
-                    else if (entry.isFile())
-                        output.push(relativePath);
-                    else
-                        throw new Error(`Codex native payload 包含不支持的节点：${path.join(root, relativePath)}`);
-                }
-            }
-            return output;
-        };
-        const manifestPaths = new Set(['plugin.json', path.join('.codex-plugin', 'plugin.json')]);
-        const allowedMetadata = new Set(['metadata.json', '.metadata.json']);
-        const [expectedFiles, actualFiles] = await Promise.all([
-            collectFiles(expectedRoot),
-            collectFiles(cacheRoot),
-        ]);
-        const expectedSet = new Set(expectedFiles);
-        for (const relativePath of expectedFiles) {
-            if (manifestPaths.has(relativePath))
-                continue;
-            const expectedPath = path.join(expectedRoot, relativePath);
-            const actualPath = path.join(cacheRoot, relativePath);
-            const actualStats = await fs.lstat(actualPath).catch(() => null);
-            if (!actualStats?.isFile() || actualStats.isSymbolicLink()) {
-                throw new Error(`Codex native cache 缺少 expected payload：${actualPath}`);
-            }
-            const [expectedContent, actualContent] = await Promise.all([
-                fs.readFile(expectedPath),
-                fs.readFile(actualPath),
-            ]);
-            if (!expectedContent.equals(actualContent)) {
-                throw new Error(`Codex native cache expected payload digest 不匹配：${actualPath}`);
-            }
-        }
-        for (const relativePath of actualFiles) {
-            if (expectedSet.has(relativePath)
-                || manifestPaths.has(relativePath)
-                || allowedMetadata.has(relativePath))
-                continue;
-            throw new Error(`Codex native cache 包含 unexpected loadable payload：${path.join(cacheRoot, relativePath)}`);
-        }
-    };
-    let matchedManifest = false;
-    for (const candidate of candidates) {
-        if (!await fs.pathExists(candidate))
-            continue;
-        const manifest = await fs.readJson(candidate).catch(() => null);
-        if (!manifest) {
-            throw new Error(`Codex native cache manifest 无法解析：${candidate}`);
-        }
-        const identity = manifest.id ?? manifest.name;
-        const matches = ((identity === options.pluginName || identity === pluginId)
-            && manifest.version === options.pluginVersion
-            && (options.skillsRelativeRoot === null
-                ? typeof manifest.skills !== 'string'
-                : typeof manifest.skills === 'string'
-                    && path.posix.normalize(manifest.skills.replace(/^\.\//u, '')) === options.skillsRelativeRoot));
-        if (!matches) {
-            throw new Error(`Codex native cache manifest 不匹配：${candidate}`);
-        }
-        matchedManifest = true;
-    }
-    if (!matchedManifest) {
-        throw new Error(`Codex native cache 缺少匹配 ${pluginId}@${options.pluginVersion} 的 manifest：${cacheRoot}`);
-    }
-    for (const skillKey of options.requiredSkillKeys) {
-        const skillPath = path.join(cacheRoot, ...options.skillsRelativeRoot.split('/'), skillKey, 'SKILL.md');
-        if (!await fs.pathExists(skillPath)) {
-            throw new Error(`Codex native cache 缺少 required Skill：${skillPath}`);
-        }
-    }
-    await assertExpectedPayload();
-    if (options.nativeRender) {
-        const actualPayloadDigest = await calculateCodexNativeRenderPayloadDigest(cacheRoot);
-        if (actualPayloadDigest !== options.nativeRender.payloadDigest) {
-            throw new Error(`Codex native cache render payload digest 不匹配：${cacheRoot}`);
-        }
-        const receiptEvidence = await readCodexNativeRenderReceiptEvidence(cacheRoot);
-        if (receiptEvidence.state !== 'present'
-            || receiptEvidence.receipt.payloadDigest !== options.nativeRender.payloadDigest
-            || !codexNativeRenderProjectionsEqual(receiptEvidence.receipt, options.nativeRender.projection)
-            || receiptEvidence.receipt.targets.map((target) => target.skillKey).sort().join('\0')
-                !== options.nativeRender.targetSkillKeys.join('\0')) {
-            throw new Error(`Codex native cache render receipt 不匹配：${cacheRoot}`);
-        }
-    }
-}
 async function readJsonObjectIfExists(filePath, label) {
     let value;
     try {
@@ -2793,7 +2502,111 @@ function createClaudeMarketplaceComponent(options) {
         },
     };
 }
-async function materializeCodexNativeRender(options) {
+const codexNativeRenderPreparationCaches = new WeakMap();
+function codexNativeRenderPreparationCache(context) {
+    let cache = codexNativeRenderPreparationCaches.get(context);
+    if (!cache) {
+        cache = new WeakMap();
+        codexNativeRenderPreparationCaches.set(context, cache);
+    }
+    return cache;
+}
+function pluginHasCodexNativeSkillSurface(plugin) {
+    return plugin.manifest.skills !== undefined
+        || codexNativeRenderTargets(plugin).length > 0;
+}
+async function resolveSensitiveUserConfigValues(plugin, env) {
+    const hasSensitiveFields = Object.values(plugin.manifest.config?.fields ?? {}).some((field) => field.sensitive === true
+        || (field.type === 'object'
+            && (Object.values(field.properties ?? {}).some((child) => child.sensitive === true)
+                || (field.additionalProperties !== false
+                    && field.additionalProperties?.sensitive === true))));
+    if (!hasSensitiveFields)
+        return [];
+    const config = await resolveArtifactRenderConfig({
+        sourceId: plugin.sourceId,
+        sourceIdentity: plugin.sourceIdentity,
+        pluginName: plugin.manifest.name,
+        manifest: plugin.manifest,
+        scope: 'user',
+        cwd: plugin.rootDir,
+        env,
+    });
+    return collectSensitivePluginConfigValues(plugin.manifest, config.values);
+}
+async function assertNoSensitiveValuesInCodexNativePayload(options) {
+    if (options.sensitiveValues.length === 0)
+        return;
+    if (!await codexPayloadPathSafe(options.payloadRoot, options.allowedRoot)) {
+        throw new Error('Codex native sensitive scan payload path is unsafe.');
+    }
+    const codexManifestPath = path.join(options.payloadRoot, '.codex-plugin', 'plugin.json');
+    const codexManifestStats = await lstatCodexResidueIfPresent(codexManifestPath);
+    if (!codexManifestStats?.isFile()) {
+        throw new Error('Codex native sensitive scan manifest is missing or unsafe.');
+    }
+    const codexManifest = await fs.readJson(codexManifestPath).catch(() => null);
+    if (!codexManifest
+        || codexManifest.name !== options.plugin.manifest.name
+        || codexManifest.version !== options.plugin.manifest.version) {
+        throw new Error('Codex native sensitive scan manifest identity is invalid.');
+    }
+    const rawSkillsRoot = codexManifest.skills;
+    if (rawSkillsRoot !== undefined) {
+        if (typeof rawSkillsRoot !== 'string' || rawSkillsRoot.trim() === '') {
+            throw new Error('Codex native sensitive scan Skills root is invalid.');
+        }
+        const { root: skillsRoot } = await resolveCodexSkillsRoot(options.payloadRoot, rawSkillsRoot);
+        const skillsRootStats = await lstatCodexResidueIfPresent(skillsRoot);
+        if (!skillsRootStats?.isDirectory()) {
+            throw new Error('Codex native sensitive scan Skills root is missing or unsafe.');
+        }
+        for (const entry of await fs.readdir(skillsRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const skillRoot = path.join(skillsRoot, entry.name);
+            const skillFileStats = await lstatCodexResidueIfPresent(path.join(skillRoot, 'SKILL.md'));
+            if (!skillFileStats)
+                continue;
+            if (!skillFileStats.isFile()) {
+                throw new Error('Codex native sensitive scan Skill entry is unsafe.');
+            }
+            const tree = await readDynamicSkillTree(skillRoot, 'codex.skill');
+            if (!tree)
+                continue;
+            const leakedPath = findSensitiveTokenPath(withoutVerifiedRequirementsReceipt(options.plugin, tree.files), options.sensitiveValues);
+            if (leakedPath) {
+                throw new Error(`codexNativeRenderSensitiveValue: Codex native Skill "${entry.name}" exposes ` +
+                    `sensitive config in "${leakedPath}".`);
+            }
+        }
+    }
+    const receiptPath = path.join(options.payloadRoot, CODEX_NATIVE_RENDER_RECEIPT_PATH);
+    const receiptStats = await lstatCodexResidueIfPresent(receiptPath);
+    if (receiptStats) {
+        if (!receiptStats.isFile()) {
+            throw new Error('Codex native sensitive scan render receipt path is unsafe.');
+        }
+        const receiptContent = await fs.readFile(receiptPath);
+        let actualReceipt;
+        try {
+            actualReceipt = parseCodexNativeRenderReceipt(receiptContent.toString('utf8'));
+        }
+        catch {
+            actualReceipt = undefined;
+        }
+        const verified = options.verifiedRenderReceipt
+            && JSON.stringify(actualReceipt) === JSON.stringify(options.verifiedRenderReceipt);
+        if (!verified) {
+            const receiptLeak = findSensitiveTokenPath({ [CODEX_NATIVE_RENDER_RECEIPT_PATH]: receiptContent }, options.sensitiveValues);
+            if (receiptLeak) {
+                throw new Error(`codexNativeRenderSensitiveValue: Codex native render receipt exposes sensitive config in ` +
+                    `"${receiptLeak}".`);
+            }
+        }
+    }
+}
+async function prepareCodexNativeRender(options) {
     const targets = codexNativeRenderTargets(options.plugin);
     if (targets.length === 0)
         return null;
@@ -2805,6 +2618,8 @@ async function materializeCodexNativeRender(options) {
         byScope.set(requestScope, group);
     }
     const renderedArtifacts = [];
+    const receiptTargets = [];
+    const presentSkillKeys = [];
     let rendererDigest;
     for (const scope of ['user', 'project']) {
         const group = byScope.get(scope);
@@ -2834,9 +2649,31 @@ async function materializeCodexNativeRender(options) {
             manifestDigest: rendered.target.manifestDigest,
         });
         for (const artifact of validated.artifacts) {
+            if (artifact.target !== 'codex.skill') {
+                throw new Error(`Codex native renderer returned non-Skill artifact "${artifact.id}".`);
+            }
+            const sourceDirs = rendered.context.artifactSources.find((entry) => entry.id === artifact.id && entry.target === artifact.target)?.sourceDirs ?? [];
+            const tree = await createCodexSkillExpectedTree({
+                artifact,
+                sourceDirs,
+                requireReadme: true,
+                requirementsReceipt: requirementsReceipt(options.plugin),
+                sourceRequirementsReceiptPolicy: 'allow',
+            });
+            assertNoSensitiveConfigInFiles(withoutVerifiedRequirementsReceipt(options.plugin, tree.files), collectSensitivePluginConfigValues(options.plugin.manifest, rendered.context.config.values), 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
+            const skillKey = artifact.skillKey;
             renderedArtifacts.push({
                 artifact,
-                sourceDirs: rendered.context.artifactSources.find((entry) => entry.id === artifact.id && entry.target === artifact.target)?.sourceDirs ?? [],
+                skillKey,
+                tree,
+            });
+            if (artifact.state === 'present')
+                presentSkillKeys.push(skillKey);
+            receiptTargets.push({
+                id: artifact.id,
+                skillKey,
+                configDigest: artifact.configDigest,
+                artifactDigest: createCodexSkillStagingTreeContentDigest(tree),
             });
         }
     }
@@ -2844,72 +2681,88 @@ async function materializeCodexNativeRender(options) {
         throw new Error('Codex native renderer did not produce the complete declared target set.');
     }
     const skillsRelativeRoot = await resolveCodexSkillsRelativeRoot(options.plugin);
-    const skillsRoot = path.join(options.stagingRoot, 'plugins', options.plugin.manifest.name, ...skillsRelativeRoot.split('/'));
-    const receiptTargets = [];
-    const presentSkillKeys = [];
-    for (const { artifact, sourceDirs } of renderedArtifacts) {
-        if (artifact.target !== 'codex.skill') {
-            throw new Error(`Codex native renderer returned non-Skill artifact "${artifact.id}".`);
-        }
-        const skillKey = artifact.skillKey;
-        const tree = await createCodexSkillExpectedTree({
-            artifact,
-            sourceDirs,
-            requireReadme: true,
-            requirementsReceipt: requirementsReceipt(options.plugin),
-            sourceRequirementsReceiptPolicy: 'allow',
+    const logicalPluginId = options.plugin.pluginId
+        ?? (options.plugin.sourceId ? `${options.plugin.sourceId}/${options.plugin.manifest.name}` : undefined);
+    if (!logicalPluginId || !options.plugin.sourceIdentity) {
+        throw new Error('Codex native render materialization requires namespaced source identity.');
+    }
+    const projection = createCodexNativeRenderProjection({
+        logicalPluginId,
+        sourceIdentity: options.plugin.sourceIdentity,
+        pluginVersion: options.plugin.manifest.version,
+        rendererDigest,
+        targets: receiptTargets,
+    });
+    return {
+        logicalPluginId,
+        sourceIdentity: options.plugin.sourceIdentity,
+        rendererDigest,
+        skillsRelativeRoot,
+        renderedArtifacts,
+        receiptTargets,
+        projection,
+        presentSkillKeys: presentSkillKeys.sort(),
+        targetSkillKeys: targets.map((target) => target.skillKey).sort(),
+    };
+}
+function prepareCodexNativeRenderCached(options) {
+    const cache = codexNativeRenderPreparationCache(options.context);
+    let preparation = cache.get(options.plugin);
+    if (!preparation) {
+        preparation = prepareCodexNativeRender({
+            plugin: options.plugin,
+            env: options.context.env,
+            scriptTimeoutMs: options.scriptTimeoutMs,
         });
+        cache.set(options.plugin, preparation);
+    }
+    return preparation;
+}
+async function requirePreparedCodexNativeRender(options) {
+    if (codexNativeRenderTargets(options.plugin).length === 0)
+        return null;
+    const preparation = codexNativeRenderPreparationCache(options.context).get(options.plugin);
+    if (!preparation) {
+        throw new Error('codexNativeRenderPreflightMissing: Codex native renderer was not prepared.');
+    }
+    return preparation;
+}
+async function materializeCodexNativeRender(options) {
+    const skillsRoot = path.join(options.stagingRoot, 'plugins', options.plugin.manifest.name, ...options.prepared.skillsRelativeRoot.split('/'));
+    for (const { artifact, skillKey, tree } of options.prepared.renderedArtifacts) {
         const skillRoot = path.join(skillsRoot, skillKey);
         if (artifact.state === 'present') {
             await writeDynamicSkillTree(skillRoot, tree);
-            presentSkillKeys.push(skillKey);
         }
         else {
             await fs.remove(skillRoot);
         }
-        receiptTargets.push({
-            id: artifact.id,
-            skillKey,
-            configDigest: artifact.configDigest,
-            artifactDigest: createCodexSkillStagingTreeContentDigest(tree),
-        });
     }
     await ensureCodexActiveSkillsManifest({
         plugin: options.plugin,
         marketplaceRoot: options.stagingRoot,
-        hasRequiredSkills: options.hasStaticSkills || presentSkillKeys.length > 0,
-    });
-    const logicalPluginId = options.plugin.pluginId
-        ?? (options.plugin.sourceId ? `${options.plugin.sourceId}/${options.plugin.manifest.name}` : undefined);
-    if (!logicalPluginId || !options.plugin.sourceIdentity) {
-        throw new Error('Codex native render materialization requires namespaced source identity.');
-    }
-    const projection = createCodexNativeRenderProjection({
-        logicalPluginId,
-        sourceIdentity: options.plugin.sourceIdentity,
-        pluginVersion: options.plugin.manifest.version,
-        rendererDigest,
-        targets: receiptTargets,
+        hasRequiredSkills: options.hasStaticSkills || options.prepared.presentSkillKeys.length > 0,
     });
     const pluginRoot = path.join(options.stagingRoot, 'plugins', options.plugin.manifest.name);
     const payloadDigest = await calculateCodexNativeRenderPayloadDigest(pluginRoot);
     const receipt = createCodexNativeRenderReceipt({
-        logicalPluginId,
-        sourceIdentity: options.plugin.sourceIdentity,
+        logicalPluginId: options.prepared.logicalPluginId,
+        sourceIdentity: options.prepared.sourceIdentity,
         pluginVersion: options.plugin.manifest.version,
-        rendererDigest,
-        targets: receiptTargets,
+        rendererDigest: options.prepared.rendererDigest,
+        targets: options.prepared.receiptTargets,
         payloadDigest,
     });
     await fs.outputFile(path.join(pluginRoot, CODEX_NATIVE_RENDER_RECEIPT_PATH), serializeCodexNativeRenderReceipt(receipt), 'utf8');
     return {
         payloadDigest,
-        projection,
-        presentSkillKeys: presentSkillKeys.sort(),
-        targetSkillKeys: targets.map((target) => target.skillKey).sort(),
+        projection: options.prepared.projection,
+        receipt,
+        presentSkillKeys: options.prepared.presentSkillKeys,
+        targetSkillKeys: options.prepared.targetSkillKeys,
     };
 }
-async function mirrorCatalog(catalog, env, target, prepareStaging) {
+async function mirrorCatalog(catalog, env, target, logicalIdentity, prepareStaging) {
     if (!target?.sourceId || !target.marketplaceRoot) {
         const rootDir = resolveAwHome(env);
         await fs.ensureDir(rootDir);
@@ -2957,6 +2810,7 @@ async function mirrorCatalog(catalog, env, target, prepareStaging) {
             schemaVersion: 2,
             sourceId: target.sourceId,
             sourceIdentity: target.sourceIdentity,
+            logicalIdentity,
             marketplaceName,
         }, { spaces: 2 });
         const destinationExists = await fs.lstat(destination).then(() => true, (error) => {
@@ -3146,8 +3000,53 @@ async function applyPlannedOperationAction(action) {
 function createNativeDriver(options) {
     const runner = options.context.nativeCliRunner;
     const currentCodexManager = () => options.context.codexManager;
-    const mirrorTransactions = new WeakMap();
+    const nativeGroupPreparations = new Map();
+    const nativeTargetPreparations = new WeakMap();
+    const codexNativeStates = new Map();
+    const pendingCodexNativeStates = new Map();
+    const codexMutationMarketplaces = new Set();
     const completedNativeSkillWrites = new WeakSet();
+    const committedNativeGroups = new Set();
+    let nativeMarketplaceEligibleTargets;
+    let deferredPostchecks = [];
+    const nativeGroupKey = (target) => [
+        target.identity.sourceId ?? '',
+        target.identity.sourceIdentity ?? '',
+        target.identity.marketplaceName ?? MARKETPLACE_NAME,
+        path.normalize(path.resolve(target.identity.marketplaceRoot ?? resolveAwHome(options.context.env))),
+        target.identity.platform,
+    ].join('\0');
+    const observationScopeFor = (target) => codexObservationScope(options.context, target.identity.marketplaceName ?? MARKETPLACE_NAME, target.identity.scope);
+    const groupTargets = (target) => {
+        if (!options.operationScopedNativePhases)
+            return [target];
+        const key = nativeGroupKey(target);
+        return options.targets.filter((candidate) => nativeGroupKey(candidate) === key
+            && (nativeMarketplaceEligibleTargets?.has(candidate) ?? true));
+    };
+    const nativeSkillOverlay = async (target) => {
+        const canonicalMarketplaceRoot = await canonicalizePathThroughExistingAncestor(target.identity.marketplaceRoot ?? resolveAwHome(options.context.env));
+        const nativePluginRoot = await canonicalizePathThroughExistingAncestor(path.join(canonicalMarketplaceRoot, 'plugins', target.identity.pluginName));
+        const desiredSkillPaths = new Set((target.desiredOwnedComponents ?? [])
+            .filter((component) => component.kind === 'skill-directory')
+            .map((component) => path.resolve(component.path)));
+        const enabledSkillPaths = new Set(target.artifacts
+            .filter((artifact) => artifact.kind === 'skill' && artifact.state !== 'disabled')
+            .map((artifact) => path.resolve(artifact.path)));
+        return {
+            marketplaceRoot: canonicalMarketplaceRoot,
+            writes: (target.operationActions ?? []).filter((action) => action.kind === 'writeOwnedArtifact'
+                && action.artifactKind === 'skill-directory'
+                && desiredSkillPaths.has(path.resolve(action.path))
+                && enabledSkillPaths.has(path.resolve(action.path))
+                && target.identity.scope === 'user'
+                && !path.relative(nativePluginRoot, action.path).startsWith('..')),
+        };
+    };
+    const asNativeGroupFailure = (error) => {
+        const result = error instanceof Error ? error : new Error(String(error));
+        return Object.assign(result, { nativeMarketplaceGroupFailure: true });
+    };
     const findTarget = (component) => {
         const target = options.targets.find((entry) => entry.identity.pluginName === component.identity.plugin
             && entry.identity.sourceId === component.identity.sourceId
@@ -3157,13 +3056,144 @@ function createNativeDriver(options) {
             throw new Error('Ownership executor cannot resolve its desired target.');
         return target;
     };
+    const codexStateKey = (target, pluginId) => `${nativeGroupKey(target)}\0${pluginId}`;
+    const runObservedCodexMutation = async (options_) => runCodexMutationWithInvalidation({
+        ...options_,
+        ...(options.operationScopedNativePhases
+            ? {}
+            : { observationSession: options.context.codexObservationSession }),
+    });
+    const prepareNativeGroup = async (target) => {
+        const key = nativeGroupKey(target);
+        let preparation = options.operationScopedNativePhases
+            ? nativeGroupPreparations.get(key)
+            : nativeTargetPreparations.get(target);
+        if (!preparation) {
+            preparation = (async () => {
+                const members = groupTargets(target);
+                const materializing = members.filter((candidate) => candidate.writeNativeRequired ?? candidate.requiresNative);
+                const overlayTargets = members.filter((candidate) => candidate.nativeOverlayDesired ?? candidate.requiresNative);
+                if (target.identity.platform === 'codex') {
+                    const observationScope = codexObservationScope(options.context, target.identity.marketplaceName ?? MARKETPLACE_NAME, members.some((candidate) => candidate.identity.scope === 'project') ? 'project' : 'user');
+                    const nativePluginIds = [...new Set(members.flatMap((candidate) => candidate.ownedComponents.flatMap((component) => component.kind === 'native-plugin' ? [component.pluginId] : [])))].sort();
+                    for (const pluginId of nativePluginIds) {
+                        const member = members.find((candidate) => candidate.ownedComponents.some((component) => component.kind === 'native-plugin' && component.pluginId === pluginId));
+                        const registration = await inspectCodexPluginRegistrationLive({
+                            pluginId,
+                            cwd: member.identity.cwd,
+                            env: options.context.env,
+                            nativeCliRunner: runner,
+                            manager: currentCodexManager(),
+                            scope: observationScope,
+                            observationSession: options.context.codexObservationSession,
+                        });
+                        codexNativeStates.set(codexStateKey(member, pluginId), requireObservedCodexNativeState(registration.observation, 'native group precheck') === 'installed' ? 'present' : 'absent');
+                    }
+                }
+                if (materializing.length === 0)
+                    return;
+                const first = materializing[0];
+                if (!first.catalog)
+                    throw new Error('Missing rebuild target catalog data.');
+                const catalogRoot = path.resolve(first.catalog.rootDir);
+                if (overlayTargets.some((candidate) => !candidate.catalog || path.resolve(candidate.catalog.rootDir) !== catalogRoot)) {
+                    throw new Error('nativeMarketplaceGroupInvalid: grouped targets do not share one Catalog root.');
+                }
+                const materializationTargets = [...overlayTargets].sort((left, right) => [
+                    left.identity.pluginId ?? left.identity.pluginName,
+                    left.identity.scope,
+                    left.identity.cwd,
+                ].join('\0').localeCompare([
+                    right.identity.pluginId ?? right.identity.pluginName,
+                    right.identity.scope,
+                    right.identity.cwd,
+                ].join('\0'), 'en'));
+                const nativeSkillOverlays = new Map(await Promise.all(materializationTargets.map(async (candidate) => [
+                    candidate,
+                    await nativeSkillOverlay(candidate),
+                ])));
+                const transaction = await mirrorCatalog(first.catalog, options.context.env, first.identity, first.plugin.catalogLogicalIdentity, first.identity.platform === 'codex' ? async (stagingRoot) => {
+                    for (const candidate of materializationTargets) {
+                        const overlay = nativeSkillOverlays.get(candidate);
+                        const requiredSkillWrites = overlay.writes;
+                        for (const action of requiredSkillWrites) {
+                            await applyPlannedOperationAction({
+                                ...action,
+                                path: path.join(stagingRoot, path.relative(overlay.marketplaceRoot, action.path)),
+                                allowedRoot: path.join(stagingRoot, path.relative(overlay.marketplaceRoot, action.allowedRoot)),
+                            });
+                        }
+                        const hasStaticSkills = candidate.plugin.manifest.skills !== undefined
+                            || requiredSkillWrites.length > 0;
+                        const preparedNativeRender = await requirePreparedCodexNativeRender({
+                            context: options.context,
+                            plugin: candidate.plugin,
+                        });
+                        const nativeRender = preparedNativeRender
+                            ? await materializeCodexNativeRender({
+                                plugin: candidate.plugin,
+                                stagingRoot,
+                                prepared: preparedNativeRender,
+                                hasStaticSkills,
+                            })
+                            : null;
+                        if (!nativeRender) {
+                            await ensureCodexActiveSkillsManifest({
+                                plugin: candidate.plugin,
+                                marketplaceRoot: stagingRoot,
+                                hasRequiredSkills: hasStaticSkills,
+                            });
+                        }
+                        if (pluginHasCodexNativeSkillSurface(candidate.plugin)) {
+                            await assertNoSensitiveValuesInCodexNativePayload({
+                                plugin: candidate.plugin,
+                                payloadRoot: path.join(stagingRoot, 'plugins', candidate.identity.pluginName),
+                                allowedRoot: stagingRoot,
+                                sensitiveValues: await resolveSensitiveUserConfigValues(candidate.plugin, options.context.env),
+                                ...(nativeRender ? { verifiedRenderReceipt: nativeRender.receipt } : {}),
+                            });
+                        }
+                    }
+                } : undefined);
+                try {
+                    await transaction.commit();
+                }
+                catch (error) {
+                    if (error.durableMaterializeCommit !== true) {
+                        try {
+                            await transaction.rollback();
+                        }
+                        catch (rollbackError) {
+                            throw new AggregateError([error, rollbackError], 'nativeMarketplaceGroupCommitFailed: marketplace commit and rollback failed.');
+                        }
+                    }
+                    throw error;
+                }
+                for (const candidate of materializationTargets) {
+                    for (const action of nativeSkillOverlays.get(candidate)?.writes ?? []) {
+                        completedNativeSkillWrites.add(action);
+                    }
+                }
+                committedNativeGroups.add(key);
+            })().catch((error) => {
+                throw asNativeGroupFailure(error);
+            });
+            if (options.operationScopedNativePhases) {
+                nativeGroupPreparations.set(key, preparation);
+            }
+            else {
+                nativeTargetPreparations.set(target, preparation);
+            }
+        }
+        await preparation;
+    };
     const inspectCodexMarketplace = async (component) => {
         if (component.locator.kind !== 'codex-marketplace')
             throw new Error('Invalid Codex marketplace locator.');
         const target = findTarget(component);
         const configPath = resolveCodexPaths(target.identity.cwd, 'user', options.context.env).configTomlPath;
-        const marketplace = (await readCodexConfigFile(configPath))
-            .snapshot.marketplaces[component.locator.marketplaceName];
+        const config = await readCodexConfigFile(configPath);
+        const marketplace = config.snapshot.marketplaces[component.locator.marketplaceName];
         const canonical = !marketplace
             ? 'absent'
             : marketplace.sourceType === 'local'
@@ -3171,29 +3201,47 @@ function createNativeDriver(options) {
                 && path.normalize(marketplace.source ?? '') === path.normalize(component.locator.marketplaceRoot)
                 ? 'present'
                 : 'foreign';
-        const plugin = await inspectCodexNativeResidue({
-            pluginName: component.identity.plugin,
-            cwd: target.identity.cwd,
-            env: options.context.env,
-            marketplaceName: component.locator.marketplaceName,
-            marketplaceRoot: component.locator.marketplaceRoot,
-        });
-        if (plugin.state === 'foreign')
-            return 'foreign';
         if (component.locator.desired) {
-            return canonical === 'present' && plugin.state === 'present' && plugin.enabled
-                ? 'present'
-                : 'absent';
+            if (canonical !== 'present')
+                return canonical;
+            const pluginId = `${component.identity.plugin}@${component.locator.marketplaceName}`;
+            return config.snapshot.plugins[pluginId]?.enabled === true ? 'present' : 'absent';
         }
         if (canonical !== 'present')
             return canonical;
-        const remaining = await discoverCodexNativeResidueNames({
-            cwd: target.identity.cwd,
-            env: options.context.env,
-            marketplaceName: component.locator.marketplaceName,
-            marketplaceRoot: component.locator.marketplaceRoot,
-        });
-        return remaining.some((name) => name !== component.identity.plugin) ? 'absent' : 'present';
+        const suffix = `@${component.locator.marketplaceName}`;
+        const currentPluginId = `${component.identity.plugin}${suffix}`;
+        const projectConfig = await readCodexConfigFile(resolveCodexPaths(target.identity.cwd, 'project', options.context.env).configTomlPath);
+        const configuredPluginIds = [
+            ...Object.keys(config.snapshot.plugins),
+            ...Object.keys(projectConfig.snapshot.plugins),
+        ].filter((pluginId) => pluginId.endsWith(suffix));
+        if (configuredPluginIds.some((pluginId) => pluginId !== currentPluginId))
+            return 'absent';
+        const ownedSession = options.context.codexObservationSession ? undefined
+            : await createCodexNativeObservationSession({
+                exactCwd: target.identity.cwd,
+                env: options.context.env,
+                runner,
+                manager: currentCodexManager() ?? SYSTEM_CODEX_MANAGER,
+            });
+        const session = options.context.codexObservationSession ?? ownedSession;
+        try {
+            const observationScope = observationScopeFor(target);
+            const snapshot = await session.snapshot(component.locator.marketplaceName, observationScope);
+            if (!snapshot.neutral || (observationScope === 'both' && !snapshot.exact))
+                return 'absent';
+            const officialPluginIds = new Set([
+                ...(snapshot.exact?.keys() ?? []),
+                ...snapshot.neutral.keys(),
+            ]);
+            return [...officialPluginIds].some((pluginId) => pluginId !== currentPluginId)
+                ? 'absent'
+                : 'present';
+        }
+        finally {
+            await ownedSession?.dispose();
+        }
     };
     const inspectClaudeMarketplace = async (component) => {
         if (component.locator.kind !== 'claude-marketplace')
@@ -3335,6 +3383,15 @@ function createNativeDriver(options) {
                     }) ? { removeAgentRegistrations: [locator.roleKey] } : null);
                     return;
                 case 'codex-marketplace': {
+                    if (locator.desired)
+                        return;
+                    const target = findTarget(component);
+                    await prepareNativeGroup(target);
+                    codexMutationMarketplaces.add(locator.marketplaceName);
+                    await runObservedCodexMutation({
+                        marketplaceName: locator.marketplaceName,
+                        mutation: () => runNativeCliChecked(buildCodexMarketplaceRemoveInvocation(currentCodexManager() ?? SYSTEM_CODEX_MANAGER, locator.marketplaceName, target.identity.cwd, options.context.env), runner),
+                    });
                     return;
                 }
                 case 'claude-marketplace': {
@@ -3384,7 +3441,114 @@ function createNativeDriver(options) {
     };
     return {
         ownership,
+        setNativeMarketplaceEligibleTargets: (eligibleTargets) => {
+            nativeMarketplaceEligibleTargets = new Set(eligibleTargets);
+        },
+        prepareNativeMarketplaceGroup: prepareNativeGroup,
+        selectRecoveryCleanupComponents: (target, components) => {
+            if (!committedNativeGroups.has(nativeGroupKey(target)))
+                return components;
+            const marketplaceRoot = path.resolve(target.identity.marketplaceRoot ?? resolveAwHome(options.context.env));
+            return components.filter((component) => {
+                if (!('path' in component))
+                    return true;
+                const relative = path.relative(marketplaceRoot, path.resolve(component.path));
+                return relative === '..'
+                    || relative.startsWith(`..${path.sep}`)
+                    || path.isAbsolute(relative);
+            });
+        },
+        ...(options.operationScopedNativePhases ? {
+            deferPostcheck: (target, postcheck) => {
+                if (target.identity.platform !== 'codex')
+                    return false;
+                deferredPostchecks.push({
+                    target,
+                    postcheck: async () => {
+                        if (target.requiresNative) {
+                            const marketplaceName = target.identity.marketplaceName ?? MARKETPLACE_NAME;
+                            const pluginId = `${target.identity.pluginName}@${marketplaceName}`;
+                            const registration = await inspectCodexPluginRegistrationLive({
+                                pluginId,
+                                cwd: target.identity.cwd,
+                                env: options.context.env,
+                                nativeCliRunner: runner,
+                                manager: currentCodexManager(),
+                                scope: observationScopeFor(target),
+                                observationSession: options.context.codexObservationSession,
+                            });
+                            const state = requireObservedCodexNativeState(registration.observation, 'native install postcheck');
+                            requireCodexObservationCoverage(registration, observationScopeFor(target), 'native install postcheck');
+                            if (state !== 'installed') {
+                                throw new Error(`codexNativeInstallIncomplete: ${pluginId} is absent from Codex plugin list.`);
+                            }
+                            const installedEntry = registration.observation.state === 'observed'
+                                && registration.observation.value === 'installed'
+                                ? registration.observation.entry
+                                : undefined;
+                            if (installedEntry?.version !== undefined
+                                && installedEntry.version !== target.identity.pluginVersion) {
+                                throw new Error(`codexNativeInstallIncomplete: ${pluginId} version is ${installedEntry.version}; expected ${target.identity.pluginVersion}.`);
+                            }
+                        }
+                        await postcheck();
+                    },
+                });
+                return true;
+            },
+            completePostchecks: async () => {
+                const pending = deferredPostchecks;
+                deferredPostchecks = [];
+                const failures = [];
+                for (const entry of pending) {
+                    try {
+                        await entry.postcheck();
+                    }
+                    catch (error) {
+                        failures.push({ target: entry.target, error });
+                    }
+                }
+                return failures;
+            },
+        } : {}),
+        captureCodexPostMutationSnapshots: async (marketplaceNames = []) => {
+            for (const marketplaceName of marketplaceNames) {
+                codexMutationMarketplaces.add(marketplaceName);
+            }
+            if (codexMutationMarketplaces.size === 0)
+                return;
+            const session = options.context.codexObservationSession;
+            if (!session) {
+                throw new Error('codexNativeObservationUnavailable: grouped postcheck requires an observation session.');
+            }
+            const marketplaces = [...codexMutationMarketplaces].sort();
+            codexMutationMarketplaces.clear();
+            for (const marketplaceName of marketplaces)
+                session.invalidate(marketplaceName);
+            await Promise.all(marketplaces.map((marketplaceName) => session.snapshot(marketplaceName, options.context.codexObservationScopeByMarketplace?.get(marketplaceName)
+                ?? (options.targets.some((target) => (nativeMarketplaceEligibleTargets?.has(target) ?? true)
+                    && target.identity.platform === 'codex'
+                    && (target.identity.marketplaceName ?? MARKETPLACE_NAME) === marketplaceName
+                    && target.identity.scope === 'project')
+                    ? 'both'
+                    : 'user'))));
+        },
         preflightMutation: async (target) => {
+            if (!target.codexNativeObservationExpectation
+                && !target.codexNativeSensitivePreflightRequired)
+                return;
+            const sensitiveValues = pluginHasCodexNativeSkillSurface(target.plugin)
+                ? await resolveSensitiveUserConfigValues(target.plugin, options.context.env)
+                : [];
+            if (sensitiveValues.length > 0) {
+                await assertNoSensitiveValuesInCanonicalCodexNativePayload({
+                    plugin: target.plugin,
+                    marketplaceRoot: target.identity.marketplaceRoot ?? resolveAwHome(options.context.env),
+                    marketplaceName: target.identity.marketplaceName ?? MARKETPLACE_NAME,
+                    env: options.context.env,
+                    sensitiveValues,
+                });
+            }
             if (!target.codexNativeObservationExpectation)
                 return;
             const pluginId = `${target.identity.pluginName}@${target.identity.marketplaceName ?? MARKETPLACE_NAME}`;
@@ -3394,6 +3558,8 @@ function createNativeDriver(options) {
                 env: options.context.env,
                 nativeCliRunner: runner,
                 manager: currentCodexManager(),
+                scope: observationScopeFor(target),
+                observationSession: options.context.codexObservationSession,
             });
             const observed = requireObservedCodexNativeState(registration.observation, 'artifact write precheck');
             if (target.codexNativeObservationExpectation === 'installed' && observed !== 'installed') {
@@ -3427,20 +3593,13 @@ function createNativeDriver(options) {
                 || (Object.hasOwn(config.snapshot.plugins, expectedPluginId) && !canonical)) {
                 throw new Error(`externalOwnershipPresent: Codex marketplace ${marketplaceName} has a foreign source instead of its canonical namespaced root.`);
             }
-        },
-        commitMaterialize: async (target) => {
-            const transaction = mirrorTransactions.get(target);
-            if (!transaction)
-                return;
-            await transaction.commit();
-            mirrorTransactions.delete(target);
-        },
-        rollbackMaterialize: async (target) => {
-            const transaction = mirrorTransactions.get(target);
-            if (!transaction)
-                return;
-            await transaction.rollback();
-            mirrorTransactions.delete(target);
+            if (target.nativeOverlayDesired) {
+                await prepareCodexNativeRenderCached({
+                    context: options.context,
+                    plugin: target.plugin,
+                    scriptTimeoutMs: options.scriptTimeoutMs,
+                });
+            }
         },
         finalizeCleanup: async () => undefined,
         probeNative: async (component) => {
@@ -3459,12 +3618,17 @@ function createNativeDriver(options) {
                 return state.pluginState;
             }
             if (target.identity.platform === 'codex') {
+                const pending = pendingCodexNativeStates.get(codexStateKey(target, component.pluginId));
+                if (pending)
+                    return pending;
                 const registration = await inspectCodexPluginRegistrationLive({
                     pluginId: component.pluginId,
                     cwd: target.identity.cwd,
                     env: options.context.env,
                     nativeCliRunner: runner,
                     manager: currentCodexManager(),
+                    scope: observationScopeFor(target),
+                    observationSession: options.context.codexObservationSession,
                 });
                 return observedCodexNativeState(registration.observation, 'native probe');
             }
@@ -3495,41 +3659,20 @@ function createNativeDriver(options) {
                     env: options.context.env,
                     nativeCliRunner: runner,
                     manager: currentCodexManager(),
+                    scope: observationScopeFor(target),
+                    observationSession: options.context.codexObservationSession,
                 });
                 const nativeState = observedCodexNativeState(registration.observation, 'native health postcheck');
                 if (nativeState !== 'present')
                     return nativeState;
-                if (!registration.observations[target.identity.scope]
-                    || registration.activations[target.identity.scope] !== true)
-                    return 'partial';
-                const codexManager = currentCodexManager();
-                if (target.identity.scope !== 'project' || !codexManager)
-                    return 'present';
                 const userConfig = await readCodexConfigFile(resolveCodexPaths(target.identity.cwd, 'user', options.context.env).configTomlPath);
+                const userEnabled = userConfig.snapshot.plugins[pluginId]?.enabled === true;
+                if (target.identity.scope === 'user')
+                    return userEnabled ? 'present' : 'partial';
                 const projectConfig = await readCodexConfigFile(resolveCodexPaths(target.identity.cwd, 'project', options.context.env).configTomlPath);
-                const neutralCwd = await fs.mkdtemp(path.join(os.tmpdir(), 'aw-codex-postcheck-'));
-                try {
-                    const invocations = buildCodexProjectPluginListInvocations(codexManager, {
-                        exactCwd: target.identity.cwd,
-                        neutralCwd,
-                        env: options.context.env,
-                    });
-                    const [exactResult, neutralResult] = await Promise.all([
-                        runNativeCliChecked(invocations.exact, runner),
-                        runNativeCliChecked(invocations.neutral, runner),
-                    ]);
-                    postcheckCodexProjectPluginActivation({
-                        pluginId,
-                        userEnabled: userConfig.snapshot.plugins[pluginId]?.enabled === true,
-                        projectEnabled: projectConfig.snapshot.plugins[pluginId]?.enabled === true,
-                        exactResult,
-                        neutralResult,
-                    });
-                }
-                finally {
-                    await fs.remove(neutralCwd);
-                }
-                return 'present';
+                return userEnabled || projectConfig.snapshot.plugins[pluginId]?.enabled === true
+                    ? 'present'
+                    : 'partial';
             }
             return 'absent';
         },
@@ -3537,33 +3680,51 @@ function createNativeDriver(options) {
             const target = findTarget(component);
             if (!target)
                 throw new Error('Native ownership removal cannot resolve its desired target.');
+            await prepareNativeGroup(target);
             if (target.identity.platform === 'codex') {
-                const registration = await inspectCodexPluginRegistrationLive({
-                    pluginId: component.pluginId,
-                    cwd: target.identity.cwd,
-                    env: options.context.env,
-                    nativeCliRunner: runner,
-                    manager: currentCodexManager(),
-                });
-                const before = observedCodexNativeState(registration.observation, 'native remove precheck');
+                const marketplaceName = component.pluginId.slice(component.pluginId.lastIndexOf('@') + 1);
+                const stateKey = codexStateKey(target, component.pluginId);
+                const before = pendingCodexNativeStates.get(stateKey) ?? codexNativeStates.get(stateKey);
+                if (!before) {
+                    throw new Error('codexNativeObservationUnavailable: native group precheck is missing.');
+                }
                 const removalRequired = before === 'present';
                 if (!removalRequired)
                     return;
                 try {
-                    await runNativeCliChecked(buildCodexPluginRemoveInvocation(requireCodexManager(currentCodexManager()), component.pluginId, target.identity.cwd, options.context.env), runner);
+                    codexMutationMarketplaces.add(marketplaceName);
+                    await runObservedCodexMutation({
+                        marketplaceName,
+                        mutation: () => runNativeCliChecked(buildCodexPluginRemoveInvocation(requireCodexManager(currentCodexManager()), component.pluginId, target.identity.cwd, options.context.env), runner),
+                    });
                 }
                 catch {
                     throw new Error(`codexNativeRemoveFailed: ${CODEX_REMOVE_RECOVERY}`);
                 }
-                const after = await inspectCodexPluginRegistrationLive({
-                    pluginId: component.pluginId,
-                    cwd: target.identity.cwd,
-                    env: options.context.env,
-                    nativeCliRunner: runner,
-                    manager: currentCodexManager(),
-                });
-                if (observedCodexNativeState(after.observation, 'native remove postcheck') !== 'absent') {
-                    throw new Error(`codexNativeRemoveIncomplete: ${CODEX_REMOVE_RECOVERY}`);
+                pendingCodexNativeStates.set(stateKey, 'absent');
+                const postcheck = async () => {
+                    const after = await inspectCodexPluginRegistrationLive({
+                        pluginId: component.pluginId,
+                        cwd: target.identity.cwd,
+                        env: options.context.env,
+                        nativeCliRunner: runner,
+                        manager: currentCodexManager(),
+                        scope: observationScopeFor(target),
+                        observationSession: options.context.codexObservationSession,
+                    });
+                    const expected = pendingCodexNativeStates.get(stateKey) ?? 'absent';
+                    const observed = requireObservedCodexNativeState(after.observation, 'native mutation postcheck');
+                    if ((observed === 'installed' ? 'present' : 'absent') !== expected) {
+                        throw new Error(expected === 'absent'
+                            ? `codexNativeRemoveIncomplete: ${CODEX_REMOVE_RECOVERY}`
+                            : `codexNativeInstallIncomplete: ${component.pluginId} is absent from Codex plugin list.`);
+                    }
+                };
+                if (options.operationScopedNativePhases) {
+                    deferredPostchecks.push({ target, postcheck });
+                }
+                else {
+                    await postcheck();
                 }
             }
             else {
@@ -3595,169 +3756,106 @@ function createNativeDriver(options) {
         writeNative: async (target) => {
             if (!target.catalog)
                 throw new Error('Missing rebuild target catalog data.');
-            const catalog = target.catalog;
             const marketplaceName = target.identity.marketplaceName ?? MARKETPLACE_NAME;
             const expectedMarketplaceRoot = target.identity.marketplaceRoot ?? resolveAwHome(options.context.env);
-            const writeGeneration = async () => {
-                if (mirrorTransactions.has(target)) {
-                    throw new Error('Marketplace mirror transaction is already active for this target.');
+            if (target.identity.platform === 'codex') {
+                const config = await readCodexConfigFile(resolveCodexPaths(target.identity.cwd, 'user', options.context.env).configTomlPath);
+                const marketplace = config.snapshot.marketplaces[marketplaceName];
+                if (marketplace && (marketplace.sourceType !== 'local'
+                    || marketplace.sourcePointsToManifest
+                    || path.normalize(marketplace.source ?? '') !== path.normalize(expectedMarketplaceRoot))) {
+                    throw new Error(`externalOwnershipPresent: Codex marketplace ${marketplaceName} 已由 foreign source 占用，拒绝覆盖。`);
                 }
-                {
-                    if (target.identity.platform === 'codex') {
-                        const config = await readCodexConfigFile(resolveCodexPaths(target.identity.cwd, 'user', options.context.env).configTomlPath);
-                        const marketplace = config.snapshot.marketplaces[marketplaceName];
-                        if (marketplace && (marketplace.sourceType !== 'local'
-                            || marketplace.sourcePointsToManifest
-                            || path.normalize(marketplace.source ?? '') !== path.normalize(expectedMarketplaceRoot))) {
-                            throw new Error(`externalOwnershipPresent: Codex marketplace ${marketplaceName} 已由 foreign source 占用，拒绝覆盖。`);
-                        }
-                    }
-                    else {
-                        const state = await readClaudeNativeState({
-                            pluginName: target.identity.pluginName,
-                            scope: target.identity.scope,
-                            cwd: target.identity.cwd,
-                            env: options.context.env,
-                            marketplaceName,
-                            marketplaceRoot: expectedMarketplaceRoot,
-                        });
-                        if (state.marketplaceState === 'foreign') {
-                            throw new Error(`Claude marketplace ${marketplaceName} 已由 foreign source 占用，拒绝覆盖。`);
-                        }
-                    }
-                    const pluginId = `${target.identity.pluginName}@${marketplaceName}`;
-                    let codexRemovalRequired = false;
-                    if (target.identity.platform === 'codex') {
-                        const registration = await inspectCodexPluginRegistrationLive({
-                            pluginId,
-                            cwd: target.identity.cwd,
-                            env: options.context.env,
-                            nativeCliRunner: runner,
-                            manager: currentCodexManager(),
-                        });
-                        codexRemovalRequired = requireObservedCodexNativeState(registration.observation, 'native write precheck') === 'installed';
-                    }
-                    const canonicalMarketplaceRoot = await canonicalizePathThroughExistingAncestor(expectedMarketplaceRoot);
-                    const nativePluginRoot = await canonicalizePathThroughExistingAncestor(path.join(canonicalMarketplaceRoot, 'plugins', target.identity.pluginName));
-                    const desiredSkillPaths = new Set((target.desiredOwnedComponents ?? [])
-                        .filter((component) => component.kind === 'skill-directory')
-                        .map((component) => path.resolve(component.path)));
-                    const enabledSkillPaths = new Set(target.artifacts
-                        .filter((artifact) => artifact.kind === 'skill' && artifact.state !== 'disabled')
-                        .map((artifact) => path.resolve(artifact.path)));
-                    const requiredSkillWrites = (target.operationActions ?? []).filter((action) => action.kind === 'writeOwnedArtifact'
-                        && action.artifactKind === 'skill-directory'
-                        && desiredSkillPaths.has(path.resolve(action.path))
-                        && enabledSkillPaths.has(path.resolve(action.path))
-                        && target.identity.scope === 'user'
-                        && !path.relative(nativePluginRoot, action.path).startsWith('..'));
-                    const staged = { nativeRender: null };
-                    let skillsRelativeRoot = null;
-                    const mirrored = await mirrorCatalog(catalog, options.context.env, target.identity, target.identity.platform === 'codex' ? async (stagingRoot) => {
-                        for (const action of requiredSkillWrites) {
-                            await applyPlannedOperationAction({
-                                ...action,
-                                path: path.join(stagingRoot, path.relative(canonicalMarketplaceRoot, action.path)),
-                                allowedRoot: path.join(stagingRoot, path.relative(canonicalMarketplaceRoot, action.allowedRoot)),
-                            });
-                        }
-                        const hasStaticSkills = target.plugin.manifest.skills !== undefined
-                            || requiredSkillWrites.length > 0;
-                        staged.nativeRender = await materializeCodexNativeRender({
-                            plugin: target.plugin,
-                            stagingRoot,
-                            env: options.context.env,
-                            scriptTimeoutMs: options.scriptTimeoutMs,
-                            hasStaticSkills,
-                        });
-                        skillsRelativeRoot = staged.nativeRender
-                            && (hasStaticSkills || staged.nativeRender.presentSkillKeys.length > 0)
-                            ? await resolveCodexSkillsRelativeRoot(target.plugin)
-                            : staged.nativeRender ? null : await ensureCodexActiveSkillsManifest({
-                                plugin: target.plugin,
-                                marketplaceRoot: stagingRoot,
-                                hasRequiredSkills: hasStaticSkills,
-                            });
-                    } : undefined);
-                    mirrorTransactions.set(target, mirrored);
-                    for (const action of requiredSkillWrites)
-                        completedNativeSkillWrites.add(action);
-                    const marketplaceRoot = mirrored.rootDir;
-                    if (target.identity.platform === 'codex') {
-                        if (codexRemovalRequired) {
-                            await runNativeCliChecked(buildCodexPluginRemoveInvocation(requireCodexManager(currentCodexManager()), pluginId, target.identity.cwd, options.context.env), runner);
-                        }
-                        const config = await readCodexConfigFile(resolveCodexPaths(target.identity.cwd, 'user', options.context.env).configTomlPath);
-                        const marketplace = config.snapshot.marketplaces[marketplaceName];
-                        if (path.normalize(marketplace?.source ?? '') !== path.normalize(marketplaceRoot)) {
-                            await runNativeCliChecked(buildCodexMarketplaceAddInvocation(requireCodexManager(currentCodexManager()), marketplaceRoot, target.identity.cwd, options.context.env), runner);
-                        }
-                        await runNativeCliChecked(buildCodexMarketplaceListInvocation(requireCodexManager(currentCodexManager()), target.identity.cwd, options.context.env), runner);
-                        await runNativeCliChecked(buildCodexPluginAddInvocation(requireCodexManager(currentCodexManager()), pluginId, target.identity.cwd, options.context.env), runner);
-                        await runNativeCliChecked(buildCodexPluginListInvocation(requireCodexManager(currentCodexManager()), target.identity.cwd, options.context.env), runner);
-                        const installed = await inspectCodexPluginRegistrationLive({
-                            pluginId,
-                            cwd: target.identity.cwd,
-                            env: options.context.env,
-                            nativeCliRunner: runner,
-                            manager: currentCodexManager(),
-                        });
-                        if (observedCodexNativeState(installed.observation, 'native install postcheck') !== 'present') {
-                            throw new Error(`codexNativeInstallIncomplete: ${pluginId} is absent from Codex plugin list.`);
-                        }
-                        await assertCodexNativeInstallState({
-                            pluginName: target.identity.pluginName,
-                            pluginVersion: target.identity.pluginVersion,
-                            cwd: target.identity.cwd,
-                            env: options.context.env,
-                            marketplaceRoot,
-                            marketplaceName,
-                            skillsRelativeRoot,
-                            requiredSkillKeys: [
-                                ...requiredSkillWrites.flatMap((action) => action.owner?.artifactKey ? [action.owner.artifactKey] : []),
-                                ...(staged.nativeRender?.presentSkillKeys ?? []),
-                            ],
-                            ...(staged.nativeRender ? { nativeRender: staged.nativeRender } : {}),
-                        });
-                    }
-                    else {
-                        await runNativeCliChecked({
-                            command: 'claude',
-                            args: ['plugin', 'marketplace', 'add', marketplaceRoot, '--scope', target.identity.scope],
-                            cwd: target.identity.cwd,
-                            env: options.context.env,
-                        }, runner);
-                        await runNativeCliChecked({
-                            command: 'claude',
-                            args: ['plugin', 'install', pluginId, '--scope', target.identity.scope],
-                            cwd: target.identity.cwd,
-                            env: options.context.env,
-                        }, runner);
-                        await runNativeCliChecked({
-                            command: 'claude',
-                            args: ['plugin', 'list'],
-                            cwd: target.identity.cwd,
-                            env: options.context.env,
-                        }, runner);
-                        const after = await readClaudeNativeState({
-                            pluginName: target.identity.pluginName,
-                            scope: target.identity.scope,
-                            cwd: target.identity.cwd,
-                            env: options.context.env,
-                            marketplaceName,
-                            marketplaceRoot,
-                        });
-                        if (after.marketplaceDeclaredState !== 'canonical'
-                            || after.marketplaceMaterializedState !== 'canonical'
-                            || after.pluginState !== 'present'
-                            || !after.pluginEnabled
-                            || !after.pluginVersions.includes(target.identity.pluginVersion)) {
-                            throw new Error(`Claude native install postcheck 失败：declaredMarketplace=${after.marketplaceDeclaredState}，materializedMarketplace=${after.marketplaceMaterializedState}，plugin=${after.pluginState}，enabled=${after.pluginEnabled}，versions=${after.pluginVersions.join(',')}。`);
-                        }
-                    }
+            }
+            else {
+                const state = await readClaudeNativeState({
+                    pluginName: target.identity.pluginName,
+                    scope: target.identity.scope,
+                    cwd: target.identity.cwd,
+                    env: options.context.env,
+                    marketplaceName,
+                    marketplaceRoot: expectedMarketplaceRoot,
+                });
+                if (state.marketplaceState === 'foreign') {
+                    throw new Error(`Claude marketplace ${marketplaceName} 已由 foreign source 占用，拒绝覆盖。`);
                 }
-            };
-            await writeGeneration();
+            }
+            await prepareNativeGroup(target);
+            const pluginId = `${target.identity.pluginName}@${marketplaceName}`;
+            if (target.identity.platform === 'codex') {
+                const stateKey = codexStateKey(target, pluginId);
+                const codexRemovalRequired = pendingCodexNativeStates.get(stateKey)
+                    ?? codexNativeStates.get(stateKey);
+                if (!codexRemovalRequired) {
+                    throw new Error('codexNativeObservationUnavailable: native group precheck is missing.');
+                }
+                if (codexRemovalRequired === 'present') {
+                    codexMutationMarketplaces.add(marketplaceName);
+                    await runObservedCodexMutation({
+                        marketplaceName,
+                        mutation: () => runNativeCliChecked(buildCodexPluginRemoveInvocation(requireCodexManager(currentCodexManager()), pluginId, target.identity.cwd, options.context.env), runner),
+                    });
+                    pendingCodexNativeStates.set(stateKey, 'absent');
+                }
+                const config = await readCodexConfigFile(resolveCodexPaths(target.identity.cwd, 'user', options.context.env).configTomlPath);
+                const marketplace = config.snapshot.marketplaces[marketplaceName];
+                if (path.normalize(marketplace?.source ?? '') !== path.normalize(expectedMarketplaceRoot)) {
+                    codexMutationMarketplaces.add(marketplaceName);
+                    await runObservedCodexMutation({
+                        marketplaceName,
+                        mutation: () => runNativeCliChecked(buildCodexMarketplaceAddInvocation(requireCodexManager(currentCodexManager()), expectedMarketplaceRoot, target.identity.cwd, options.context.env), runner),
+                    });
+                }
+                codexMutationMarketplaces.add(marketplaceName);
+                await runObservedCodexMutation({
+                    marketplaceName,
+                    mutation: () => runNativeCliChecked(buildCodexPluginAddInvocation(requireCodexManager(currentCodexManager()), pluginId, target.identity.cwd, options.context.env), runner),
+                });
+                pendingCodexNativeStates.set(stateKey, 'present');
+                const installedConfig = await readCodexConfigFile(resolveCodexPaths(target.identity.cwd, 'user', options.context.env).configTomlPath);
+                const installedMarketplace = installedConfig.snapshot.marketplaces[marketplaceName];
+                if (installedMarketplace?.sourceType !== 'local'
+                    || installedMarketplace.sourcePointsToManifest
+                    || path.normalize(installedMarketplace.source ?? '') !== path.normalize(expectedMarketplaceRoot)
+                    || installedConfig.snapshot.plugins[pluginId]?.enabled !== true) {
+                    throw new Error(`codexNativeInstallIncomplete: ${pluginId} public config is not canonical and enabled.`);
+                }
+            }
+            else {
+                await runNativeCliChecked({
+                    command: 'claude',
+                    args: ['plugin', 'marketplace', 'add', expectedMarketplaceRoot, '--scope', target.identity.scope],
+                    cwd: target.identity.cwd,
+                    env: options.context.env,
+                }, runner);
+                await runNativeCliChecked({
+                    command: 'claude',
+                    args: ['plugin', 'install', pluginId, '--scope', target.identity.scope],
+                    cwd: target.identity.cwd,
+                    env: options.context.env,
+                }, runner);
+                await runNativeCliChecked({
+                    command: 'claude',
+                    args: ['plugin', 'list'],
+                    cwd: target.identity.cwd,
+                    env: options.context.env,
+                }, runner);
+                const after = await readClaudeNativeState({
+                    pluginName: target.identity.pluginName,
+                    scope: target.identity.scope,
+                    cwd: target.identity.cwd,
+                    env: options.context.env,
+                    marketplaceName,
+                    marketplaceRoot: expectedMarketplaceRoot,
+                });
+                if (after.marketplaceDeclaredState !== 'canonical'
+                    || after.marketplaceMaterializedState !== 'canonical'
+                    || after.pluginState !== 'present'
+                    || !after.pluginEnabled
+                    || !after.pluginVersions.includes(target.identity.pluginVersion)) {
+                    throw new Error(`Claude native install postcheck 失败：declaredMarketplace=${after.marketplaceDeclaredState}，materializedMarketplace=${after.marketplaceMaterializedState}，plugin=${after.pluginState}，enabled=${after.pluginEnabled}，versions=${after.pluginVersions.join(',')}。`);
+                }
+            }
         },
         writeArtifacts: async (target) => {
             for (const operationAction of target.operationActions ?? []) {
@@ -3771,33 +3869,45 @@ function createNativeDriver(options) {
             }
             return target.artifacts;
         },
-        runPostApply: async (invocation) => {
-            try {
-                await runPostApplyScript({
-                    plugin: invocation.plugin,
-                    platform: invocation.target.identity.platform,
-                    scope: invocation.target.identity.scope,
-                    cwd: invocation.target.identity.cwd,
-                    context: options.context,
-                    artifacts: [...invocation.artifacts],
-                    components: invocation.components,
-                    scriptTimeoutMs: options.scriptTimeoutMs,
-                });
+        runPreApply: async (invocation) => {
+            const run = () => runPreApplyScript({
+                plugin: invocation.plugin,
+                platform: invocation.target.identity.platform,
+                scope: invocation.target.identity.scope,
+                cwd: invocation.target.identity.cwd,
+                context: options.context,
+                scriptTimeoutMs: options.scriptTimeoutMs,
+            });
+            const cache = options.context.preApplyExecutionCache;
+            if (!cache) {
+                await run();
+                return;
             }
-            catch (error) {
-                await options.context.reporter.notice({
-                    level: 'warning',
-                    message: error instanceof Error ? error.message : String(error),
-                    source: {
-                        plugin: invocation.plugin.manifest.name,
-                        platform: invocation.target.identity.platform,
-                        scope: invocation.target.identity.scope,
-                        action: 'postApply',
-                    },
-                    target: 'stderr',
-                });
-                throw error;
+            const { identity } = invocation.target;
+            const sourceIdentity = invocation.plugin.sourceIdentity ?? identity.sourceIdentity;
+            const pluginId = invocation.plugin.pluginId ?? identity.pluginId;
+            if (!sourceIdentity || !pluginId) {
+                await run();
+                return;
             }
+            const projectKey = identity.scope === 'project'
+                ? identity.platform === 'codex'
+                    ? await resolveCodexProjectKey(identity.cwd)
+                    : await resolveClaudeProjectKey(identity.cwd)
+                : '';
+            const key = [
+                sourceIdentity,
+                pluginId,
+                identity.platform,
+                identity.scope,
+                projectKey,
+            ].join('\0');
+            let execution = cache.get(key);
+            if (!execution) {
+                execution = run();
+                cache.set(key, execution);
+            }
+            await execution;
         },
     };
 }
@@ -3806,6 +3916,9 @@ export function createRebuildIntegration(options) {
     const driver = createNativeDriver({ targets, ...options });
     return {
         driver,
+        setNativeMarketplaceEligibleTargets: driver.setNativeMarketplaceEligibleTargets,
+        prepareNativeMarketplaceGroup: driver.prepareNativeMarketplaceGroup,
+        captureCodexPostMutationSnapshots: driver.captureCodexPostMutationSnapshots,
         buildTarget: async (input) => {
             input = {
                 ...input,
@@ -3920,7 +4033,11 @@ export function createRebuildIntegration(options) {
             })))).flat();
             const skillRoots = input.platform === 'codex'
                 ? input.scope === 'project'
-                    ? []
+                    ? materializing
+                        || ((input.command === 'cleanup' || input.command === 'uninstall')
+                            && input.readOnlyInspectionPlan !== true)
+                        ? [path.join(input.cwd, '.agents', 'skills')]
+                        : []
                     : [
                         path.join(getCodexHome(options.context.env), 'skills'),
                         ...(preserveCodexSharedNativePayload || input.readOnlyShallowInspectionPlan === true
@@ -3935,6 +4052,7 @@ export function createRebuildIntegration(options) {
                 pluginName: input.plugin.manifest.name,
                 platform: input.platform,
                 scope: input.scope,
+                recursive: !(input.platform === 'codex' && input.scope === 'project'),
             })));
             const scannedSkills = (await scanSkills()).flat();
             const legacyCodexNativeSkills = input.platform === 'codex'
@@ -3978,15 +4096,14 @@ export function createRebuildIntegration(options) {
                 command: input.command,
             });
             if (preserveCodexSharedNativePayload) {
-                const nativePluginRoots = await Promise.all([
-                    path.join(input.marketplaceRoot ?? resolveAwHome(options.context.env), 'plugins', input.plugin.manifest.name),
-                    path.join(getCodexHome(options.context.env), 'plugins', 'cache', input.marketplaceName ?? MARKETPLACE_NAME, input.plugin.manifest.name),
-                ].map((root) => canonicalizePathThroughExistingAncestor(root)));
+                const nativePluginRoot = await canonicalizePathThroughExistingAncestor(path.join(input.marketplaceRoot ?? resolveAwHome(options.context.env), 'plugins', input.plugin.manifest.name));
+                const privateCacheRoot = path.resolve(getCodexHome(options.context.env), 'plugins', 'cache');
                 historicalComponents = historicalComponents.filter((component) => {
                     if (!('path' in component))
                         return true;
-                    return nativePluginRoots.every((nativePluginRoot) => {
-                        const relative = path.relative(nativePluginRoot, path.resolve(component.path));
+                    const componentPath = path.resolve(component.path);
+                    return [nativePluginRoot, privateCacheRoot].every((protectedRoot) => {
+                        const relative = path.relative(protectedRoot, componentPath);
                         return relative === '..'
                             || relative.startsWith(`..${path.sep}`)
                             || path.isAbsolute(relative);
@@ -4017,23 +4134,31 @@ export function createRebuildIntegration(options) {
             const nativeDesired = nativeRequired
                 && input.command !== 'cleanup'
                 && input.command !== 'uninstall';
-            const codexNative = input.platform === 'codex' && nativeRequired
-                ? await inspectCodexNativeResidue({
-                    pluginName: input.plugin.manifest.name,
+            const codexRegistration = input.platform === 'codex'
+                && nativeDesired
+                && input.readOnlyInspectionPlan !== true
+                ? await inspectCodexPluginRegistrationLive({
+                    pluginId: `${input.plugin.manifest.name}@${input.marketplaceName ?? MARKETPLACE_NAME}`,
                     cwd: input.cwd,
                     env: options.context.env,
-                    marketplaceName: input.marketplaceName,
-                    marketplaceRoot: input.marketplaceRoot,
+                    nativeCliRunner: options.context.nativeCliRunner,
+                    manager: options.context.codexManager,
+                    scope: codexObservationScope(options.context, input.marketplaceName ?? MARKETPLACE_NAME, input.scope),
+                    observationSession: options.context.codexObservationSession,
                 })
                 : undefined;
-            const codexNativeExact = codexNative?.state === 'present'
-                && codexNative.versions.length > 0
-                && codexNative.versions.every((version) => version === input.plugin.manifest.version);
+            const codexNativeExact = codexRegistration?.observation.state === 'observed'
+                && codexRegistration.observation.value === 'installed'
+                && (codexRegistration.observation.entry.version === undefined
+                    || codexRegistration.observation.entry.version === input.plugin.manifest.version);
             const materializeNativeRequired = nativeDesired && (input.platform === 'claude'
                 || input.command === 'reinstall'
                 || !codexNativeExact);
             const nativeCleanupCandidate = input.platform === 'claude'
-                && input.includeNativeCleanupCandidate !== false;
+                ? input.includeNativeCleanupCandidate !== false
+                : input.platform === 'codex'
+                    && nativeRequired
+                    && (input.command === 'cleanup' || input.command === 'uninstall');
             const nativePlugin = (nativeDesired || nativeCleanupCandidate)
                 ? [{
                         kind: 'native-plugin',
@@ -4046,7 +4171,7 @@ export function createRebuildIntegration(options) {
                 && input.command !== 'uninstall';
             const marketplace = input.platform === 'codex'
                 && input.scope === 'user'
-                && nativeDesired
+                && nativeRequired
                 && input.readOnlyShallowInspectionPlan !== true
                 ? [createCodexMarketplaceComponent({
                         pluginName: input.plugin.manifest.name,
@@ -4116,36 +4241,37 @@ export function createRebuildIntegration(options) {
             ]);
             bindNamespacedOwnerIdentity(allComponents, input);
             const desiredKeys = new Set(desiredComponents.map(componentIdentityKey));
-            const operationActions = writes.flatMap((write) => [
-                ...(write.action ? [write.action] : []),
-                ...(write.additionalActions ?? []),
-            ]);
-            finalizeOwnedArtifactActions(operationActions);
-            if (nativeDesired) {
-                operationActions.unshift({
-                    kind: 'ensureNativeRegistration',
+            const operationActions = [];
+            const preApply = input.plugin.manifest.scripts?.preApply;
+            if (preApply && input.command !== 'cleanup' && input.command !== 'uninstall') {
+                const script = path.resolve(input.plugin.rootDir, preApply.path.replace(/^\.\//u, ''));
+                const scriptDigest = `sha256:${crypto.createHash('sha256')
+                    .update(await fs.readFile(script)).digest('hex')}`;
+                operationActions.push({
+                    kind: 'runPreApply',
                     pluginId: input.pluginId ?? pluginActionId(input.plugin),
                     platform: input.platform,
                     scope: input.scope,
-                    registration: `${input.plugin.manifest.name}@${input.marketplaceName ?? MARKETPLACE_NAME}`,
-                    marketplaceName: input.marketplaceName ?? MARKETPLACE_NAME,
-                    marketplaceRoot: input.marketplaceRoot ?? resolveAwHome(options.context.env),
+                    script: preApply.path,
+                    scriptDigest,
                 });
             }
-            const postApply = input.plugin.manifest.scripts?.postApply;
-            if (postApply && input.command !== 'cleanup' && input.command !== 'uninstall') {
-                const script = path.resolve(input.plugin.rootDir, postApply.path.replace(/^\.\//u, ''));
-                const scriptDigest = `sha256:${crypto.createHash('sha256')
-                    .update(await fs.readFile(script)).digest('hex')}`;
+            if (nativeDesired) {
                 operationActions.push({
-                    kind: 'runPostApply',
+                    kind: 'ensureNativeRegistration',
                     pluginId: input.pluginId ?? pluginActionId(input.plugin),
                     platform: input.platform,
                     scope: input.scope,
-                    script: postApply.path,
-                    scriptDigest,
+                    registration: `${input.plugin.manifest.name}@${input.marketplaceName ?? MARKETPLACE_NAME}`,
+                    marketplaceName: input.marketplaceName ?? MARKETPLACE_NAME,
+                    marketplaceRoot: input.marketplaceRoot ?? resolveAwHome(options.context.env),
                 });
             }
+            operationActions.push(...writes.flatMap((write) => [
+                ...(write.action ? [write.action] : []),
+                ...(write.additionalActions ?? []),
+            ]));
+            finalizeOwnedArtifactActions(operationActions);
             const target = {
                 plugin: input.plugin,
                 identity: {
@@ -4167,10 +4293,11 @@ export function createRebuildIntegration(options) {
                 optionalOwnedComponents: allComponents.filter((component) => optionalComponentKeys.has(componentIdentityKey(component))),
                 requiresNative: nativeDesired,
                 writeNativeRequired: materializeNativeRequired,
+                nativeOverlayDesired: nativeDesired,
                 artifacts: writes.map((write) => write.artifact),
                 operationActions,
                 catalog: input.catalog,
-                postApplySource: input.plugin,
+                preApplySource: input.plugin,
             };
             targets.push(target);
             return target;
@@ -4213,24 +4340,22 @@ export async function inspectRebuildTarget(options) {
     if (!target.requiresNative)
         return { target, inspection };
     if (target.identity.platform === 'codex') {
-        const residue = await inspectCodexNativeResidue({
-            pluginName: target.identity.pluginName,
+        const nativeInspection = inspection.components.find((component) => component.component.kind === 'native-plugin');
+        if (nativeInspection?.state !== 'present')
+            return { target, inspection };
+        const registration = await inspectCodexPluginRegistrationLive({
+            pluginId: `${target.identity.pluginName}@${target.identity.marketplaceName ?? MARKETPLACE_NAME}`,
             cwd: target.identity.cwd,
             env: options.context.env,
-            marketplaceName: target.identity.marketplaceName,
-            marketplaceRoot: target.identity.marketplaceRoot,
+            nativeCliRunner: options.context.nativeCliRunner,
+            manager: options.context.codexManager,
+            scope: target.identity.scope,
+            observationSession: options.context.codexObservationSession,
         });
-        if (residue.state !== 'present' || !residue.enabled)
-            return { target, inspection };
-        const installed = [...new Set(residue.installedVersions)];
-        if (installed.length > 0) {
-            return installed.length === 1
-                ? { target, inspection, installedVersion: installed[0] }
-                : { target, inspection };
-        }
-        const cached = [...new Set(residue.cacheVersions)];
-        return cached.length === 1
-            ? { target, inspection, installedVersion: cached[0] }
+        return registration.observation.state === 'observed'
+            && registration.observation.value === 'installed'
+            && registration.observation.entry.version !== undefined
+            ? { target, inspection, installedVersion: registration.observation.entry.version }
             : { target, inspection };
     }
     const native = await readClaudeNativeState({
@@ -4366,13 +4491,48 @@ export async function discoverRebuildTargetNames(options) {
             }
         }
         else {
-            for (const name of await discoverCodexNativeResidueNames({
-                cwd: options.cwd,
+            const marketplaceName = options.marketplaceName ?? MARKETPLACE_NAME;
+            const marketplaceRoot = options.marketplaceRoot ?? resolveAwHome(options.env);
+            const marketplace = config.snapshot.marketplaces[marketplaceName];
+            const canonicalMarketplace = marketplace?.sourceType === 'local'
+                && !marketplace.sourcePointsToManifest
+                && path.normalize(marketplace.source ?? '') === path.normalize(marketplaceRoot);
+            const suffix = `@${marketplaceName}`;
+            const configuredPluginIds = Object.keys(config.snapshot.plugins)
+                .filter((pluginId) => pluginId.endsWith(suffix));
+            if (configuredPluginIds.length > 0 && !canonicalMarketplace) {
+                throw new Error(`externalOwnershipPresent: Codex marketplace ${marketplaceName} has a foreign public config source.`);
+            }
+            for (const pluginId of canonicalMarketplace ? configuredPluginIds : []) {
+                const name = pluginId.slice(0, -suffix.length);
+                if (/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(name))
+                    names.add(name);
+            }
+            const session = await createCodexNativeObservationSession({
+                exactCwd: options.cwd,
                 env: options.env,
-                marketplaceName: options.marketplaceName,
-                marketplaceRoot: options.marketplaceRoot,
-            }))
-                names.add(name);
+                runner: options.nativeCliRunner,
+            });
+            try {
+                const snapshot = await session.snapshot(marketplaceName, 'user');
+                if (!snapshot.neutral) {
+                    if (options.nativeFailureMode !== 'ignore') {
+                        throw new Error('codexNativeObservationFailed: cannot discover official Codex plugins.');
+                    }
+                }
+                else {
+                    for (const pluginId of snapshot.neutral.keys()) {
+                        if (!pluginId.endsWith(suffix))
+                            continue;
+                        const name = pluginId.slice(0, -suffix.length);
+                        if (/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(name))
+                            names.add(name);
+                    }
+                }
+            }
+            finally {
+                await session.dispose();
+            }
         }
     }
     else {