@lesliechan721/aw 0.1.0-beta.5 → 0.1.0-beta.50

package/dist/src/utils/catalog-source-references.js

@@ -4,13 +4,10 @@ import { readClaudeSettings } from '../adapters/helpers.js';
 import { readCodexConfigFile } from './codex-config.js';
 import { readJsonFileIfExists } from './json.js';
 import { getClaudeHome, getCodexHome, canonicalizePathThroughExistingAncestorSync, resolveAwHome, resolveAwHomeCanonical, resolveRepoRootSync, } from './state-paths.js';
-import { OWNED_TEXT_HEADER_PREFIX, parseSharedOwnerToken, parseOwnedTextHeader, readSkillOwnerMarker, SKILL_OWNER_MARKER, } from './ownership.js';
-import { createLifecycleProjectLocationKey, inspectLifecycleActiveSnapshotForInventory, } from './lifecycle-active-store.js';
-import { CodexNativeResidueProbeError, discoverCodexNativeResidueNames, } from '../commands/rebuild-integration.js';
-import { parseCodexSharedHooksFile } from './hooks-contract.js';
+import { OWNED_TEXT_HEADER_PREFIX, SHARED_OWNER_TOKEN_PREFIX, parseSharedOwnerToken, parseOwnedTextHeader, readSkillOwnerMarker, SKILL_OWNER_MARKER, } from './ownership.js';
 import { sanitizeCatalogSourceErrorMessage } from './catalog-public-error.js';
-import { readPluginManifest } from './manifest.js';
 import { readStrictNamespacedMarketplaceRoot } from './local-marketplace.js';
+import { readPluginIntentState, resolvePluginIntentStatePath, } from './plugin-intent-state.js';
 export function canonicalMarketplaceRegistrationNames(references, sourceId) {
     return [...new Set(references.flatMap((reference) => reference.kind === 'namespacedMarketplace'
             && reference.sourceId === sourceId
@@ -47,7 +44,7 @@ function claudeConsumersFromSettings(value, marketplaceName, scope) {
     }
     return output;
 }
-function claudeConsumersFromInstalled(value, marketplaceName, currentProject, includeHistoricalProjects) {
+function claudeConsumersFromInstalled(value, marketplaceName, currentProject, includeHistoricalProjects = false) {
     const output = [];
     if (value !== null && !isRecord(value)) {
         throw new Error('Claude installed_plugins must be a JSON object.');
@@ -90,7 +87,7 @@ function claudeConsumersFromInstalled(value, marketplaceName, currentProject, in
                     ? canonicalizePathThroughExistingAncestorSync(item.projectPath)
                     : null
                 : undefined;
-            if (!includeHistoricalProjects && scope === 'project' && projectKey !== currentProject)
+            if (scope === 'project' && !includeHistoricalProjects && projectKey !== currentProject)
                 continue;
             const pluginName = typeof item.name === 'string'
                 ? item.name
@@ -156,9 +153,7 @@ function inventoryErrorRelevance(location, env, cwd) {
         [path.join(awHome, 'plugin-config'), 'user'],
         [path.join(canonicalAwHome, 'plugin-config'), 'user'],
         [path.join(repoRoot, '.agent-workflows', 'plugin-config'), 'project'],
-        [path.join(repoRoot, '.agent-workflows', 'plugin-config.local'), 'project'],
         [path.join(canonicalRepoRoot, '.agent-workflows', 'plugin-config'), 'project'],
-        [path.join(canonicalRepoRoot, '.agent-workflows', 'plugin-config.local'), 'project'],
     ]) {
         const segments = pathSegmentsWithin(root, location);
         if (segments !== null) {
@@ -175,26 +170,6 @@ function inventoryErrorRelevance(location, env, cwd) {
             return { global: false, scope: 'project' };
         }
     }
-    const lifecycle = pathSegmentsWithin(path.join(awHome, 'lifecycle-active'), location);
-    if (lifecycle?.[0]) {
-        const platform = lifecycle[1] === 'codex' || lifecycle[1] === 'claude'
-            ? lifecycle[1]
-            : undefined;
-        const scope = lifecycle[2] === 'user' || lifecycle[2] === 'project'
-            ? lifecycle[2]
-            : undefined;
-        const pluginName = platform && scope && lifecycle.length >= 5
-            && (scope === 'project' || lifecycle[3] === 'user')
-            ? lifecycle[4]
-            : undefined;
-        return {
-            global: false,
-            sourceId: lifecycle[0],
-            ...(pluginName ? { pluginName } : {}),
-            ...(platform ? { platform } : {}),
-            ...(scope ? { scope } : {}),
-        };
-    }
     return { global: true };
 }
 function isAbsentState(error) {
@@ -297,7 +272,7 @@ async function inventoryPluginConfigRoots(options) {
             cwd: options.cwd,
         });
         if (userRoot)
-            roots.push(userRoot);
+            roots.push({ root: userRoot, scope: 'user' });
     }
     const rawRepoRoot = resolveRepoRootSync(options.cwd);
     const repoRoot = await inventoryRead({
@@ -317,18 +292,16 @@ async function inventoryPluginConfigRoots(options) {
         env: options.env,
         cwd: options.cwd,
     })) {
-        for (const storeName of ['plugin-config', 'plugin-config.local']) {
-            const projectRoot = await inventoryCanonicalDescendantDirectory({
-                root: rawRepoRoot,
-                segments: ['.agent-workflows', storeName],
-                errors: options.errors,
-                kind: 'configDirectoryRead',
-                env: options.env,
-                cwd: options.cwd,
-            });
-            if (projectRoot)
-                roots.push(projectRoot);
-        }
+        const projectRoot = await inventoryCanonicalDescendantDirectory({
+            root: rawRepoRoot,
+            segments: ['.agent-workflows', 'plugin-config'],
+            errors: options.errors,
+            kind: 'configDirectoryRead',
+            env: options.env,
+            cwd: options.cwd,
+        });
+        if (projectRoot)
+            roots.push({ root: projectRoot, scope: 'project', projectKey: repoRoot });
     }
     return roots;
 }
@@ -341,7 +314,6 @@ export async function inventoryLegacyOwnerReferences(options) {
     const skillRoots = new Set([
         path.join(getCodexHome(env), 'skills'),
         path.join(getClaudeHome(env), 'skills'),
-        path.join(repoRoot, '.agents', 'skills'),
         path.join(repoRoot, '.claude', 'skills'),
     ]);
     const legacyPluginsRoot = path.join(awHome, 'plugins');
@@ -355,54 +327,23 @@ export async function inventoryLegacyOwnerReferences(options) {
         for (const root of await resolveCanonicalPluginSkillRoots(path.join(legacyPluginsRoot, plugin.name), true, errors, env, options.cwd))
             skillRoots.add(root);
     }
-    const marketplacesRoot = path.join(awHome, 'marketplaces');
-    const marketplaces = await inventoryCanonicalDirectoryEntries({
-        errors, location: marketplacesRoot, kind: 'marketplaceDirectoryRead', env, cwd: options.cwd,
-    });
-    for (const entry of marketplaces) {
-        const marketplaceRoot = path.join(marketplacesRoot, entry.name);
-        if (!await inventoryCanonicalDirectory({
-            errors,
-            location: marketplaceRoot,
-            kind: 'marketplaceRootValidation',
-            env,
-            cwd: options.cwd,
-        }))
-            continue;
-        const pluginsRoot = path.join(marketplacesRoot, entry.name, 'plugins');
-        const plugins = await inventoryCanonicalDirectoryEntries({
-            errors, location: pluginsRoot, kind: 'pluginDirectoryRead', env, cwd: options.cwd,
-        });
-        for (const plugin of plugins) {
-            const pluginRoot = path.join(pluginsRoot, plugin.name);
-            if (!await inventoryCanonicalDirectory({
-                errors,
-                location: pluginRoot,
-                kind: 'pluginDirectoryRead',
-                env,
-                cwd: options.cwd,
-            }))
-                continue;
-            for (const root of await resolveCanonicalPluginSkillRoots(pluginRoot, false, errors, env, options.cwd))
-                skillRoots.add(root);
-        }
-    }
     for (const root of skillRoots) {
         references.push(...await findDirectSkillOwnerMarkers(root, errors, env, options.cwd));
     }
     for (const configRoot of [
         getCodexHome(env),
         getClaudeHome(env),
-        path.join(repoRoot, '.codex'),
         path.join(repoRoot, '.claude'),
     ]) {
         references.push(...await findOwnedHeadersInDirectory(path.join(configRoot, 'rules'), new Set(['.md', '.rules']), true, errors, env, options.cwd), ...await findOwnedHeadersInDirectory(path.join(configRoot, 'agents'), new Set(['.md', '.toml']), true, errors, env, options.cwd));
     }
-    references.push(...await findOwnedHeadersInDirectory(path.join(repoRoot, '.agents', 'rules'), new Set(['.md']), false, errors, env, options.cwd), ...await findOwnedHeadersInDirectory(path.join(repoRoot, '.agents', 'agents'), new Set(['.md']), false, errors, env, options.cwd));
-    for (const filePath of [
-        path.join(getCodexHome(env), 'AGENTS.md'),
-        path.join(repoRoot, '.codex', 'AGENTS.md'),
+    for (const [directory, extensions] of [
+        [path.join(repoRoot, '.codex', 'rules'), new Set(['.md', '.rules'])],
+        [path.join(repoRoot, '.codex', 'agents'), new Set(['.md', '.toml'])],
     ]) {
+        references.push(...(await findOwnedHeadersInDirectory(directory, extensions, true, errors, env, options.cwd)).filter((reference) => reference.kind === 'namespacedOwner'));
+    }
+    for (const filePath of [path.join(getCodexHome(env), 'AGENTS.md')]) {
         const reference = await readOwnedHeaderReference(filePath, false, errors, env, options.cwd);
         if (reference)
             references.push(reference);
@@ -424,7 +365,8 @@ export async function inventoryLegacyConfigReferences(options) {
     const env = options.env ?? process.env;
     const references = [];
     const errors = [];
-    for (const directory of await inventoryPluginConfigRoots({ errors, env, cwd: options.cwd })) {
+    for (const configRoot of await inventoryPluginConfigRoots({ errors, env, cwd: options.cwd })) {
+        const directory = configRoot.root;
         const entries = await inventoryRead({
             operation: () => fs.readdir(directory, { withFileTypes: true }),
             absent: [], errors, location: directory, kind: 'configDirectoryRead', env, cwd: options.cwd,
@@ -441,7 +383,13 @@ export async function inventoryLegacyConfigReferences(options) {
                 absent: null, errors, location: legacyFile, kind: 'configFileStat', env, cwd: options.cwd,
             });
             if (stat?.isFile()) {
-                references.push({ kind: 'legacyConfig', location: legacyFile, pluginName: entry.name });
+                references.push({
+                    kind: 'legacyConfig',
+                    location: legacyFile,
+                    pluginName: entry.name,
+                    scope: configRoot.scope,
+                    ...(configRoot.projectKey ? { projectKey: configRoot.projectKey } : {}),
+                });
             }
         }
     }
@@ -458,13 +406,13 @@ function ownerReferenceFromRaw(entryPath, raw) {
             ...(typeof raw.scope === 'string' ? { scope: raw.scope } : {}),
         };
     }
-    if (raw?.schemaVersion === 2 && raw.owner === 'agent-workflows'
-        && typeof raw.sourceId === 'string') {
+    if (raw?.schemaVersion === 3 && raw.owner === 'agent-workflows'
+        && typeof raw.sourceId === 'string'
+        && raw.pluginId === `${raw.sourceId}/${raw.plugin}`) {
         return {
             kind: 'namespacedOwner',
             location: entryPath,
             sourceId: raw.sourceId,
-            ...(typeof raw.sourceIdentity === 'string' ? { sourceIdentity: raw.sourceIdentity } : {}),
             ...(typeof raw.plugin === 'string' ? { pluginName: raw.plugin } : {}),
             ...(typeof raw.platform === 'string' ? { platform: raw.platform } : {}),
             ...(typeof raw.scope === 'string' ? { scope: raw.scope } : {}),
@@ -472,6 +420,27 @@ function ownerReferenceFromRaw(entryPath, raw) {
     }
     return null;
 }
+function legacyOwnedHeaderReference(filePath, content) {
+    const normalized = content.replace(/\r\n/gu, '\n');
+    const frontmatterEnd = normalized.startsWith('---\n')
+        ? normalized.indexOf('\n---\n', 4)
+        : -1;
+    const headerIndex = frontmatterEnd === -1 ? 0 : frontmatterEnd + '\n---\n'.length;
+    const lineEnd = normalized.indexOf('\n', headerIndex);
+    const line = normalized.slice(headerIndex, lineEnd === -1 ? normalized.length : lineEnd);
+    if (!line.startsWith(OWNED_TEXT_HEADER_PREFIX))
+        return null;
+    const raw = (() => {
+        try {
+            return JSON.parse(line.slice(OWNED_TEXT_HEADER_PREFIX.length));
+        }
+        catch {
+            return null;
+        }
+    })();
+    const reference = ownerReferenceFromRaw(filePath, raw);
+    return reference?.kind === 'legacyOwner' ? reference : null;
+}
 async function readOwnedHeaderReference(filePath, requireGeneratedName, errors, env, cwd) {
     const stats = await inventoryRead({
         operation: () => fs.stat(filePath),
@@ -497,6 +466,16 @@ async function readOwnedHeaderReference(filePath, requireGeneratedName, errors,
         return null;
     if (!content.includes(OWNED_TEXT_HEADER_PREFIX))
         return null;
+    const legacyReference = legacyOwnedHeaderReference(filePath, content);
+    if (legacyReference) {
+        if (requireGeneratedName
+            && legacyReference.pluginName
+            && !path.basename(filePath).startsWith(`aw-${legacyReference.pluginName}-`)) {
+            errors.push(inventoryError(new Error('Owned text header path does not match its plugin identity.'), filePath, 'ownerHeaderPathValidation', env, cwd));
+            return null;
+        }
+        return legacyReference;
+    }
     let parsed;
     try {
         parsed = parseOwnedTextHeader(content);
@@ -509,11 +488,17 @@ async function readOwnedHeaderReference(filePath, requireGeneratedName, errors,
         return null;
     if (requireGeneratedName
         && !path.basename(filePath).startsWith(`aw-${parsed.identity.plugin}-`)) {
-        errors.push(inventoryError(new Error('Owned text header path does not match its plugin identity.'), filePath, 'ownerHeaderPathValidation', env, cwd));
+        errors.push(inventoryError(new Error('Owned text header path does not match its plugin identity.'), filePath, 'ownerHeaderPathValidation', env, cwd, {
+            global: false,
+            ...(parsed.identity.sourceId ? { sourceId: parsed.identity.sourceId } : {}),
+            pluginName: parsed.identity.plugin,
+            platform: parsed.identity.platform,
+            scope: parsed.identity.scope,
+        }));
         return null;
     }
     return ownerReferenceFromRaw(filePath, {
-        schemaVersion: parsed.identity.sourceId === undefined ? 1 : 2,
+        schemaVersion: 3,
         ...parsed.identity,
     });
 }
@@ -608,6 +593,12 @@ async function findDirectSkillOwnerMarkers(root, errors, env, cwd) {
             marker = await readSkillOwnerMarker({ skillRoot, allowedRoot: root });
         }
         catch (error) {
+            const legacy = await fs.readJson(markerPath).catch(() => null);
+            const legacyReference = ownerReferenceFromRaw(markerPath, legacy);
+            if (legacyReference?.kind === 'legacyOwner') {
+                output.push(legacyReference);
+                continue;
+            }
             if (!isAbsentState(error)) {
                 const code = error.code;
                 const message = error instanceof Error ? error.message : String(error);
@@ -640,7 +631,6 @@ function sharedOwnerTokenReferences(filePath, tokens, errors, env, cwd) {
             kind: 'namespacedOwner',
             location: filePath,
             sourceId: identity.sourceId,
-            sourceIdentity: identity.sourceIdentity,
             pluginName: identity.plugin,
             platform: identity.platform,
             scope: identity.scope,
@@ -655,25 +645,21 @@ async function codexSharedOwnerReferences(filePath, scope, errors, env, cwd) {
             value,
             location: filePath,
         })),
-        ...Object.values(config.snapshot.mcpServers).flatMap((server) => {
-            const env = server.value?.env;
-            const value = isRecord(env) && typeof env.AW_AGENT_WORKFLOWS_OWNER === 'string'
-                ? env.AW_AGENT_WORKFLOWS_OWNER
-                : null;
-            return value ? [{ value, location: filePath }] : [];
-        }),
     ];
-    const references = sharedOwnerTokenReferences(filePath, ownerValues.map((entry) => entry.value).filter((value) => value.startsWith('aw-owner-v2:')), errors, env, cwd);
-    for (const { value, location } of ownerValues) {
-        if (value.startsWith('aw-owner-v2:') || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(value))
-            continue;
-        references.push({
-            kind: 'legacyOwner',
-            location,
-            pluginName: value,
-            platform: 'codex',
-            scope,
-        });
+    const references = sharedOwnerTokenReferences(filePath, ownerValues.map((entry) => entry.value).filter((value) => value.startsWith(SHARED_OWNER_TOKEN_PREFIX)), errors, env, cwd);
+    if (scope === 'user') {
+        for (const { value, location } of ownerValues) {
+            if (value.startsWith(SHARED_OWNER_TOKEN_PREFIX)
+                || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(value))
+                continue;
+            references.push({
+                kind: 'legacyOwner',
+                location,
+                pluginName: value,
+                platform: 'codex',
+                scope,
+            });
+        }
     }
     return references;
 }
@@ -682,72 +668,50 @@ async function claudeSharedOwnerReferences(filePath, scope, errors, env, cwd) {
     const generated = settings && isRecord(settings.awGenerated) ? settings.awGenerated : null;
     const permissions = generated && isRecord(generated.permissions) ? generated.permissions : {};
     const keys = Object.keys(permissions);
-    const references = sharedOwnerTokenReferences(filePath, keys.filter((token) => token.startsWith('aw-owner-v2:')), errors, env, cwd);
-    for (const key of keys) {
-        if (key.startsWith('aw-owner-v2:') || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(key))
-            continue;
-        references.push({
-            kind: 'legacyOwner',
-            location: filePath,
-            pluginName: key,
-            platform: 'claude',
-            scope,
-        });
-    }
-    return references;
-}
-async function codexHookOwnerReferences(filePath, errors, env, cwd) {
-    const raw = await readJsonFileIfExists(filePath);
-    if (!raw)
-        return [];
-    const parsed = parseCodexSharedHooksFile(raw);
-    const output = [];
-    for (const hook of parsed.managedIdentities) {
-        if (!hook.command.includes(OWNED_TEXT_HEADER_PREFIX))
-            continue;
-        let owner;
-        try {
-            owner = parseOwnedTextHeader(hook.command)?.identity;
-        }
-        catch (error) {
-            errors.push(inventoryError(error, filePath, 'ownerHeaderParse', env, cwd));
-            continue;
+    const references = sharedOwnerTokenReferences(filePath, keys.filter((token) => token.startsWith(SHARED_OWNER_TOKEN_PREFIX)), errors, env, cwd);
+    if (scope === 'user') {
+        for (const key of keys) {
+            if (key.startsWith(SHARED_OWNER_TOKEN_PREFIX)
+                || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(key))
+                continue;
+            references.push({
+                kind: 'legacyOwner',
+                location: filePath,
+                pluginName: key,
+                platform: 'claude',
+                scope,
+            });
         }
-        if (!owner)
-            continue;
-        output.push(owner.sourceId ? {
-            kind: 'namespacedOwner',
-            location: filePath,
-            sourceId: owner.sourceId,
-            sourceIdentity: owner.sourceIdentity,
-            pluginName: owner.plugin,
-            platform: owner.platform,
-            scope: owner.scope,
-        } : {
-            kind: 'legacyOwner',
-            location: filePath,
-            pluginName: owner.plugin,
-            platform: owner.platform,
-            scope: owner.scope,
-        });
     }
-    return output;
+    return references;
 }
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function assertNamespacedConfigEnvelope(value, sourceId, pluginName) {
+function assertNamespacedConfigEnvelope(value, sourceId, pluginName, scope) {
     if (!isRecord(value)
-        || value.schemaVersion !== 2
+        || value.schemaVersion !== 5
         || typeof value.sourceId !== 'string'
-        || typeof value.sourceIdentity !== 'string'
-        || !/^sha256:[0-9a-f]{64}$/u.test(value.sourceIdentity)
         || typeof value.pluginName !== 'string'
+        || !isRecord(value.binding)
         || !isRecord(value.values)
         || Object.keys(value).some((key) => ![
-            'schemaVersion', 'sourceId', 'sourceIdentity', 'pluginName', 'values',
+            'schemaVersion', 'sourceId', 'pluginName', 'binding', 'values',
         ].includes(key))) {
-        throw new Error('Namespaced plugin config is not a valid schema 2 envelope.');
+        throw new Error('Namespaced plugin config is not a valid schema 5 envelope.');
+    }
+    const binding = value.binding;
+    const validBinding = scope === 'user'
+        ? binding.kind === 'source'
+            && typeof binding.sourceIdentity === 'string'
+            && /^sha256:[0-9a-f]{64}$/u.test(binding.sourceIdentity)
+            && Object.keys(binding).every((key) => ['kind', 'sourceIdentity'].includes(key))
+        : binding.kind === 'catalog'
+            && typeof binding.logicalIdentity === 'string'
+            && binding.logicalIdentity.trim().length > 0
+            && Object.keys(binding).every((key) => ['kind', 'logicalIdentity'].includes(key));
+    if (!validBinding) {
+        throw new Error(`Namespaced ${scope} plugin config has an invalid binding.`);
     }
     if (value.sourceId !== sourceId || value.pluginName !== pluginName) {
         throw new Error('Namespaced plugin config identity does not match its directory path.');
@@ -768,7 +732,7 @@ function isAwPluginConsumerKey(value) {
 function hasAwPluginConsumerKeys(value) {
     return isRecord(value) && Object.keys(value).some(isAwPluginConsumerKey);
 }
-async function oldMarketplaceReferences(env, cwd, errors) {
+async function oldMarketplaceReferences(env, cwd, errors, includePlatformHistoricalProjects) {
     const codexPath = path.join(getCodexHome(env), 'config.toml');
     const claudeSettingsPath = path.join(getClaudeHome(env), 'settings.json');
     const claudeKnownPath = path.join(getClaudeHome(env), 'plugins', 'known_marketplaces.json');
@@ -864,7 +828,7 @@ async function oldMarketplaceReferences(env, cwd, errors) {
             location: resolveRepoRootSync(cwd), kind: 'projectRootRead', env, cwd,
         });
         try {
-            for (const consumer of claudeConsumersFromInstalled(installed, 'aw', path.normalize(canonicalProjectRoot), false)) {
+            for (const consumer of claudeConsumersFromInstalled(installed, 'aw', path.normalize(canonicalProjectRoot), includePlatformHistoricalProjects)) {
                 output.push({ kind: 'legacyMarketplace', location: claudeInstalledPath, ...consumer });
             }
         }
@@ -931,10 +895,49 @@ export async function inventoryCatalogSourceReferences(options) {
     const awHome = resolveAwHome(env);
     const references = [];
     const errors = [];
+    const canonicalProjectRoot = await inventoryRead({
+        operation: () => fs.realpath(resolveRepoRootSync(options.cwd)),
+        absent: path.resolve(resolveRepoRootSync(options.cwd)),
+        errors,
+        location: resolveRepoRootSync(options.cwd),
+        kind: 'projectRootRead',
+        env,
+        cwd: options.cwd,
+    });
     const legacyConfig = await inventoryLegacyConfigReferences(options);
     references.push(...legacyConfig.references);
     errors.push(...legacyConfig.errors);
-    for (const configRoot of await inventoryPluginConfigRoots({ errors, env, cwd: options.cwd })) {
+    for (const scope of ['user', 'project']) {
+        const location = resolvePluginIntentStatePath({ scope, cwd: options.cwd, env });
+        const state = await inventoryRead({
+            operation: () => readPluginIntentState({ scope, cwd: options.cwd, env }),
+            absent: null,
+            errors,
+            location,
+            kind: 'lifecycleIntentRead',
+            env,
+            cwd: options.cwd,
+        });
+        if (!state)
+            continue;
+        for (const pluginId of new Set([
+            ...state.roots.map((root) => root.pluginId),
+            ...state.dependencyScopeOverrides.map((override) => override.pluginId),
+        ])) {
+            const separator = pluginId.indexOf('/');
+            if (separator <= 0 || separator === pluginId.length - 1)
+                continue;
+            references.push({
+                kind: 'namespacedLifecycle',
+                location,
+                sourceId: pluginId.slice(0, separator),
+                pluginName: pluginId.slice(separator + 1),
+                scope,
+            });
+        }
+    }
+    for (const configInventory of await inventoryPluginConfigRoots({ errors, env, cwd: options.cwd })) {
+        const configRoot = configInventory.root;
         const sourceEntries = await inventoryRead({
             operation: () => fs.readdir(configRoot, { withFileTypes: true }),
             absent: [], errors, location: configRoot, kind: 'configDirectoryRead', env, cwd: options.cwd,
@@ -974,7 +977,7 @@ export async function inventoryCatalogSourceReferences(options) {
                 if (value === null)
                     continue;
                 try {
-                    assertNamespacedConfigEnvelope(value, sourceEntry.name, pluginEntry.name);
+                    assertNamespacedConfigEnvelope(value, sourceEntry.name, pluginEntry.name, configInventory.scope);
                 }
                 catch (error) {
                     errors.push(inventoryError(error, configPath, 'configFileValidation', env, options.cwd));
@@ -984,160 +987,9 @@ export async function inventoryCatalogSourceReferences(options) {
                     kind: 'namespacedConfig',
                     location: configPath,
                     sourceId: sourceEntry.name,
-                    sourceIdentity: value.sourceIdentity,
                     pluginName: pluginEntry.name,
-                });
-            }
-        }
-    }
-    const lifecycleRoot = path.join(awHome, 'lifecycle-active');
-    const lifecycleSources = await inventoryCanonicalDirectoryEntries({
-        errors, location: lifecycleRoot, kind: 'lifecycleDirectoryRead', env, cwd: options.cwd,
-    });
-    for (const platform of ['codex', 'claude']) {
-        const legacyRoot = path.join(lifecycleRoot, platform);
-        if (!lifecycleSources.some((entry) => entry.name === platform))
-            continue;
-        const legacyEntries = await inventoryCanonicalDirectoryEntries({
-            errors, location: legacyRoot, kind: 'lifecycleNamespaceValidation', env, cwd: options.cwd,
-        });
-        if (legacyEntries.length > 0) {
-            references.push({ kind: 'legacyLifecycle', location: legacyRoot });
-        }
-    }
-    const canonicalProjectRoot = await inventoryRead({
-        operation: () => fs.realpath(resolveRepoRootSync(options.cwd)),
-        absent: path.resolve(resolveRepoRootSync(options.cwd)), errors,
-        location: resolveRepoRootSync(options.cwd), kind: 'projectRootRead', env, cwd: options.cwd,
-    });
-    const projectLocationKey = createLifecycleProjectLocationKey(canonicalProjectRoot);
-    for (const sourceEntry of lifecycleSources) {
-        if (sourceEntry.name === 'codex' || sourceEntry.name === 'claude')
-            continue;
-        const sourceLifecycleRoot = path.join(lifecycleRoot, sourceEntry.name);
-        if (!await inventoryCanonicalDirectory({
-            errors,
-            location: sourceLifecycleRoot,
-            kind: 'lifecycleNamespaceValidation',
-            env,
-            cwd: options.cwd,
-        }))
-            continue;
-        const relevantRoots = [];
-        for (const platform of ['codex', 'claude']) {
-            const userRoot = await inventoryCanonicalDescendantDirectory({
-                root: sourceLifecycleRoot,
-                segments: [platform, 'user', 'user'],
-                errors,
-                kind: 'lifecycleDirectoryRead',
-                env,
-                cwd: options.cwd,
-            });
-            if (userRoot)
-                relevantRoots.push(userRoot);
-            const projectRoot = await inventoryCanonicalDescendantDirectory({
-                root: sourceLifecycleRoot,
-                segments: [platform, 'project'],
-                errors,
-                kind: 'lifecycleDirectoryRead',
-                env,
-                cwd: options.cwd,
-            });
-            if (!projectRoot)
-                continue;
-            if (options.includeHistoricalProjects) {
-                const projectLocations = await inventoryRead({
-                    operation: () => fs.readdir(projectRoot, { withFileTypes: true }),
-                    absent: [], errors, location: projectRoot, kind: 'lifecycleDirectoryRead', env, cwd: options.cwd,
-                });
-                for (const location of projectLocations) {
-                    const projectLocationRoot = path.join(projectRoot, location.name);
-                    if (await inventoryCanonicalDirectory({
-                        errors,
-                        location: projectLocationRoot,
-                        kind: 'lifecycleLocationValidation',
-                        env,
-                        cwd: options.cwd,
-                    }))
-                        relevantRoots.push(projectLocationRoot);
-                }
-            }
-            else {
-                const projectLocationRoot = path.join(projectRoot, projectLocationKey);
-                if (await inventoryCanonicalDirectory({
-                    errors,
-                    location: projectLocationRoot,
-                    kind: 'lifecycleLocationValidation',
-                    env,
-                    cwd: options.cwd,
-                }))
-                    relevantRoots.push(projectLocationRoot);
-            }
-        }
-        for (const relevantRoot of relevantRoots) {
-            const pluginEntries = await inventoryRead({
-                operation: () => fs.readdir(relevantRoot, { withFileTypes: true }),
-                absent: [], errors, location: relevantRoot, kind: 'lifecycleDirectoryRead', env, cwd: options.cwd,
-            });
-            const parts = path.relative(sourceLifecycleRoot, relevantRoot).split(path.sep);
-            const platform = parts[0];
-            const scope = parts[1];
-            if ((platform !== 'codex' && platform !== 'claude')
-                || (scope !== 'user' && scope !== 'project'))
-                continue;
-            for (const pluginEntry of pluginEntries) {
-                const pluginName = pluginEntry.name;
-                const pluginRoot = path.join(relevantRoot, pluginName);
-                if (!await inventoryCanonicalDirectory({
-                    errors,
-                    location: pluginRoot,
-                    kind: 'lifecyclePluginRootValidation',
-                    env,
-                    cwd: options.cwd,
-                }))
-                    continue;
-                const metadataPath = path.join(relevantRoot, pluginName, 'active', 'metadata.json');
-                const raw = await inventoryRead({
-                    operation: () => fs.readJson(metadataPath), absent: null, errors,
-                    location: metadataPath, kind: 'lifecycleMetadataRead', env, cwd: options.cwd,
-                });
-                if (!raw)
-                    continue;
-                if (raw.schemaVersion !== 2 || typeof raw.sourceIdentity !== 'string') {
-                    errors.push(inventoryError(new Error('Lifecycle active metadata is not valid schema 2 state.'), metadataPath, 'lifecycleMetadataValidation', env, options.cwd));
-                    continue;
-                }
-                const snapshot = await inventoryRead({
-                    operation: () => inspectLifecycleActiveSnapshotForInventory({
-                        sourceId: sourceEntry.name,
-                        sourceIdentity: raw.sourceIdentity,
-                        pluginName,
-                        platform,
-                        scope,
-                        cwd: scope === 'project' && typeof raw.projectKey === 'string'
-                            ? raw.projectKey
-                            : options.cwd,
-                        env,
-                        loadPlugin: (bundleRoot) => readPluginManifest(bundleRoot, { mode: 'bundle' }),
-                    }),
-                    absent: null,
-                    errors,
-                    location: metadataPath,
-                    kind: 'lifecycleSnapshotValidation',
-                    env,
-                    cwd: options.cwd,
-                });
-                if (!snapshot)
-                    continue;
-                references.push({
-                    kind: 'namespacedLifecycle',
-                    location: snapshot.activeRoot,
-                    sourceId: snapshot.metadata.sourceId,
-                    sourceIdentity: snapshot.metadata.sourceIdentity,
-                    pluginName: snapshot.metadata.pluginName,
-                    platform: snapshot.metadata.platform,
-                    scope: snapshot.metadata.scope,
-                    projectKey: snapshot.metadata.projectKey,
+                    scope: configInventory.scope,
+                    ...(configInventory.projectKey ? { projectKey: configInventory.projectKey } : {}),
                 });
             }
         }
@@ -1150,19 +1002,23 @@ export async function inventoryCatalogSourceReferences(options) {
         [path.join(getClaudeHome(env), 'settings.json'), 'nativeStateRead', () => claudeSharedOwnerReferences(path.join(getClaudeHome(env), 'settings.json'), 'user', errors, env, options.cwd)],
         [path.join(resolveRepoRootSync(options.cwd), '.codex', 'config.toml'), 'nativeStateRead', () => codexSharedOwnerReferences(path.join(resolveRepoRootSync(options.cwd), '.codex', 'config.toml'), 'project', errors, env, options.cwd)],
         [path.join(resolveRepoRootSync(options.cwd), '.claude', 'settings.json'), 'nativeStateRead', () => claudeSharedOwnerReferences(path.join(resolveRepoRootSync(options.cwd), '.claude', 'settings.json'), 'project', errors, env, options.cwd)],
-        [path.join(resolveRepoRootSync(options.cwd), '.codex', 'hooks.json'), 'nativeStateRead', () => codexHookOwnerReferences(path.join(resolveRepoRootSync(options.cwd), '.codex', 'hooks.json'), errors, env, options.cwd)],
     ]) {
         references.push(...await inventoryRead({
             operation, absent: [], errors, location, kind, env, cwd: options.cwd,
         }));
     }
-    references.push(...await oldMarketplaceReferences(env, options.cwd, errors));
+    references.push(...await oldMarketplaceReferences(env, options.cwd, errors, options.includePlatformHistoricalProjects === true));
     const marketplacesRoot = path.join(awHome, 'marketplaces');
     const codexConfigPath = path.join(getCodexHome(env), 'config.toml');
     const codexConfig = await inventoryRead({
         operation: () => readCodexConfigFile(codexConfigPath), absent: null, errors,
         location: codexConfigPath, kind: 'nativeStateRead', env, cwd: options.cwd,
     });
+    const projectCodexConfigPath = path.join(resolveRepoRootSync(options.cwd), '.codex', 'config.toml');
+    const projectCodexConfig = await inventoryRead({
+        operation: () => readCodexConfigFile(projectCodexConfigPath), absent: null, errors,
+        location: projectCodexConfigPath, kind: 'nativeStateRead', env, cwd: options.cwd,
+    });
     const userClaudeSettingsPath = path.join(getClaudeHome(env), 'settings.json');
     const userClaudeSettings = await inventoryRead({
         operation: () => readJsonFileIfExists(userClaudeSettingsPath), absent: null, errors,
@@ -1199,6 +1055,19 @@ export async function inventoryCatalogSourceReferences(options) {
             scope: 'user',
         });
     }
+    for (const pluginId of Object.keys(projectCodexConfig?.snapshot.plugins ?? {})) {
+        const separator = pluginId.lastIndexOf('@');
+        if (separator <= 0 || separator === pluginId.length - 1)
+            continue;
+        references.push({
+            kind: 'namespacedMarketplace',
+            location: projectCodexConfigPath,
+            pluginName: pluginId.slice(0, separator),
+            marketplaceName: pluginId.slice(separator + 1),
+            platform: 'codex',
+            scope: 'project',
+        });
+    }
     for (const [location, registrations] of [
         [codexConfigPath, Object.entries(codexConfig?.snapshot.marketplaces ?? {}).flatMap(([marketplaceName, marketplace]) => {
                 const sourceId = marketplace.sourceType === 'local' && !marketplace.sourcePointsToManifest
@@ -1293,43 +1162,22 @@ export async function inventoryCatalogSourceReferences(options) {
             && !codexMarketplace.sourcePointsToManifest
             && path.normalize(codexMarketplace.source ?? '') === path.normalize(marketplaceRoot);
         const consumers = [];
-        if (marketplaceName !== null
-            && (strictRoot !== null || (canonicalRoot && codexMarketplaceIsCanonical))) {
-            let residueNames = [];
-            try {
-                residueNames = await discoverCodexNativeResidueNames({
-                    cwd: options.cwd,
-                    env,
-                    marketplaceName,
-                    marketplaceRoot,
-                });
-            }
-            catch (error) {
-                const residueError = error instanceof CodexNativeResidueProbeError ? error : null;
-                const pluginName = residueError?.pluginName;
-                errors.push(inventoryError(error, residueError?.location ?? configPath, 'nativeStateRead', env, options.cwd, {
-                    global: false,
-                    sourceId: sourceEntry.name,
-                    ...(pluginName ? { pluginName } : {}),
-                    platform: 'codex',
-                    scope: 'user',
-                }));
-            }
-            for (const pluginName of residueNames) {
-                consumers.push({ pluginName, platform: 'codex', scope: 'user' });
-            }
-        }
         if (marketplaceName !== null && (strictRoot !== null || codexMarketplaceIsCanonical)) {
             for (const pluginId of Object.keys(codexConfig?.snapshot.plugins ?? {})) {
                 const pluginName = pluginNameFromMarketplaceId(pluginId, marketplaceName);
                 if (pluginName)
                     consumers.push({ pluginName, platform: 'codex', scope: 'user' });
             }
+            for (const pluginId of Object.keys(projectCodexConfig?.snapshot.plugins ?? {})) {
+                const pluginName = pluginNameFromMarketplaceId(pluginId, marketplaceName);
+                if (pluginName)
+                    consumers.push({ pluginName, platform: 'codex', scope: 'project' });
+            }
         }
         if (marketplaceName !== null) {
             consumers.push(...claudeConsumersFromSettings(userClaudeSettings, marketplaceName, 'user'), ...claudeConsumersFromSettings(projectClaudeSettings, marketplaceName, 'project'));
             try {
-                consumers.push(...claudeConsumersFromInstalled(claudeInstalled, marketplaceName, path.normalize(canonicalProjectRoot), options.includeHistoricalProjects === true));
+                consumers.push(...claudeConsumersFromInstalled(claudeInstalled, marketplaceName, path.normalize(canonicalProjectRoot), options.includePlatformHistoricalProjects === true));
             }
             catch (error) {
                 errors.push(inventoryError(error, claudeInstalledPath, 'nativeStateRead', env, options.cwd));
@@ -1379,7 +1227,7 @@ export class LegacyCatalogStateUnsupportedError extends Error {
     code = 'legacyStateUnsupported';
     inventory;
     constructor(inventory) {
-        super('legacyStateUnsupported: legacy owner, config, lifecycle, or marketplace state must be migrated before catalog source identity changes.');
+        super('legacyStateUnsupported: legacy owner or config state is unsupported. Use a new AW_HOME, or cleanup with the old CLI first.');
         this.name = 'LegacyCatalogStateUnsupportedError';
         this.inventory = inventory;
     }