@lesliechan721/aw 0.1.0-beta.11 → 0.1.0-beta.13

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

@@ -6,23 +6,23 @@ import { generateInstructionArtifacts, renderCodexManagedInstructionBlock, } fro
 import { generateCodexPermissionArtifacts, mergeClaudePermissions, } from '../generators/permissions.js';
 import { buildGeneratedName } from '../generators/shared.js';
 import { applyConditionalCodexConfigTransactionFile, applyCodexConfigTransactionFile, composeManagedDeveloperInstructionsBlock, readCodexConfigFile, } from '../utils/codex-config.js';
-import { canonicalizePathThroughExistingAncestor } from '../utils/state-paths.js';
+import { canonicalizePathThroughExistingAncestor, resolveClaudeProjectKey, resolveCodexProjectKey, } from '../utils/state-paths.js';
 import { createCodexSkillExpectedTree, createCodexSkillStagingTreeContentDigest, } from '../utils/codex-skill-staging.js';
-import { createDynamicSkillExpectedTree, createDynamicSkillTreeContentDigest, readDynamicSkillTree, validateSkillDirectory, writeDynamicSkillTree, } from '../utils/dynamic-skill-tree.js';
+import { AW_PLUGIN_REQUIREMENTS_RECEIPT_PATH, createDynamicSkillExpectedTree, createDynamicSkillTreeContentDigest, readDynamicSkillTree, validateSkillDirectory, writeDynamicSkillTree, } from '../utils/dynamic-skill-tree.js';
 import { parseCodexSharedHooksFile, serializeTrackedHookGroupIdentity, } from '../utils/hooks-contract.js';
 import { buildCodexMarketplaceAddInvocation, buildCodexMarketplaceRemoveInvocation, buildCodexPluginAddInvocation, buildCodexPluginRemoveInvocation, CodexProjectConfigNotEffectiveError, runNativeCliChecked, SYSTEM_CODEX_MANAGER, } from '../utils/native-cli.js';
 import { OWNED_TEXT_HEADER_PREFIX, createSharedOwnerToken, createSkillOwnerMarkerContent, parseSharedOwnerToken, parseOwnedTextHeader, readSkillOwnerMarker, renderOwnedTextFile, inspectOwnedComponents, writeOwnedTextFile, } from '../utils/ownership.js';
 import { resolveArtifactRenderConfig, resolveArtifactRendererTarget, runArtifactRenderer, } from '../utils/artifact-renderer.js';
 import { createArtifactConfigDigest, validateArtifactPlan, } from '../utils/artifact-plan.js';
-import { resolveAwDeliveredArtifactIds } from '../utils/artifact-request.js';
-import { createAwPluginRequirementsReceipt, } from '../utils/manifest.js';
+import { resolveAwDeliveredArtifactRequestBatches } from '../utils/artifact-request.js';
+import { createAwPluginRequirementsReceipt, parseAwPluginRequirementsReceipt, tryParseStrictSemVer, } from '../utils/manifest.js';
 import { resolvePlatformEntries } from '../utils/platform-entries.js';
 import { resolveAwHome, resolveClaudePaths, resolveCodexPaths, resolveRepoRoot, getCodexHome, } from '../utils/paths.js';
 import { assertNoSensitiveConfigInFiles, collectSensitivePluginConfigValues, runPreApplyScript, } from '../utils/plugin-scripts.js';
 import { findSensitiveTokenPath } from '../utils/sensitive-content.js';
 import { atomicRemoveConfigFile, atomicReplaceConfigFile, withConfigFileMutation, } from '../utils/plugin-config.js';
 import { readCatalogSourcesConfigSnapshot } from '../utils/catalog-sources.js';
-import { getNamespacedMarketplaceName, projectMarketplaceManifestForPlatform, readStrictNamespacedMarketplaceRoot, replayNamespacedCodexSkillOverlays, } from '../utils/local-marketplace.js';
+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 { analyzeCodexSurface } from '../utils/codex-surface-analysis.js';
@@ -39,6 +39,26 @@ function requirementsReceipt(plugin) {
     const receipt = createAwPluginRequirementsReceipt({ name: plugin.manifest.name, version: plugin.manifest.version }, plugin.manifest.requires?.aw.capabilities ?? []);
     return Buffer.from(`${JSON.stringify(receipt, null, 2)}\n`, 'utf8');
 }
+function withoutVerifiedRequirementsReceipt(plugin, files) {
+    const receipt = files[AW_PLUGIN_REQUIREMENTS_RECEIPT_PATH];
+    if (!receipt)
+        return { ...files };
+    let actual;
+    let expected;
+    try {
+        actual = parseAwPluginRequirementsReceipt(JSON.parse(receipt.toString('utf8')));
+        expected = parseAwPluginRequirementsReceipt(JSON.parse(requirementsReceipt(plugin).toString('utf8')));
+    }
+    catch {
+        return { ...files };
+    }
+    if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+        return { ...files };
+    }
+    const output = { ...files };
+    delete output[AW_PLUGIN_REQUIREMENTS_RECEIPT_PATH];
+    return output;
+}
 export class CodexActivationPostcheckError extends Error {
     code = 'codexActivationPostcheckFailed';
     codexPluginIds;
@@ -924,25 +944,29 @@ function renderCodexRole(options) {
     ].join('\n');
 }
 async function resolveDynamicArtifacts(options) {
-    const requestedArtifactIds = resolveAwDeliveredArtifactIds({
+    const requestBatches = resolveAwDeliveredArtifactRequestBatches({
         manifest: options.plugin.manifest,
         platform: options.platform,
         scope: options.scope,
     });
-    if (requestedArtifactIds.length === 0) {
+    if (requestBatches.length === 0) {
         return { artifacts: [], sourceDirs: () => [], sensitiveValues: [] };
     }
-    const render = await runArtifactRenderer({
-        event: options.event,
-        plugin: options.plugin,
-        platform: options.platform,
-        scope: options.scope,
-        cwd: options.cwd,
-        commandEnv: options.env,
-        previousArtifacts: [...options.previousArtifacts],
-        requestedArtifactIds,
-        scriptTimeoutMs: options.scriptTimeoutMs,
-    });
+    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,
@@ -953,19 +977,26 @@ async function resolveDynamicArtifacts(options) {
         cwd: options.cwd,
         env: options.env,
     });
-    const artifacts = validateArtifactPlan({
-        manifest: options.plugin.manifest,
-        plan: render.plan,
-        platform: options.platform,
-        scope: options.scope,
-        requestedArtifactIds: render.context.requestedArtifactIds,
-        renderConfig: config,
-        rendererDigest: render.target.rendererDigest,
-        manifestDigest: render.target.manifestDigest,
-    }).artifacts;
+    const artifacts = [];
+    const sourceDirsByArtifact = new Map();
+    for (const render of renders) {
+        artifacts.push(...validateArtifactPlan({
+            manifest: options.plugin.manifest,
+            plan: render.plan,
+            platform: options.platform,
+            scope: options.scope,
+            requestedArtifactIds: render.context.requestedArtifactIds,
+            renderConfig: config,
+            rendererDigest: render.target.rendererDigest,
+            manifestDigest: render.target.manifestDigest,
+        }).artifacts);
+        for (const source of render.context.artifactSources) {
+            sourceDirsByArtifact.set(`${source.id}\0${source.target}`, source.sourceDirs);
+        }
+    }
     return {
         artifacts,
-        sourceDirs: (artifact) => render.context.artifactSources.find((entry) => entry.id === artifact.id && entry.target === artifact.target)?.sourceDirs ?? [],
+        sourceDirs: (artifact) => sourceDirsByArtifact.get(`${artifact.id}\0${artifact.target}`) ?? [],
         sensitiveValues: collectSensitivePluginConfigValues(options.plugin.manifest, config.values),
     };
 }
@@ -1140,7 +1171,7 @@ async function buildClaudeWrites(options) {
             requirementsReceipt: requirementsReceipt(options.plugin),
             sourceRequirementsReceiptPolicy: 'allow',
         });
-        assertNoSensitiveConfigInFiles(tree.files, dynamic.sensitiveValues, 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
+        assertNoSensitiveConfigInFiles(withoutVerifiedRequirementsReceipt(options.plugin, tree.files), dynamic.sensitiveValues, 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
         writes.push(dynamicSkillWrite({
             ...options,
             platform: 'claude',
@@ -1217,7 +1248,7 @@ async function buildCodexWrites(options) {
             requirementsReceipt: requirementsReceipt(options.plugin),
             sourceRequirementsReceiptPolicy: 'allow',
         });
-        assertNoSensitiveConfigInFiles(tree.files, dynamic.sensitiveValues, 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
+        assertNoSensitiveConfigInFiles(withoutVerifiedRequirementsReceipt(options.plugin, tree.files), dynamic.sensitiveValues, 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
         writes.push(dynamicSkillWrite({
             ...options,
             platform: 'codex',
@@ -1782,6 +1813,8 @@ async function codexPayloadPathSafe(payloadRoot, allowedRoot = payloadRoot) {
     }
     return true;
 }
+class CodexNativeProjectionUnsafeError extends Error {
+}
 async function resolveCodexSkillsRoot(payloadRoot, rawSkillsRoot) {
     const normalizedSeparators = rawSkillsRoot.replace(/\\/gu, '/');
     const relativeRoot = path.posix.normalize(normalizedSeparators.replace(/^\.\//u, ''));
@@ -1791,11 +1824,11 @@ async function resolveCodexSkillsRoot(payloadRoot, rawSkillsRoot) {
         || relativeRoot.startsWith('../')
         || path.posix.isAbsolute(normalizedSeparators)
         || path.win32.isAbsolute(rawSkillsRoot)) {
-        throw new Error('codexNativeSkillsRootInvalid: Codex native Skills root is invalid.');
+        throw new CodexNativeProjectionUnsafeError('codexNativeSkillsRootInvalid: Codex native Skills root is invalid.');
     }
     const root = path.join(payloadRoot, ...relativeRoot.split('/'));
     if (!await codexReadPathSafe(payloadRoot, root)) {
-        throw new Error('codexNativeSkillsRootInvalid: Codex native Skills root is unsafe.');
+        throw new CodexNativeProjectionUnsafeError('codexNativeSkillsRootInvalid: Codex native Skills root is unsafe.');
     }
     return { relativeRoot, root };
 }
@@ -1810,16 +1843,45 @@ async function readCodexNativeRenderReceiptEvidence(payloadRoot) {
     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(await fs.readFile(receiptPath, 'utf8')),
-        };
+        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
@@ -1830,54 +1892,101 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
     const marketplace = await readStrictNamespacedMarketplaceRoot({
         trustedMarketplaceRoot: path.join(resolveAwHome(options.env), 'marketplaces'),
         rootDir: options.marketplaceRoot,
-        sourceId: options.plugin.sourceId,
-        marketplaceName: options.marketplaceName,
     });
     if (!marketplace) {
-        throw new Error('Codex native render canonical marketplace generation is missing.');
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionReceiptMissing');
     }
-    if (marketplace.config.sourceIdentity !== options.plugin.sourceIdentity) {
-        return { state: 'foreign' };
+    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);
-    if (!await codexPayloadPathSafe(payloadRoot, options.marketplaceRoot)) {
-        throw new Error('Codex native render canonical marketplace payload path is unsafe.');
-    }
-    const receiptEvidence = await readCodexNativeRenderReceiptEvidence(payloadRoot);
-    if (receiptEvidence.state !== 'present') {
-        throw new Error('Codex native render canonical marketplace receipt is missing or unreadable.');
+    const payloadStats = await lstatIfPresent(payloadRoot);
+    if (!payloadStats) {
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionReceiptMissing');
     }
-    const receipt = receiptEvidence.receipt;
-    if (receipt.logicalPluginId !== logicalPluginId
-        || receipt.strategy !== 'shared-user'
-        || receipt.sourceIdentity !== marketplace.config.sourceIdentity) {
-        throw new Error('Codex native render canonical marketplace receipt identity is invalid.');
+    if (!payloadStats.isDirectory() || payloadStats.isSymbolicLink()) {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
     }
-    const payloadDigest = await calculateCodexNativeRenderPayloadDigest(payloadRoot);
-    if (payloadDigest !== receipt.payloadDigest) {
-        throw new Error('Codex native render canonical marketplace payload does not match its receipt.');
-    }
-    const sourceManifestPath = path.join(payloadRoot, '.agents-plugin', 'plugin.json');
-    const sourceManifestStats = await lstatIfPresent(sourceManifestPath);
-    const sourceManifest = sourceManifestStats?.isFile() && !sourceManifestStats.isSymbolicLink()
-        ? await fs.readJson(sourceManifestPath).catch(() => null)
-        : null;
-    if (sourceManifest?.name !== options.plugin.manifest.name
-        || sourceManifest.version !== receipt.pluginVersion) {
-        throw new Error('Codex native render canonical marketplace plugin identity is invalid.');
+    if (!await codexPayloadPathSafe(payloadRoot, options.marketplaceRoot)) {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
     }
     const codexManifestPath = path.join(payloadRoot, '.codex-plugin', 'plugin.json');
-    const codexManifestStats = await lstatIfPresent(codexManifestPath);
-    const codexManifest = codexManifestStats?.isFile() && !codexManifestStats.isSymbolicLink()
-        ? await fs.readJson(codexManifestPath).catch(() => null)
-        : null;
-    if (!codexManifest) {
-        throw new Error('Codex native render canonical marketplace manifest is invalid.');
+    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 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: {},
@@ -1885,22 +1994,37 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
     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'))) {
-            throw new Error('Codex native render canonical marketplace Skill has an AW owner marker.');
+            return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+        }
+        const skillStats = await lstatIfPresent(skillRoot);
+        if (skillStats && (!skillStats.isDirectory() || skillStats.isSymbolicLink())) {
+            return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+        }
+        let tree;
+        try {
+            tree = skillStats ? await readDynamicSkillTree(skillRoot, 'codex.skill') : null;
+        }
+        catch (error) {
+            return codexNativeRenderEvidenceIssue(error instanceof Error && typeof error.code !== 'string'
+                ? 'damaged'
+                : 'unreadable', 'projectionPayloadDigestMismatch');
         }
-        const tree = await readDynamicSkillTree(skillRoot, 'codex.skill');
         const artifactDigest = tree
             ? createCodexSkillStagingTreeContentDigest(tree)
             : emptyArtifactDigest;
         if (artifactDigest !== receiptTarget.artifactDigest) {
-            throw new Error('Codex native render canonical marketplace Skill does not match its receipt.');
+            return codexNativeRenderEvidenceIssue('damaged', 'projectionPayloadDigestMismatch');
         }
     }
-    const targets = codexNativeRenderTargets(options.plugin);
+    const payloadDigest = await calculateCodexNativeRenderPayloadDigest(payloadRoot);
+    if (payloadDigest !== receipt.payloadDigest) {
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionPayloadDigestMismatch');
+    }
     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, sourceProjection: 'drifted' };
+        return { state: 'present', payloadDigest, receipt, sourceProjection: 'drifted' };
     }
     const renderer = await resolveArtifactRendererTarget(options.plugin);
     if (renderer.noOp || !renderer.rendererDigest) {
@@ -1934,7 +2058,7 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
                     target: 'codex.skill',
                     refreshKeys: target.refreshKeys,
                 },
-                configValues: config.values,
+                renderConfig: config,
                 digestSalt: renderer.rendererDigest,
             }),
             artifactDigest: receiptTargets.get(target.id).artifactDigest,
@@ -1942,6 +2066,7 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
     });
     return {
         state: 'present',
+        receipt,
         projection,
         payloadDigest,
         sourceProjection: codexNativeRenderProjectionsEqual(receipt, projection)
@@ -1966,11 +2091,31 @@ async function assertNoSensitiveValuesInCanonicalCodexNativePayload(options) {
         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) {
@@ -2053,7 +2198,7 @@ export async function inspectCodexSharedNativeLive(options) {
     });
     let expectedPayloadDigest = dynamicProjectionExpected ? undefined : options.expectedPayloadDigest;
     let sourceProjection;
-    let expectedMarketplaceForeign = false;
+    let sourceProjectionIssue;
     const installed = pluginList.observation.state === 'observed'
         && pluginList.observation.value === 'installed';
     if (installed && dynamicProjectionExpected && options.nativeRenderPlugin) {
@@ -2064,32 +2209,48 @@ export async function inspectCodexSharedNativeLive(options) {
                 marketplaceName,
                 env: options.env,
             });
-            if (expected.state === 'foreign') {
-                expectedMarketplaceForeign = true;
+            if (expected.state === 'issue') {
+                sourceProjectionIssue = expected;
             }
             else {
                 expectedPayloadDigest = expected.payloadDigest;
                 sourceProjection = expected.sourceProjection;
             }
         }
-        catch {
-            sourceProjection = 'drifted';
+        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 = expectedMarketplaceForeign
-        ? { state: 'blocked', reason: 'foreign', diagnostic: 'marketplaceRegistrationForeign' }
-        : inspectCodexSharedNative({
-            pluginName: options.pluginName,
-            pluginId,
-            marketplaceName,
-            canonicalMarketplaceRoot: marketplaceRoot,
-            desiredVersion: options.desiredVersion,
-            expectedPayloadDigest,
-            marketplaceRegistration: config.snapshot.marketplaces[marketplaceName],
-            marketplacePathSafe,
-            observation: pluginList.observation,
-            ...(sourceProjection ? { sourceProjection } : {}),
-        });
+    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 } : {}),
@@ -2522,7 +2683,7 @@ async function assertNoSensitiveValuesInCodexNativePayload(options) {
             const tree = await readDynamicSkillTree(skillRoot, 'codex.skill');
             if (!tree)
                 continue;
-            const leakedPath = findSensitiveTokenPath(tree.files, options.sensitiveValues);
+            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}".`);
@@ -2535,10 +2696,22 @@ async function assertNoSensitiveValuesInCodexNativePayload(options) {
         if (!receiptStats.isFile()) {
             throw new Error('Codex native sensitive scan render receipt path is unsafe.');
         }
-        const receiptLeak = findSensitiveTokenPath({ [CODEX_NATIVE_RENDER_RECEIPT_PATH]: await fs.readFile(receiptPath) }, options.sensitiveValues);
-        if (receiptLeak) {
-            throw new Error(`codexNativeRenderSensitiveValue: Codex native render receipt exposes sensitive config in ` +
-                `"${receiptLeak}".`);
+        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}".`);
+            }
         }
     }
 }
@@ -2596,7 +2769,7 @@ async function prepareCodexNativeRender(options) {
                 requirementsReceipt: requirementsReceipt(options.plugin),
                 sourceRequirementsReceiptPolicy: 'allow',
             });
-            assertNoSensitiveConfigInFiles(tree.files, collectSensitivePluginConfigValues(options.plugin.manifest, rendered.context.config.values), 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
+            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,
@@ -2693,11 +2866,12 @@ async function materializeCodexNativeRender(options) {
     return {
         payloadDigest,
         projection: options.prepared.projection,
+        receipt,
         presentSkillKeys: options.prepared.presentSkillKeys,
         targetSkillKeys: options.prepared.targetSkillKeys,
     };
 }
-async function mirrorCatalog(catalog, env, target, logicalIdentity, prepareStaging) {
+async function mirrorCatalog(catalog, env, target, logicalIdentity, prepareStaging, rematerializedCodexNativePluginIds = new Set()) {
     if (!target?.sourceId || !target.marketplaceRoot) {
         const rootDir = resolveAwHome(env);
         await fs.ensureDir(rootDir);
@@ -2761,6 +2935,14 @@ async function mirrorCatalog(catalog, env, target, logicalIdentity, prepareStagi
                 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()}`;
@@ -3085,10 +3267,15 @@ function createNativeDriver(options) {
                                 payloadRoot: path.join(stagingRoot, 'plugins', candidate.identity.pluginName),
                                 allowedRoot: stagingRoot,
                                 sensitiveValues: await resolveSensitiveUserConfigValues(candidate.plugin, options.context.env),
+                                ...(nativeRender ? { verifiedRenderReceipt: nativeRender.receipt } : {}),
                             });
                         }
                     }
-                } : undefined);
+                } : 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();
                 }
@@ -3478,6 +3665,7 @@ function createNativeDriver(options) {
                 await assertNoSensitiveValuesInCanonicalCodexNativePayload({
                     plugin: target.plugin,
                     marketplaceRoot: target.identity.marketplaceRoot ?? resolveAwHome(options.context.env),
+                    marketplaceName: target.identity.marketplaceName ?? MARKETPLACE_NAME,
                     env: options.context.env,
                     sensitiveValues,
                 });
@@ -3803,7 +3991,7 @@ function createNativeDriver(options) {
             return target.artifacts;
         },
         runPreApply: async (invocation) => {
-            await runPreApplyScript({
+            const run = () => runPreApplyScript({
                 plugin: invocation.plugin,
                 platform: invocation.target.identity.platform,
                 scope: invocation.target.identity.scope,
@@ -3811,6 +3999,36 @@ function createNativeDriver(options) {
                 context: options.context,
                 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;
         },
     };
 }