@lesliechan721/aw 0.1.0-beta.6 → 0.1.0-beta.60

package/dist/src/utils/local-marketplace.js

@@ -1,11 +1,17 @@
 import path from 'node:path';
 import fs from 'fs-extra';
-import { SKILL_OWNER_MARKER, readSkillOwnerMarker } from './ownership.js';
+import { normalizeInstalledCommandProducer, validateCommandEntryFiles } from '@lesliechan721/aw-plugin-core/manifest';
+import { readSkillOwnerMarker } from './ownership.js';
 import { readJsonFile } from './json.js';
 import { assertStrictSemVer } from './manifest.js';
 import { resolveCliPackageRoot } from './paths.js';
+import { canonicalizePathThroughExistingAncestor } from './state-paths.js';
 import { sanitizeCatalogSourceErrorMessage } from './catalog-public-error.js';
 import { normalizeMarketplaceProductToken } from './platform-support.js';
+import { CODEX_NATIVE_RENDER_RECEIPT_PATH, parseCodexNativeRenderReceipt, serializeCodexNativeRenderReceipt, } from './codex-native-render-receipt.js';
+import { calculateCodexNativeRenderPayloadDigest } from './catalog-digests.js';
+import { createCodexSkillStagingTreeContentDigest } from './codex-skill-staging.js';
+import { readDynamicSkillTree } from './dynamic-skill-tree.js';
 const SOURCE_IDENTITY_PATTERN = /^sha256:[0-9a-f]{64}$/;
 export function getNamespacedMarketplaceName(sourceId) {
     return `aw-${sourceId}`;
@@ -32,6 +38,28 @@ export function projectMarketplaceManifestForPlatform(manifest, platform) {
 export function getLocalMarketplacePluginRoot(rootDir, pluginName) {
     return path.join(rootDir, 'plugins', pluginName);
 }
+export async function assertSafeNamespacedMarketplacePluginRoot(rootDir, pluginName) {
+    const pluginsRoot = path.join(rootDir, 'plugins');
+    const pluginRoot = getLocalMarketplacePluginRoot(rootDir, pluginName);
+    const pluginsStats = await lstatMarketplacePath(pluginsRoot);
+    if (pluginsStats && (!pluginsStats.isDirectory() || pluginsStats.isSymbolicLink())) {
+        throw new MarketplaceRootValidationError(pluginsRoot, 'marketplace plugins ancestor must be a regular directory.', 'unsafe');
+    }
+    const pluginStats = pluginsStats ? await lstatMarketplacePath(pluginRoot) : null;
+    if (pluginStats && (!pluginStats.isDirectory() || pluginStats.isSymbolicLink())) {
+        throw new MarketplaceRootValidationError(pluginRoot, 'marketplace plugin projection must be a regular directory.', 'unsafe');
+    }
+    const physicalRoot = await fs.realpath(rootDir);
+    for (const candidate of [pluginsStats ? pluginsRoot : null, pluginStats ? pluginRoot : null]) {
+        if (!candidate)
+            continue;
+        const relative = path.relative(physicalRoot, await fs.realpath(candidate));
+        if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+            throw new MarketplaceRootValidationError(candidate, 'marketplace plugin path escapes its physical root.', 'unsafe');
+        }
+    }
+    return pluginRoot;
+}
 export function getLocalMarketplaceCodexSkillsRoot(rootDir, pluginName) {
     return path.join(getLocalMarketplacePluginRoot(rootDir, pluginName), 'codex', 'skills');
 }
@@ -47,10 +75,12 @@ export async function readCliPackageInfo() {
 }
 export class MarketplaceRootValidationError extends Error {
     location;
+    reason;
     code = 'marketplaceRootInvalid';
-    constructor(location, message, cause) {
+    constructor(location, message, reason, cause) {
         super(`marketplaceRootInvalid: ${message}`, cause === undefined ? undefined : { cause });
         this.location = location;
+        this.reason = reason;
         this.name = 'MarketplaceRootValidationError';
     }
 }
@@ -59,7 +89,7 @@ function assertMarketplacePathBoundary(trustedRoot, candidatePath) {
     const candidate = path.resolve(candidatePath);
     const relative = path.relative(root, candidate);
     if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
-        throw new MarketplaceRootValidationError(candidate, 'marketplace path escapes its trusted root.');
+        throw new MarketplaceRootValidationError(candidate, 'marketplace path escapes its trusted root.', 'unsafe');
     }
     return { root, candidate };
 }
@@ -76,34 +106,48 @@ async function lstatMarketplacePath(filePath) {
 }
 async function inspectMarketplacePath(trustedRoot, candidatePath, finalKind) {
     const { root, candidate } = assertMarketplacePathBoundary(trustedRoot, candidatePath);
-    const paths = [root];
-    let current = root;
-    for (const segment of path.relative(root, candidate).split(path.sep).filter(Boolean)) {
-        current = path.join(current, segment);
-        paths.push(current);
-    }
-    let candidateStats = null;
-    for (const currentPath of paths) {
-        let stats;
-        try {
-            stats = await lstatMarketplacePath(currentPath);
-        }
-        catch (error) {
-            throw new MarketplaceRootValidationError(currentPath, 'marketplace path cannot be inspected.', error);
-        }
-        if (!stats)
-            return null;
-        const isFinal = currentPath === candidate;
-        const valid = isFinal && finalKind === 'file'
-            ? stats.isFile() && !stats.isSymbolicLink()
-            : stats.isDirectory() && !stats.isSymbolicLink();
-        if (!valid) {
-            throw new MarketplaceRootValidationError(currentPath, isFinal && finalKind === 'file'
-                ? 'marketplace JSON target must be a regular file.'
-                : 'marketplace path must be a regular directory.');
-        }
-        if (isFinal)
-            candidateStats = stats;
+    let rootStats;
+    let candidateStats;
+    try {
+        [rootStats, candidateStats] = await Promise.all([
+            lstatMarketplacePath(root),
+            lstatMarketplacePath(candidate),
+        ]);
+    }
+    catch (error) {
+        throw new MarketplaceRootValidationError(candidate, 'marketplace path cannot be inspected.', 'unreadable', error);
+    }
+    if (!rootStats)
+        return null;
+    if (!rootStats.isDirectory() || rootStats.isSymbolicLink()) {
+        throw new MarketplaceRootValidationError(root, 'marketplace root must be a regular directory.', 'unsafe');
+    }
+    let physicalRoot;
+    let physicalCandidate;
+    try {
+        [physicalRoot, physicalCandidate] = await Promise.all([
+            canonicalizePathThroughExistingAncestor(root),
+            canonicalizePathThroughExistingAncestor(candidate),
+        ]);
+    }
+    catch (error) {
+        throw new MarketplaceRootValidationError(candidate, 'marketplace path cannot be resolved.', 'unreadable', error);
+    }
+    try {
+        assertMarketplacePathBoundary(physicalRoot, physicalCandidate);
+    }
+    catch {
+        throw new MarketplaceRootValidationError(candidate, 'marketplace physical path escapes its trusted root.', 'unsafe');
+    }
+    if (!candidateStats)
+        return null;
+    const valid = finalKind === 'file'
+        ? candidateStats.isFile() && !candidateStats.isSymbolicLink()
+        : candidateStats.isDirectory() && !candidateStats.isSymbolicLink();
+    if (!valid) {
+        throw new MarketplaceRootValidationError(candidate, finalKind === 'file'
+            ? 'marketplace JSON target must be a regular file.'
+            : 'marketplace path must be a regular directory.', 'unsafe');
     }
     return candidateStats;
 }
@@ -113,28 +157,14 @@ async function readStrictOptionalJsonObject(trustedRoot, filePath) {
     try {
         const value = await fs.readJson(filePath);
         if (!isRecord(value)) {
-            throw new MarketplaceRootValidationError(filePath, 'marketplace JSON must contain an object.');
+            throw new MarketplaceRootValidationError(filePath, 'marketplace JSON must contain an object.', 'invalid');
         }
         return value;
     }
     catch (error) {
         if (error instanceof MarketplaceRootValidationError)
             throw error;
-        throw new MarketplaceRootValidationError(filePath, 'marketplace JSON cannot be read.', error);
-    }
-}
-async function readOptionalJsonObject(filePath) {
-    try {
-        const value = await fs.readJson(filePath);
-        if (!isRecord(value))
-            throw new Error(`Expected a JSON object at ${filePath}.`);
-        return value;
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === 'ENOENT' || code === 'ENOTDIR')
-            return null;
-        throw error;
+        throw new MarketplaceRootValidationError(filePath, 'marketplace JSON cannot be read.', error instanceof SyntaxError ? 'invalid' : 'unreadable', error);
     }
 }
 export async function readStrictNamespacedMarketplaceRoot(options) {
@@ -149,10 +179,12 @@ export async function readStrictNamespacedMarketplaceRoot(options) {
         || config.sourceId.length === 0
         || typeof config.sourceIdentity !== 'string'
         || !SOURCE_IDENTITY_PATTERN.test(config.sourceIdentity)
+        || (config.logicalIdentity !== undefined
+            && (typeof config.logicalIdentity !== 'string' || config.logicalIdentity.trim() === ''))
         || typeof config.marketplaceName !== 'string'
         || config.marketplaceName.length === 0
         || config.sourceId !== path.basename(options.rootDir)) {
-        throw new MarketplaceRootValidationError(configPath, 'marketplace config must contain a canonical schema 2 identity.');
+        throw new MarketplaceRootValidationError(configPath, 'marketplace config must contain a canonical schema 2 identity.', 'invalid');
     }
     if ((options.sourceId !== undefined && config.sourceId !== options.sourceId)
         || (options.sourceIdentity !== undefined && config.sourceIdentity !== options.sourceIdentity)
@@ -161,11 +193,11 @@ export async function readStrictNamespacedMarketplaceRoot(options) {
     }
     const agentsManifest = await readStrictOptionalJsonObject(trustedMarketplaceRoot, path.join(options.rootDir, '.agents', 'plugins', 'marketplace.json'));
     if (!agentsManifest || agentsManifest.name !== config.marketplaceName) {
-        throw new MarketplaceRootValidationError(path.join(options.rootDir, '.agents', 'plugins', 'marketplace.json'), 'Codex marketplace manifest name does not match config.');
+        throw new MarketplaceRootValidationError(path.join(options.rootDir, '.agents', 'plugins', 'marketplace.json'), 'Codex marketplace manifest name does not match config.', 'invalid');
     }
     const claudeManifest = await readStrictOptionalJsonObject(trustedMarketplaceRoot, path.join(options.rootDir, '.claude-plugin', 'marketplace.json'));
     if (claudeManifest && claudeManifest.name !== config.marketplaceName) {
-        throw new MarketplaceRootValidationError(path.join(options.rootDir, '.claude-plugin', 'marketplace.json'), 'Claude marketplace manifest name does not match config.');
+        throw new MarketplaceRootValidationError(path.join(options.rootDir, '.claude-plugin', 'marketplace.json'), 'Claude marketplace manifest name does not match config.', 'invalid');
     }
     return {
         rootDir: options.rootDir,
@@ -176,8 +208,14 @@ export async function readStrictNamespacedMarketplaceRoot(options) {
 }
 function normalizePluginRelativeDirectory(value, fallback) {
     const raw = typeof value === 'string' ? value : fallback;
-    const normalized = path.posix.normalize(raw.replace(/^\.\//, ''));
-    if (!normalized || normalized === '.' || normalized === '..' || normalized.startsWith('../')) {
+    const normalizedSeparators = raw.replace(/\\/gu, '/');
+    const normalized = path.posix.normalize(normalizedSeparators.replace(/^\.\//, ''));
+    if (!normalized
+        || normalized === '.'
+        || normalized === '..'
+        || normalized.startsWith('../')
+        || path.posix.isAbsolute(normalizedSeparators)
+        || path.win32.isAbsolute(raw)) {
         return null;
     }
     return normalized;
@@ -190,19 +228,337 @@ async function assertTreeHasNoSymlinks(root) {
             await assertTreeHasNoSymlinks(path.join(root, entry.name));
     }
 }
-async function pathExists(filePath) {
+class CodexNativeProjectionNotReusableError extends Error {
+}
+function nativeCodexTargets(manifest) {
+    const targets = manifest.artifacts?.targets ?? [];
+    if (!Array.isArray(targets))
+        return [];
+    return targets.flatMap((target) => {
+        if (!isRecord(target)
+            || target.platform !== 'codex'
+            || target.target !== 'codex.skill'
+            || !isRecord(target.delivery)
+            || target.delivery.mode !== 'codex-native'
+            || typeof target.id !== 'string'
+            || typeof target.skillKey !== 'string')
+            return [];
+        return [{ id: target.id, skillKey: target.skillKey }];
+    }).sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
+}
+async function assertRegularProjectionTree(root, rejectOwnerMarker = false) {
+    for (const entry of await fs.readdir(root, { withFileTypes: true })) {
+        if (entry.isSymbolicLink() || (!entry.isDirectory() && !entry.isFile())) {
+            throw new Error(`codexNativeProjectionUnsafe: projection contains an unsafe node: ${entry.name}`);
+        }
+        if (rejectOwnerMarker && entry.name === '.agent-workflows-owner.json') {
+            throw new Error('codexNativeProjectionUnsafe: native Skill cannot contain an AW owner marker.');
+        }
+        if (entry.isDirectory()) {
+            await assertRegularProjectionTree(path.join(root, entry.name), rejectOwnerMarker);
+        }
+    }
+}
+async function readProjectionJson(trustedRoot, filePath) {
+    const stats = await inspectMarketplacePath(trustedRoot, filePath, 'file');
+    if (!stats)
+        throw new CodexNativeProjectionNotReusableError();
     try {
-        await fs.lstat(filePath);
-        return true;
+        const value = await fs.readJson(filePath);
+        if (!isRecord(value))
+            throw new CodexNativeProjectionNotReusableError();
+        return value;
     }
     catch (error) {
-        const code = error.code;
-        if (code === 'ENOENT' || code === 'ENOTDIR')
-            return false;
-        throw error;
+        if (error instanceof CodexNativeProjectionNotReusableError)
+            throw error;
+        if (error.code)
+            throw error;
+        throw new CodexNativeProjectionNotReusableError();
     }
 }
-async function readOverlayDirectory(directoryPath, redactedRoots) {
+async function readValidatedCodexProjection(options) {
+    const pluginRoot = path.join(options.sourceRoot, 'plugins', options.pluginName);
+    const platformManifest = await readProjectionJson(options.sourceRoot, path.join(pluginRoot, '.codex-plugin', 'plugin.json'));
+    if (platformManifest.name !== options.pluginName)
+        throw new Error('codexNativeProjectionIdentityMismatch: plugin identity does not match its marketplace path.');
+    const skillsRelative = normalizePluginRelativeDirectory(platformManifest.skills, 'codex/skills');
+    if (!skillsRelative)
+        throw new Error('codexNativeProjectionUnsafe: Codex Skills root is unsafe.');
+    const receiptPath = path.join(pluginRoot, CODEX_NATIVE_RENDER_RECEIPT_PATH);
+    if (!await inspectMarketplacePath(options.sourceRoot, receiptPath, 'file'))
+        throw new CodexNativeProjectionNotReusableError();
+    let receipt;
+    try {
+        receipt = parseCodexNativeRenderReceipt(await fs.readFile(receiptPath, 'utf8'));
+    }
+    catch (error) {
+        if (error.code)
+            throw error;
+        throw new CodexNativeProjectionNotReusableError();
+    }
+    if (receipt.logicalPluginId !== `${options.sourceId}/${options.pluginName}` || receipt.sourceIdentity !== options.sourceIdentity) {
+        throw new Error('codexNativeProjectionIdentityMismatch: receipt identity does not match its marketplace.');
+    }
+    // The other platform may have updated the common bundle metadata. The installed
+    // Codex manifest and verified receipt retain this platform's actual version and targets.
+    if (platformManifest.version !== receipt.pluginVersion)
+        throw new CodexNativeProjectionNotReusableError();
+    const emptyDigest = createCodexSkillStagingTreeContentDigest({ skillKey: 'empty', files: {} });
+    for (const target of receipt.targets) {
+        const skillRoot = path.join(pluginRoot, ...skillsRelative.split('/'), target.skillKey);
+        const stats = await inspectMarketplacePath(options.sourceRoot, skillRoot, 'directory');
+        if (stats)
+            await assertRegularProjectionTree(skillRoot, true);
+        let tree;
+        try {
+            tree = stats ? await readDynamicSkillTree(skillRoot, 'codex.skill') : null;
+        }
+        catch (error) {
+            if (error.code)
+                throw error;
+            throw new CodexNativeProjectionNotReusableError();
+        }
+        if ((stats && !tree) || (tree ? createCodexSkillStagingTreeContentDigest(tree) : emptyDigest) !== target.artifactDigest)
+            throw new CodexNativeProjectionNotReusableError();
+    }
+    if (await calculateCodexNativeRenderPayloadDigest(pluginRoot) !== receipt.payloadDigest)
+        throw new CodexNativeProjectionNotReusableError();
+    return receipt;
+}
+async function preserveMarketplacePluginProjection(options) {
+    const sourcePluginRoot = path.join(options.sourceRoot, 'plugins', options.pluginName);
+    const stagingPluginRoot = path.join(options.stagingRoot, 'plugins', options.pluginName);
+    const sourceManifest = await readProjectionJson(options.sourceRoot, path.join(sourcePluginRoot, '.agents-plugin', 'plugin.json'));
+    const stagingManifest = await readProjectionJson(options.stagingRoot, path.join(stagingPluginRoot, '.agents-plugin', 'plugin.json'));
+    if (sourceManifest.name !== options.pluginName || stagingManifest.name !== options.pluginName)
+        throw new Error(`${nativeCodexTargets(sourceManifest).length ? 'codexNativeProjectionIdentityMismatch' : 'marketplaceProjectionIdentityMismatch'}: plugin identity does not match its marketplace path.`);
+    await assertRegularProjectionTree(sourcePluginRoot);
+    await assertRegularProjectionTree(stagingPluginRoot);
+    let receipt;
+    if (nativeCodexTargets(sourceManifest).length || await inspectMarketplacePath(options.sourceRoot, path.join(sourcePluginRoot, CODEX_NATIVE_RENDER_RECEIPT_PATH), 'file')) {
+        receipt = await readValidatedCodexProjection(options);
+    }
+    else {
+        for (const platform of ['codex', 'claude']) {
+            const manifestPath = path.join(sourcePluginRoot, `.${platform}-plugin`, 'plugin.json');
+            if (!await inspectMarketplacePath(options.sourceRoot, manifestPath, 'file'))
+                continue;
+            const manifest = await readProjectionJson(options.sourceRoot, manifestPath);
+            if (manifest.name !== options.pluginName)
+                throw new Error('marketplaceProjectionIdentityMismatch: plugin identity does not match its marketplace path.');
+            assertStrictSemVer(manifest.version, 'preserved platform plugin version');
+        }
+    }
+    await fs.remove(stagingPluginRoot);
+    await fs.copy(sourcePluginRoot, stagingPluginRoot, { dereference: false });
+    if (receipt && await calculateCodexNativeRenderPayloadDigest(stagingPluginRoot) !== receipt.payloadDigest)
+        throw new CodexNativeProjectionNotReusableError();
+}
+async function preserveUnrequestedMarketplacePlatforms(options) {
+    if (options.requested.has('codex') && options.requested.has('claude'))
+        return { platforms: [] };
+    const sourcePluginRoot = path.join(options.sourceRoot, 'plugins', options.pluginName);
+    const stagingPluginRoot = path.join(options.stagingRoot, 'plugins', options.pluginName);
+    const sourceManifest = await readProjectionJson(options.sourceRoot, path.join(sourcePluginRoot, '.agents-plugin', 'plugin.json'));
+    if (sourceManifest.name !== options.pluginName)
+        throw new Error('marketplaceProjectionIdentityMismatch: retained plugin identity does not match its path.');
+    const platforms = [];
+    let receipt;
+    for (const platform of ['codex', 'claude']) {
+        if (options.requested.has(platform))
+            continue;
+        const manifestRelative = `.${platform}-plugin`;
+        if (!await inspectMarketplacePath(options.sourceRoot, path.join(sourcePluginRoot, manifestRelative, 'plugin.json'), 'file'))
+            continue;
+        const manifest = await readProjectionJson(options.sourceRoot, path.join(sourcePluginRoot, manifestRelative, 'plugin.json'));
+        if (manifest.name !== options.pluginName)
+            throw new Error('marketplaceProjectionIdentityMismatch: retained platform identity does not match its path.');
+        assertStrictSemVer(manifest.version, 'preserved platform plugin version');
+        const roots = new Set([platform, manifestRelative]);
+        const skillsRelative = manifest.skills === undefined ? undefined : normalizePluginRelativeDirectory(manifest.skills, `${platform}/skills`);
+        if (manifest.skills !== undefined) {
+            const relative = normalizePluginRelativeDirectory(manifest.skills, `${platform}/skills`);
+            if (!relative || ['codex', 'claude'].some((other) => other !== platform && (relative === other || relative.startsWith(`${other}/`))) || ['.agents-plugin', '.codex-plugin', '.claude-plugin'].some((root) => relative === root || relative.startsWith(`${root}/`))) {
+                throw new Error('marketplaceProjectionInvalid: retained Skill root overlaps another platform.');
+            }
+            roots.add(relative);
+        }
+        for (const requested of options.requested) {
+            const requestedManifest = await readProjectionJson(options.stagingRoot, path.join(stagingPluginRoot, `.${requested}-plugin`, 'plugin.json'));
+            const requestedSkills = requestedManifest.skills === undefined ? undefined : normalizePluginRelativeDirectory(requestedManifest.skills, `${requested}/skills`);
+            if (requestedManifest.skills !== undefined && !requestedSkills)
+                throw new Error('marketplaceProjectionInvalid: requested Skill root is unsafe.');
+            for (const retainedRoot of roots)
+                for (const requestedRoot of [requested, `.${requested}-plugin`, '.agents-plugin', ...(requestedSkills ? [requestedSkills] : [])]) {
+                    if (retainedRoot === requestedRoot || retainedRoot.startsWith(`${requestedRoot}/`) || requestedRoot.startsWith(`${retainedRoot}/`))
+                        throw new Error('marketplaceProjectionInvalid: retained platform resources overlap the requested platform.');
+                }
+        }
+        const codexReceipt = platform === 'codex' && await inspectMarketplacePath(options.sourceRoot, path.join(sourcePluginRoot, CODEX_NATIVE_RENDER_RECEIPT_PATH), 'file')
+            ? await readValidatedCodexProjection(options) : undefined;
+        if (platform === 'codex' && !codexReceipt) {
+            for (const target of nativeCodexTargets(sourceManifest)) {
+                const tree = skillsRelative ? path.join(sourcePluginRoot, ...skillsRelative.split('/'), target.skillKey) : undefined;
+                if (tree && await inspectMarketplacePath(options.sourceRoot, tree, 'directory'))
+                    throw new Error('codexNativeProjectionDamaged: an installed dynamic Skill has no render receipt; reinstall both platforms.');
+            }
+        }
+        const checked = new Set();
+        const validateRecords = async (directory) => {
+            if (checked.has(directory))
+                return;
+            checked.add(directory);
+            for (const entry of await fs.readdir(directory, { withFileTypes: true })) {
+                const absolute = path.join(directory, entry.name);
+                if (entry.isDirectory())
+                    await validateRecords(absolute);
+                else if (entry.name === '.aw-command-producer.json') {
+                    const record = normalizeInstalledCommandProducer(await fs.readJson(absolute));
+                    const producer = record.producer;
+                    if (producer.sourceId !== options.sourceId || producer.sourceIdentity !== options.sourceIdentity || producer.pluginName !== options.pluginName || producer.platform !== platform || producer.scope !== 'user' || producer.projectRoot !== null || producer.kind === 'package')
+                        throw new Error('commandOwnerMismatch: retained native producer does not match its platform and source.');
+                    const skillKey = producer.kind === 'static-skill' ? producer.key : codexReceipt?.targets.find((target) => target.id === producer.key)?.skillKey;
+                    if (!skillsRelative || !skillKey || directory !== path.join(sourcePluginRoot, ...skillsRelative.split('/'), skillKey))
+                        throw new Error('commandOwnerMismatch: retained native producer is outside its exact Skill path.');
+                    if (!await readDynamicSkillTree(directory, `${platform}.skill`))
+                        throw new Error('commandResourceInvalid: retained native producer has no valid Skill.');
+                    await validateCommandEntryFiles(directory, record.sets.flatMap((set) => set.entries));
+                }
+            }
+        };
+        for (const relative of roots) {
+            const source = path.join(sourcePluginRoot, ...relative.split('/'));
+            if (await inspectMarketplacePath(options.sourceRoot, source, 'directory')) {
+                await assertRegularProjectionTree(source, true);
+                await validateRecords(source);
+            }
+        }
+        if (codexReceipt) {
+            receipt = { pluginName: options.pluginName, receipt: codexReceipt };
+            await fs.copy(path.join(sourcePluginRoot, CODEX_NATIVE_RENDER_RECEIPT_PATH), path.join(stagingPluginRoot, CODEX_NATIVE_RENDER_RECEIPT_PATH));
+        }
+        for (const relative of roots) {
+            const source = path.join(sourcePluginRoot, ...relative.split('/'));
+            const destination = path.join(stagingPluginRoot, ...relative.split('/'));
+            await fs.remove(destination);
+            if (await inspectMarketplacePath(options.sourceRoot, source, 'directory'))
+                await fs.copy(source, destination, { dereference: false });
+        }
+        platforms.push(platform);
+    }
+    return { platforms, ...(receipt ? { receipt } : {}) };
+}
+/** Rebind only the combined payload digest after verified, unrelated platform changes. */
+export async function refreshPreservedPlatformReceipt(stagingRoot, retained) {
+    const pluginRoot = path.join(stagingRoot, 'plugins', retained.pluginName);
+    const payloadDigest = await calculateCodexNativeRenderPayloadDigest(pluginRoot);
+    await fs.outputFile(path.join(pluginRoot, CODEX_NATIVE_RENDER_RECEIPT_PATH), serializeCodexNativeRenderReceipt({ ...retained.receipt, payloadDigest }), 'utf8');
+}
+/**
+ * Replays unselected plugin copies into a fresh Catalog generation.
+ * Retains their payload and marketplace entries even when the Catalog changes.
+ * Codex native dynamic projections must also retain their original validated receipt.
+ * Damaged weak projections are skipped so their owning plugin can recover by sync.
+ */
+export async function replayNamespacedMarketplacePluginProjections(options) {
+    let existing;
+    try {
+        existing = await readStrictNamespacedMarketplaceRoot({
+            trustedMarketplaceRoot: path.dirname(options.sourceRoot),
+            rootDir: options.sourceRoot,
+            sourceId: options.sourceId,
+            sourceIdentity: options.sourceIdentity,
+            marketplaceName: options.marketplaceName,
+        });
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('sourceChanged:'))
+            throw error;
+        throw new Error(`marketplaceProjectionReadFailed: ${sanitizeCatalogSourceErrorMessage(error instanceof Error ? error.message : String(error), process.env, [options.sourceRoot, options.stagingRoot])}`);
+    }
+    if (!existing)
+        return;
+    const retainedPluginNames = { codex: new Set(), claude: new Set() };
+    const pluginsRoot = path.join(options.sourceRoot, 'plugins');
+    let entries;
+    try {
+        entries = await readOverlayDirectory(options.sourceRoot, pluginsRoot, [options.sourceRoot, options.stagingRoot]);
+    }
+    catch (error) {
+        throw new Error(`marketplaceProjectionReadFailed: ${sanitizeCatalogSourceErrorMessage(error instanceof Error ? error.message : String(error), process.env, [options.sourceRoot, options.stagingRoot])}`);
+    }
+    for (const entry of entries) {
+        if (entry.isSymbolicLink()) {
+            throw new Error('codexNativeProjectionUnsafe: plugin root cannot be a symlink.');
+        }
+        if (!entry.isDirectory())
+            continue;
+        const logicalPluginId = `${options.sourceId}/${entry.name}`;
+        if (options.rematerializedPluginIds?.has(logicalPluginId)) {
+            const requested = options.rematerializedPluginPlatforms?.get(logicalPluginId);
+            if (requested) {
+                try {
+                    const retained = await preserveUnrequestedMarketplacePlatforms({ ...options, pluginName: entry.name, requested });
+                    for (const platform of retained.platforms)
+                        retainedPluginNames[platform].add(entry.name);
+                    if (retained.receipt)
+                        options.onPreservedPlatformReceipt?.(retained.receipt);
+                }
+                catch (error) {
+                    throw new Error(`marketplaceProjectionInvalid: cannot preserve the unrequested platform for ${logicalPluginId}; reinstall both platforms. ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            continue;
+        }
+        try {
+            await preserveMarketplacePluginProjection({ ...options, pluginName: entry.name });
+            retainedPluginNames.codex.add(entry.name);
+            retainedPluginNames.claude.add(entry.name);
+        }
+        catch (error) {
+            if (error instanceof CodexNativeProjectionNotReusableError)
+                continue;
+            throw new Error(`marketplaceProjectionReadFailed: ${sanitizeCatalogSourceErrorMessage(error instanceof Error ? error.message : String(error), process.env, [options.sourceRoot, options.stagingRoot])}`);
+        }
+    }
+    for (const [sourceManifest, relativePath, platform] of [
+        [existing.agentsManifest, '.agents/plugins/marketplace.json', 'codex'],
+        [existing.claudeManifest, '.claude-plugin/marketplace.json', 'claude'],
+    ]) {
+        const manifestPath = path.join(options.stagingRoot, relativePath);
+        const stagingManifest = await readStrictOptionalJsonObject(options.stagingRoot, manifestPath);
+        const retainedNames = retainedPluginNames[platform];
+        if (!stagingManifest || retainedNames.size === 0)
+            continue;
+        if (!Array.isArray(stagingManifest.plugins) || (sourceManifest && !Array.isArray(sourceManifest.plugins))) {
+            throw new Error('marketplaceProjectionInvalid: marketplace plugins must be an array.');
+        }
+        const retainedEntries = (sourceManifest?.plugins ?? []).filter((entry) => isRecord(entry)
+            && typeof entry.name === 'string' && retainedNames.has(entry.name));
+        await fs.writeJson(manifestPath, {
+            ...stagingManifest,
+            plugins: [
+                ...stagingManifest.plugins.filter((entry) => !isRecord(entry) || !retainedNames.has(String(entry.name))),
+                ...retainedEntries.map((entry) => ({
+                    ...entry,
+                    source: `./plugins/${entry.name}`,
+                })),
+            ],
+        }, { spaces: 2 });
+    }
+}
+async function inspectOverlayPath(trustedRoot, targetPath, finalKind, redactedRoots) {
+    try {
+        return await inspectMarketplacePath(trustedRoot, targetPath, finalKind);
+    }
+    catch (error) {
+        throw new Error(`marketplaceOverlayReadFailed: ${sanitizeCatalogSourceErrorMessage(error instanceof Error ? error.message : String(error), process.env, redactedRoots)}`);
+    }
+}
+async function readOverlayDirectory(trustedRoot, directoryPath, redactedRoots) {
+    if (!await inspectOverlayPath(trustedRoot, directoryPath, 'directory', redactedRoots))
+        return [];
     try {
         return await fs.readdir(directoryPath, { withFileTypes: true });
     }
@@ -233,7 +589,7 @@ export async function replayNamespacedCodexSkillOverlays(options) {
         return;
     const pluginsRoot = path.join(options.sourceRoot, 'plugins');
     const redactedRoots = [options.sourceRoot, options.stagingRoot];
-    for (const pluginEntry of await readOverlayDirectory(pluginsRoot, redactedRoots)) {
+    for (const pluginEntry of await readOverlayDirectory(options.sourceRoot, pluginsRoot, redactedRoots)) {
         if (pluginEntry.isSymbolicLink()) {
             throw new Error(`Codex Skill overlay plugin root cannot be a symlink: ${pluginEntry.name}`);
         }
@@ -241,28 +597,25 @@ export async function replayNamespacedCodexSkillOverlays(options) {
             continue;
         const pluginName = pluginEntry.name;
         const sourcePluginRoot = path.join(pluginsRoot, pluginName);
-        const sourcePlatformManifest = await readOptionalJsonObject(path.join(sourcePluginRoot, '.codex-plugin', 'plugin.json'));
+        const sourcePlatformManifest = await readStrictOptionalJsonObject(options.sourceRoot, path.join(sourcePluginRoot, '.codex-plugin', 'plugin.json'));
         const sourceSkillsRelative = normalizePluginRelativeDirectory(sourcePlatformManifest?.skills, 'codex/skills');
         if (!sourceSkillsRelative)
             continue;
         const sourceSkillsRoot = path.join(sourcePluginRoot, ...sourceSkillsRelative.split('/'));
         const overlays = [];
-        for (const entry of await readOverlayDirectory(sourceSkillsRoot, redactedRoots)) {
+        for (const entry of await readOverlayDirectory(options.sourceRoot, sourceSkillsRoot, redactedRoots)) {
             if (entry.isSymbolicLink()) {
                 throw new Error(`Codex Skill overlay cannot be a symlink: ${path.join(sourceSkillsRoot, entry.name)}`);
             }
             if (!entry.isDirectory())
                 continue;
             const skillRoot = path.join(sourceSkillsRoot, entry.name);
-            if (!await pathExists(path.join(skillRoot, SKILL_OWNER_MARKER)))
-                continue;
-            await readSkillOwnerMarker({
+            const owner = await readSkillOwnerMarker({
                 skillRoot,
                 allowedRoot: sourceSkillsRoot,
                 expectedIdentity: {
                     owner: 'agent-workflows',
                     sourceId: options.sourceId,
-                    sourceIdentity: options.sourceIdentity,
                     pluginId: `${options.sourceId}/${pluginName}`,
                     plugin: pluginName,
                     artifactKey: entry.name,
@@ -270,47 +623,44 @@ export async function replayNamespacedCodexSkillOverlays(options) {
                     scope: 'user',
                 },
             });
+            if (!owner)
+                continue;
             overlays.push({ key: entry.name, root: skillRoot });
         }
         if (overlays.length === 0)
             continue;
         const stagingPluginRoot = path.join(options.stagingRoot, 'plugins', pluginName);
-        if (!await pathExists(stagingPluginRoot)) {
-            await assertTreeHasNoSymlinks(sourcePluginRoot);
-            await fs.copy(sourcePluginRoot, stagingPluginRoot, {
-                overwrite: false, errorOnExist: true, dereference: false,
-            });
+        if (!await inspectOverlayPath(options.stagingRoot, stagingPluginRoot, 'directory', redactedRoots))
             continue;
-        }
-        const stagingManifest = await readOptionalJsonObject(path.join(stagingPluginRoot, '.agents-plugin', 'plugin.json'));
+        const stagingManifest = await readStrictOptionalJsonObject(options.stagingRoot, path.join(stagingPluginRoot, '.agents-plugin', 'plugin.json'));
         const targets = stagingManifest?.artifacts?.targets ?? [];
         const dynamicKeys = new Set(targets.flatMap((target) => {
             if (!isRecord(target))
                 return [];
             return target.platform === 'codex'
                 && target.target === 'codex.skill'
+                && isRecord(target.delivery)
+                && target.delivery.mode === 'codex-native'
                 && Array.isArray(target.scopes)
                 && target.scopes.includes('user')
                 && typeof target.skillKey === 'string'
                 ? [target.skillKey]
                 : [];
         }));
-        const stagingPlatformManifest = await readOptionalJsonObject(path.join(stagingPluginRoot, '.codex-plugin', 'plugin.json'));
+        const stagingPlatformManifest = await readStrictOptionalJsonObject(options.stagingRoot, path.join(stagingPluginRoot, '.codex-plugin', 'plugin.json'));
         const stagingSkillsRelative = normalizePluginRelativeDirectory(stagingPlatformManifest?.skills, 'codex/skills');
         if (!stagingSkillsRelative)
             continue;
         const stagingSkillsRoot = path.join(stagingPluginRoot, ...stagingSkillsRelative.split('/'));
+        await inspectOverlayPath(options.stagingRoot, stagingSkillsRoot, 'directory', redactedRoots);
         for (const overlay of overlays) {
+            if (!dynamicKeys.has(overlay.key))
+                continue;
             const destination = path.join(stagingSkillsRoot, overlay.key);
-            if (dynamicKeys.has(overlay.key) || !await pathExists(destination)) {
-                await assertTreeHasNoSymlinks(overlay.root);
-                await fs.copy(overlay.root, destination, {
-                    overwrite: true, errorOnExist: false, dereference: false,
-                });
-            }
-            else {
-                await fs.copyFile(path.join(overlay.root, SKILL_OWNER_MARKER), path.join(destination, SKILL_OWNER_MARKER));
-            }
+            await assertTreeHasNoSymlinks(overlay.root);
+            await fs.copy(overlay.root, destination, {
+                overwrite: true, errorOnExist: false, dereference: false,
+            });
         }
     }
 }