@lesliechan721/aw 0.1.0-beta.3 → 0.1.0-beta.31

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

@@ -2,33 +2,322 @@ import crypto from 'node:crypto';
 import path from 'node:path';
 import fs from 'fs-extra';
 import { generateAgentArtifacts } from '../generators/agents.js';
-import { extractCodexHookGroups } from '../generators/hooks.js';
 import { generateInstructionArtifacts, renderCodexManagedInstructionBlock, } from '../generators/instructions.js';
 import { generateCodexPermissionArtifacts, mergeClaudePermissions, } from '../generators/permissions.js';
 import { buildGeneratedName } from '../generators/shared.js';
-import { applyConditionalCodexConfigTransactionFile, applyCodexConfigTransactionFile, composeManagedDeveloperInstructionsBlock, readCodexConfigFile, readRenderedCodexMcpServersFile, } from '../utils/codex-config.js';
+import { applyConditionalCodexConfigTransactionFile, applyCodexConfigTransactionFile, composeManagedDeveloperInstructionsBlock, readCodexConfigFile, } from '../utils/codex-config.js';
+import { canonicalizePathThroughExistingAncestor, resolveClaudeProjectKey, resolveCodexProjectKey, } from '../utils/state-paths.js';
 import { createCodexSkillExpectedTree, createCodexSkillStagingTreeContentDigest, } from '../utils/codex-skill-staging.js';
-import { createDynamicSkillExpectedTree, createDynamicSkillTreeContentDigest, skillDirectoryMatchesExpectedTree, validateSkillDirectory, writeDynamicSkillTree, } from '../utils/dynamic-skill-tree.js';
-import { parseCodexSharedHooksFile, renderTrackedHookGroupIdentity, resolvePlatformHookDefinitions, serializeTrackedHookGroupIdentity, } from '../utils/hooks-contract.js';
-import { buildCodexMarketplaceAddInvocation, buildCodexMarketplaceListInvocation, buildCodexMarketplaceRemoveInvocation, buildCodexPluginAddInvocation, buildCodexPluginListInvocation, buildCodexPluginRemoveInvocation, runNativeCliChecked, } from '../utils/native-cli.js';
-import { OWNED_TEXT_HEADER_PREFIX, createSharedOwnerToken, createSkillOwnerMarkerContent, parseSharedOwnerToken, parseOwnedTextHeader, readSkillOwnerMarker, inspectOwnedComponents, writeOwnedTextFile, } from '../utils/ownership.js';
-import { resolveArtifactRenderConfig, runArtifactRenderer } from '../utils/artifact-renderer.js';
-import { validateArtifactPlan } from '../utils/artifact-plan.js';
-import { readPluginManifest } from '../utils/manifest.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, 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 { resolveAwDeliveredArtifactRequestBatches } from '../utils/artifact-request.js';
+import { createAwPluginRequirementsReceipt, parseAwPluginRequirementsReceipt, tryParseStrictSemVer, } from '../utils/manifest.js';
 import { resolvePlatformEntries } from '../utils/platform-entries.js';
 import { resolveAwHome, resolveClaudePaths, resolveCodexPaths, resolveRepoRoot, getCodexHome, } from '../utils/paths.js';
-import { runLifecycleScript } from '../utils/plugin-scripts.js';
-import { atomicRemoveConfigFile, atomicReplaceConfigFile, withConfigFileLock, } from '../utils/plugin-config.js';
-import { withActiveMarketplaceLifecycleLease, withActiveMarketplaceRuntimeLease, } from '../utils/active-marketplace-runtime-lock.js';
+import { assertNoSensitiveConfigInFiles, collectSensitivePluginConfigValues, runPreApplyScript, } from '../utils/plugin-scripts.js';
+import { validateRuntimeSkillClosure } from '../utils/runtime-skill-closure.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, replayNamespacedCodexSkillOverlays, } from '../utils/local-marketplace.js';
-import { cleanupOrphanNamespacedMarketplaceRoot, commitMarketplaceGenerationBackup, } from '../utils/orphan-marketplace-cleanup.js';
+import { getNamespacedMarketplaceName, MarketplaceRootValidationError, projectMarketplaceManifestForPlatform, readStrictNamespacedMarketplaceRoot, replayNamespacedCodexNativeRenderProjections, replayNamespacedCodexSkillOverlays, } from '../utils/local-marketplace.js';
+import { commitMarketplaceGenerationBackup } from '../utils/orphan-marketplace-cleanup.js';
 import { readClaudeSettings, writeClaudeSettings } from '../adapters/helpers.js';
-import { requiresCodexNativePlugin } from '../utils/codex-project-surface.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 } 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';
 const MARKETPLACE_NAME = 'aw';
-const MCP_OWNER_ENV = 'AW_AGENT_WORKFLOWS_OWNER';
+const LEGACY_MCP_OWNER_ENV = 'AW_AGENT_WORKFLOWS_OWNER';
+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;
+    constructor(codexPluginIds, detail) {
+        super(`codexActivationPostcheckFailed: ${detail}`);
+        this.name = 'CodexActivationPostcheckError';
+        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;
+}
+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() },
+    };
+    for (const plan of options.plans) {
+        const rewrittenPluginIds = new Set(plan.sharedNativeActions
+            .filter((action) => action.action === 'install'
+            || action.action === 'replace'
+            || action.action === 'repair')
+            .map((action) => action.codexPluginId));
+        for (const scope of ['user', 'project']) {
+            for (const action of plan.activationActions[scope]) {
+                if (action.action === 'enable' || action.action === 'disable') {
+                    byScope[scope].upserts[action.codexPluginId] = action.desired;
+                    byScope[scope].removals.delete(action.codexPluginId);
+                }
+                else if (action.action === 'remove') {
+                    byScope[scope].removals.add(action.codexPluginId);
+                }
+                else if (rewrittenPluginIds.has(action.codexPluginId)
+                    && (action.desired || scope === 'user')) {
+                    byScope[scope].upserts[action.codexPluginId] = action.desired;
+                    byScope[scope].removals.delete(action.codexPluginId);
+                }
+            }
+        }
+        for (const removal of plan.staleActivationRemovals) {
+            if (!Object.hasOwn(byScope[removal.scope].upserts, removal.codexPluginId)) {
+                byScope[removal.scope].removals.add(removal.codexPluginId);
+            }
+        }
+    }
+    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 (!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');
+            requireCodexObservationCoverage(registration, observationScope, 'activation precheck');
+            if (observedState !== 'installed') {
+                throw new Error('codexNativeObservationFailed: activation precheck did not observe the installed Codex plugin.');
+            }
+        }
+    }
+    for (const scope of ['user', 'project']) {
+        const enables = Object.fromEntries(Object.entries(byScope[scope].upserts)
+            .filter(([, desired]) => desired));
+        if (Object.keys(enables).length === 0)
+            continue;
+        const configPath = resolveCodexPaths(options.cwd, scope, options.env).configTomlPath;
+        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) {
+            throw new CodexActivationPostcheckError(missingEnables, `${missingEnables.join(', ')} ${scope} activation was not enabled before obsolete activation removal.`);
+        }
+    }
+    for (const scope of ['user', 'project']) {
+        const transaction = byScope[scope];
+        const disables = Object.fromEntries(Object.entries(transaction.upserts)
+            .filter(([, desired]) => !desired));
+        if (Object.keys(disables).length === 0 && transaction.removals.size === 0)
+            continue;
+        const update = await applyCodexConfigTransactionFile(resolveCodexPaths(options.cwd, scope, options.env).configTomlPath, {
+            ...(transaction.removals.size > 0
+                ? { removePluginActivations: [...transaction.removals].sort() }
+                : {}),
+            ...(Object.keys(disables).length > 0
+                ? { 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),
+        readCodexConfigFile(resolveCodexPaths(options.cwd, 'project', options.env).configTomlPath),
+    ]);
+    const configMismatchIds = [];
+    const configMismatchDetails = [];
+    for (const plan of options.plans) {
+        for (const scope of ['user', 'project']) {
+            const snapshot = scope === 'user' ? userConfig.snapshot : projectConfig.snapshot;
+            for (const action of plan.activationActions[scope]) {
+                const actual = snapshot.plugins[action.codexPluginId]?.enabled;
+                const expected = action.desired
+                    ? true
+                    : action.action === 'disable' || actual === false ? false : undefined;
+                if (actual !== expected) {
+                    configMismatchIds.push(action.codexPluginId);
+                    configMismatchDetails.push(`${action.codexPluginId} ${scope} activation is ${String(actual)}; expected ${String(expected)}.`);
+                }
+            }
+            for (const removal of plan.staleActivationRemovals.filter((entry) => entry.scope === scope)) {
+                if (snapshot.plugins[removal.codexPluginId]?.enabled !== undefined) {
+                    configMismatchIds.push(removal.codexPluginId);
+                    configMismatchDetails.push(`stale ${removal.codexPluginId} ${scope} activation remains.`);
+                }
+            }
+        }
+    }
+    if (configMismatchIds.length > 0) {
+        throw new CodexActivationPostcheckError(configMismatchIds, configMismatchDetails.join(' '));
+    }
+    const observedActivationChecks = options.plans.flatMap((plan) => plan.postcheck.support === 'observed'
+        ? plan.postcheck.plugins
+        : []);
+    if (observedActivationChecks.length === 0)
+        return;
+    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 {
+        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,
+            env: options.env,
+            runner: options.runner,
+            manager: options.manager,
+        });
+    const session = options.observationSession ?? ownedSession;
+    try {
+        const failedPluginIds = [];
+        const failureDetails = [];
+        for (const check of checks) {
+            try {
+                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) {
+                failedPluginIds.push(check.codexPluginId);
+                failureDetails.push(error instanceof Error ? error.message : String(error));
+            }
+        }
+        if (failedPluginIds.length > 0) {
+            throw new CodexActivationPostcheckError(failedPluginIds, failureDetails.join(' '));
+        }
+    }
+    finally {
+        await ownedSession?.dispose();
+    }
+}
+const CODEX_REMOVE_RECOVERY = 'Codex residue was retained. Retry cleanup or uninstall, upgrade AW, or install a compatible official Codex CLI.';
 function ownerIdentity(plugin, artifactKey, platform, scope) {
     return { owner: 'agent-workflows', plugin, artifactKey, platform, scope };
 }
@@ -37,7 +326,6 @@ function pluginOwnerIdentity(plugin, artifactKey, platform, scope) {
         ...ownerIdentity(plugin.manifest.name, artifactKey, platform, scope),
         ...(plugin.sourceId ? {
             sourceId: plugin.sourceId,
-            sourceIdentity: plugin.sourceIdentity,
             pluginId: plugin.pluginId,
         } : {}),
     };
@@ -47,7 +335,6 @@ function bindNamespacedOwnerIdentity(components, source) {
         return;
     for (const component of components) {
         component.identity.sourceId = source.sourceId;
-        component.identity.sourceIdentity = source.sourceIdentity;
         component.identity.pluginId = source.pluginId;
     }
 }
@@ -59,11 +346,76 @@ function pathComponent(options) {
         return options;
     return {
         ...options,
-        validateHealth: async () => {
-            await validateSkillDirectory(options.path, options.identity.platform === 'codex' ? 'codex.skill' : 'claude.skill', { ownerMarkerPolicy: 'ignore' });
+        validateHealth: true,
+    };
+}
+function pristineTreeDescriptor(tree) {
+    return Object.entries(tree.files)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([relativePath, content]) => ({
+        relativePath,
+        contentDigest: `sha256:${crypto.createHash('sha256').update(content).digest('hex')}`,
+    }));
+}
+function pluginActionId(plugin) {
+    return plugin.pluginId ?? plugin.manifest.name;
+}
+function skillWriteAction(options) {
+    const files = [
+        ...Object.entries(options.tree.files).map(([relativePath, content]) => ({
+            relativePath,
+            contentBase64: content.toString('base64'),
+            contentDigest: `sha256:${crypto.createHash('sha256').update(content).digest('hex')}`,
+        })),
+        {
+            relativePath: '.agent-workflows-owner.json',
+            contentBase64: Buffer.from(createSkillOwnerMarkerContent(options.identity)).toString('base64'),
+            contentDigest: `sha256:${crypto.createHash('sha256')
+                .update(createSkillOwnerMarkerContent(options.identity)).digest('hex')}`,
         },
+    ].sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+    const contentDigest = `sha256:${crypto.createHash('sha256').update(JSON.stringify(files)).digest('hex')}`;
+    return {
+        kind: 'writeOwnedArtifact',
+        pluginId: pluginActionId(options.plugin),
+        platform: options.platform,
+        scope: options.scope,
+        path: options.path,
+        allowedRoot: options.allowedRoot,
+        owner: options.identity,
+        artifactKind: 'skill-directory',
+        files,
+        contentDigest,
+        allowPristineUnowned: options.allowPristineUnowned,
     };
 }
+function finalizeOwnedArtifactActions(actions) {
+    for (const action of actions) {
+        if (action.kind !== 'writeOwnedArtifact' || !action.owner)
+            continue;
+        if (action.artifactKind === 'owned-text-file') {
+            if (action.sourceContent === undefined)
+                throw new Error('Owned text action is missing source content.');
+            action.content = renderOwnedTextFile(action.sourceContent, action.owner);
+            action.contentDigest = `sha256:${crypto.createHash('sha256').update(action.content).digest('hex')}`;
+            continue;
+        }
+        if (action.artifactKind === 'skill-directory') {
+            const markerContent = createSkillOwnerMarkerContent(action.owner);
+            const marker = {
+                relativePath: '.agent-workflows-owner.json',
+                contentBase64: Buffer.from(markerContent).toString('base64'),
+                contentDigest: `sha256:${crypto.createHash('sha256').update(markerContent).digest('hex')}`,
+            };
+            action.files = [
+                ...(action.files ?? []).filter((file) => file.relativePath !== marker.relativePath),
+                marker,
+            ].sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+            action.contentDigest = `sha256:${crypto.createHash('sha256')
+                .update(JSON.stringify(action.files)).digest('hex')}`;
+        }
+    }
+}
 function generatedTextWrite(options) {
     const artifactPath = path.join(options.configDir, options.relativePath);
     const identity = ownerIdentity(options.plugin.manifest.name, options.artifactKey, options.platform, options.scope);
@@ -73,6 +425,7 @@ function generatedTextWrite(options) {
         allowedRoot: options.configDir,
         identity,
     });
+    const content = options.content;
     return {
         artifact: {
             path: artifactPath,
@@ -81,14 +434,18 @@ function generatedTextWrite(options) {
             artifactKey: options.artifactKey,
         },
         component,
-        write: async () => {
-            await fs.ensureDir(options.configDir);
-            await writeOwnedTextFile({
-                path: artifactPath,
-                allowedRoot: options.configDir,
-                identity,
-                content: options.content,
-            });
+        action: {
+            kind: 'writeOwnedArtifact',
+            pluginId: pluginActionId(options.plugin),
+            platform: options.platform,
+            scope: options.scope,
+            path: artifactPath,
+            allowedRoot: options.configDir,
+            owner: identity,
+            artifactKind: 'owned-text-file',
+            sourceContent: content,
+            content,
+            contentDigest: `sha256:${crypto.createHash('sha256').update(content).digest('hex')}`,
         },
     };
 }
@@ -162,15 +519,7 @@ function createClaudePermissionsComponent(options) {
         kind: 'shared-config',
         identity: options.identity,
         label: `${options.settingsPath}#awGenerated.permissions.${ownerKey}`,
-        inspect: async () => {
-            const settings = await readClaudeSettings(options.settingsPath);
-            return settings.awGenerated?.permissions?.[ownerKey] ? 'present' : 'absent';
-        },
-        remove: async () => {
-            const settings = await readClaudeSettings(options.settingsPath);
-            rebuildClaudePermissions(settings, ownerKey);
-            await writeClaudeSettings(options.settingsPath, settings);
-        },
+        locator: { kind: 'claude-permissions', settingsPath: options.settingsPath, ownerKey },
     };
 }
 function createCodexInstructionComponent(options) {
@@ -179,97 +528,65 @@ function createCodexInstructionComponent(options) {
         kind: 'managed-block',
         identity: options.identity,
         label: `${options.configPath}#developer_instructions:${ownerKey}`,
-        inspect: async () => {
-            const config = await readCodexConfigFile(options.configPath);
-            return config.snapshot.developerInstructions.managedBlocks[ownerKey]
-                ? 'present'
-                : 'absent';
+        locator: { kind: 'codex-instruction', configPath: options.configPath, ownerKey },
+    };
+}
+function createCodexActivationComponent(options) {
+    return {
+        kind: 'shared-config',
+        identity: options.identity,
+        label: `${options.configPath}#plugins.${options.codexPluginId}.enabled`,
+        locator: {
+            kind: 'codex-activation',
+            configPath: options.configPath,
+            codexPluginId: options.codexPluginId,
+            desired: options.desired,
         },
-        remove: async () => {
-            await applyCodexConfigTransactionFile(options.configPath, {
-                removeManagedInstructionPluginName: ownerKey,
-            });
+    };
+}
+function createCodexActivationCleanupComponent(options) {
+    return {
+        kind: 'shared-config',
+        identity: options.identity,
+        label: `${options.configPath}#plugins.${options.codexPluginId}.enabled`,
+        locator: {
+            kind: 'codex-activation',
+            configPath: options.configPath,
+            codexPluginId: options.codexPluginId,
+            desired: options.disposition === 'remove' ? false : true,
+            disposition: options.disposition,
         },
     };
 }
-function codexMcpOwner(actual) {
+function legacyCodexMcpOwner(actual) {
     const envValue = actual?.value?.env;
     return envValue
         && typeof envValue === 'object'
         && !Array.isArray(envValue)
-        && typeof envValue[MCP_OWNER_ENV] === 'string'
-        ? envValue[MCP_OWNER_ENV]
+        && typeof envValue[LEGACY_MCP_OWNER_ENV] === 'string'
+        ? envValue[LEGACY_MCP_OWNER_ENV]
         : null;
 }
-function createCodexMcpComponent(options) {
+function createLegacyCodexMcpCleanupComponent(options) {
     const ownerKey = createSharedOwnerToken(options.identity);
     return {
         kind: 'shared-config',
         identity: options.identity,
         label: `${options.configPath}#mcp_servers.${options.serverKey}`,
-        inspect: async () => {
-            const config = await readCodexConfigFile(options.configPath);
-            const actual = config.snapshot.mcpServers[options.serverKey];
-            if (!actual)
-                return 'absent';
-            return codexMcpOwner(actual) === ownerKey ? 'present' : 'foreign';
-        },
-        remove: async () => {
-            await applyConditionalCodexConfigTransactionFile(options.configPath, (snapshot) => {
-                const actual = snapshot.mcpServers[options.serverKey];
-                return codexMcpOwner(actual) === ownerKey
-                    ? { removeMcpServers: [options.serverKey] }
-                    : null;
-            });
-        },
-    };
-}
-async function codexRoleRegistrationOwned(options) {
-    if (!options.registration?.configFile)
-        return false;
-    const expected = path.normalize(path.relative(path.dirname(options.configPath), options.rolePath));
-    const actual = path.normalize(path.relative(path.dirname(options.configPath), path.resolve(path.dirname(options.configPath), options.registration.configFile)));
-    if (actual !== expected)
-        return false;
-    const raw = await fs.readFile(options.rolePath, 'utf8').catch(() => '');
-    try {
-        return Boolean(parseOwnedTextHeader(raw, options.fileIdentity));
-    }
-    catch {
-        return false;
-    }
-}
-function createCodexRoleRegistrationComponent(options) {
-    const inspect = async () => {
-        const config = await readCodexConfigFile(options.configPath);
-        const registration = config.snapshot.agents[options.roleKey];
-        if (!registration)
-            return 'absent';
-        return await codexRoleRegistrationOwned({ ...options, registration })
-            ? 'present'
-            : 'foreign';
-    };
-    return {
-        kind: 'shared-config',
-        identity: options.identity,
-        label: `${options.configPath}#agents.${options.roleKey}`,
-        inspect,
-        remove: async () => {
-            await applyConditionalCodexConfigTransactionFile(options.configPath, async (snapshot) => {
-                const registration = snapshot.agents[options.roleKey];
-                return await codexRoleRegistrationOwned({ ...options, registration })
-                    ? { removeAgentRegistrations: [options.roleKey] }
-                    : null;
-            });
+        locator: {
+            kind: 'legacy-codex-mcp',
+            configPath: options.configPath,
+            serverKey: options.serverKey,
+            ownerKey,
         },
     };
 }
-async function readCodexHooks(hooksPath) {
+async function readLegacyCodexHooks(hooksPath) {
     if (!await fs.pathExists(hooksPath))
         return parseCodexSharedHooksFile({ hooks: {} });
     return parseCodexSharedHooksFile(await fs.readJson(hooksPath));
 }
-function renderCodexHookGroups(groups) {
+function renderLegacyCodexHookGroups(groups) {
     const hooks = {};
     for (const group of groups) {
         hooks[group.event] ??= [];
@@ -277,16 +594,15 @@ function renderCodexHookGroups(groups) {
     }
     return `${JSON.stringify({ hooks }, null, 2)}\n`;
 }
-export async function applyCodexHookGroupsTransactionFile(hooksPath, update, testHooks) {
-    return withConfigFileLock({
+async function applyLegacyCodexHookCleanupTransactionFile(hooksPath, update) {
+    return withConfigFileMutation({
         filePath: hooksPath,
         allowedRoot: path.dirname(hooksPath),
         action: async () => {
-            const parsed = await readCodexHooks(hooksPath);
+            const parsed = await readLegacyCodexHooks(hooksPath);
             const groups = update(parsed);
             if (!groups)
                 return false;
-            await testHooks?.beforeCommit?.();
             if (groups.length === 0) {
                 await atomicRemoveConfigFile({
                     filePath: hooksPath,
@@ -297,91 +613,64 @@ export async function applyCodexHookGroupsTransactionFile(hooksPath, update, tes
                 await atomicReplaceConfigFile({
                     filePath: hooksPath,
                     allowedRoot: path.dirname(hooksPath),
-                    content: renderCodexHookGroups(groups),
+                    content: renderLegacyCodexHookGroups(groups),
                 });
             }
             return true;
         },
     });
 }
-function renderCodexSharedHookGroup(identity) {
-    const rendered = renderTrackedHookGroupIdentity(identity);
-    const rawGroup = {
-        ...(rendered.matcher === undefined ? {} : { matcher: rendered.matcher }),
-        hooks: rendered.hooks,
-    };
-    return {
-        event: rendered.event,
-        matcher: rendered.matcher,
-        hooks: rendered.hooks,
-        rawGroup,
-    };
-}
-function createCodexHookComponent(options) {
+function createLegacyCodexHookCleanupComponent(options) {
     const serialized = serializeTrackedHookGroupIdentity(options.identity);
     return {
         kind: 'shared-config',
         identity: ownerIdentity(options.pluginName, internalArtifactKey('hook', serialized), 'codex', options.scope),
         label: `${options.hooksPath}#${serialized}`,
-        inspect: async () => {
-            const parsed = await readCodexHooks(options.hooksPath);
-            return parsed.managedIdentities.some((entry) => serializeTrackedHookGroupIdentity(entry) === serialized)
-                ? 'present'
-                : 'absent';
-        },
-        remove: async () => {
-            await applyCodexHookGroupsTransactionFile(options.hooksPath, (parsed) => {
-                let removed = false;
-                const remaining = parsed.groups.flatMap((entry) => {
-                    if (!removed
-                        && entry.managedIdentity
-                        && serializeTrackedHookGroupIdentity(entry.managedIdentity) === serialized) {
-                        removed = true;
-                        return [];
-                    }
-                    return [entry.rawGroup];
-                });
-                return removed ? remaining : null;
-            });
+        locator: {
+            kind: 'legacy-codex-hook',
+            hooksPath: options.hooksPath,
+            serializedIdentity: serialized,
         },
     };
 }
-function ownedCodexHookIdentity(options) {
-    const artifactKey = internalArtifactKey('hook', serializeTrackedHookGroupIdentity(options.identity));
-    const identity = {
-        ...ownerIdentity(options.pluginName, artifactKey, 'codex', options.scope),
-        ...(options.sourceId ? {
-            sourceId: options.sourceId,
-            sourceIdentity: options.sourceIdentity,
-            pluginId: options.pluginId,
-        } : {}),
-    };
+async function codexRoleRegistrationOwned(options) {
+    if (!options.registration?.configFile)
+        return false;
+    const expected = path.normalize(path.relative(path.dirname(options.configPath), options.rolePath));
+    const actual = path.normalize(path.relative(path.dirname(options.configPath), path.resolve(path.dirname(options.configPath), options.registration.configFile)));
+    if (actual !== expected)
+        return false;
+    const raw = await fs.readFile(options.rolePath, 'utf8').catch(() => '');
+    try {
+        return Boolean(parseOwnedTextHeader(raw, options.fileIdentity));
+    }
+    catch {
+        return false;
+    }
+}
+function createCodexRoleRegistrationComponent(options) {
     return {
-        ...options.identity,
-        command: `${OWNED_TEXT_HEADER_PREFIX}${JSON.stringify(JSON.parse(createSkillOwnerMarkerContent(identity)))}\n${options.identity.command}`,
+        kind: 'shared-config',
+        identity: options.identity,
+        label: `${options.configPath}#agents.${options.roleKey}`,
+        locator: {
+            kind: 'codex-role-registration',
+            configPath: options.configPath,
+            roleKey: options.roleKey,
+            rolePath: options.rolePath,
+            fileIdentity: options.fileIdentity,
+        },
     };
 }
 function sameOwnerIdentity(left, right) {
     return left.owner === right.owner
         && left.sourceId === right.sourceId
-        && left.sourceIdentity === right.sourceIdentity
         && left.pluginId === right.pluginId
         && left.plugin === right.plugin
         && left.artifactKey === right.artifactKey
         && left.platform === right.platform
         && left.scope === right.scope;
 }
-function readOwnedHookIdentity(identity, scope) {
-    try {
-        const parsed = parseOwnedTextHeader(identity.command);
-        return parsed?.identity.platform === 'codex' && parsed.identity.scope === scope
-            ? parsed.identity
-            : null;
-    }
-    catch {
-        return null;
-    }
-}
 function sharedOwnerPluginName(value) {
     return parseSharedOwnerToken(value)?.plugin ?? value;
 }
@@ -391,7 +680,6 @@ async function scanCodexSharedComponents(options) {
         ...ownerIdentity(options.pluginName, artifactKey, 'codex', options.scope),
         ...(options.sourceId ? {
             sourceId: options.sourceId,
-            sourceIdentity: options.sourceIdentity,
             pluginId: options.pluginId,
         } : {}),
     });
@@ -399,13 +687,12 @@ async function scanCodexSharedComponents(options) {
         kind: 'shared-config',
         identity: ownerIdentity(options.pluginName, internalArtifactKey('corrupted-shared-config', filePath), 'codex', options.scope),
         label: filePath,
-        inspect: async () => {
-            throw new Error(`包含 ${options.pluginName} 的 AW ownership 证据，但共享配置无法解析：${error instanceof Error ? error.message : String(error)}`);
+        locator: {
+            kind: 'corrupted',
+            message: `包含 ${options.pluginName} 的 AW ownership 证据，但共享配置无法解析：${error instanceof Error ? error.message : String(error)}`,
         },
-        remove: async () => undefined,
     });
     const containsOwnedEvidence = (raw) => raw.includes(options.pluginName) && (raw.includes('[[aw-managed:start plugin=')
-        || raw.includes(MCP_OWNER_ENV)
         || raw.includes(OWNED_TEXT_HEADER_PREFIX)
         || raw.includes('agent-workflows'));
     if (options.scanConfig) {
@@ -427,24 +714,6 @@ async function scanCodexSharedComponents(options) {
                 configPath: options.paths.configTomlPath,
             }));
         }
-        for (const [serverKey, server] of Object.entries(config?.snapshot.mcpServers ?? {})) {
-            const envValue = server.value?.env;
-            if (envValue
-                && typeof envValue === 'object'
-                && !Array.isArray(envValue)
-                && parseSharedOwnerToken(String(envValue[MCP_OWNER_ENV]))?.pluginId === options.pluginId) {
-                const identity = expectedIdentity(internalArtifactKey('mcp', serverKey));
-                if (createSharedOwnerToken(identity) !== envValue[MCP_OWNER_ENV])
-                    continue;
-                output.push(createCodexMcpComponent({
-                    identity,
-                    scope: options.scope,
-                    configPath: options.paths.configTomlPath,
-                    serverKey,
-                    owned: true,
-                }));
-            }
-        }
         for (const [roleKey, registration] of Object.entries(config?.snapshot.agents ?? {})) {
             if (!registration.configFile)
                 continue;
@@ -469,28 +738,6 @@ async function scanCodexSharedComponents(options) {
             }));
         }
     }
-    if (options.scope === 'project' && options.scanHooks) {
-        const hooks = await readCodexHooks(options.paths.hooksPath).catch(async (error) => {
-            if (!options.ignoreReadErrors)
-                throw error;
-            const raw = await fs.readFile(options.paths.hooksPath, 'utf8').catch(() => '');
-            if (containsOwnedEvidence(raw)) {
-                output.push(corruptedComponent(options.paths.hooksPath, error));
-            }
-            return null;
-        });
-        for (const identity of hooks?.managedIdentities ?? []) {
-            const parsedIdentity = readOwnedHookIdentity(identity, options.scope);
-            if (!parsedIdentity || !sameOwnerIdentity(parsedIdentity, expectedIdentity(parsedIdentity.artifactKey)))
-                continue;
-            output.push(createCodexHookComponent({
-                pluginName: options.pluginName,
-                scope: options.scope,
-                hooksPath: options.paths.hooksPath,
-                identity,
-            }));
-        }
-    }
     return output;
 }
 async function scanClaudeSharedComponents(options) {
@@ -499,7 +746,6 @@ async function scanClaudeSharedComponents(options) {
         ...ownerIdentity(options.pluginName, 'permissions', 'claude', options.scope),
         ...(options.sourceId ? {
             sourceId: options.sourceId,
-            sourceIdentity: options.sourceIdentity,
             pluginId: options.pluginId,
         } : {}),
     };
@@ -576,7 +822,8 @@ async function scanOwnedSkills(options) {
                 }));
                 continue;
             }
-            pending.push(skillRoot);
+            if (options.recursive !== false)
+                pending.push(skillRoot);
         }
     }
     return output;
@@ -602,14 +849,19 @@ async function preflightCodexWriteSafety(options) {
     const pluginName = options.plugin.manifest.name;
     const userConfigPath = resolveCodexPaths(options.cwd, 'user', options.env).configTomlPath;
     const projectConfigPath = resolveCodexPaths(options.cwd, 'project', options.env).configTomlPath;
+    const nativeSurface = analyzeCodexSurface(options.plugin.manifest).nativeKinds.length > 0;
+    const needsUserConfig = options.scope === 'user'
+        || nativeSurface;
     let userConfig;
-    try {
-        userConfig = await readCodexConfigFile(userConfigPath);
-    }
-    catch (error) {
-        throw new Error(`codexProjectUserConfigUnreadable: 无法解析用户级 Codex 配置 ${userConfigPath}：${error instanceof Error ? error.message : String(error)}`);
+    if (needsUserConfig) {
+        try {
+            userConfig = await readCodexConfigFile(userConfigPath);
+        }
+        catch (error) {
+            throw new Error(`codexProjectUserConfigUnreadable: 无法解析用户级 Codex 配置 ${userConfigPath}：${error instanceof Error ? error.message : String(error)}`);
+        }
     }
-    if (options.scope === 'project') {
+    if (options.scope === 'project' && userConfig) {
         const expectedPluginId = `${pluginName}@${options.plugin.marketplaceName ?? MARKETPLACE_NAME}`;
         for (const [key, plugin] of Object.entries(userConfig.snapshot.plugins)) {
             if (key !== expectedPluginId
@@ -624,7 +876,7 @@ async function preflightCodexWriteSafety(options) {
         && target.target === 'codex.agentRole'
         && target.roleKey)
         .map((target) => target.roleKey));
-    const needsProjectConfig = options.scope === 'project' && Boolean(options.plugin.manifest.mcpServers
+    const needsProjectConfig = options.scope === 'project' && Boolean(nativeSurface
         || resolvePlatformEntries(options.plugin.manifest.extensions?.instructions, 'codex').length > 0
         || (options.plugin.manifest.artifacts?.targets ?? []).some((target) => target.platform === 'codex'
             && target.scopes.includes('project')
@@ -641,7 +893,7 @@ async function preflightCodexWriteSafety(options) {
     if (roleKeys.size === 0)
         return;
     for (const configPath of options.scope === 'project'
-        ? [userConfigPath, projectConfigPath]
+        ? [projectConfigPath]
         : [userConfigPath]) {
         const configScope = configPath === userConfigPath ? 'user' : 'project';
         const ownedRolePaths = [];
@@ -692,68 +944,63 @@ function renderCodexRole(options) {
         '',
     ].join('\n');
 }
-async function resolveCodexMcpServers(plugin, scope) {
-    if (!plugin.manifest.mcpServers)
-        return {};
-    const relative = plugin.manifest.mcpServers.replace(/^\.\//u, '');
-    const direct = path.resolve(plugin.rootDir, relative);
-    const mcpPath = await fs.pathExists(direct)
-        ? direct
-        : path.resolve(plugin.rootDir, 'codex', relative);
-    const servers = await readRenderedCodexMcpServersFile(mcpPath);
-    return Object.fromEntries(Object.entries(servers).map(([key, server]) => {
-        const existingEnv = server.env;
-        if (existingEnv !== undefined && (typeof existingEnv !== 'object' || Array.isArray(existingEnv))) {
-            throw new Error(`MCP server ${key} 的 env 必须是 object。`);
-        }
-        const env = (existingEnv ?? {});
-        const ownerKey = createSharedOwnerToken(pluginOwnerIdentity(plugin, internalArtifactKey('mcp', key), 'codex', scope));
-        if (env[MCP_OWNER_ENV] !== undefined
-            && env[MCP_OWNER_ENV] !== plugin.manifest.name
-            && env[MCP_OWNER_ENV] !== ownerKey) {
-            throw new Error(`MCP server ${key} 不能覆盖保留的 ${MCP_OWNER_ENV} owner marker。`);
-        }
-        return [key, {
-                ...server,
-                env: { ...env, [MCP_OWNER_ENV]: ownerKey },
-            }];
-    }));
-}
 async function resolveDynamicArtifacts(options) {
-    const declarations = (options.plugin.manifest.artifacts?.targets ?? []).filter((target) => target.platform === options.platform && target.scopes.includes(options.scope));
-    if (declarations.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],
-        scriptTimeoutMs: options.scriptTimeoutMs,
-    });
+    const requestBatches = options.requestedArtifactIds
+        ? [options.requestedArtifactIds]
+        : resolveAwDeliveredArtifactRequestBatches({
+            manifest: options.plugin.manifest,
+            platform: options.platform,
+            scope: options.scope,
+        });
+    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,
-        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) {
@@ -766,7 +1013,7 @@ function dynamicSkillWrite(options) {
         identity,
         ...(options.platform === 'codex' && options.scope === 'user'
             ? {
-                unownedIsPristine: (actualPath) => skillDirectoryMatchesExpectedTree(actualPath, options.tree),
+                pristineTree: pristineTreeDescriptor(options.tree),
             }
             : {}),
     });
@@ -790,17 +1037,19 @@ function dynamicSkillWrite(options) {
                 : createDynamicSkillTreeContentDigest(options.tree),
         },
         ...(options.artifact.state === 'present' ? { component } : {}),
-        write: async () => {
-            if (options.artifact.state === 'disabled') {
-                return;
-            }
-            await writeDynamicSkillTree(options.skillPath, options.tree, {
+        ...(options.artifact.state === 'present' ? {
+            action: skillWriteAction({
+                plugin: options.plugin,
+                platform: options.platform,
+                scope: options.scope,
+                path: options.skillPath,
                 allowedRoot: options.allowedRoot,
                 identity,
+                tree: options.tree,
                 allowPristineUnowned: options.platform === 'codex' && options.scope === 'user',
-            });
-        },
-    };
+            }),
+        } : {}),
+    };
 }
 async function resolveCodexSkillsRelativeRoot(plugin, marketplaceFallbackRoot) {
     const manifestPaths = [
@@ -824,71 +1073,6 @@ async function resolveCodexSkillsRelativeRoot(plugin, marketplaceFallbackRoot) {
     }
     return normalized;
 }
-async function buildBundledCodexSkillWrites(options) {
-    const relativeRoot = await resolveCodexSkillsRelativeRoot(options.plugin);
-    const sourceRoot = path.join(options.plugin.rootDir, ...relativeRoot.split('/'));
-    if (!await fs.pathExists(sourceRoot))
-        return [];
-    const dynamicKeys = new Set((options.plugin.manifest.artifacts?.targets ?? [])
-        .filter((target) => target.target === 'codex.skill' && target.skillKey)
-        .map((target) => target.skillKey));
-    const targetRoot = options.scope === 'project'
-        ? path.join(options.repoRoot, '.agents', 'skills')
-        : path.join(options.marketplaceRoot ?? resolveAwHome(options.env), 'plugins', options.plugin.manifest.name, ...relativeRoot.split('/'));
-    const writes = [];
-    for (const entry of await fs.readdir(sourceRoot, { withFileTypes: true })) {
-        if (entry.isSymbolicLink()) {
-            throw new Error(`Codex skills source 不能包含符号链接：${entry.name}`);
-        }
-        if (!entry.isDirectory() || dynamicKeys.has(entry.name))
-            continue;
-        const skillSource = path.join(sourceRoot, entry.name);
-        if (!await fs.pathExists(path.join(skillSource, 'SKILL.md')))
-            continue;
-        const tree = await createCodexSkillExpectedTree({
-            artifact: {
-                target: 'codex.skill',
-                skillKey: entry.name,
-                state: 'present',
-                content: { files: {} },
-            },
-            sourceDirs: [skillSource],
-        });
-        const skillPath = path.join(targetRoot, entry.name);
-        const canRecoverPristine = options.scope === 'user'
-            && path.resolve(skillSource) !== path.resolve(skillPath);
-        const identity = ownerIdentity(options.plugin.manifest.name, entry.name, 'codex', options.scope);
-        const component = pathComponent({
-            kind: 'skill-directory',
-            path: skillPath,
-            allowedRoot: targetRoot,
-            identity,
-            ...(canRecoverPristine
-                ? {
-                    unownedIsPristine: (actualPath) => skillDirectoryMatchesExpectedTree(actualPath, tree),
-                }
-                : {}),
-        });
-        writes.push({
-            artifact: {
-                path: skillPath,
-                paths: Object.keys(tree.files).map((relativePath) => path.join(skillPath, relativePath)),
-                kind: 'skill',
-                platform: 'codex',
-                artifactKey: entry.name,
-            },
-            component,
-            write: async () => {
-                await writeDynamicSkillTree(skillPath, tree, {
-                    allowedRoot: targetRoot,
-                    identity,
-                    allowPristineUnowned: canRecoverPristine,
-                });
-            },
-        });
-    }
-    return writes;
-}
 async function buildClaudeWrites(options) {
     const paths = resolveClaudePaths(options.cwd, options.scope, options.env);
     const writes = [];
@@ -903,7 +1087,10 @@ async function buildClaudeWrites(options) {
             artifact,
             sourceDirs: dynamic.sourceDirs(artifact),
             requireReadme: true,
+            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',
@@ -931,13 +1118,20 @@ async function buildClaudeWrites(options) {
             scope: options.scope,
             settingsPath: paths.settingsPath,
         });
+        const desiredPermissions = mergeClaudePermissions(permissions);
+        const mutation = { kind: 'claude-permissions', permissions: desiredPermissions };
         writes.push({
             artifact: { path: paths.settingsPath, kind: 'permission', platform: 'claude' },
             component,
-            write: async () => {
-                const settings = await readClaudeSettings(paths.settingsPath);
-                rebuildClaudePermissions(settings, createSharedOwnerToken(component.identity), mergeClaudePermissions(permissions));
-                await writeClaudeSettings(paths.settingsPath, settings);
+            action: {
+                kind: 'updateSharedConfig',
+                pluginId: pluginActionId(options.plugin),
+                platform: 'claude',
+                scope: options.scope,
+                owner: component.identity,
+                locator: component.locator,
+                mutation,
+                contentDigest: `sha256:${crypto.createHash('sha256').update(JSON.stringify(mutation)).digest('hex')}`,
             },
         });
     }
@@ -955,23 +1149,18 @@ async function buildCodexWrites(options) {
     const dynamicRoles = dynamic.artifacts.filter((entry) => entry.target === 'codex.agentRole');
     const dynamicSkills = dynamic.artifacts.filter((entry) => entry.target === 'codex.skill');
     const repoRoot = await resolveRepoRoot(options.cwd);
-    writes.push(...await buildBundledCodexSkillWrites({
-        plugin: options.plugin,
-        scope: options.scope,
-        repoRoot,
-        env: options.env,
-        marketplaceRoot: options.marketplaceRoot,
-    }));
-    const relativeSkillsRoot = await resolveCodexSkillsRelativeRoot(options.plugin);
     const skillRoot = options.scope === 'user'
-        ? path.join(options.marketplaceRoot ?? resolveAwHome(options.env), 'plugins', options.plugin.manifest.name, ...relativeSkillsRoot.split('/'))
+        ? path.join(getCodexHome(options.env), 'skills')
         : path.join(repoRoot, '.agents', 'skills');
     for (const artifact of dynamicSkills) {
         const tree = await createCodexSkillExpectedTree({
             artifact,
             sourceDirs: dynamic.sourceDirs(artifact),
             requireReadme: true,
+            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',
@@ -984,7 +1173,6 @@ async function buildCodexWrites(options) {
     const staticInstructions = dynamicInstructions.length > 0
         ? []
         : resolvePlatformEntries(options.plugin.manifest.extensions?.instructions, 'codex');
-    const mcpServers = await resolveCodexMcpServers(options.plugin, options.scope);
     const hasInstructionOutput = dynamicInstructions.length > 0 || staticInstructions.length > 0;
     if (hasInstructionOutput) {
         const component = createCodexInstructionComponent({
@@ -1005,6 +1193,7 @@ async function buildCodexWrites(options) {
                     value: renderCodexManagedInstructionBlock(options.plugin.manifest.name, staticInstructions),
                 }
                 : undefined;
+        const instructionMutation = { kind: 'codex-instruction', ...(block ? { block } : {}) };
         for (const artifact of dynamicInstructions.length > 0 ? dynamicInstructions : [{
                 id: undefined,
                 target: undefined,
@@ -1026,42 +1215,20 @@ async function buildCodexWrites(options) {
                     ...(artifact.disabledReason ? { disabledReason: artifact.disabledReason } : {}),
                 },
                 ...(block ? { component } : {}),
-                write: async () => {
-                    await applyCodexConfigTransactionFile(paths.configTomlPath, block
-                        ? { upsertManagedInstructionBlock: block }
-                        : { removeManagedInstructionPluginName: createSharedOwnerToken(component.identity) });
+                action: {
+                    kind: 'updateSharedConfig',
+                    pluginId: pluginActionId(options.plugin),
+                    platform: 'codex',
+                    scope: options.scope,
+                    owner: component.identity,
+                    locator: component.locator,
+                    mutation: instructionMutation,
+                    contentDigest: `sha256:${crypto.createHash('sha256')
+                        .update(JSON.stringify(instructionMutation)).digest('hex')}`,
                 },
             });
         }
     }
-    for (const [serverKey, server] of Object.entries(mcpServers)) {
-        const component = createCodexMcpComponent({
-            identity: pluginOwnerIdentity(options.plugin, internalArtifactKey('mcp', serverKey), 'codex', options.scope),
-            scope: options.scope,
-            configPath: paths.configTomlPath,
-            serverKey,
-            owned: false,
-        });
-        writes.push({
-            artifact: {
-                path: paths.configTomlPath,
-                kind: 'mcpServer',
-                platform: 'codex',
-                artifactKey: serverKey,
-            },
-            component,
-            write: async () => {
-                await applyConditionalCodexConfigTransactionFile(paths.configTomlPath, (snapshot) => {
-                    const actual = snapshot.mcpServers[serverKey];
-                    const actualOwner = codexMcpOwner(actual);
-                    if (actual && actualOwner !== createSharedOwnerToken(component.identity)) {
-                        throw new Error(`Codex MCP server "${serverKey}" is foreign and cannot be overwritten by plugin "${options.plugin.manifest.name}".`);
-                    }
-                    return { upsertMcpServers: { [serverKey]: server } };
-                });
-            },
-        });
-    }
     for (const artifact of dynamicRoles) {
         const roleKey = artifact.roleKey;
         const rolePath = path.join(paths.configDir, 'agents', `${buildGeneratedName(options.plugin.manifest.name, roleKey)}.toml`);
@@ -1102,41 +1269,51 @@ async function buildCodexWrites(options) {
             },
             ...(present ? { component: roleComponent } : {}),
             ...(present ? { additionalComponents: [registrationComponent] } : {}),
-            write: async () => {
-                if (!present) {
-                    return;
-                }
-                await fs.ensureDir(paths.configDir);
-                await writeOwnedTextFile({
-                    path: rolePath,
-                    allowedRoot: paths.configDir,
-                    identity: roleComponent.identity,
-                    content: renderCodexRole({
+            ...(present ? {
+                action: (() => {
+                    const content = renderCodexRole({
                         roleKey,
                         description: description,
                         developerInstructions: roleFile.developer_instructions,
                         model: roleFile.model,
                         modelReasoningEffort: roleFile.model_reasoning_effort,
-                    }),
-                });
-                const registration = {
-                    description,
-                    configFile: path.relative(path.dirname(paths.configTomlPath), rolePath).split(path.sep).join('/'),
-                };
-                await applyConditionalCodexConfigTransactionFile(paths.configTomlPath, async (snapshot) => {
-                    const actual = snapshot.agents[roleKey];
-                    if (actual && !await codexRoleRegistrationOwned({
-                        fileIdentity: roleComponent.identity,
-                        configPath: paths.configTomlPath,
-                        roleKey,
-                        rolePath,
-                        registration: actual,
-                    })) {
-                        throw new Error(`Codex agent registration "${roleKey}" is foreign and cannot be overwritten by plugin "${options.plugin.manifest.name}".`);
-                    }
-                    return { upsertAgentRegistrations: { [roleKey]: registration } };
-                });
-            },
+                    });
+                    return {
+                        kind: 'writeOwnedArtifact',
+                        pluginId: pluginActionId(options.plugin),
+                        platform: 'codex',
+                        scope: options.scope,
+                        path: rolePath,
+                        allowedRoot: paths.configDir,
+                        owner: roleComponent.identity,
+                        artifactKind: 'owned-text-file',
+                        sourceContent: content,
+                        content,
+                        contentDigest: `sha256:${crypto.createHash('sha256').update(content).digest('hex')}`,
+                    };
+                })(),
+            } : {}),
+            ...(present ? {
+                additionalActions: [(() => {
+                        const mutation = {
+                            kind: 'codex-role-registration',
+                            roleKey,
+                            configFile: path.relative(path.dirname(paths.configTomlPath), rolePath),
+                            description: description,
+                        };
+                        return {
+                            kind: 'updateSharedConfig',
+                            pluginId: pluginActionId(options.plugin),
+                            platform: 'codex',
+                            scope: options.scope,
+                            owner: registrationComponent.identity,
+                            locator: registrationComponent.locator,
+                            mutation,
+                            contentDigest: `sha256:${crypto.createHash('sha256')
+                                .update(JSON.stringify(mutation)).digest('hex')}`,
+                        };
+                    })()],
+            } : {}),
         });
     }
     for (const artifact of generateCodexPermissionArtifacts(options.plugin.manifest.name, resolvePlatformEntries(options.plugin.manifest.extensions?.permissions, 'codex'))) {
@@ -1161,42 +1338,44 @@ async function buildCodexWrites(options) {
             kind: 'agent',
         }));
     }
-    if (options.scope === 'project') {
-        const hooks = resolvePlatformHookDefinitions(options.plugin.manifest, 'codex');
-        for (const rawIdentity of extractCodexHookGroups(hooks)) {
-            const identity = ownedCodexHookIdentity({
-                pluginName: options.plugin.manifest.name,
-                sourceId: options.plugin.sourceId,
-                sourceIdentity: options.plugin.sourceIdentity,
-                pluginId: options.plugin.pluginId,
-                scope: options.scope,
-                identity: rawIdentity,
-            });
-            const component = createCodexHookComponent({
-                pluginName: options.plugin.manifest.name,
-                scope: options.scope,
-                hooksPath: paths.hooksPath,
-                identity,
-            });
-            writes.push({
-                artifact: {
-                    path: paths.hooksPath,
-                    kind: 'hook',
-                    platform: 'codex',
-                    hookGroups: [identity],
-                },
-                component,
-                write: async () => {
-                    await applyCodexHookGroupsTransactionFile(paths.hooksPath, (parsed) => {
-                        const serialized = serializeTrackedHookGroupIdentity(identity);
-                        const exists = parsed.managedIdentities.some((entry) => serializeTrackedHookGroupIdentity(entry) === serialized);
-                        return exists
-                            ? null
-                            : [...parsed.rawGroups, renderCodexSharedHookGroup(identity)];
-                    });
-                },
-            });
-        }
+    const codexPluginId = `${options.plugin.manifest.name}@${options.marketplaceName ?? options.plugin.marketplaceName ?? MARKETPLACE_NAME}`;
+    const nativeSurface = analyzeCodexSurface(options.plugin.manifest).nativeKinds.length > 0;
+    const userActivationDesired = options.scope === 'user'
+        || options.userActivationDesired?.has(codexPluginId) === true;
+    for (const activation of !nativeSurface ? [] : options.scope === 'project'
+        ? [
+            {
+                scope: 'user',
+                desired: userActivationDesired,
+                configPath: resolveCodexPaths(options.cwd, 'user', options.env).configTomlPath,
+            },
+            { scope: 'project', desired: true, configPath: paths.configTomlPath },
+        ]
+        : [{ scope: 'user', desired: true, configPath: paths.configTomlPath }]) {
+        const component = createCodexActivationComponent({
+            identity: pluginOwnerIdentity(options.plugin, internalArtifactKey('activation', activation.scope), 'codex', options.scope),
+            configPath: activation.configPath,
+            codexPluginId,
+            desired: activation.desired,
+        });
+        writes.push({
+            artifact: {
+                path: activation.configPath,
+                kind: 'instruction',
+                platform: 'codex',
+                artifactKey: internalArtifactKey('activation', activation.scope),
+            },
+            component,
+            action: {
+                kind: 'setActivation',
+                pluginId: pluginActionId(options.plugin),
+                platform: 'codex',
+                scope: activation.scope,
+                enabled: activation.desired,
+                configPath: activation.configPath,
+                registration: codexPluginId,
+            },
+        });
     }
     return writes;
 }
@@ -1222,7 +1401,6 @@ async function buildInspectionWrites(options) {
                     scope: options.scope,
                     settingsPath: paths.settingsPath,
                 }),
-                write: async () => undefined,
             });
         }
         for (const target of options.plugin.manifest.artifacts?.targets ?? []) {
@@ -1253,20 +1431,12 @@ async function buildInspectionWrites(options) {
                 ...(target.states.includes('present') && target.states.includes('disabled')
                     ? { optional: true }
                     : {}),
-                write: async () => undefined,
             });
         }
         return writes;
     }
     const paths = resolveCodexPaths(options.cwd, options.scope, options.env);
     const repoRoot = await resolveRepoRoot(options.cwd);
-    writes.push(...await buildBundledCodexSkillWrites({
-        plugin: options.plugin,
-        scope: options.scope,
-        repoRoot,
-        env: options.env,
-        marketplaceRoot: options.marketplaceRoot,
-    }));
     const instructions = resolvePlatformEntries(options.plugin.manifest.extensions?.instructions, 'codex');
     const targets = (options.plugin.manifest.artifacts?.targets ?? []).filter((target) => target.platform === 'codex' && target.scopes.includes(options.scope));
     const instructionTargets = targets.filter((target) => target.target === 'codex.developerInstructionsBlock');
@@ -1283,35 +1453,16 @@ async function buildInspectionWrites(options) {
                 configPath: paths.configTomlPath,
             }),
             ...(instructions.length === 0 && instructionOptional ? { optional: true } : {}),
-            write: async () => undefined,
-        });
-    }
-    const mcpServers = await resolveCodexMcpServers(options.plugin, options.scope);
-    for (const serverKey of Object.keys(mcpServers)) {
-        writes.push({
-            artifact: {
-                path: paths.configTomlPath,
-                kind: 'mcpServer',
-                platform: 'codex',
-                artifactKey: serverKey,
-            },
-            component: createCodexMcpComponent({
-                identity: pluginOwnerIdentity(options.plugin, internalArtifactKey('mcp', serverKey), 'codex', options.scope),
-                scope: options.scope,
-                configPath: paths.configTomlPath,
-                serverKey,
-                owned: false,
-            }),
-            write: async () => undefined,
         });
     }
-    const relativeSkillsRoot = await resolveCodexSkillsRelativeRoot(options.plugin);
     const dynamicSkillRoot = options.scope === 'user'
-        ? path.join(options.marketplaceRoot ?? resolveAwHome(options.env), 'plugins', options.plugin.manifest.name, ...relativeSkillsRoot.split('/'))
+        ? path.join(getCodexHome(options.env), 'skills')
         : path.join(repoRoot, '.agents', 'skills');
     for (const target of targets) {
         const state = target.states.includes('present') ? 'present' : 'disabled';
-        if (target.target === 'codex.skill' && target.skillKey) {
+        if (target.target === 'codex.skill'
+            && target.delivery?.mode === 'aw-extension'
+            && target.skillKey) {
             const skillPath = path.join(dynamicSkillRoot, target.skillKey);
             const component = pathComponent({
                 kind: 'skill-directory',
@@ -1333,7 +1484,6 @@ async function buildInspectionWrites(options) {
                 ...(target.states.includes('present') && target.states.includes('disabled')
                     ? { optional: true }
                     : {}),
-                write: async () => undefined,
             });
         }
         if (target.target === 'codex.agentRole' && target.roleKey) {
@@ -1368,7 +1518,6 @@ async function buildInspectionWrites(options) {
                 ...(target.states.includes('present') && target.states.includes('disabled')
                     ? { optional: true }
                     : {}),
-                write: async () => undefined,
             });
         }
     }
@@ -1392,32 +1541,34 @@ async function buildInspectionWrites(options) {
             kind: 'agent',
         }));
     }
-    if (options.scope === 'project') {
-        for (const rawIdentity of extractCodexHookGroups(resolvePlatformHookDefinitions(options.plugin.manifest, 'codex'))) {
-            const identity = ownedCodexHookIdentity({
-                pluginName: options.plugin.manifest.name,
-                sourceId: options.plugin.sourceId,
-                sourceIdentity: options.plugin.sourceIdentity,
-                pluginId: options.plugin.pluginId,
-                scope: options.scope,
-                identity: rawIdentity,
-            });
-            writes.push({
-                artifact: {
-                    path: paths.hooksPath,
-                    kind: 'hook',
-                    platform: 'codex',
-                    hookGroups: [identity],
-                },
-                component: createCodexHookComponent({
-                    pluginName: options.plugin.manifest.name,
-                    scope: options.scope,
-                    hooksPath: paths.hooksPath,
-                    identity,
-                }),
-                write: async () => undefined,
-            });
-        }
+    const nativeSurface = analyzeCodexSurface(options.plugin.manifest).nativeKinds.length > 0;
+    const codexPluginId = `${options.plugin.manifest.name}@${options.marketplaceName ?? options.plugin.marketplaceName ?? MARKETPLACE_NAME}`;
+    const userActivationDesired = options.scope === 'user'
+        || options.userActivationDesired?.has(codexPluginId) === true;
+    for (const activation of !nativeSurface ? [] : options.scope === 'project'
+        ? [
+            {
+                scope: 'user',
+                desired: userActivationDesired,
+                configPath: resolveCodexPaths(options.cwd, 'user', options.env).configTomlPath,
+            },
+            { scope: 'project', desired: true, configPath: paths.configTomlPath },
+        ]
+        : [{ scope: 'user', desired: true, configPath: paths.configTomlPath }]) {
+        writes.push({
+            artifact: {
+                path: activation.configPath,
+                kind: 'instruction',
+                platform: 'codex',
+                artifactKey: internalArtifactKey('activation', activation.scope),
+            },
+            component: createCodexActivationComponent({
+                identity: pluginOwnerIdentity(options.plugin, internalArtifactKey('activation', activation.scope), 'codex', options.scope),
+                configPath: activation.configPath,
+                codexPluginId,
+                desired: activation.desired,
+            }),
+        });
     }
     return writes;
 }
@@ -1430,7 +1581,6 @@ async function buildHistoricalComponents(options) {
         ...ownerIdentity(options.pluginName, artifactKey, options.platform, options.scope),
         ...(options.sourceId ? {
             sourceId: options.sourceId,
-            sourceIdentity: options.sourceIdentity,
             pluginId: options.pluginId,
         } : {}),
     });
@@ -1439,24 +1589,35 @@ async function buildHistoricalComponents(options) {
             continue;
         if (artifact.state === 'disabled')
             continue;
-        if (artifact.kind === 'hook' && options.platform === 'codex') {
+        if (options.platform === 'codex'
+            && artifact.artifactKey !== undefined
+            && new Set([
+                internalArtifactKey('activation', 'user'),
+                internalArtifactKey('activation', 'project'),
+            ]).has(artifact.artifactKey)) {
+            continue;
+        }
+        if (options.command === 'cleanup'
+            && artifact.kind === 'hook'
+            && options.platform === 'codex') {
             for (const identity of artifact.hookGroups ?? []) {
-                components.push(createCodexHookComponent({
+                components.push(createLegacyCodexHookCleanupComponent({
                     pluginName: options.pluginName,
                     scope: options.scope,
-                    hooksPath: resolveCodexPaths(options.cwd, options.scope, options.env).hooksPath,
+                    hooksPath: path.join(resolveCodexPaths(options.cwd, options.scope, options.env).configDir, 'hooks.json'),
                     identity,
                 }));
             }
             continue;
         }
-        if (artifact.kind === 'mcpServer' && options.platform === 'codex' && artifact.artifactKey) {
-            components.push(createCodexMcpComponent({
+        if (options.command === 'cleanup'
+            && artifact.kind === 'mcpServer'
+            && options.platform === 'codex'
+            && artifact.artifactKey) {
+            components.push(createLegacyCodexMcpCleanupComponent({
                 identity: historicalIdentity(internalArtifactKey('mcp', artifact.artifactKey)),
-                scope: options.scope,
                 configPath: resolveCodexPaths(options.cwd, options.scope, options.env).configTomlPath,
                 serverKey: artifact.artifactKey,
-                owned: false,
             }));
             continue;
         }
@@ -1500,230 +1661,519 @@ async function buildHistoricalComponents(options) {
     }
     return components;
 }
-function isAbsentCodexResiduePath(error) {
+function isAbsentPath(error) {
     const code = error.code;
     return code === 'ENOENT';
 }
+async function lstatIfPresent(filePath) {
+    return fs.lstat(filePath).catch((error) => {
+        if (isAbsentPath(error))
+            return null;
+        throw error;
+    });
+}
 async function lstatCodexResidueIfPresent(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 });
+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 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 configEntry = config.snapshot.plugins[pluginId];
-    if (configEntry) {
-        (canonicalMarketplace ? labels : foreignLabels).push(`${configPath}#plugins.${pluginId}`);
-    }
-    const inspectManifest = async (manifestPath, 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);
-    };
-    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, entry.name);
-    }
-    const installedStats = await lstatCodexResidueIfPresent(installedRoot);
-    if (installedStats && (!installedStats.isDirectory() || installedStats.isSymbolicLink())) {
-        foreignLabels.push(installedRoot);
-    }
-    else if (installedStats) {
-        await inspectManifest(installedManifest);
-    }
-    return foreignLabels.length > 0
-        ? {
-            state: 'foreign', labels: [...labels, ...foreignLabels], versions: [...versions],
-            enabled: configEntry?.enabled === true,
-        }
-        : labels.length > 0
-            ? { state: 'present', labels, versions: [...versions], enabled: configEntry?.enabled === true }
-            : { state: 'absent', labels: [], versions: [], enabled: false };
-}
-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) {
-        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);
+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;
+    const pending = [payloadRoot];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        for (const entry of await fs.readdir(current, { withFileTypes: true })) {
+            const entryPath = path.join(current, entry.name);
+            if (entry.isSymbolicLink())
+                return false;
+            if (entry.isDirectory()) {
+                pending.push(entryPath);
+            }
+            else if (!entry.isFile()) {
+                return false;
             }
-            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]);
+    return true;
+}
+class CodexNativeProjectionUnsafeError extends Error {
+}
+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 CodexNativeProjectionUnsafeError('codexNativeSkillsRootInvalid: Codex native Skills root is invalid.');
+    }
+    const root = path.join(payloadRoot, ...relativeRoot.split('/'));
+    if (!await codexReadPathSafe(payloadRoot, root)) {
+        throw new CodexNativeProjectionUnsafeError('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'
+        && target.delivery?.mode === 'codex-native');
+}
+async function readCodexNativeRenderReceiptEvidence(payloadRoot) {
+    const receiptPath = path.join(payloadRoot, CODEX_NATIVE_RENDER_RECEIPT_PATH);
+    const stats = await lstatIfPresent(receiptPath);
+    if (!stats)
+        return { state: 'absent' };
+    if (!stats.isFile() || stats.isSymbolicLink())
+        return { state: 'unsafe' };
+    let content;
+    try {
+        content = await fs.readFile(receiptPath, 'utf8');
+    }
+    catch {
+        return { state: 'unreadable' };
+    }
+    try {
+        return { state: 'present', receipt: parseCodexNativeRenderReceipt(content) };
+    }
+    catch {
+        return { state: 'invalid' };
+    }
+}
+function codexNativeRenderEvidenceIssue(reason, diagnostic) {
+    return { state: 'issue', reason, diagnostic };
+}
+async function readCodexNativeProjectionManifest(manifestPath) {
+    let stats;
+    try {
+        stats = await lstatIfPresent(manifestPath);
+    }
+    catch {
+        return { state: 'unreadable' };
+    }
+    if (!stats)
+        return { state: 'missing' };
+    if (!stats.isFile() || stats.isSymbolicLink())
+        return { state: 'unsafe' };
+    try {
+        const value = await fs.readJson(manifestPath);
+        return typeof value === 'object' && value !== null && !Array.isArray(value)
+            ? { state: 'present', value: value }
+            : { state: 'invalid' };
+    }
+    catch (error) {
+        return { state: error instanceof SyntaxError ? 'invalid' : 'unreadable' };
+    }
+}
+async function resolveCodexNativeRenderExpectedEvidence(options) {
+    const logicalPluginId = options.plugin.pluginId
+        ?? (options.plugin.sourceId ? `${options.plugin.sourceId}/${options.plugin.manifest.name}` : undefined);
+    if (!logicalPluginId || !options.plugin.sourceId || !options.plugin.sourceIdentity) {
+        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,
+    });
+    if (!marketplace) {
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionReceiptMissing');
+    }
+    if (marketplace.config.sourceId !== options.plugin.sourceId
+        || marketplace.config.sourceIdentity !== options.plugin.sourceIdentity
+        || marketplace.config.marketplaceName !== options.marketplaceName) {
+        return codexNativeRenderEvidenceIssue('foreign', 'projectionReceiptIdentityMismatch');
+    }
+    const payloadRoot = path.join(options.marketplaceRoot, 'plugins', options.plugin.manifest.name);
+    const payloadStats = await lstatIfPresent(payloadRoot);
+    if (!payloadStats) {
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionReceiptMissing');
+    }
+    if (!payloadStats.isDirectory() || payloadStats.isSymbolicLink()) {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+    }
+    if (!await codexPayloadPathSafe(payloadRoot, options.marketplaceRoot)) {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+    }
+    const codexManifestPath = path.join(payloadRoot, '.codex-plugin', 'plugin.json');
+    const [sourceManifestEvidence, codexManifestEvidence] = await Promise.all([
+        readCodexNativeProjectionManifest(path.join(payloadRoot, '.agents-plugin', 'plugin.json')),
+        readCodexNativeProjectionManifest(codexManifestPath),
+    ]);
+    if (sourceManifestEvidence.state === 'unsafe'
+        || codexManifestEvidence.state === 'unsafe') {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+    }
+    if ((sourceManifestEvidence.state === 'present'
+        && sourceManifestEvidence.value.name !== options.plugin.manifest.name)
+        || (codexManifestEvidence.state === 'present'
+            && codexManifestEvidence.value.name !== options.plugin.manifest.name)
+        || (sourceManifestEvidence.state === 'present'
+            && codexManifestEvidence.state === 'present'
+            && sourceManifestEvidence.value.version !== codexManifestEvidence.value.version)) {
+        return codexNativeRenderEvidenceIssue('foreign', 'manifestIdentityMismatch');
+    }
+    if (sourceManifestEvidence.state === 'unreadable'
+        || codexManifestEvidence.state === 'unreadable') {
+        return codexNativeRenderEvidenceIssue('unreadable', 'manifestUnreadable');
+    }
+    if (sourceManifestEvidence.state === 'missing'
+        || codexManifestEvidence.state === 'missing') {
+        return codexNativeRenderEvidenceIssue('damaged', 'manifestMissing');
+    }
+    if (sourceManifestEvidence.state === 'invalid'
+        || codexManifestEvidence.state === 'invalid') {
+        return codexNativeRenderEvidenceIssue('damaged', 'manifestUnreadable');
+    }
+    if (sourceManifestEvidence.state !== 'present'
+        || codexManifestEvidence.state !== 'present') {
+        return codexNativeRenderEvidenceIssue('damaged', 'manifestUnreadable');
+    }
+    const sourceManifest = sourceManifestEvidence.value;
+    const codexManifest = codexManifestEvidence.value;
+    if (typeof sourceManifest.version !== 'string'
+        || !tryParseStrictSemVer(sourceManifest.version)) {
+        return codexNativeRenderEvidenceIssue('damaged', 'manifestVersionInvalid');
+    }
+    const rawSkillsRoot = typeof codexManifest.skills === 'string' && codexManifest.skills.trim() !== ''
+        ? codexManifest.skills
+        : './codex/skills';
+    const { relativeRoot: skillsRelativeRoot } = await resolveCodexSkillsRoot(payloadRoot, rawSkillsRoot);
+    const skillsRoot = path.join(payloadRoot, ...skillsRelativeRoot.split('/'));
+    const skillsRootStats = await lstatIfPresent(skillsRoot);
+    if (skillsRootStats && (!skillsRootStats.isDirectory() || skillsRootStats.isSymbolicLink())) {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+    }
+    const targets = codexNativeRenderTargets(options.plugin);
+    for (const target of targets) {
+        if (await lstatIfPresent(path.join(skillsRoot, target.skillKey, '.agent-workflows-owner.json'))) {
+            return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
         }
-        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 receiptEvidence = await readCodexNativeRenderReceiptEvidence(payloadRoot);
+    if (receiptEvidence.state === 'absent') {
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionReceiptMissing');
+    }
+    if (receiptEvidence.state === 'unsafe') {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+    }
+    if (receiptEvidence.state === 'invalid') {
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionReceiptUnreadable');
+    }
+    if (receiptEvidence.state === 'unreadable') {
+        return codexNativeRenderEvidenceIssue('unreadable', 'projectionReceiptUnreadable');
+    }
+    const receipt = receiptEvidence.receipt;
+    if (receipt.logicalPluginId !== logicalPluginId
+        || receipt.strategy !== 'shared-user'
+        || receipt.sourceIdentity !== marketplace.config.sourceIdentity
+        || receipt.pluginVersion !== sourceManifest.version) {
+        return codexNativeRenderEvidenceIssue('foreign', 'projectionReceiptIdentityMismatch');
+    }
+    const emptyArtifactDigest = createCodexSkillStagingTreeContentDigest({
+        skillKey: 'empty',
+        files: {},
+    });
+    for (const receiptTarget of receipt.targets) {
+        const skillRoot = path.join(payloadRoot, ...skillsRelativeRoot.split('/'), receiptTarget.skillKey);
+        if (await lstatIfPresent(path.join(skillRoot, '.agent-workflows-owner.json'))) {
+            return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
         }
-        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]);
+        const skillStats = await lstatIfPresent(skillRoot);
+        if (skillStats && (!skillStats.isDirectory() || skillStats.isSymbolicLink())) {
+            return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
         }
-        let rawManifest;
+        let tree;
         try {
-            rawManifest = await fs.readJson(manifestPath);
+            tree = skillStats ? await readDynamicSkillTree(skillRoot, 'codex.skill') : null;
         }
         catch (error) {
-            throw new CodexNativeResidueProbeError(manifestPath, error, match[1]);
+            return codexNativeRenderEvidenceIssue(error instanceof Error && typeof error.code !== 'string'
+                ? 'damaged'
+                : 'unreadable', 'projectionPayloadDigestMismatch');
         }
-        if (!rawManifest || typeof rawManifest !== 'object' || Array.isArray(rawManifest)) {
-            probeFailure(manifestPath, new Error('Codex installed residue manifest must be an object.'), match[1]);
+        const artifactDigest = tree
+            ? createCodexSkillStagingTreeContentDigest(tree)
+            : emptyArtifactDigest;
+        if (artifactDigest !== receiptTarget.artifactDigest) {
+            return codexNativeRenderEvidenceIssue('damaged', 'projectionPayloadDigestMismatch');
         }
-        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;
+    const payloadDigest = await calculateCodexNativeRenderPayloadDigest(payloadRoot);
+    if (payloadDigest !== receipt.payloadDigest) {
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionPayloadDigestMismatch');
     }
-}
-async function ensureCodexActiveSkillsManifest(options) {
-    const relativeSkillsRoot = await resolveCodexSkillsRelativeRoot(options.plugin);
-    const skillsRoot = path.join(options.marketplaceRoot, 'plugins', options.plugin.manifest.name, ...relativeSkillsRoot.split('/'));
-    if (options.hasRequiredSkills && !await fs.pathExists(skillsRoot)) {
-        throw new Error(`Codex required Skills root 不存在：${skillsRoot}`);
+    const receiptTargets = new Map(receipt.targets.map((target) => [target.id, target]));
+    if (targets.length === 0
+        || targets.length !== receipt.targets.length
+        || targets.some((target) => receiptTargets.get(target.id)?.skillKey !== target.skillKey)) {
+        return { state: 'present', payloadDigest, receipt, sourceProjection: 'drifted' };
     }
-    const manifestPath = path.join(options.marketplaceRoot, 'plugins', options.plugin.manifest.name, '.codex-plugin', 'plugin.json');
-    const manifest = await fs.readJson(manifestPath).catch((error) => {
-        if (error.code === 'ENOENT')
-            return {};
-        throw error;
+    const renderer = await resolveArtifactRendererTarget(options.plugin);
+    if (renderer.noOp || !renderer.rendererDigest) {
+        throw new Error('Codex native render projection requires an artifact renderer.');
+    }
+    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',
+        cwd: options.plugin.rootDir,
+        env: options.env,
     });
-    const updated = {
+    if (config.issues.length > 0) {
+        throw new Error(`Invalid AW config for ${options.plugin.manifest.name}.`);
+    }
+    const projection = createCodexNativeRenderProjection({
+        logicalPluginId,
+        sourceIdentity: options.plugin.sourceIdentity,
+        pluginVersion: options.plugin.manifest.version,
+        rendererDigest: renderer.rendererDigest,
+        targets: targets.map((target) => ({
+            id: target.id,
+            skillKey: target.skillKey,
+            configDigest: createArtifactConfigDigest({
+                artifact: {
+                    id: target.id,
+                    platform: 'codex',
+                    target: 'codex.skill',
+                    refreshKeys: target.refreshKeys,
+                },
+                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';
+    }
+    if (observation.state === 'unobserved')
+        return 'partial';
+    throw new Error(`codexNativeObservationFailed: ${operation} requires Codex plugin list evidence.`);
+}
+function requireObservedCodexNativeState(observation, operation) {
+    if (observation.state === 'observed')
+        return observation.value;
+    const code = observation.state === 'failed'
+        ? 'codexNativeObservationFailed'
+        : 'codexNativeObservationUnavailable';
+    throw new Error(`${code}: ${operation} requires Codex plugin list evidence.`);
+}
+export async function inspectCodexPluginRegistrationLive(options) {
+    if (!options.nativeCliRunner) {
+        return {
+            observation: { state: 'unobserved' },
+            observations: { user: false, project: false },
+            activations: {},
+        };
+    }
+    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 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';
+    const dynamicProjectionExpected = options.nativeRenderPlugin !== undefined
+        && codexNativeRenderTargets(options.nativeRenderPlugin).length > 0;
+    if (inspectionMode === 'payload'
+        && options.expectedPayloadDigest === undefined
+        && !dynamicProjectionExpected) {
+        throw new Error('Payload inspection requires the expected shared native digest.');
+    }
+    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 pluginList = options.pluginRegistration ?? await inspectCodexPluginRegistrationLive({
+        pluginId,
+        cwd: options.cwd,
+        env: options.env,
+        nativeCliRunner: options.nativeCliRunner,
+        manager: options.manager,
+        scope: options.observationScope,
+        observationSession: options.observationSession,
+    });
+    let expectedPayloadDigest = dynamicProjectionExpected ? undefined : options.expectedPayloadDigest;
+    let sourceProjection;
+    let sourceProjectionIssue;
+    const installed = pluginList.observation.state === 'observed'
+        && pluginList.observation.value === 'installed';
+    if (installed && dynamicProjectionExpected && options.nativeRenderPlugin) {
+        try {
+            const expected = await resolveCodexNativeRenderExpectedEvidence({
+                plugin: options.nativeRenderPlugin,
+                marketplaceRoot,
+                marketplaceName,
+                env: options.env,
+            });
+            if (expected.state === 'issue') {
+                sourceProjectionIssue = expected;
+            }
+            else {
+                expectedPayloadDigest = expected.payloadDigest;
+                sourceProjection = expected.sourceProjection;
+            }
+        }
+        catch (error) {
+            if (error instanceof MarketplaceRootValidationError) {
+                sourceProjectionIssue = {
+                    reason: error.reason === 'unsafe'
+                        ? 'foreign'
+                        : error.reason === 'invalid' ? 'damaged' : 'unreadable',
+                    diagnostic: error.reason === 'unsafe'
+                        ? 'payloadPathUnsafe'
+                        : 'projectionReceiptUnreadable',
+                };
+            }
+            else {
+                sourceProjectionIssue = {
+                    reason: error instanceof CodexNativeProjectionUnsafeError ? 'foreign' : 'unreadable',
+                    diagnostic: error instanceof CodexNativeProjectionUnsafeError
+                        ? 'payloadPathUnsafe'
+                        : 'projectionReceiptUnreadable',
+                };
+            }
+        }
+    }
+    const sharedNative = inspectCodexSharedNative({
+        pluginName: options.pluginName,
+        pluginId,
+        marketplaceName,
+        canonicalMarketplaceRoot: marketplaceRoot,
+        desiredVersion: options.desiredVersion,
+        expectedPayloadDigest,
+        marketplaceRegistration: config.snapshot.marketplaces[marketplaceName],
+        marketplacePathSafe,
+        observation: pluginList.observation,
+        ...(sourceProjection ? { sourceProjection } : {}),
+        ...(sourceProjectionIssue ? { sourceProjectionIssue } : {}),
+    });
+    return {
+        sharedNative,
+        ...(expectedPayloadDigest ? { expectedPayloadDigest } : {}),
+    };
+}
+async function ensureCodexActiveSkillsManifest(options) {
+    const relativeSkillsRoot = await resolveCodexSkillsRelativeRoot(options.plugin);
+    const skillsRoot = path.join(options.marketplaceRoot, 'plugins', options.plugin.manifest.name, ...relativeSkillsRoot.split('/'));
+    if (options.hasRequiredSkills && !await fs.pathExists(skillsRoot)) {
+        throw new Error(`Codex required Skills root 不存在：${skillsRoot}`);
+    }
+    const manifestPath = path.join(options.marketplaceRoot, 'plugins', options.plugin.manifest.name, '.codex-plugin', 'plugin.json');
+    const manifest = await fs.readJson(manifestPath).catch((error) => {
+        if (error.code === 'ENOENT')
+            return {};
+        throw error;
+    });
+    const updated = {
         ...manifest,
         name: options.plugin.manifest.name,
         version: options.plugin.manifest.version,
@@ -1737,174 +2187,18 @@ async function ensureCodexActiveSkillsManifest(options) {
 }
 function createCodexMarketplaceComponent(options) {
     const configPath = resolveCodexPaths(options.cwd, 'user', options.env).configTomlPath;
-    const inspectCanonicalMarketplace = async () => {
-        const config = await readCodexConfigFile(configPath);
-        const marketplace = config.snapshot.marketplaces[options.marketplaceName];
-        if (!marketplace)
-            return 'absent';
-        if (marketplace.sourceType !== 'local'
-            || marketplace.sourcePointsToManifest
-            || path.normalize(marketplace.source ?? '') !== path.normalize(options.marketplaceRoot))
-            return 'foreign';
-        return 'present';
-    };
-    const hasRemainingPlugins = async () => {
-        return (await discoverCodexNativeResidueNames({
-            cwd: options.cwd,
-            env: options.env,
-            marketplaceName: options.marketplaceName,
-            marketplaceRoot: options.marketplaceRoot,
-        })).some((name) => name !== options.pluginName);
-    };
-    const inspect = async () => {
-        const canonical = await inspectCanonicalMarketplace();
-        const plugin = await inspectCodexNativeResidue({
-            pluginName: options.pluginName,
-            cwd: options.cwd,
-            env: options.env,
-            marketplaceName: options.marketplaceName,
-            marketplaceRoot: options.marketplaceRoot,
-        });
-        if (plugin.state === 'foreign')
-            return 'foreign';
-        if (options.desired) {
-            return canonical === 'present' && plugin.state === 'present' && plugin.enabled
-                ? 'present'
-                : 'absent';
-        }
-        if (canonical !== 'present')
-            return canonical;
-        return await hasRemainingPlugins() ? 'absent' : 'present';
-    };
     return {
         kind: 'shared-config',
         identity: ownerIdentity(options.pluginName, `marketplace-${options.marketplaceName}`, 'codex', 'user'),
         label: `${configPath}#marketplaces.${options.marketplaceName}`,
-        inspect,
-        remove: async () => {
-            const currentResidue = await inspectCodexNativeResidue({
-                pluginName: options.pluginName,
-                cwd: options.cwd,
-                env: options.env,
-                marketplaceName: options.marketplaceName,
-                marketplaceRoot: options.marketplaceRoot,
-            });
-            if (currentResidue.state === 'foreign') {
-                throw new Error(`Codex native owner 为 foreign，拒绝移除 marketplace：${currentResidue.labels.join('，')}`);
-            }
-            if (await inspectCanonicalMarketplace() !== 'present'
-                || currentResidue.state === 'present'
-                || await hasRemainingPlugins())
-                return;
-            await runNativeCliChecked(buildCodexMarketplaceRemoveInvocation(options.marketplaceName, options.cwd, options.env), options.runner);
-            await runNativeCliChecked(buildCodexMarketplaceListInvocation(options.cwd, options.env), options.runner);
+        locator: {
+            kind: 'codex-marketplace',
+            marketplaceName: options.marketplaceName,
+            marketplaceRoot: options.marketplaceRoot,
+            desired: options.desired,
         },
     };
 }
-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();
-}
 async function readJsonObjectIfExists(filePath, label) {
     let value;
     try {
@@ -2210,128 +2504,459 @@ export async function inspectNativeMarketplaceRegistrations(options) {
     return { codex, claude };
 }
 function createClaudeMarketplaceComponent(options) {
-    const inspect = async () => {
-        const state = await readClaudeNativeState(options);
-        if (state.pluginState === 'foreign')
-            return 'foreign';
-        if (options.desired) {
-            return state.marketplaceDeclaredState === 'canonical'
-                && state.marketplaceMaterializedState === 'canonical'
-                && state.pluginState === 'present'
-                && state.pluginEnabled
-                ? 'present'
-                : 'absent';
-        }
-        if (state.marketplaceState !== 'canonical')
-            return state.marketplaceState;
-        const projectPath = options.scope === 'project'
-            ? path.normalize(await resolveRepoRoot(options.cwd))
-            : undefined;
-        return state.marketplaceConsumers.some((consumer) => !(consumer.name === options.pluginName
-            && consumer.scope === options.scope
-            && (options.scope === 'user' || path.normalize(consumer.projectPath ?? '') === projectPath)))
-            ? 'absent'
-            : 'present';
-    };
     return {
         kind: 'shared-config',
         identity: ownerIdentity(options.pluginName, `marketplace-${options.marketplaceName}`, 'claude', options.scope),
         label: `${resolveClaudePaths(options.cwd, options.scope, options.env).settingsPath}#marketplaces.${options.marketplaceName}`,
-        inspect,
-        remove: async () => {
-            if (await inspect() !== 'present')
-                return;
-            const before = await readClaudeNativeState(options);
-            if (before.pluginState !== 'absent')
-                return;
-            if (before.marketplaceConsumers.length > 0)
-                return;
-            await runNativeCliChecked({
-                command: 'claude',
-                args: ['plugin', 'marketplace', 'remove', options.marketplaceName],
-                cwd: options.cwd,
-                env: options.env,
-            }, options.runner);
-            const after = await readClaudeNativeState(options);
-            if (after.marketplaceState !== 'absent') {
-                throw new Error('Claude marketplace remove 后 canonical aw source 仍存在。');
-            }
+        locator: {
+            kind: 'claude-marketplace',
+            marketplaceName: options.marketplaceName,
+            marketplaceRoot: options.marketplaceRoot,
+            desired: options.desired,
         },
     };
 }
-function createNativeVersionComponent(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 requested = options.requestedArtifactIds
+        ? new Set(options.requestedArtifactIds)
+        : undefined;
+    const targets = codexNativeRenderTargets(options.plugin)
+        .filter((target) => !requested || requested.has(target.id));
+    if (targets.length === 0)
+        return null;
+    const byScope = new Map();
+    for (const target of targets) {
+        const requestScope = target.scopes.includes('user') ? 'user' : 'project';
+        const group = byScope.get(requestScope) ?? [];
+        group.push(target);
+        byScope.set(requestScope, group);
+    }
+    const renderedArtifacts = [];
+    const receiptTargets = [];
+    const presentSkillKeys = [];
+    let rendererDigest;
+    for (const scope of ['user', 'project']) {
+        const group = byScope.get(scope);
+        if (!group || group.length === 0)
+            continue;
+        const rendered = await runArtifactRenderer({
+            event: 'install',
+            plugin: options.plugin,
+            platform: 'codex',
+            scope,
+            configScope: 'user',
+            cwd: options.plugin.rootDir,
+            commandEnv: options.env,
+            previousArtifacts: [],
+            requestedArtifactIds: group.map((target) => target.id),
+            scriptTimeoutMs: options.scriptTimeoutMs,
+        });
+        rendererDigest = rendered.target.rendererDigest;
+        const validated = validateArtifactPlan({
+            manifest: options.plugin.manifest,
+            plan: rendered.plan,
+            platform: 'codex',
+            scope,
+            requestedArtifactIds: rendered.context.requestedArtifactIds,
+            renderConfig: rendered.context.config,
+            rendererDigest: rendered.target.rendererDigest,
+            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,
+                skillKey,
+                tree,
+            });
+            if (artifact.state === 'present')
+                presentSkillKeys.push(skillKey);
+            receiptTargets.push({
+                id: artifact.id,
+                skillKey,
+                configDigest: artifact.configDigest,
+                artifactDigest: createCodexSkillStagingTreeContentDigest(tree),
+            });
+        }
+    }
+    if (!rendererDigest || renderedArtifacts.length !== targets.length) {
+        throw new Error('Codex native renderer did not produce the complete declared target set.');
+    }
+    const skillsRelativeRoot = await resolveCodexSkillsRelativeRoot(options.plugin);
+    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);
+        }
+        else {
+            await fs.remove(skillRoot);
+        }
+    }
+    await ensureCodexActiveSkillsManifest({
+        plugin: options.plugin,
+        marketplaceRoot: options.stagingRoot,
+        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: options.prepared.logicalPluginId,
+        sourceIdentity: options.prepared.sourceIdentity,
+        pluginVersion: options.plugin.manifest.version,
+        rendererDigest: options.prepared.rendererDigest,
+        targets: options.prepared.receiptTargets,
+        payloadDigest,
+    });
+    await fs.outputFile(path.join(pluginRoot, CODEX_NATIVE_RENDER_RECEIPT_PATH), serializeCodexNativeRenderReceipt(receipt), 'utf8');
     return {
-        kind: 'shared-config',
-        identity: ownerIdentity(options.pluginName, internalArtifactKey('native-version', options.pluginVersion), options.platform, options.scope),
-        label: `${options.pluginName}@${options.marketplaceName ?? MARKETPLACE_NAME}#version=${options.pluginVersion}`,
-        inspect: async () => {
-            let versions;
-            if (options.platform === 'codex') {
-                const residue = await inspectCodexNativeResidue({
-                    pluginName: options.pluginName,
-                    cwd: options.cwd,
-                    env: options.env,
-                    marketplaceName: options.marketplaceName,
-                    marketplaceRoot: options.marketplaceRoot,
+        payloadDigest,
+        projection: options.prepared.projection,
+        receipt,
+        presentSkillKeys: options.prepared.presentSkillKeys,
+        targetSkillKeys: options.prepared.targetSkillKeys,
+    };
+}
+/**
+ * Materialize only the selected Codex or Claude Skills into an isolated review root.
+ * The caller owns outputRoot and is responsible for its cleanup.
+ */
+export async function materializeReviewNativeSkills(options) {
+    if (options.skills.length === 0) {
+        throw new Error('Review materialization requires at least one selected Skill.');
+    }
+    const skillsRoot = path.join(options.outputRoot, 'skills');
+    await fs.ensureDir(skillsRoot);
+    const declarations = options.plugin.manifest.artifacts?.targets ?? [];
+    const dynamicSelections = options.skills.filter((skill) => skill.targetId !== null);
+    const selectedDeclarations = dynamicSelections.map((selection) => {
+        const matches = declarations.filter((target) => target.id === selection.targetId
+            && target.platform === options.platform
+            && target.scopes.includes(options.scope)
+            && target.skillKey === selection.skill
+            && target.target === `${options.platform}.skill`);
+        if (matches.length !== 1) {
+            throw new Error(`Selected ${options.platform} Skill target "${selection.targetId}" is missing or ambiguous.`);
+        }
+        return matches[0];
+    });
+    const selectedNames = options.skills.map((skill) => skill.skill);
+    const disabledNativeSkillNames = new Set();
+    if (new Set(selectedNames).size !== selectedNames.length) {
+        throw new Error('Review materialization selected the same Skill more than once.');
+    }
+    for (const selection of options.skills.filter((skill) => skill.targetId === null)) {
+        const sourceRoot = path.join(options.plugin.rootDir, options.platform, 'skills', selection.skill);
+        const destination = path.join(skillsRoot, selection.skill);
+        await fs.copy(sourceRoot, destination, {
+            overwrite: false,
+            errorOnExist: true,
+            dereference: false,
+        });
+    }
+    const directTargetIds = selectedDeclarations
+        .filter((target) => target.delivery?.mode !== 'codex-native')
+        .map((target) => target.id);
+    if (directTargetIds.length > 0) {
+        const dynamic = await resolveDynamicArtifacts({
+            plugin: options.plugin,
+            platform: options.platform,
+            scope: options.scope,
+            cwd: options.cwd,
+            env: options.env,
+            event: 'install',
+            previousArtifacts: [],
+            requestedArtifactIds: directTargetIds,
+            scriptTimeoutMs: options.scriptTimeoutMs,
+        });
+        for (const artifact of dynamic.artifacts) {
+            if (artifact.state !== 'present') {
+                throw new Error(`Selected Skill target "${artifact.id}" did not produce a present Skill.`);
+            }
+            if (artifact.target !== `${options.platform}.skill`) {
+                throw new Error(`Selected target "${artifact.id}" did not produce a ${options.platform} Skill.`);
+            }
+            let tree;
+            if (artifact.target === 'codex.skill') {
+                tree = await createCodexSkillExpectedTree({
+                    artifact,
+                    sourceDirs: dynamic.sourceDirs(artifact),
+                    requireReadme: true,
+                    requirementsReceipt: requirementsReceipt(options.plugin),
+                    sourceRequirementsReceiptPolicy: 'allow',
                 });
-                versions = residue.enabled && residue.state === 'present' ? residue.versions : [];
             }
-            else {
-                const state = await readClaudeNativeState({
-                    pluginName: options.pluginName,
-                    scope: options.scope,
-                    cwd: options.cwd,
-                    env: options.env,
-                    marketplaceName: options.marketplaceName,
-                    marketplaceRoot: options.marketplaceRoot,
+            else if (artifact.target === 'claude.skill') {
+                tree = await createDynamicSkillExpectedTree({
+                    artifact,
+                    sourceDirs: dynamic.sourceDirs(artifact),
+                    requireReadme: true,
+                    requirementsReceipt: requirementsReceipt(options.plugin),
+                    sourceRequirementsReceiptPolicy: 'allow',
                 });
-                versions = state.pluginEnabled && state.pluginState === 'present'
-                    ? state.pluginVersions
-                    : [];
             }
-            return versions.includes(options.pluginVersion) ? 'present' : 'absent';
-        },
-        remove: async () => undefined,
-    };
+            else {
+                throw new Error(`Selected target "${artifact.id}" is not a Skill.`);
+            }
+            assertNoSensitiveConfigInFiles(withoutVerifiedRequirementsReceipt(options.plugin, tree.files), dynamic.sensitiveValues, 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
+            await writeDynamicSkillTree(path.join(skillsRoot, tree.skillKey), tree);
+        }
+    }
+    const nativeTargetIds = selectedDeclarations
+        .filter((target) => target.delivery?.mode === 'codex-native')
+        .map((target) => target.id);
+    if (nativeTargetIds.length > 0) {
+        if (options.platform !== 'codex') {
+            throw new Error('Codex native Skill targets are only valid for the Codex platform.');
+        }
+        const marketplaceRoot = path.join(options.outputRoot, '.native-marketplace');
+        const payloadRoot = path.join(marketplaceRoot, 'plugins', options.plugin.manifest.name);
+        await fs.copy(options.plugin.rootDir, payloadRoot, {
+            overwrite: false,
+            errorOnExist: true,
+            dereference: false,
+        });
+        const prepared = await prepareCodexNativeRender({
+            plugin: options.plugin,
+            env: options.env,
+            requestedArtifactIds: nativeTargetIds,
+            scriptTimeoutMs: options.scriptTimeoutMs,
+        });
+        if (!prepared) {
+            throw new Error('Selected Codex native Skill targets did not produce a projection.');
+        }
+        const staged = await materializeCodexNativeRender({
+            plugin: options.plugin,
+            stagingRoot: marketplaceRoot,
+            prepared,
+            hasStaticSkills: options.plugin.manifest.skills !== undefined,
+        });
+        await assertNoSensitiveValuesInCodexNativePayload({
+            plugin: options.plugin,
+            payloadRoot,
+            allowedRoot: marketplaceRoot,
+            sensitiveValues: await resolveSensitiveUserConfigValues(options.plugin, options.env),
+            verifiedRenderReceipt: staged.receipt,
+        });
+        const presentSkillKeys = new Set(staged.presentSkillKeys);
+        if (options.allowDisabledNativeSkills) {
+            for (const target of selectedDeclarations.filter((entry) => entry.delivery?.mode === 'codex-native' && !presentSkillKeys.has(entry.skillKey))) {
+                disabledNativeSkillNames.add(target.skillKey);
+            }
+        }
+        for (const target of selectedDeclarations.filter((entry) => entry.delivery?.mode === 'codex-native' && presentSkillKeys.has(entry.skillKey))) {
+            const sourceRoot = path.join(payloadRoot, ...prepared.skillsRelativeRoot.split('/'), target.skillKey);
+            await fs.copy(sourceRoot, path.join(skillsRoot, target.skillKey), {
+                overwrite: false,
+                errorOnExist: true,
+                dereference: false,
+            });
+        }
+        await fs.remove(marketplaceRoot);
+    }
+    const skills = [];
+    for (const skill of selectedNames.sort((left, right) => left.localeCompare(right))) {
+        const skillRoot = path.join(skillsRoot, skill);
+        if (disabledNativeSkillNames.has(skill))
+            continue;
+        await validateSkillDirectory(skillRoot, `${options.platform}.skill`, {
+            requirementsReceiptPolicy: 'allow',
+        });
+        await validateRuntimeSkillClosure(skillRoot);
+        skills.push({ skill, path: skillRoot });
+    }
+    return { rootDir: options.outputRoot, skills };
 }
-async function mirrorCatalog(catalog, env, target) {
+async function mirrorCatalog(catalog, env, target, logicalIdentity, prepareStaging, rematerializedCodexNativePluginIds = new Set()) {
     if (!target?.sourceId || !target.marketplaceRoot) {
         const rootDir = resolveAwHome(env);
         await fs.ensureDir(rootDir);
         await fs.copy(catalog.rootDir, rootDir, { overwrite: true });
+        await prepareStaging?.(rootDir);
         return { rootDir, commit: async () => undefined, rollback: async () => undefined };
     }
     const awHome = path.resolve(resolveAwHome(env));
-    const awHomeStats = await fs.lstat(awHome).catch((error) => {
-        if (error.code === 'ENOENT')
-            return null;
-        throw error;
-    });
-    if (!awHomeStats?.isDirectory() || awHomeStats.isSymbolicLink()) {
-        throw new Error(`marketplaceRootInvalid: AW_HOME must be a regular directory: ${awHome}`);
-    }
-    const canonicalAwHome = await fs.realpath(awHome);
-    const expectedParent = path.join(canonicalAwHome, 'marketplaces');
     const destination = target.marketplaceRoot;
     const parent = path.dirname(destination);
-    if (path.resolve(parent) !== path.join(awHome, 'marketplaces')) {
-        throw new Error(`marketplaceRootInvalid: marketplace parent is not under canonical AW_HOME: ${parent}`);
+    if (!await isSafeCodexMarketplaceRoot({
+        awHome,
+        sourceId: target.sourceId,
+        marketplaceRoot: destination,
+    })) {
+        throw new Error(`marketplaceRootInvalid: marketplace root is unsafe: ${destination}`);
     }
-    let parentStats = await fs.lstat(parent).catch((error) => {
-        if (error.code === 'ENOENT')
-            return null;
-        throw error;
-    });
-    if (!parentStats) {
+    if (!await fs.pathExists(parent)) {
         await fs.mkdir(parent);
-        parentStats = await fs.lstat(parent);
     }
-    if (!parentStats.isDirectory() || parentStats.isSymbolicLink()) {
-        throw new Error(`marketplaceRootInvalid: marketplace parent must be a regular directory: ${parent}`);
-    }
-    const canonicalParent = await fs.realpath(parent);
-    if (canonicalParent !== expectedParent) {
-        throw new Error(`marketplaceRootInvalid: marketplace parent is outside canonical AW_HOME: ${parent}`);
+    if (!await isSafeCodexMarketplaceRoot({
+        awHome,
+        sourceId: target.sourceId,
+        marketplaceRoot: destination,
+    })) {
+        throw new Error(`marketplaceRootInvalid: marketplace root became unsafe: ${destination}`);
     }
     const staging = await fs.mkdtemp(path.join(parent, `.${target.sourceId}-staging-`));
     try {
@@ -2353,6 +2978,7 @@ async function mirrorCatalog(catalog, env, target) {
             schemaVersion: 2,
             sourceId: target.sourceId,
             sourceIdentity: target.sourceIdentity,
+            logicalIdentity,
             marketplaceName,
         }, { spaces: 2 });
         const destinationExists = await fs.lstat(destination).then(() => true, (error) => {
@@ -2368,7 +2994,16 @@ async function mirrorCatalog(catalog, env, target) {
                 sourceIdentity: target.sourceIdentity,
                 marketplaceName,
             });
+            await replayNamespacedCodexNativeRenderProjections({
+                sourceRoot: destination,
+                stagingRoot: staging,
+                sourceId: target.sourceId,
+                sourceIdentity: target.sourceIdentity,
+                marketplaceName,
+                rematerializedPluginIds: rematerializedCodexNativePluginIds,
+            });
         }
+        await prepareStaging?.(staging);
         const backup = `${destination}.backup-${crypto.randomUUID()}`;
         if (destinationExists)
             await fs.move(destination, backup);
@@ -2434,70 +3069,651 @@ async function mirrorCatalog(catalog, env, target) {
         throw error;
     }
 }
+async function applyPlannedOperationAction(action) {
+    switch (action.kind) {
+        case 'writeOwnedArtifact': {
+            if (!action.owner || !action.allowedRoot || !action.artifactKind) {
+                throw new Error('Owned artifact action is missing owner or locator data.');
+            }
+            if (action.artifactKind === 'owned-text-file') {
+                if (action.content === undefined)
+                    throw new Error('Owned text action is missing content.');
+                const digest = `sha256:${crypto.createHash('sha256').update(action.content).digest('hex')}`;
+                if (digest !== action.contentDigest)
+                    throw new Error('Owned text action content digest mismatch.');
+                if (action.sourceContent === undefined)
+                    throw new Error('Owned text action is missing source content.');
+                await fs.ensureDir(action.allowedRoot);
+                await writeOwnedTextFile({
+                    path: action.path,
+                    allowedRoot: action.allowedRoot,
+                    identity: action.owner,
+                    content: action.sourceContent,
+                });
+                return;
+            }
+            const files = action.files ?? [];
+            const digest = `sha256:${crypto.createHash('sha256').update(JSON.stringify(files)).digest('hex')}`;
+            if (digest !== action.contentDigest)
+                throw new Error('Skill action content digest mismatch.');
+            const treeFiles = {};
+            for (const file of files) {
+                const content = Buffer.from(file.contentBase64, 'base64');
+                if (`sha256:${crypto.createHash('sha256').update(content).digest('hex')}` !== file.contentDigest) {
+                    throw new Error(`Skill action file digest mismatch: ${file.relativePath}`);
+                }
+                if (file.relativePath !== '.agent-workflows-owner.json')
+                    treeFiles[file.relativePath] = content;
+            }
+            await writeDynamicSkillTree(action.path, {
+                skillKey: action.owner.artifactKey,
+                files: treeFiles,
+            }, {
+                allowedRoot: action.allowedRoot,
+                identity: action.owner,
+                allowPristineUnowned: action.allowPristineUnowned === true,
+            });
+            return;
+        }
+        case 'updateSharedConfig': {
+            const mutation = action.mutation;
+            switch (mutation.kind) {
+                case 'claude-permissions': {
+                    if (action.locator.kind !== 'claude-permissions')
+                        throw new Error('Claude permission locator mismatch.');
+                    const settings = await readClaudeSettings(action.locator.settingsPath);
+                    rebuildClaudePermissions(settings, action.locator.ownerKey, mutation.permissions);
+                    await writeClaudeSettings(action.locator.settingsPath, settings);
+                    return;
+                }
+                case 'codex-instruction': {
+                    if (action.locator.kind !== 'codex-instruction')
+                        throw new Error('Codex instruction locator mismatch.');
+                    await applyCodexConfigTransactionFile(action.locator.configPath, mutation.block
+                        ? { upsertManagedInstructionBlock: mutation.block }
+                        : { removeManagedInstructionPluginName: action.locator.ownerKey });
+                    return;
+                }
+                case 'codex-role-registration': {
+                    if (action.locator.kind !== 'codex-role-registration')
+                        throw new Error('Codex role locator mismatch.');
+                    const locator = action.locator;
+                    const registration = {
+                        description: mutation.description,
+                        configFile: mutation.configFile.split(path.sep).join('/'),
+                    };
+                    await applyConditionalCodexConfigTransactionFile(locator.configPath, async (snapshot) => {
+                        const actual = snapshot.agents[mutation.roleKey];
+                        if (actual && !await codexRoleRegistrationOwned({
+                            fileIdentity: locator.fileIdentity,
+                            configPath: locator.configPath,
+                            roleKey: mutation.roleKey,
+                            rolePath: locator.rolePath,
+                            registration: actual,
+                        })) {
+                            throw new Error(`Codex agent registration "${mutation.roleKey}" is foreign and cannot be overwritten by plugin "${action.owner.plugin}".`);
+                        }
+                        return { upsertAgentRegistrations: { [mutation.roleKey]: registration } };
+                    });
+                    return;
+                }
+                case 'codex-activation':
+                    throw new Error('Codex activation must use a setActivation action.');
+            }
+        }
+        case 'setActivation':
+            if (!action.configPath || !action.registration) {
+                throw new Error('Activation action is missing configPath or registration.');
+            }
+            await applyCodexConfigTransactionFile(action.configPath, {
+                upsertPluginActivations: { [action.registration]: action.enabled },
+            });
+            return;
+        default:
+            throw new Error(`Operation action ${action.kind} is not an artifact write action.`);
+    }
+}
 function createNativeDriver(options) {
     const runner = options.context.nativeCliRunner;
-    const materializeLeaseHeld = new WeakSet();
-    const mirrorTransactions = new WeakMap();
-    const finalizeNamespacedCleanup = async (target) => {
-        const { sourceId, sourceIdentity, marketplaceRoot, marketplaceName } = target.identity;
-        if (!sourceId || !sourceIdentity || !marketplaceRoot)
-            return;
-        await cleanupOrphanNamespacedMarketplaceRoot({
-            sourceId,
-            sourceIdentity,
-            ...(marketplaceName ? { marketplaceName } : {}),
+    const currentCodexManager = () => options.context.codexManager;
+    const nativeGroupPreparations = new Map();
+    const nativeTargetPreparations = new WeakMap();
+    const codexNativeStates = new Map();
+    const pendingCodexNativeStates = new Map();
+    const codexMutationMarketplaces = new Set();
+    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 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
+            && entry.identity.platform === component.identity.platform
+            && entry.identity.scope === component.identity.scope);
+        if (!target)
+            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 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 hasStaticSkills = candidate.plugin.manifest.skills !== undefined;
+                        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, new Set(first.identity.platform === 'codex'
+                    ? materializationTargets.flatMap((candidate) => pluginHasCodexNativeSkillSurface(candidate.plugin)
+                        ? [candidate.identity.pluginId ?? `${candidate.identity.sourceId}/${candidate.identity.pluginName}`]
+                        : [])
+                    : []));
+                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;
+                }
+                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 config = await readCodexConfigFile(configPath);
+        const marketplace = config.snapshot.marketplaces[component.locator.marketplaceName];
+        const canonical = !marketplace
+            ? 'absent'
+            : marketplace.sourceType === 'local'
+                && !marketplace.sourcePointsToManifest
+                && path.normalize(marketplace.source ?? '') === path.normalize(component.locator.marketplaceRoot)
+                ? 'present'
+                : 'foreign';
+        if (component.locator.desired) {
+            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 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')
+            throw new Error('Invalid Claude marketplace locator.');
+        const target = findTarget(component);
+        const state = await readClaudeNativeState({
+            pluginName: component.identity.plugin,
+            scope: component.identity.scope,
             cwd: target.identity.cwd,
             env: options.context.env,
+            marketplaceName: component.locator.marketplaceName,
+            marketplaceRoot: component.locator.marketplaceRoot,
         });
+        if (state.pluginState === 'foreign')
+            return 'foreign';
+        if (component.locator.desired) {
+            return state.marketplaceDeclaredState === 'canonical'
+                && state.marketplaceMaterializedState === 'canonical'
+                && state.pluginState === 'present'
+                && state.pluginEnabled
+                ? 'present'
+                : 'absent';
+        }
+        if (state.marketplaceState !== 'canonical')
+            return state.marketplaceState;
+        const projectPath = component.identity.scope === 'project'
+            ? path.normalize(await resolveRepoRoot(target.identity.cwd))
+            : undefined;
+        return state.marketplaceConsumers.some((consumer) => !(consumer.name === component.identity.plugin
+            && consumer.scope === component.identity.scope
+            && (component.identity.scope === 'user'
+                || path.normalize(consumer.projectPath ?? '') === projectPath))) ? 'absent' : 'present';
     };
-    return {
-        withOwnershipLease: (target, operation) => (!options.context.runtimeLeaseHeld
-            && target.identity.platform === 'codex'
-            && target.identity.scope === 'user'
-            && !materializeLeaseHeld.has(target)
-            ? withActiveMarketplaceRuntimeLease(options.context.env, operation)
-            : operation()),
-        withMaterializeLease: (target, operation) => {
-            if (!target.identity.sourceId)
-                return operation();
-            if (options.context.runtimeLeaseHeld && !options.context.lifecycleLeaseHeld) {
-                throw new Error('lockOrderViolation: namespaced materialization cannot acquire lifecycle after runtime.');
-            }
-            const runOperation = async () => {
-                const previousRuntimeHeld = options.context.runtimeLeaseHeld;
-                options.context.runtimeLeaseHeld = true;
-                materializeLeaseHeld.add(target);
-                try {
-                    if (options.context.expectedCatalogConfigDigest) {
-                        const current = await readCatalogSourcesConfigSnapshot(options.context.env);
-                        if (current.digest !== options.context.expectedCatalogConfigDigest) {
-                            throw new Error('catalogSourceConflict: catalog source config changed before owner publication.');
+    const ownership = {
+        inspectShared: async (component) => {
+            const locator = component.locator;
+            switch (locator.kind) {
+                case 'claude-permissions':
+                    return (await readClaudeSettings(locator.settingsPath)).awGenerated
+                        ?.permissions?.[locator.ownerKey] ? 'present' : 'absent';
+                case 'codex-instruction':
+                    return (await readCodexConfigFile(locator.configPath)).snapshot
+                        .developerInstructions.managedBlocks[locator.ownerKey] ? 'present' : 'absent';
+                case 'codex-activation': {
+                    const actual = (await readCodexConfigFile(locator.configPath))
+                        .snapshot.plugins[locator.codexPluginId]?.enabled;
+                    if (locator.disposition === 'remove')
+                        return actual === undefined ? 'absent' : 'present';
+                    if (locator.disposition === 'disable')
+                        return actual === true ? 'present' : 'absent';
+                    return actual === locator.desired ? 'present' : 'absent';
+                }
+                case 'legacy-codex-mcp': {
+                    const actual = (await readCodexConfigFile(locator.configPath))
+                        .snapshot.mcpServers[locator.serverKey];
+                    if (!actual)
+                        return 'absent';
+                    return legacyCodexMcpOwner(actual) === locator.ownerKey ? 'present' : 'foreign';
+                }
+                case 'legacy-codex-hook':
+                    return (await readLegacyCodexHooks(locator.hooksPath)).managedIdentities.some((entry) => serializeTrackedHookGroupIdentity(entry) === locator.serializedIdentity)
+                        ? 'present'
+                        : 'absent';
+                case 'codex-role-registration': {
+                    const registration = (await readCodexConfigFile(locator.configPath))
+                        .snapshot.agents[locator.roleKey];
+                    if (!registration)
+                        return 'absent';
+                    return await codexRoleRegistrationOwned({
+                        fileIdentity: locator.fileIdentity,
+                        configPath: locator.configPath,
+                        roleKey: locator.roleKey,
+                        rolePath: locator.rolePath,
+                        registration,
+                    }) ? 'present' : 'foreign';
+                }
+                case 'codex-marketplace':
+                    return inspectCodexMarketplace(component);
+                case 'claude-marketplace':
+                    return inspectClaudeMarketplace(component);
+                case 'corrupted':
+                    throw new Error(locator.message);
+            }
+        },
+        removeShared: async (component) => {
+            const locator = component.locator;
+            switch (locator.kind) {
+                case 'claude-permissions': {
+                    const settings = await readClaudeSettings(locator.settingsPath);
+                    rebuildClaudePermissions(settings, locator.ownerKey);
+                    await writeClaudeSettings(locator.settingsPath, settings);
+                    return;
+                }
+                case 'codex-instruction':
+                    await applyCodexConfigTransactionFile(locator.configPath, {
+                        removeManagedInstructionPluginName: locator.ownerKey,
+                    });
+                    return;
+                case 'codex-activation':
+                    await applyConditionalCodexConfigTransactionFile(locator.configPath, (snapshot) => {
+                        const actual = snapshot.plugins[locator.codexPluginId]?.enabled;
+                        if (locator.disposition === 'remove') {
+                            return actual === undefined ? null : { removePluginActivations: [locator.codexPluginId] };
                         }
-                    }
-                    return await operation();
+                        if (locator.disposition === 'disable') {
+                            return actual === true
+                                ? { upsertPluginActivations: { [locator.codexPluginId]: false } }
+                                : null;
+                        }
+                        return { removePluginActivations: [locator.codexPluginId] };
+                    });
+                    return;
+                case 'legacy-codex-mcp':
+                    await applyConditionalCodexConfigTransactionFile(locator.configPath, (snapshot) => legacyCodexMcpOwner(snapshot.mcpServers[locator.serverKey]) === locator.ownerKey
+                        ? { removeMcpServers: [locator.serverKey] }
+                        : null);
+                    return;
+                case 'legacy-codex-hook':
+                    await applyLegacyCodexHookCleanupTransactionFile(locator.hooksPath, (parsed) => {
+                        let removed = false;
+                        const remaining = parsed.groups.flatMap((entry) => {
+                            if (!removed && entry.managedIdentity
+                                && serializeTrackedHookGroupIdentity(entry.managedIdentity) === locator.serializedIdentity) {
+                                removed = true;
+                                return [];
+                            }
+                            return [entry.rawGroup];
+                        });
+                        return removed ? remaining : null;
+                    });
+                    return;
+                case 'codex-role-registration':
+                    await applyConditionalCodexConfigTransactionFile(locator.configPath, async (snapshot) => await codexRoleRegistrationOwned({
+                        fileIdentity: locator.fileIdentity,
+                        configPath: locator.configPath,
+                        roleKey: locator.roleKey,
+                        rolePath: locator.rolePath,
+                        registration: snapshot.agents[locator.roleKey],
+                    }) ? { 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;
                 }
-                finally {
-                    materializeLeaseHeld.delete(target);
-                    options.context.runtimeLeaseHeld = previousRuntimeHeld;
+                case 'claude-marketplace': {
+                    return;
                 }
-            };
-            const withRuntime = () => options.context.runtimeLeaseHeld
-                ? runOperation()
-                : withActiveMarketplaceRuntimeLease(options.context.env, runOperation);
-            if (options.context.lifecycleLeaseHeld)
-                return withRuntime();
-            return withActiveMarketplaceLifecycleLease(options.context.env, async () => {
-                const previousLifecycleHeld = options.context.lifecycleLeaseHeld;
-                options.context.lifecycleLeaseHeld = true;
-                try {
-                    return await withRuntime();
+                case 'corrupted':
+                    throw new Error(locator.message);
+            }
+        },
+        validateSkillDirectory: async (component) => {
+            await validateSkillDirectory(component.path, component.identity.platform === 'codex' ? 'codex.skill' : 'claude.skill', { ownerMarkerPolicy: 'ignore', requirementsReceiptPolicy: 'allow' });
+        },
+        skillDirectoryMatchesPristineTree: async ({ actualPath, files }) => {
+            const expectedFiles = new Map(files.map((entry) => [entry.relativePath, entry.contentDigest]));
+            const expectedDirectories = new Set(['']);
+            for (const relativePath of expectedFiles.keys()) {
+                const segments = relativePath.split('/');
+                for (let index = 1; index < segments.length; index += 1) {
+                    expectedDirectories.add(segments.slice(0, index).join('/'));
+                }
+            }
+            const seen = new Set();
+            const pending = [{ absolutePath: actualPath, relativePath: '' }];
+            while (pending.length > 0) {
+                const current = pending.pop();
+                for (const entry of await fs.readdir(current.absolutePath, { withFileTypes: true })) {
+                    const relativePath = current.relativePath ? `${current.relativePath}/${entry.name}` : entry.name;
+                    if (entry.isSymbolicLink())
+                        return false;
+                    const absolutePath = path.join(current.absolutePath, entry.name);
+                    if (entry.isDirectory()) {
+                        if (!expectedDirectories.has(relativePath))
+                            return false;
+                        pending.push({ absolutePath, relativePath });
+                        continue;
+                    }
+                    if (!entry.isFile())
+                        return false;
+                    const digest = `sha256:${crypto.createHash('sha256').update(await fs.readFile(absolutePath)).digest('hex')}`;
+                    if (expectedFiles.get(relativePath) !== digest)
+                        return false;
+                    seen.add(relativePath);
                 }
-                finally {
-                    options.context.lifecycleLeaseHeld = previousLifecycleHeld;
+            }
+            return seen.size === expectedFiles.size;
+        },
+    };
+    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}`;
+            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 observed = requireObservedCodexNativeState(registration.observation, 'artifact write precheck');
+            if (target.codexNativeObservationExpectation === 'installed' && observed !== 'installed') {
+                throw new Error('codexNativeExpectedInstalled: artifact write precheck requires the reused Codex plugin to remain installed.');
+            }
         },
         preflightMaterialize: async (target) => {
+            if (target.identity.sourceId && options.context.expectedCatalogConfigDigest) {
+                const current = await readCatalogSourcesConfigSnapshot(options.context.env);
+                if (current.digest !== options.context.expectedCatalogConfigDigest) {
+                    throw new Error('catalogSourceConflict: catalog source config changed before owner publication.');
+                }
+            }
             if (target.identity.platform === 'claude') {
                 await assertNoClaudeUnboundNativeNameCollision({
                     pluginName: target.identity.pluginName,
@@ -2518,27 +3734,17 @@ 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.`);
             }
+            if (target.nativeOverlayDesired) {
+                await prepareCodexNativeRenderCached({
+                    context: options.context,
+                    plugin: target.plugin,
+                    scriptTimeoutMs: options.scriptTimeoutMs,
+                });
+            }
         },
-        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);
-        },
-        finalizeCleanup: finalizeNamespacedCleanup,
+        finalizeCleanup: async () => undefined,
         probeNative: async (component) => {
-            const target = [...plansTargetEntries(options.plans)].find((entry) => entry.target.identity.pluginName === component.identity.plugin
-                && entry.target.identity.sourceId === component.identity.sourceId
-                && entry.target.identity.platform === component.identity.platform
-                && entry.target.identity.scope === component.identity.scope)?.target;
+            const target = findTarget(component);
             if (!target)
                 throw new Error('Native ownership probe cannot resolve its desired target.');
             if (target.identity.platform === 'claude') {
@@ -2552,23 +3758,25 @@ function createNativeDriver(options) {
                 });
                 return state.pluginState;
             }
-            if (target.identity.platform === 'codex' && target.identity.scope === 'user') {
-                const residue = await inspectCodexNativeResidue({
-                    pluginName: target.identity.pluginName,
+            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,
-                    marketplaceName: target.identity.marketplaceName,
-                    marketplaceRoot: target.identity.marketplaceRoot,
+                    nativeCliRunner: runner,
+                    manager: currentCodexManager(),
+                    scope: observationScopeFor(target),
+                    observationSession: options.context.codexObservationSession,
                 });
-                return residue.state;
+                return observedCodexNativeState(registration.observation, 'native probe');
             }
             return 'absent';
         },
         probeNativeHealth: async (component) => {
-            const target = [...plansTargetEntries(options.plans)].find((entry) => entry.target.identity.pluginName === component.identity.plugin
-                && entry.target.identity.sourceId === component.identity.sourceId
-                && entry.target.identity.platform === component.identity.platform
-                && entry.target.identity.scope === component.identity.scope)?.target;
+            const target = findTarget(component);
             if (!target)
                 throw new Error('Native health probe cannot resolve its desired target.');
             if (target.identity.platform === 'claude') {
@@ -2584,50 +3792,80 @@ function createNativeDriver(options) {
                     return state.pluginState;
                 return state.pluginEnabled ? 'present' : 'partial';
             }
-            if (target.identity.platform === 'codex' && target.identity.scope === 'user') {
-                const residue = await inspectCodexNativeResidue({
-                    pluginName: target.identity.pluginName,
+            if (target.identity.platform === 'codex') {
+                const pluginId = `${target.identity.pluginName}@${target.identity.marketplaceName ?? MARKETPLACE_NAME}`;
+                const registration = await inspectCodexPluginRegistrationLive({
+                    pluginId,
                     cwd: target.identity.cwd,
                     env: options.context.env,
-                    marketplaceName: target.identity.marketplaceName,
-                    marketplaceRoot: target.identity.marketplaceRoot,
+                    nativeCliRunner: runner,
+                    manager: currentCodexManager(),
+                    scope: observationScopeFor(target),
+                    observationSession: options.context.codexObservationSession,
                 });
-                if (residue.state !== 'present')
-                    return residue.state;
-                return residue.enabled ? 'present' : 'partial';
+                const nativeState = observedCodexNativeState(registration.observation, 'native health postcheck');
+                if (nativeState !== 'present')
+                    return nativeState;
+                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);
+                return userEnabled || projectConfig.snapshot.plugins[pluginId]?.enabled === true
+                    ? 'present'
+                    : 'partial';
             }
             return 'absent';
         },
         removeNative: async (component) => {
-            const target = [...plansTargetEntries(options.plans)].find((entry) => entry.target.identity.pluginName === component.identity.plugin
-                && entry.target.identity.sourceId === component.identity.sourceId
-                && entry.target.identity.platform === component.identity.platform
-                && entry.target.identity.scope === component.identity.scope)?.target;
+            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 before = await inspectCodexNativeResidue({
-                    pluginName: target.identity.pluginName,
-                    cwd: target.identity.cwd,
-                    env: options.context.env,
-                    marketplaceName: target.identity.marketplaceName,
-                    marketplaceRoot: target.identity.marketplaceRoot,
-                });
-                if (before.state === 'foreign') {
-                    throw new Error(`Codex native owner 为 foreign，拒绝调用 plugin remove：${before.labels.join('，')}`);
+                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.');
                 }
-                if (before.state === 'absent')
+                const removalRequired = before === 'present';
+                if (!removalRequired)
                     return;
-                await runNativeCliChecked(buildCodexPluginRemoveInvocation(component.pluginId, target.identity.cwd, options.context.env), runner);
-                const residue = await inspectCodexNativeResidue({
-                    pluginName: target.identity.pluginName,
-                    cwd: target.identity.cwd,
-                    env: options.context.env,
-                    marketplaceName: target.identity.marketplaceName,
-                    marketplaceRoot: target.identity.marketplaceRoot,
-                });
-                if (residue.state !== 'absent') {
-                    throw new Error(`Codex native remove 后仍有残留：${residue.labels.join('，')}`);
+                try {
+                    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}`);
+                }
+                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 {
@@ -2657,162 +3895,176 @@ function createNativeDriver(options) {
             }
         },
         writeNative: async (target) => {
-            const plan = options.plans.get(target);
-            if (!plan)
-                throw new Error('Missing rebuild integration plan.');
+            if (!target.catalog)
+                throw new Error('Missing rebuild target catalog data.');
             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 mirrored = await mirrorCatalog(plan.catalog, options.context.env, target.identity);
-                    mirrorTransactions.set(target, mirrored);
-                    const marketplaceRoot = mirrored.rootDir;
-                    const pluginId = `${target.identity.pluginName}@${marketplaceName}`;
-                    if (target.identity.platform === 'codex') {
-                        const requiredSkillWrites = plan.writes.filter((entry) => !entry.optional
-                            && entry.component?.kind === 'skill-directory'
-                            && entry.artifact.kind === 'skill'
-                            && entry.artifact.state !== 'disabled'
-                            && target.identity.scope === 'user');
-                        for (const write of requiredSkillWrites) {
-                            await write.write();
-                        }
-                        const skillsRelativeRoot = await ensureCodexActiveSkillsManifest({
-                            plugin: target.plugin,
-                            marketplaceRoot,
-                            hasRequiredSkills: requiredSkillWrites.length > 0,
-                        });
-                        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(marketplaceRoot, target.identity.cwd, options.context.env), runner);
-                        }
-                        await runNativeCliChecked(buildCodexMarketplaceListInvocation(target.identity.cwd, options.context.env), runner);
-                        await runNativeCliChecked(buildCodexPluginAddInvocation(pluginId, target.identity.cwd, options.context.env), runner);
-                        await runNativeCliChecked(buildCodexPluginListInvocation(target.identity.cwd, options.context.env), runner);
-                        await assertCodexNativeInstallState({
-                            pluginName: target.identity.pluginName,
-                            pluginVersion: target.identity.pluginVersion,
-                            cwd: target.identity.cwd,
-                            env: options.context.env,
-                            marketplaceRoot,
-                            marketplaceName,
-                            skillsRelativeRoot,
-                            requiredSkillKeys: requiredSkillWrites.flatMap((write) => write.artifact.artifactKey ? [write.artifact.artifactKey] : []),
-                        });
-                    }
-                    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 (target.identity.sourceId
-                && !options.context.runtimeLeaseHeld
-                && !materializeLeaseHeld.has(target)
-                ? withActiveMarketplaceRuntimeLease(options.context.env, writeGeneration)
-                : 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) => {
-            const plan = options.plans.get(target);
-            if (!plan)
-                throw new Error('Missing rebuild integration plan.');
-            const writeAll = async () => {
-                for (const write of plan.writes)
-                    await write.write();
-                return plan.writes.map((write) => write.artifact);
-            };
-            return !options.context.runtimeLeaseHeld
-                && !materializeLeaseHeld.has(target)
-                && target.identity.platform === 'codex' && target.identity.scope === 'user'
-                ? withActiveMarketplaceRuntimeLease(options.context.env, writeAll)
-                : writeAll();
+            for (const operationAction of target.operationActions ?? []) {
+                if (operationAction.kind === 'writeOwnedArtifact'
+                    || operationAction.kind === 'updateSharedConfig'
+                    || operationAction.kind === 'setActivation') {
+                    await applyPlannedOperationAction(operationAction);
+                }
+            }
+            return target.artifacts;
         },
-        runLifecycle: async (invocation) => {
-            await runLifecycleScript({
-                event: invocation.event,
-                pluginName: invocation.plugin.manifest.name,
+        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,
-                currentPlugin: invocation.plugin,
-                artifacts: [...invocation.artifacts],
                 scriptTimeoutMs: options.scriptTimeoutMs,
             });
+            const cache = options.context.preApplyExecutionCache;
+            if (!cache) {
+                await run();
+                return;
+            }
+            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;
         },
     };
 }
-const planTargets = new WeakMap();
-function plansTargetEntries(plans) {
-    return (planTargets.get(plans) ?? []).flatMap((target) => {
-        const plan = plans.get(target);
-        return plan ? [{ target, plan }] : [];
-    });
-}
 export function createRebuildIntegration(options) {
-    const plans = new WeakMap();
-    planTargets.set(plans, []);
-    const driver = createNativeDriver({ plans, ...options });
+    const targets = [...(options.preparedTargets ?? [])];
+    const driver = createNativeDriver({ targets, ...options });
     return {
         driver,
+        setNativeMarketplaceEligibleTargets: driver.setNativeMarketplaceEligibleTargets,
+        prepareNativeMarketplaceGroup: driver.prepareNativeMarketplaceGroup,
+        captureCodexPostMutationSnapshots: driver.captureCodexPostMutationSnapshots,
         buildTarget: async (input) => {
+            input = {
+                ...input,
+                sourceId: input.sourceId ?? input.plugin.sourceId,
+                sourceIdentity: input.sourceIdentity ?? input.plugin.sourceIdentity,
+                pluginId: input.pluginId ?? input.plugin.pluginId,
+            };
             const materializing = input.command !== 'cleanup'
                 && input.command !== 'uninstall'
                 && input.readOnlyInspectionPlan !== true;
@@ -2821,13 +4073,10 @@ export function createRebuildIntegration(options) {
                     cwd: input.cwd,
                     rootNames: input.platform === 'codex' ? ['.agents', '.codex'] : ['.claude'],
                     managedPaths: input.platform === 'codex'
-                        ? ['.codex/config.toml', '.codex/hooks.json']
+                        ? ['.codex/config.toml']
                         : ['.claude/settings.json'],
                 });
                 input = { ...input, cwd: canonicalRepoRoot };
-                if (materializing && input.platform === 'codex' && input.plugin.manifest.apps) {
-                    throw new Error(`Codex project scope 不支持 apps：${input.plugin.manifest.name}`);
-                }
             }
             if (materializing && input.platform === 'codex') {
                 await preflightCodexWriteSafety({
@@ -2837,26 +4086,10 @@ export function createRebuildIntegration(options) {
                     env: options.context.env,
                 });
             }
-            const event = input.command === 'upgrade' ? 'upgrade' : 'install';
-            let historicalArtifacts = [];
-            if (input.includeHistoricalLifecycleArtifacts) {
-                const loadPlugin = (bundleRoot) => readPluginManifest(bundleRoot, { mode: 'bundle' });
-                const { readLifecycleActiveSnapshot } = await import('../utils/lifecycle-active-store.js');
-                const active = await readLifecycleActiveSnapshot({
-                    ...(input.sourceId ? {
-                        sourceId: input.sourceId,
-                        sourceIdentity: input.sourceIdentity,
-                    } : {}),
-                    pluginName: input.plugin.manifest.name,
-                    platform: input.platform,
-                    scope: input.scope,
-                    cwd: input.cwd,
-                    env: options.context.env,
-                    loadPlugin,
-                });
-                historicalArtifacts = active?.artifacts ?? [];
-            }
+            const event = 'install';
+            const historicalArtifacts = [];
             let writes = [];
+            let currentRemovalComponents = [];
             if (input.command !== 'cleanup' && input.command !== 'uninstall') {
                 if (input.readOnlyInspectionPlan) {
                     writes = await buildInspectionWrites({
@@ -2866,6 +4099,8 @@ export function createRebuildIntegration(options) {
                         cwd: input.cwd,
                         env: options.context.env,
                         marketplaceRoot: input.marketplaceRoot,
+                        marketplaceName: input.marketplaceName,
+                        userActivationDesired: options.context.codexUserActivationDesired,
                     });
                 }
                 else if (input.platform === 'codex') {
@@ -2875,6 +4110,8 @@ export function createRebuildIntegration(options) {
                         event,
                         historicalArtifacts,
                         scriptTimeoutMs: options.scriptTimeoutMs,
+                        marketplaceName: input.marketplaceName,
+                        userActivationDesired: options.context.codexUserActivationDesired,
                     });
                 }
                 else {
@@ -2887,6 +4124,22 @@ export function createRebuildIntegration(options) {
                     });
                 }
             }
+            else if (input.platform === 'codex' && input.scope === 'project') {
+                const currentRemovalWrites = await buildInspectionWrites({
+                    plugin: input.plugin,
+                    platform: input.platform,
+                    scope: input.scope,
+                    cwd: input.cwd,
+                    env: options.context.env,
+                    marketplaceRoot: input.marketplaceRoot,
+                    marketplaceName: input.marketplaceName,
+                    userActivationDesired: options.context.codexUserActivationDesired,
+                });
+                currentRemovalComponents = currentRemovalWrites.flatMap((write) => [
+                    ...(write.additionalComponents ?? []),
+                    ...(write.component ? [write.component] : []),
+                ]);
+            }
             const desiredComponents = writes.filter((write) => !write.optional).flatMap((write) => [
                 ...(write.additionalComponents ?? []),
                 ...(write.component ? [write.component] : []),
@@ -2914,8 +4167,12 @@ export function createRebuildIntegration(options) {
             })))).flat();
             const skillRoots = input.platform === 'codex'
                 ? input.scope === 'project'
-                    ? [path.join(await resolveRepoRoot(input.cwd), '.agents', 'skills')]
-                    : [path.join(input.marketplaceRoot ?? resolveAwHome(options.context.env), 'plugins', input.plugin.manifest.name)]
+                    ? materializing
+                        || ((input.command === 'cleanup' || input.command === 'uninstall')
+                            && input.readOnlyInspectionPlan !== true)
+                        ? [path.join(input.cwd, '.agents', 'skills')]
+                        : []
+                    : [path.join(getCodexHome(options.context.env), 'skills')]
                 : [path.join(configDir, 'skills')];
             const scanSkills = () => Promise.all(skillRoots.map((root) => scanOwnedSkills({
                 sourceId: input.sourceId,
@@ -2924,13 +4181,38 @@ 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 (input.platform === 'codex'
-                && input.scope === 'user'
-                && input.readOnlyInspectionPlan !== true
-                ? withActiveMarketplaceRuntimeLease(options.context.env, scanSkills)
-                : scanSkills())).flat();
-            const historicalComponents = await buildHistoricalComponents({
+            const scannedSkills = (await scanSkills()).flat();
+            const legacyCodexNativeSkills = input.platform === 'codex'
+                ? (await (async () => {
+                    const skillKeys = [...new Set(codexNativeRenderTargets(input.plugin)
+                            .map((target) => target.skillKey))];
+                    if (skillKeys.length === 0)
+                        return [];
+                    const projectRoot = await assertCanonicalProjectManagedRoots({
+                        cwd: input.cwd,
+                        rootNames: ['.agents'],
+                    });
+                    const roots = [
+                        {
+                            root: path.join(getCodexHome(options.context.env), 'skills'),
+                            scope: 'user',
+                        },
+                        {
+                            root: path.join(projectRoot, '.agents', 'skills'),
+                            scope: 'project',
+                        },
+                    ];
+                    return roots.flatMap(({ root, scope }) => skillKeys.map((skillKey) => pathComponent({
+                        kind: 'skill-directory',
+                        path: path.join(root, skillKey),
+                        allowedRoot: root,
+                        identity: ownerIdentity(input.plugin.manifest.name, skillKey, 'codex', scope),
+                    })));
+                })())
+                : [];
+            let historicalComponents = await buildHistoricalComponents({
                 sourceId: input.sourceId,
                 sourceIdentity: input.sourceIdentity,
                 pluginId: input.pluginId,
@@ -2940,7 +4222,23 @@ export function createRebuildIntegration(options) {
                 cwd: input.cwd,
                 env: options.context.env,
                 artifacts: historicalArtifacts,
+                command: input.command,
             });
+            if (input.platform === 'codex') {
+                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;
+                    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);
+                    });
+                });
+            }
             const sharedComponents = input.platform === 'codex'
                 ? await scanCodexSharedComponents({
                     sourceId: input.sourceId,
@@ -2950,7 +4248,6 @@ export function createRebuildIntegration(options) {
                     scope: input.scope,
                     paths: resolveCodexPaths(input.cwd, input.scope, options.context.env),
                     scanConfig: true,
-                    scanHooks: true,
                     ignoreReadErrors: true,
                 })
                 : await scanClaudeSharedComponents({
@@ -2962,9 +4259,36 @@ export function createRebuildIntegration(options) {
                     settingsPath: resolveClaudePaths(input.cwd, input.scope, options.context.env).settingsPath,
                 });
             const nativeRequired = input.platform === 'claude'
-                || (input.scope === 'user' && requiresCodexNativePlugin(input.plugin, input.scope));
-            const nativeCleanupCandidate = input.platform === 'claude' || input.scope === 'user';
-            const nativePlugin = (nativeRequired || nativeCleanupCandidate)
+                || analyzeCodexSurface(input.plugin.manifest).nativeKinds.length > 0;
+            const nativeDesired = nativeRequired
+                && input.command !== 'cleanup'
+                && input.command !== 'uninstall';
+            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,
+                    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 = 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.platform === 'codex'
+                    && nativeRequired
+                    && (input.command === 'cleanup' || input.command === 'uninstall');
+            const nativePlugin = (nativeDesired || nativeCleanupCandidate)
                 ? [{
                         kind: 'native-plugin',
                         identity: ownerIdentity(input.plugin.manifest.name, 'native', input.platform, input.scope),
@@ -2974,9 +4298,13 @@ export function createRebuildIntegration(options) {
             const marketplaceDesired = nativeRequired
                 && input.command !== 'cleanup'
                 && input.command !== 'uninstall';
-            const marketplace = input.platform === 'codex' && input.scope === 'user'
+            const marketplace = input.platform === 'codex'
+                && input.scope === 'user'
+                && nativeRequired
+                && input.readOnlyShallowInspectionPlan !== true
                 ? [createCodexMarketplaceComponent({
                         pluginName: input.plugin.manifest.name,
+                        codexManager: options.context.codexManager,
                         cwd: input.cwd,
                         env: options.context.env,
                         runner: options.context.nativeCliRunner,
@@ -2984,7 +4312,7 @@ export function createRebuildIntegration(options) {
                         marketplaceRoot: input.marketplaceRoot ?? resolveAwHome(options.context.env),
                         desired: marketplaceDesired,
                     })]
-                : input.platform === 'claude'
+                : input.platform === 'claude' && marketplaceDesired
                     ? [createClaudeMarketplaceComponent({
                             pluginName: input.plugin.manifest.name,
                             scope: input.scope,
@@ -2996,38 +4324,83 @@ export function createRebuildIntegration(options) {
                             desired: marketplaceDesired,
                         })]
                     : [];
-            const nativeVersion = nativeRequired
-                && input.command !== 'cleanup'
-                && input.command !== 'uninstall'
-                ? [createNativeVersionComponent({
-                        pluginName: input.plugin.manifest.name,
-                        pluginVersion: input.plugin.manifest.version,
-                        platform: input.platform,
-                        scope: input.scope,
-                        cwd: input.cwd,
-                        env: options.context.env,
-                        marketplaceName: input.marketplaceName,
-                        marketplaceRoot: input.marketplaceRoot,
-                    })]
+            if (nativeDesired)
+                desiredComponents.push(...nativePlugin, ...marketplace);
+            const activationCleanup = input.platform === 'codex'
+                && nativeRequired
+                && (input.command === 'cleanup' || input.command === 'uninstall')
+                ? (input.scope === 'project'
+                    ? [
+                        createCodexActivationComponent({
+                            identity: ownerIdentity(input.plugin.manifest.name, internalArtifactKey('activation', 'project'), 'codex', input.scope),
+                            configPath: resolveCodexPaths(input.cwd, 'project', options.context.env).configTomlPath,
+                            codexPluginId: `${input.plugin.manifest.name}@${input.marketplaceName ?? MARKETPLACE_NAME}`,
+                            desired: true,
+                        }),
+                    ]
+                    : [createCodexActivationComponent({
+                            identity: ownerIdentity(input.plugin.manifest.name, internalArtifactKey('activation', 'user'), 'codex', input.scope),
+                            configPath: resolveCodexPaths(input.cwd, 'user', options.context.env).configTomlPath,
+                            codexPluginId: `${input.plugin.manifest.name}@${input.marketplaceName ?? MARKETPLACE_NAME}`,
+                            desired: true,
+                        })])
+                : [];
+            const explicitActivationCleanup = input.platform === 'codex'
+                ? (input.codexActivationCleanup ?? []).map((activation) => createCodexActivationCleanupComponent({
+                    identity: ownerIdentity(input.plugin.manifest.name, internalArtifactKey('activation', activation.scope), 'codex', input.scope),
+                    configPath: resolveCodexPaths(input.cwd, activation.scope, options.context.env).configTomlPath,
+                    codexPluginId: activation.codexPluginId,
+                    disposition: activation.disposition,
+                }))
                 : [];
-            if (nativeRequired
-                && input.command !== 'cleanup'
-                && input.command !== 'uninstall')
-                desiredComponents.push(...nativePlugin, ...marketplace, ...nativeVersion);
             const allComponents = dedupeComponents([
                 ...desiredComponents,
                 ...optionalComponents,
                 ...(input.platform === 'codex' ? sharedComponents : []),
                 ...scannedText,
                 ...scannedSkills,
+                ...legacyCodexNativeSkills,
+                ...currentRemovalComponents,
                 ...historicalComponents,
                 ...(input.platform === 'claude' ? sharedComponents : []),
                 ...nativePlugin,
                 ...marketplace,
-                ...nativeVersion,
+                ...activationCleanup,
+                ...explicitActivationCleanup,
             ]);
             bindNamespacedOwnerIdentity(allComponents, input);
             const desiredKeys = new Set(desiredComponents.map(componentIdentityKey));
+            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,
+                    script: preApply.path,
+                    scriptDigest,
+                });
+            }
+            if (nativeDesired) {
+                operationActions.push({
+                    kind: 'ensureNativeRegistration',
+                    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),
+                });
+            }
+            operationActions.push(...writes.flatMap((write) => [
+                ...(write.action ? [write.action] : []),
+                ...(write.additionalActions ?? []),
+            ]));
+            finalizeOwnedArtifactActions(operationActions);
             const target = {
                 plugin: input.plugin,
                 identity: {
@@ -3047,24 +4420,27 @@ export function createRebuildIntegration(options) {
                 ownedComponents: allComponents,
                 desiredOwnedComponents: allComponents.filter((component) => desiredKeys.has(componentIdentityKey(component))),
                 optionalOwnedComponents: allComponents.filter((component) => optionalComponentKeys.has(componentIdentityKey(component))),
-                requiresNative: nativeRequired
-                    && input.command !== 'cleanup'
-                    && input.command !== 'uninstall',
+                requiresNative: nativeDesired,
+                writeNativeRequired: materializeNativeRequired,
+                nativeOverlayDesired: nativeDesired,
                 artifacts: writes.map((write) => write.artifact),
-                lifecycleSource: input.plugin,
-            };
-            plans.set(target, {
+                operationActions,
                 catalog: input.catalog,
-                event,
-                writes,
-            });
-            planTargets.get(plans).push(target);
+                preApplySource: input.plugin,
+            };
+            targets.push(target);
             return target;
         },
     };
 }
 export async function inspectRebuildTarget(options) {
-    const integration = createRebuildIntegration({ context: options.context });
+    const integration = createRebuildIntegration({
+        context: {
+            ...options.context,
+            codexUserActivationDesired: options.userActivationDesired
+                ?? options.context.codexUserActivationDesired,
+        },
+    });
     const target = await integration.buildTarget({
         ...(options.sourceId ? {
             sourceId: options.sourceId,
@@ -3079,15 +4455,53 @@ export async function inspectRebuildTarget(options) {
         cwd: options.cwd,
         command: 'install',
         catalog: options.catalog,
-        includeHistoricalLifecycleArtifacts: false,
         readOnlyInspectionPlan: true,
+        readOnlyShallowInspectionPlan: options.shallow,
     });
     const inspection = await inspectOwnedComponents({
         components: target.ownedComponents,
-        nativeProbe: integration.driver.probeNativeHealth ?? integration.driver.probeNative,
+        executor: integration.driver.ownership,
+        nativeProbe: options.nativeProbe
+            ?? integration.driver.probeNativeHealth
+            ?? integration.driver.probeNative,
         verifyHealth: true,
     });
-    return { target, inspection };
+    if (!target.requiresNative)
+        return { target, inspection };
+    if (target.identity.platform === 'codex') {
+        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,
+            nativeCliRunner: options.context.nativeCliRunner,
+            manager: options.context.codexManager,
+            scope: target.identity.scope,
+            observationSession: options.context.codexObservationSession,
+        });
+        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({
+        pluginName: target.identity.pluginName,
+        scope: target.identity.scope,
+        cwd: target.identity.cwd,
+        env: options.context.env,
+        marketplaceName: target.identity.marketplaceName,
+        marketplaceRoot: target.identity.marketplaceRoot,
+    });
+    const versions = [...new Set(native.pluginVersions)];
+    return native.marketplaceState === 'canonical'
+        && native.pluginState === 'present'
+        && native.pluginEnabled
+        && versions.length === 1
+        ? { target, inspection, installedVersion: versions[0] }
+        : { target, inspection };
 }
 async function discoverOwnerNamesInTextRoot(root, platform, scope) {
     if (!await fs.pathExists(root))
@@ -3146,7 +4560,7 @@ export async function discoverRebuildTargetNames(options) {
             cwd: options.cwd,
             rootNames: options.platform === 'codex' ? ['.agents', '.codex'] : ['.claude'],
             managedPaths: options.platform === 'codex'
-                ? ['.codex/config.toml', '.codex/hooks.json']
+                ? ['.codex/config.toml']
                 : ['.claude/settings.json'],
         });
         options = { ...options, cwd: canonicalRepoRoot };
@@ -3160,7 +4574,7 @@ export async function discoverRebuildTargetNames(options) {
         names.add(name);
     const skillRoots = options.platform === 'codex'
         ? options.scope === 'project'
-            ? [path.join(await resolveRepoRoot(options.cwd), '.agents', 'skills')]
+            ? []
             : [path.join(resolveAwHome(options.env), 'plugins')]
         : [path.join(paths.configDir, 'skills')];
     if (options.platform === 'codex' && options.scope === 'user') {
@@ -3195,34 +4609,59 @@ export async function discoverRebuildTargetNames(options) {
         for (const name of Object.keys(config.snapshot.developerInstructions.managedBlocks)) {
             names.add(sharedOwnerPluginName(name));
         }
-        for (const server of Object.values(config.snapshot.mcpServers)) {
-            const envValue = server.value?.env;
-            const owner = envValue
-                && typeof envValue === 'object'
-                && !Array.isArray(envValue)
-                && typeof envValue[MCP_OWNER_ENV] === 'string'
-                ? envValue[MCP_OWNER_ENV]
-                : null;
-            if (owner)
-                names.add(sharedOwnerPluginName(owner));
-        }
         if (options.scope === 'project') {
-            const hooksPath = resolveCodexPaths(options.cwd, options.scope, options.env).hooksPath;
-            const hooks = await readCodexHooks(hooksPath).catch(() => null);
-            for (const identity of hooks?.managedIdentities ?? []) {
-                const owner = readOwnedHookIdentity(identity, options.scope);
-                if (owner)
-                    names.add(owner.plugin);
+            const suffix = `@${options.marketplaceName ?? MARKETPLACE_NAME}`;
+            for (const pluginId of Object.keys(config.snapshot.plugins)) {
+                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);
             }
         }
         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 {