@lesliechan721/aw 0.1.0-beta.17 → 0.1.0-beta.19

package/dist/src/commands/status-v6.js

@@ -23,7 +23,26 @@ import { readPluginIntentState, } from '../utils/plugin-intent-state.js';
 import { IMPLEMENTED_AW_CAPABILITIES } from './aw-capabilities.js';
 import { createDependencyPlacementPlan } from './dependency-operation-plan.js';
 import { getCodexOperationRequirement } from '../utils/agent-version.js';
-import { inspectSystemCodexFilesystem, } from '../utils/codex-manager.js';
+import { inspectSystemCodex, } from '../utils/codex-manager.js';
+export function statusTargetPlacements(target) {
+    if (target.platform === 'claude')
+        return [target];
+    return target.placements.map((placement) => ({
+        pluginName: target.pluginName,
+        sourceId: target.sourceId,
+        sourceIdentity: target.sourceIdentity,
+        pluginId: target.pluginId,
+        ...(target.version ? { version: target.version } : {}),
+        platform: target.platform,
+        cwd: target.cwd,
+        ...placement,
+        sharedComponents: target.components.filter((component) => component.kind !== 'systemConsumer' || component.key === `codex:${placement.scope}`),
+        sharedReasons: target.reasons.filter((reason) => reason.code.startsWith('codexSharedNative') || reason.code === 'staleCacheObserved'),
+    }));
+}
+export function flattenStatusTargets(targets) {
+    return targets.flatMap(statusTargetPlacements);
+}
 export function projectStatusSharedNativeReasons(sharedNative, existingReasonCodes = [], desiredEnabled = false) {
     if (!sharedNative)
         return [];
@@ -64,7 +83,7 @@ export function projectStatusSharedNativeReasons(sharedNative, existingReasonCod
     ];
 }
 function statusComponent(target, kind, key) {
-    return target.components.find((component) => component.kind === kind && (key === undefined || component.key === key));
+    return [...target.components, ...(target.sharedComponents ?? [])].find((component) => component.kind === kind && (key === undefined || component.key === key));
 }
 export function statusTargetIntent(target) {
     const metadata = statusComponent(target, 'intent', 'desired')?.metadata;
@@ -121,7 +140,7 @@ export function statusTargetSharedNative(target) {
 export function statusTargetActivation(target) {
     const user = statusComponent(target, 'activation', 'user');
     const project = statusComponent(target, 'activation', 'project');
-    const consumer = statusComponent(target, 'systemConsumer', 'codex');
+    const consumer = statusComponent(target, 'systemConsumer');
     if (!user && !project && !consumer)
         return undefined;
     const activation = user ?? project ?? consumer;
@@ -181,7 +200,7 @@ export function setStatusDependencyInspectionHookForTests(hook) {
     dependencyInspectionHookForTests = hook;
 }
 export async function loadConsoleItemsResult(options = {}, runtime = {}) {
-    const result = await statusCommandV7({
+    const result = await statusCommandV8({
         cwd: options.cwd ?? process.cwd(),
         env: runtime.env,
         platform: options.platform,
@@ -203,7 +222,7 @@ export async function loadConsoleItemsResult(options = {}, runtime = {}) {
             ...(pluginSummary ? { pluginSummary } : {}),
             targets: [],
         };
-        current.targets.push(target);
+        current.targets.push(...statusTargetPlacements(target));
         groups.set(target.pluginId, current);
     }
     const allSourcesFailed = result.payload.catalog.sources.length > 0
@@ -251,6 +270,7 @@ function finalizeTargetError(error, targetState) {
     return {
         ...error,
         severity: error.code === 'artifactCollision'
+            || error.code === 'dependencyGraphInvalid'
             || (targetState === 'error'
                 && error.dependencyPluginId === undefined)
             ? 'blocking'
@@ -416,7 +436,7 @@ function projectDependencyClosureForTarget(options) {
     visit(options.pluginId);
     return closure;
 }
-function statusRecovery(options) {
+export function statusRecovery(options) {
     if (options.errorCodes?.some((code) => code === 'codexProjectPluginVersionTooLow'
         || code === 'codexProjectPluginUnsupported'
         || code === 'codexSystemCliUnsupported')) {
@@ -431,8 +451,29 @@ function statusRecovery(options) {
                 description: '升级 AW CLI 到支持插件所需 capability 的版本后重试。',
             }];
     }
+    if (options.errorCodes?.includes('dependencyGraphInvalid')) {
+        return [{
+                command: 'manual',
+                description: '修复 Catalog 中的插件依赖循环后重试。',
+            }];
+    }
     if (options.state === 'ready' || options.state === 'absent')
         return [];
+    if (options.desired.scopes.length === 0
+        && options.sharedNative?.state === 'replaceable'
+        && options.sharedNative.reason === 'damaged') {
+        return [
+            ...(options.actualEnabled ? [{
+                    command: 'cleanup',
+                    ...(options.scope ? { scope: options.scope } : {}),
+                    description: `仅清理 ${options.scope ?? '当前'} scope 的激活；不会修复或删除损坏的共享内容。`,
+                }] : []),
+            {
+                command: 'manual',
+                description: `共享内容已损坏。先明确选择 user 或 project 使用范围，再运行 aw install ${options.pluginId} --platform codex --scope <user|project> 重建。`,
+            },
+        ];
+    }
     if (options.state === 'orphaned') {
         return [{ command: 'cleanup', description: '清理可证明属于 AW 的遗留输出。' }];
     }
@@ -556,20 +597,51 @@ export function projectTargetRevision(availableVersion, installedVersion) {
         return { state: 'upgradeAvailable', availableVersion, installedVersion };
     return { state: 'unknown', availableVersion, installedVersion };
 }
-function renderStatusV7(payload, verbose) {
+function renderStatusV8(payload, verbose) {
     const lines = [`Catalog sources: ${payload.catalog.sources.length}`];
     for (const source of payload.catalog.sources) {
         lines.push(`${source.primary ? '*' : '-'} ${source.id}: ${source.error ?? source.freshness ?? 'unavailable'}`);
     }
     for (const target of payload.targets) {
         const reasons = target.reasons.length > 0
-            ? ` [${target.reasons.map((reason) => `${reason.code}: ${reason.message}`).join('; ')}]`
+            ? ` [${target.reasons.map((reason) => reason.message.startsWith(`${reason.code}:`)
+                ? reason.message : `${reason.code}: ${reason.message}`).join('; ')}]`
             : '';
-        lines.push(`${target.pluginId} ${target.platform}: ${target.state}${reasons}`);
+        if (target.platform === 'claude') {
+            lines.push(`${target.pluginId} ${target.platform} (${target.scope}): ${target.state}${reasons}`);
+        }
+        else {
+            lines.push(`${target.pluginId} ${target.platform}: ${target.state}${reasons}`);
+            const desiredScopes = target.placements.filter((placement) => placement.components.some((component) => component.kind === 'intent' && component.metadata?.enabled === true))
+                .map((placement) => placement.scope);
+            const actualScopes = target.placements.filter((placement) => placement.components.some((component) => component.kind === 'activation'
+                && component.key === placement.scope
+                && component.state === 'enabled'))
+                .map((placement) => placement.scope);
+            const usage = (scopes) => scopes.length === 0
+                ? 'disabled'
+                : scopes.length === 2 ? 'user+project' : scopes[0];
+            lines.push(`  desired use: ${usage(desiredScopes)}`);
+            lines.push(`  actual use: ${usage(actualScopes)}`);
+            const shared = target.components.find((component) => component.kind === 'sharedNative');
+            if (shared)
+                lines.push(`  shared content: ${shared.state} (${shared.key})`);
+            for (const placement of target.placements) {
+                lines.push(`  ${placement.scope}: ${placement.state}`);
+            }
+        }
         if (verbose) {
             for (const component of target.components) {
                 lines.push(`  component ${component.kind}/${component.key}: ${component.state}`);
             }
+            if (target.platform === 'codex') {
+                for (const placement of target.placements) {
+                    lines.push(`  placement ${placement.scope}: ${placement.state}`);
+                    for (const component of placement.components) {
+                        lines.push(`    component ${component.kind}/${component.key}: ${component.state}`);
+                    }
+                }
+            }
             for (const action of target.recoveryActions) {
                 lines.push(`  recovery ${action.command}: ${action.description}`);
             }
@@ -600,7 +672,7 @@ function collisionRootIssueId(options) {
         options.collision.artifactKey,
     ].join(':');
 }
-async function statusCommandV7InSession(options) {
+async function statusCommandV8InSession(options) {
     const env = options.env ?? process.env;
     const dependencyPluginCache = new Map();
     const dependencyInspectionCache = new Map();
@@ -637,13 +709,13 @@ async function statusCommandV7InSession(options) {
             return undefined;
         }
     };
+    const codexScopePathsAlias = codexProjectConfigAliasesUserHome(options.cwd, env);
     const [userCodexConfig, projectCodexConfig] = await Promise.all([
         readActivationConfig('user'),
-        readActivationConfig('project'),
+        codexScopePathsAlias ? undefined : readActivationConfig('project'),
     ]);
     const currentProjectKey = await resolveCanonicalRepoProjectKey(options.cwd);
     const currentProjectLocationKey = createProjectLocationKey(currentProjectKey);
-    const codexScopePathsAlias = codexProjectConfigAliasesUserHome(options.cwd, env);
     const inventoryErrors = [];
     const readInventory = options.inventoryCatalogSourceReferences
         ?? inventoryCatalogSourceReferences;
@@ -667,7 +739,8 @@ async function statusCommandV7InSession(options) {
     const inspectCodexSystemConsumer = (scope) => {
         let inspection = codexSystemConsumerInspections.get(scope);
         if (!inspection) {
-            inspection = inspectSystemCodexFilesystem({
+            inspection = inspectSystemCodex({
+                runner: nativeCliRunner,
                 cwd: options.cwd,
                 env,
                 operationRequirement: getCodexOperationRequirement(scope),
@@ -730,9 +803,9 @@ async function statusCommandV7InSession(options) {
                     if (!userCodexConfig || (probe.scope === 'project' && !projectCodexConfig)) {
                         return 'partial';
                     }
-                    const configEnabled = userCodexConfig.snapshot.plugins[`${probe.pluginName}@${probe.marketplaceName}`]?.enabled === true
-                        || (probe.scope === 'project'
-                            && projectCodexConfig?.snapshot.plugins[`${probe.pluginName}@${probe.marketplaceName}`]?.enabled === true);
+                    const configEnabled = (probe.scope === 'user'
+                        ? userCodexConfig
+                        : projectCodexConfig)?.snapshot.plugins[`${probe.pluginName}@${probe.marketplaceName}`]?.enabled === true;
                     return configEnabled
                         ? 'present'
                         : 'partial';
@@ -863,6 +936,35 @@ async function statusCommandV7InSession(options) {
                     };
                 }
                 try {
+                    const catalogEntriesByName = new Map(item.resolution.manifest.entries.map((entry) => [
+                        entry.name,
+                        entry,
+                    ]));
+                    const cyclicDependencyPluginNames = new Set();
+                    const dependencyVisitState = new Map();
+                    const dependencyVisitStack = [];
+                    const visitDependencyGraph = (pluginName) => {
+                        const state = dependencyVisitState.get(pluginName);
+                        if (state === 'visited')
+                            return;
+                        if (state === 'visiting') {
+                            const cycleStart = dependencyVisitStack.lastIndexOf(pluginName);
+                            for (const name of dependencyVisitStack.slice(cycleStart)) {
+                                cyclicDependencyPluginNames.add(name);
+                            }
+                            return;
+                        }
+                        dependencyVisitState.set(pluginName, 'visiting');
+                        dependencyVisitStack.push(pluginName);
+                        for (const dependencyName of catalogEntriesByName.get(pluginName)?.dependencies ?? []) {
+                            if (catalogEntriesByName.has(dependencyName))
+                                visitDependencyGraph(dependencyName);
+                        }
+                        dependencyVisitStack.pop();
+                        dependencyVisitState.set(pluginName, 'visited');
+                    };
+                    for (const pluginName of catalogEntriesByName.keys())
+                        visitDependencyGraph(pluginName);
                     const placementEntries = item.resolution.manifest.entries.map((entry) => {
                         const supportedPlatforms = resolveCatalogEntrySupportedPlatforms(entry.policy);
                         return {
@@ -1123,8 +1225,238 @@ async function statusCommandV7InSession(options) {
                                     const dependencyErrors = [];
                                     const dependencyReadiness = [];
                                     const directDependencies = plugin.manifest.dependencies ?? [];
+                                    const desiredInScope = sourceDesired.get(desiredTargetKey(plugin.pluginId, platform))?.scopes.includes(scope) === true;
+                                    const codexPluginId = `${entry.name}@${marketplaceName}`;
+                                    const actualCodexActivation = platform === 'codex'
+                                        && (scope === 'user' ? userCodexConfig : projectCodexConfig)
+                                            ?.snapshot.plugins[codexPluginId]?.enabled === true;
+                                    const hasScopedExtensionResidue = platform === 'codex'
+                                        && inspected.inspection.components.some((component) => component.component.kind !== 'native-plugin'
+                                            && !component.component.identity.artifactKey.startsWith('activation-')
+                                            && !component.component.identity.artifactKey.startsWith('marketplace-')
+                                            && (component.state !== 'absent' || component.collision !== undefined));
+                                    const dependencyPriority = {
+                                        ready: 5,
+                                        blockedByCollision: 4,
+                                        incomplete: 3,
+                                        error: 2,
+                                        absent: 1,
+                                    };
+                                    function dependencyPlacementsFor(dependencyId, consumerScope) {
+                                        const dependencyOverride = (consumerScope === 'project'
+                                            ? projectIntent
+                                            : userIntent).dependencyScopeOverrides.find((override) => override.pluginId === dependencyId
+                                            && (override.platform === undefined || override.platform === platform));
+                                        return dependencyOverride
+                                            ? [dependencyOverride.scope]
+                                            : consumerScope === 'project' ? ['project', 'user'] : ['user'];
+                                    }
+                                    async function inspectDependencyAtScope(dependencyName, dependencyScope) {
+                                        const dependencyId = formatPluginId({
+                                            sourceId: item.resolution.sourceId,
+                                            pluginName: dependencyName,
+                                        });
+                                        const inspectionCacheKey = [
+                                            item.resolution.sourceIdentity,
+                                            dependencyId,
+                                            platform,
+                                            dependencyScope,
+                                            dependencyScope === 'project' ? currentProjectKey : '',
+                                        ].join('\0');
+                                        if (cyclicDependencyPluginNames.has(dependencyName)) {
+                                            return {
+                                                state: 'error',
+                                                dependencyScope,
+                                                rootIssueId: `dependencyGraphInvalid:${dependencyId}`,
+                                                rootIssueCode: 'dependencyGraphInvalid',
+                                                issuePluginId: dependencyId,
+                                                issueScope: dependencyScope,
+                                            };
+                                        }
+                                        const cached = dependencyInspectionCache.get(inspectionCacheKey);
+                                        if (cached)
+                                            return cached;
+                                        const inspection = (async () => {
+                                            const dependencyEntry = item.resolution.manifest.entries.find((candidate) => candidate.name === dependencyName);
+                                            if (!dependencyEntry) {
+                                                return {
+                                                    state: 'absent',
+                                                    dependencyScope,
+                                                    rootIssueId: `dependencyMissing:${dependencyId}:${platform}:${dependencyScope}`,
+                                                    rootIssueCode: 'dependencyMissing',
+                                                    issuePluginId: dependencyId,
+                                                    issueScope: dependencyScope,
+                                                };
+                                            }
+                                            const dependencySupport = checkAwCapabilitySupport(dependencyEntry.requires.aw.capabilities ?? [], IMPLEMENTED_AW_CAPABILITIES);
+                                            if (!dependencySupport.supported) {
+                                                return {
+                                                    state: 'error',
+                                                    dependencyScope,
+                                                    rootIssueId: `awCapabilityUnsupported:${dependencyId}`,
+                                                    rootIssueCode: 'awCapabilityUnsupported',
+                                                    issuePluginId: dependencyId,
+                                                    issueScope: dependencyScope,
+                                                    missingCapabilities: dependencySupport.missing,
+                                                };
+                                            }
+                                            const pluginCacheKey = [item.resolution.sourceIdentity, dependencyId].join('\0');
+                                            let dependencyPluginPromise = dependencyPluginCache.get(pluginCacheKey);
+                                            if (!dependencyPluginPromise) {
+                                                dependencyPluginPromise = readPluginManifest(path.join(item.resolution.rootDir, 'plugins', dependencyName), { mode: 'bundle' }).then((dependencyPlugin) => {
+                                                    dependencyPlugin.sourceId = item.resolution.sourceId;
+                                                    dependencyPlugin.sourceIdentity = item.resolution.sourceIdentity;
+                                                    dependencyPlugin.catalogLogicalIdentity = item.resolution.logicalIdentity;
+                                                    dependencyPlugin.pluginId = dependencyId;
+                                                    return dependencyPlugin;
+                                                });
+                                                dependencyPluginCache.set(pluginCacheKey, dependencyPluginPromise);
+                                            }
+                                            const dependencyPlugin = await dependencyPluginPromise;
+                                            dependencyInspectionHookForTests?.();
+                                            const dependencyMarketplaceName = marketplaceNameFor(dependencyName, platform, dependencyScope);
+                                            const dependencyInspected = await inspectRebuildTarget({
+                                                sourceId: item.resolution.sourceId,
+                                                sourceIdentity: item.resolution.sourceIdentity,
+                                                pluginId: dependencyId,
+                                                marketplaceName: dependencyMarketplaceName,
+                                                marketplaceRoot,
+                                                plugin: dependencyPlugin,
+                                                platform,
+                                                scope: dependencyScope,
+                                                cwd: options.cwd,
+                                                catalog: { rootDir: item.resolution.rootDir, source: 'local' },
+                                                context: {
+                                                    env,
+                                                    nativeCliRunner,
+                                                    reporter: createNoopReporter(),
+                                                    debugLogger: createNoopDebugLogger(),
+                                                    codexObservationSession: options.codexObservationSession,
+                                                },
+                                                userActivationDesired: codexDesiredUserActivationIds,
+                                                nativeProbe: readOnlyNativeProbe({
+                                                    pluginName: dependencyName,
+                                                    sourceId: item.resolution.sourceId,
+                                                    sourceIdentity: item.resolution.sourceIdentity,
+                                                    platform,
+                                                    scope: dependencyScope,
+                                                    marketplaceName: dependencyMarketplaceName,
+                                                    marketplaceRoot,
+                                                    desired: sourceDesired.get(desiredTargetKey(dependencyId, platform))
+                                                        ?.scopes.includes(dependencyScope) === true,
+                                                }),
+                                                shallow: true,
+                                            });
+                                            const dependencyLiveState = projectedLiveState({
+                                                inspection: dependencyInspected.inspection,
+                                                required: dependencyInspected.target.desiredOwnedComponents
+                                                    ?? dependencyInspected.target.ownedComponents,
+                                                optional: dependencyInspected.target.optionalOwnedComponents ?? [],
+                                            });
+                                            const collision = dependencyInspected.inspection.components.find((component) => component.collision)?.collision;
+                                            if (collision) {
+                                                return {
+                                                    state: 'blockedByCollision',
+                                                    dependencyScope,
+                                                    rootIssueId: collisionRootIssueId({
+                                                        pluginId: dependencyId,
+                                                        platform,
+                                                        scope: dependencyScope,
+                                                        collision,
+                                                    }),
+                                                    rootIssueCode: 'artifactCollision',
+                                                    issuePluginId: dependencyId,
+                                                    issueScope: dependencyScope,
+                                                };
+                                            }
+                                            const requiredDependencyComponents = dependencyInspected.target
+                                                .desiredOwnedComponents ?? dependencyInspected.target.ownedComponents;
+                                            const desiredDependency = sourceDesired.get(desiredTargetKey(dependencyId, platform));
+                                            const projectMigrationPending = dependencyScope === 'project'
+                                                && projectIntent.dependencyScopeOverrides.some((override) => override.pluginId === dependencyId
+                                                    && override.scope === 'project'
+                                                    && (override.platform === undefined || override.platform === platform))
+                                                && desiredDependency?.scopes.includes('project') === true
+                                                && desiredDependency.scopes.includes('user') === false
+                                                && ownerInventory.references.some((reference) => reference.kind === 'namespacedOwner'
+                                                    && reference.sourceId === item.resolution.sourceId
+                                                    && reference.pluginName === dependencyName
+                                                    && reference.platform === platform
+                                                    && reference.scope === 'user');
+                                            const migrationOnlyPartial = dependencyLiveState === 'partial'
+                                                && projectMigrationPending
+                                                && dependencyInspected.inspection.components.every((component) => component.state === 'present' || component.state === 'absent')
+                                                && requiredDependencyComponents.every((required) => dependencyInspected.inspection.components.some((component) => component.component === required
+                                                    && (component.state === 'present'
+                                                        || component.state === 'absent'
+                                                            && component.component.kind !== 'native-plugin'
+                                                            && 'locator' in component.component
+                                                            && component.component.locator.kind === 'codex-activation'
+                                                            && component.component.locator.desired === false)));
+                                            const effectiveDependencyLiveState = migrationOnlyPartial
+                                                ? 'present'
+                                                : dependencyLiveState;
+                                            if (effectiveDependencyLiveState !== 'present') {
+                                                const state = effectiveDependencyLiveState === 'absent' ? 'absent'
+                                                    : effectiveDependencyLiveState === 'partial' ? 'incomplete'
+                                                        : 'error';
+                                                return {
+                                                    state,
+                                                    dependencyScope,
+                                                    rootIssueId: state === 'absent'
+                                                        ? `dependencyMissing:${dependencyId}:${platform}:${dependencyScope}`
+                                                        : state === 'incomplete'
+                                                            ? `incompleteInstallation:${dependencyId}:${platform}:${dependencyScope}`
+                                                            : `diagnostic:${dependencyId}:${platform}:${dependencyScope}`,
+                                                    rootIssueCode: state === 'absent' ? 'dependencyMissing'
+                                                        : state === 'incomplete' ? 'incompleteInstallation' : 'diagnostic',
+                                                    issuePluginId: dependencyId,
+                                                    issueScope: dependencyScope,
+                                                };
+                                            }
+                                            for (const childName of dependencyPlugin.manifest.dependencies ?? []) {
+                                                const childId = formatPluginId({
+                                                    sourceId: item.resolution.sourceId,
+                                                    pluginName: childName,
+                                                });
+                                                let childResult;
+                                                for (const childScope of dependencyPlacementsFor(childId, dependencyScope)) {
+                                                    const candidate = await inspectDependencyAtScope(childName, childScope);
+                                                    if (candidate.state === 'ready') {
+                                                        childResult = candidate;
+                                                        break;
+                                                    }
+                                                    if (!childResult
+                                                        || dependencyPriority[candidate.state]
+                                                            > dependencyPriority[childResult.state]) {
+                                                        childResult = candidate;
+                                                    }
+                                                }
+                                                if (childResult?.state !== 'ready') {
+                                                    return {
+                                                        ...childResult,
+                                                        dependencyScope,
+                                                    };
+                                                }
+                                            }
+                                            return { state: 'ready', dependencyScope };
+                                        })().catch(() => ({
+                                            state: 'error',
+                                            dependencyScope,
+                                            rootIssueId: `diagnostic:${dependencyId}:${platform}:${dependencyScope}`,
+                                            rootIssueCode: 'diagnostic',
+                                            issuePluginId: dependencyId,
+                                            issueScope: dependencyScope,
+                                        }));
+                                        dependencyInspectionCache.set(inspectionCacheKey, inspection);
+                                        return inspection;
+                                    }
                                     if (directDependencies.length > 0
-                                        && (liveState === 'present' || liveState === 'partial')) {
+                                        && (desiredInScope
+                                            || actualCodexActivation
+                                            || hasScopedExtensionResidue
+                                            || (platform !== 'codex'
+                                                && (liveState === 'present' || liveState === 'partial')))) {
                                         for (const dependencyName of directDependencies) {
                                             const dependencyId = formatPluginId({
                                                 sourceId: item.resolution.sourceId,
@@ -1178,120 +1510,12 @@ async function statusCommandV7InSession(options) {
                                                 }, 'partial'));
                                                 continue;
                                             }
-                                            const pluginCacheKey = [item.resolution.sourceIdentity, dependencyId].join('\0');
-                                            let dependencyPluginPromise = dependencyPluginCache.get(pluginCacheKey);
-                                            if (!dependencyPluginPromise) {
-                                                dependencyPluginPromise = readPluginManifest(path.join(item.resolution.rootDir, 'plugins', dependencyName), { mode: 'bundle' }).then((dependencyPlugin) => {
-                                                    dependencyPlugin.sourceId = item.resolution.sourceId;
-                                                    dependencyPlugin.sourceIdentity = item.resolution.sourceIdentity;
-                                                    dependencyPlugin.catalogLogicalIdentity = item.resolution.logicalIdentity;
-                                                    dependencyPlugin.pluginId = dependencyId;
-                                                    return dependencyPlugin;
-                                                });
-                                                dependencyPluginCache.set(pluginCacheKey, dependencyPluginPromise);
-                                            }
-                                            const dependencyOverride = (scope === 'project'
-                                                ? projectIntent
-                                                : userIntent).dependencyScopeOverrides.find((override) => override.pluginId === dependencyId
-                                                && (override.platform === undefined || override.platform === platform));
-                                            const placements = dependencyOverride
-                                                ? [dependencyOverride.scope]
-                                                : scope === 'project' ? ['project', 'user'] : ['user'];
+                                            const placements = dependencyPlacementsFor(dependencyId, scope);
                                             let dependencyResult = {
                                                 state: 'absent',
                                             };
                                             for (const dependencyScope of placements) {
-                                                const inspectionCacheKey = [
-                                                    item.resolution.sourceIdentity,
-                                                    dependencyId,
-                                                    platform,
-                                                    dependencyScope,
-                                                    dependencyScope === 'project' ? currentProjectKey : '',
-                                                ].join('\0');
-                                                let dependencyInspection = dependencyInspectionCache.get(inspectionCacheKey);
-                                                if (!dependencyInspection) {
-                                                    dependencyInspection = dependencyPluginPromise.then(async (dependencyPlugin) => {
-                                                        dependencyInspectionHookForTests?.();
-                                                        const dependencyMarketplaceName = marketplaceNameFor(dependencyName, platform, dependencyScope);
-                                                        const dependencyInspected = await inspectRebuildTarget({
-                                                            sourceId: item.resolution.sourceId,
-                                                            sourceIdentity: item.resolution.sourceIdentity,
-                                                            pluginId: dependencyId,
-                                                            marketplaceName: dependencyMarketplaceName,
-                                                            marketplaceRoot,
-                                                            plugin: dependencyPlugin,
-                                                            platform,
-                                                            scope: dependencyScope,
-                                                            cwd: options.cwd,
-                                                            catalog: { rootDir: item.resolution.rootDir, source: 'local' },
-                                                            context: {
-                                                                env,
-                                                                nativeCliRunner,
-                                                                reporter: createNoopReporter(),
-                                                                debugLogger: createNoopDebugLogger(),
-                                                                codexObservationSession: options.codexObservationSession,
-                                                            },
-                                                            userActivationDesired: codexDesiredUserActivationIds,
-                                                            nativeProbe: readOnlyNativeProbe({
-                                                                pluginName: dependencyName,
-                                                                sourceId: item.resolution.sourceId,
-                                                                sourceIdentity: item.resolution.sourceIdentity,
-                                                                platform,
-                                                                scope: dependencyScope,
-                                                                marketplaceName: dependencyMarketplaceName,
-                                                                marketplaceRoot,
-                                                                desired: sourceDesired.get(desiredTargetKey(dependencyId, platform))
-                                                                    ?.scopes.includes(dependencyScope) === true,
-                                                            }),
-                                                            shallow: true,
-                                                        });
-                                                        const dependencyLiveState = projectedLiveState({
-                                                            inspection: dependencyInspected.inspection,
-                                                            required: dependencyInspected.target.desiredOwnedComponents
-                                                                ?? dependencyInspected.target.ownedComponents,
-                                                            optional: dependencyInspected.target.optionalOwnedComponents ?? [],
-                                                        });
-                                                        const collision = dependencyInspected.inspection.components.find((component) => component.collision)?.collision;
-                                                        if (collision) {
-                                                            return {
-                                                                state: 'blockedByCollision',
-                                                                dependencyScope,
-                                                                rootIssueId: collisionRootIssueId({
-                                                                    pluginId: dependencyId,
-                                                                    platform,
-                                                                    scope: dependencyScope,
-                                                                    collision,
-                                                                }),
-                                                                rootIssueCode: 'artifactCollision',
-                                                            };
-                                                        }
-                                                        return {
-                                                            state: dependencyLiveState === 'present' ? 'ready'
-                                                                : dependencyLiveState === 'absent' ? 'absent'
-                                                                    : dependencyLiveState === 'partial' ? 'incomplete'
-                                                                        : 'error',
-                                                            dependencyScope,
-                                                            ...(dependencyLiveState === 'partial'
-                                                                ? {
-                                                                    rootIssueId: `incompleteInstallation:${dependencyId}:${platform}:${dependencyScope}`,
-                                                                    rootIssueCode: 'incompleteInstallation',
-                                                                }
-                                                                : dependencyLiveState === 'error'
-                                                                    ? {
-                                                                        rootIssueId: `diagnostic:${dependencyId}:${platform}:${dependencyScope}`,
-                                                                        rootIssueCode: 'diagnostic',
-                                                                    }
-                                                                    : {}),
-                                                        };
-                                                    }).catch(() => ({
-                                                        state: 'error',
-                                                        dependencyScope,
-                                                        rootIssueId: `diagnostic:${dependencyId}:${platform}:${dependencyScope}`,
-                                                        rootIssueCode: 'diagnostic',
-                                                    }));
-                                                    dependencyInspectionCache.set(inspectionCacheKey, dependencyInspection);
-                                                }
-                                                const candidate = await dependencyInspection;
+                                                const candidate = await inspectDependencyAtScope(dependencyName, dependencyScope);
                                                 if (candidate.state === 'ready') {
                                                     dependencyResult = candidate;
                                                     break;
@@ -1307,7 +1531,7 @@ async function statusCommandV7InSession(options) {
                                                     dependencyResult = candidate;
                                                 }
                                             }
-                                            if (dependencyResult.state === 'absent') {
+                                            if (dependencyResult.state === 'absent' && !dependencyResult.rootIssueId) {
                                                 const dependencyScope = dependencyResult.dependencyScope ?? placements[0];
                                                 dependencyResult = {
                                                     state: 'absent',
@@ -1322,28 +1546,46 @@ async function statusCommandV7InSession(options) {
                                                 dependencyPlatform: platform,
                                                 dependencyScope,
                                                 dependencyProject: dependencyScope === 'project' ? 'current' : null,
-                                                ...dependencyResult,
+                                                state: dependencyResult.state,
+                                                ...(dependencyResult.rootIssueId
+                                                    ? { rootIssueId: dependencyResult.rootIssueId }
+                                                    : {}),
+                                                ...(dependencyResult.rootIssueCode
+                                                    ? { rootIssueCode: dependencyResult.rootIssueCode }
+                                                    : {}),
                                             });
+                                            const issuePluginId = dependencyResult.issuePluginId ?? dependencyId;
+                                            const issueScope = dependencyResult.issueScope ?? dependencyScope;
                                             if (dependencyResult.state === 'absent') {
                                                 dependencyErrors.push(finalizeTargetError({
                                                     code: 'dependencyMissing',
-                                                    message: `dependencyMissing: ${dependencyId} is absent from its required live placement.`,
-                                                    dependencyPluginId: dependencyId,
+                                                    message: `dependencyMissing: ${issuePluginId} is absent from its required live placement.`,
+                                                    dependencyPluginId: issuePluginId,
                                                     dependencyPlatform: platform,
-                                                    dependencyScope,
-                                                    dependencyProject: dependencyScope === 'project' ? 'current' : null,
+                                                    dependencyScope: issueScope,
+                                                    dependencyProject: issueScope === 'project' ? 'current' : null,
                                                     rootIssueId: dependencyResult.rootIssueId,
                                                     rootIssueCode: dependencyResult.rootIssueCode,
                                                 }, 'partial'));
                                             }
                                             else if (dependencyResult.state !== 'ready') {
+                                                const code = dependencyResult.rootIssueCode === 'awCapabilityUnsupported'
+                                                    ? 'awCapabilityUnsupported'
+                                                    : dependencyResult.rootIssueCode === 'dependencyGraphInvalid'
+                                                        ? 'dependencyGraphInvalid'
+                                                        : 'dependencyNotReady';
+                                                const message = code === 'awCapabilityUnsupported'
+                                                    ? `${code}: ${issuePluginId} requires unsupported AW capabilities: ${(dependencyResult.missingCapabilities ?? []).join(', ')}.`
+                                                    : code === 'dependencyGraphInvalid'
+                                                        ? `${code}: dependency cycle includes ${issuePluginId}.`
+                                                        : `${code}: ${issuePluginId} is not ready at its required live placement.`;
                                                 dependencyErrors.push(finalizeTargetError({
-                                                    code: 'dependencyNotReady',
-                                                    message: `dependencyNotReady: ${dependencyId} is not ready at its required live placement.`,
-                                                    dependencyPluginId: dependencyId,
+                                                    code,
+                                                    message,
+                                                    dependencyPluginId: issuePluginId,
                                                     dependencyPlatform: platform,
-                                                    dependencyScope,
-                                                    dependencyProject: dependencyScope === 'project' ? 'current' : null,
+                                                    dependencyScope: issueScope,
+                                                    dependencyProject: issueScope === 'project' ? 'current' : null,
                                                     ...(dependencyResult.rootIssueId
                                                         ? { rootIssueId: dependencyResult.rootIssueId }
                                                         : {}),
@@ -1601,7 +1843,21 @@ async function statusCommandV7InSession(options) {
                     scopes,
                     currentProjectLocationKey,
                 }));
-                if (!selectorHasInventoryError) {
+                const selectorHasLiveOrIntent = ownerInventory.references.some((reference) => (reference.kind === 'namespacedOwner' || reference.kind === 'namespacedMarketplace')
+                    && reference.pluginName === selector.parsed.pluginName
+                    && reference.sourceId !== undefined
+                    && (selector.parsed.sourceId === undefined || reference.sourceId === selector.parsed.sourceId)
+                    && platforms.some((platform) => platform === reference.platform)
+                    && scopes.some((scope) => scope === reference.scope)
+                    && (reference.scope !== 'project' || reference.projectKey === currentProjectKey))
+                    || [userIntent, projectIntent].some((intent, index) => scopes.includes(index === 0 ? 'user' : 'project')
+                        && intent.roots.some((root) => {
+                            const parsed = parsePluginId(root.pluginId);
+                            return parsed.pluginName === selector.parsed.pluginName
+                                && (selector.parsed.sourceId === undefined || parsed.sourceId === selector.parsed.sourceId)
+                                && root.platforms.some((platform) => platforms.includes(platform));
+                        }));
+                if (!selectorHasInventoryError && !selectorHasLiveOrIntent) {
                     selectorErrors.push({
                         code: 'pluginNotFound',
                         message: `Plugin "${selector.raw}" was not found in the selected catalog source set.`,
@@ -1795,6 +2051,14 @@ async function statusCommandV7InSession(options) {
             sourceId: reference.sourceId,
             pluginName: reference.pluginName,
         })));
+    const isDisabledCodexReference = (reference) => {
+        if (reference.kind !== 'namespacedMarketplace' || reference.platform !== 'codex'
+            || !reference.pluginName || !reference.marketplaceName)
+            return false;
+        const config = reference.scope === 'user' ? userCodexConfig : projectCodexConfig;
+        return config?.snapshot.plugins[`${reference.pluginName}@${reference.marketplaceName}`]?.enabled === false;
+    };
+    unavailableBundleReferences.sort((left, right) => Number(isDisabledCodexReference(right)) - Number(isDisabledCodexReference(left)));
     const unavailableBundleTargets = [...new Map(unavailableBundleReferences.flatMap((reference) => {
             if (!reference.sourceId || !reference.pluginName
                 || (reference.platform !== 'codex' && reference.platform !== 'claude')
@@ -1804,6 +2068,9 @@ async function statusCommandV7InSession(options) {
             if (requested.length > 0 && !plannedSelectors.some((selector) => selector.parsed.pluginName === reference.pluginName
                 && (selector.parsed.sourceId === undefined || selector.parsed.sourceId === reference.sourceId)))
                 return [];
+            const disabled = isDisabledCodexReference(reference)
+                && ![userIntent, projectIntent].some((intent) => intent.roots.some((root) => root.pluginId === pluginId && root.platforms.includes('codex')))
+                && (desiredTargetStates.get(desiredTargetKey(pluginId, 'codex'))?.scopes.length ?? 0) === 0;
             const target = {
                 pluginName: reference.pluginName,
                 sourceId: reference.sourceId,
@@ -1812,9 +2079,9 @@ async function statusCommandV7InSession(options) {
                 platform: reference.platform,
                 scope: reference.scope,
                 cwd: path.resolve(options.cwd),
-                state: 'error',
+                state: disabled ? 'absent' : 'error',
                 components: [],
-                errors: [finalizeTargetError({
+                errors: disabled ? [] : [finalizeTargetError({
                         code: 'bundleUnavailable',
                         message: `bundleUnavailable: ${pluginId} has live state but is not present in the current source snapshot.`,
                     }, 'error')],
@@ -1894,15 +2161,13 @@ async function statusCommandV7InSession(options) {
     });
     const decorateTarget = async (target, groupedScopes, groupedTargets) => {
         const entry = selectedByPluginId.get(target.pluginId);
-        const codex = entry?.codex;
+        const codex = target.platform === 'codex' ? entry?.codex : undefined;
         const desiredAll = desiredTargetStates.get(desiredTargetKey(target.pluginId, target.platform))
             ?? { scopes: [], relation: 'none' };
-        const desired = target.platform === 'codex'
-            ? desiredAll
-            : {
-                scopes: desiredAll.scopes.includes(target.scope) ? [target.scope] : [],
-                relation: desiredAll.relation,
-            };
+        const desired = {
+            scopes: desiredAll.scopes.includes(target.scope) ? [target.scope] : [],
+            relation: desiredAll.relation,
+        };
         const sharedNative = codex?.sharedNative ?? target.sharedNative;
         const baseActivation = codex?.activation ?? target.activation;
         const consumerScope = desired.scopes.includes('project')
@@ -1925,9 +2190,7 @@ async function statusCommandV7InSession(options) {
                 systemConsumer,
             }
             : baseActivation;
-        const observationScopes = explicitScope
-            ? [explicitScope]
-            : desired.scopes.length > 0 ? desired.scopes : groupedScopes;
+        const observationScopes = [target.scope];
         const scopedTargets = groupedTargets.filter((candidate) => observationScopes.includes(candidate.scope));
         const observedTargets = scopedTargets.length > 0 ? scopedTargets : groupedTargets;
         const ownershipState = observedTargets.some((candidate) => candidate.state === 'error')
@@ -1939,6 +2202,8 @@ async function statusCommandV7InSession(options) {
                     : sharedNative?.staleCacheObserved
                         ? 'partial'
                         : 'absent';
+        const actualScopeEnabled = target.platform === 'codex'
+            && baseActivation?.[target.scope] === true;
         const hasSourceError = observedTargets.some((candidate) => candidate.errors.some((error) => error.code === 'sourceMissing'
             || error.code === 'catalogSourceUnavailable'
             || error.code === 'bundleUnavailable'
@@ -1947,18 +2212,16 @@ async function statusCommandV7InSession(options) {
             && (codex?.extensionKinds.length ?? 0) > 0
             && desired.scopes.includes('user')
             && desired.scopes.includes('project');
-        const expectedUser = desired.scopes.includes('user');
-        const expectedProject = desired.scopes.includes('project');
+        const expectedEnabled = desired.scopes.includes(target.scope);
         const activationDrift = target.platform === 'codex'
             && (codexConfigErrors.some((error) => error.scope === 'user' || observationScopes.includes(error.scope))
                 || ((codex?.nativeKinds.length ?? 0) > 0
-                    && ((expectedUser && activation?.user !== true)
-                        || (!expectedUser && activation?.user === true)
-                        || (expectedProject && activation?.project !== true)
-                        || (!expectedProject && activation?.project === true))));
+                    && (expectedEnabled && activation?.[target.scope] !== true
+                        || !expectedEnabled && activation?.[target.scope] === true)));
         const extensionComponents = observedTargets.flatMap((candidate) => candidate.components).filter((component) => component.key !== 'native'
             && !component.key.startsWith('activation-')
             && !component.key.startsWith('marketplace-'));
+        const hasScopedExtensionResidue = extensionComponents.some((component) => component.state !== 'absent' || component.error !== undefined);
         const extensions = target.platform !== 'codex'
             || (codex?.extensionKinds.length ?? 0) === 0
             ? undefined
@@ -2014,6 +2277,7 @@ async function statusCommandV7InSession(options) {
         const baseTargetErrors = observedTargets.flatMap((candidate) => candidate.errors);
         const hasBlockingBaseReason = baseTargetErrors.some((reason) => reason.severity === 'blocking');
         const capabilityUnsupported = baseTargetErrors.some((reason) => reason.code === 'awCapabilityUnsupported');
+        const dependencyNotReady = (target.dependencyReadiness ?? []).some((dependency) => dependency.state !== 'ready');
         const state = hasSourceError && desiredEnabled
             ? 'blocked'
             : consumerBlocking && desiredEnabled
@@ -2022,30 +2286,40 @@ async function statusCommandV7InSession(options) {
                     ? 'blocked'
                     : sharedNative?.state === 'blocked' || hasBlockingBaseReason || capabilityUnsupported
                         ? 'blocked'
-                        : !desiredEnabled
-                            ? ownershipState !== 'absent' || desired.relation === 'managed'
-                                ? 'orphaned'
-                                : 'absent'
-                            : dependencyMoves.length > 0
-                                ? 'needsSync'
-                                : sharedNative?.state === 'missing'
-                                    || sharedNative?.state === 'replaceable'
-                                    || sharedNative?.state === 'unobserved'
+                        : sharedNative?.state === 'replaceable' && sharedNative.reason === 'damaged'
+                            ? 'needsSync'
+                            : !desiredEnabled
+                                ? (target.platform === 'codex'
+                                    ? actualScopeEnabled || hasScopedExtensionResidue
+                                    : ownershipState !== 'absent')
+                                    || desired.relation === 'managed'
+                                    ? 'orphaned'
+                                    : 'absent'
+                                : dependencyMoves.length > 0
                                     ? 'needsSync'
-                                    : activationDrift || extensions?.state === 'drifted'
+                                    : dependencyNotReady
                                         ? 'needsSync'
-                                        : extensions?.state === 'missing' || ownershipState === 'absent'
+                                        : sharedNative?.state === 'missing'
+                                            || sharedNative?.state === 'replaceable'
+                                            || sharedNative?.state === 'unobserved'
                                             ? 'needsSync'
-                                            : ownershipState === 'partial' || ownershipState === 'error'
+                                            : activationDrift || extensions?.state === 'drifted'
                                                 ? 'needsSync'
-                                                : 'ready';
+                                                : extensions?.state === 'missing'
+                                                    || (target.platform !== 'codex' && ownershipState === 'absent')
+                                                    ? 'needsSync'
+                                                    : ownershipState === 'partial' || ownershipState === 'error'
+                                                        ? 'needsSync'
+                                                        : 'ready';
         const stableErrors = [
             ...projectStatusSharedNativeReasons(sharedNative, baseTargetErrors.map((error) => error.code), desiredEnabled),
             ...(desiredOverlapConflict
                 ? [blocking('codexExtensionScopeConflict', `${target.pluginId} has AW extensions desired at user and project scope.`)]
                 : []),
             ...(activationDrift && sharedNative?.state !== 'missing' && sharedNative?.state !== 'unobserved'
-                ? [warning('codexActivationDrift', `${target.pluginId} activation differs from desired intent.`)]
+                ? [warning('codexActivationDrift', `${target.pluginId} activation differs from desired intent: `
+                        + `${target.scope} expected=${expectedEnabled}, `
+                        + `actual=${activation?.[target.scope] ?? 'unset'}.`)]
                 : []),
             ...(extensions?.state === 'drifted'
                 ? [warning('codexExtensionDrift', `${target.pluginId} extension projection has drifted.`)]
@@ -2071,11 +2345,7 @@ async function statusCommandV7InSession(options) {
             ])).values()];
         const ownershipComponents = [...new Map(observedTargets.flatMap((candidate) => candidate.components)
                 .map((component) => [component.key, component])).values()];
-        const representativeScope = explicitScope
-            ?? (desired.scopes.length === 1
-                ? desired.scopes[0]
-                : observedTargets.find((candidate) => candidate.state !== 'absent')?.scope
-                    ?? (groupedScopes.includes('user') ? 'user' : groupedScopes[0] ?? target.scope));
+        const representativeScope = target.scope;
         const representativeTarget = observedTargets.find((candidate) => candidate.scope === representativeScope) ?? target;
         const components = [
             {
@@ -2122,7 +2392,7 @@ async function statusCommandV7InSession(options) {
                 }]),
             ...(activation?.systemConsumer ? [{
                     kind: 'systemConsumer',
-                    key: 'codex',
+                    key: `codex:${representativeScope}`,
                     state: activation.systemConsumer.state,
                     metadata: {
                         evidence: activation.evidence,
@@ -2169,6 +2439,8 @@ async function statusCommandV7InSession(options) {
                 pluginId: target.pluginId,
                 ...(dependencyMoves.length > 0 ? { dependencyMoves } : {}),
                 ...(sharedNative ? { sharedNative } : {}),
+                scope: target.scope,
+                actualEnabled: actualScopeEnabled,
                 conflictRoots: rootIntentsForTarget({
                     pluginId: target.pluginId,
                     platform: target.platform,
@@ -2177,7 +2449,9 @@ async function statusCommandV7InSession(options) {
                     available,
                 }),
                 errorCodes: dedupedErrors.map((error) => error.code),
-            }),
+            }).map((action) => action.command === 'manual' || action.scope
+                ? action
+                : { ...action, scope: representativeScope }),
         };
     };
     const codexGroups = new Map();
@@ -2192,18 +2466,84 @@ async function statusCommandV7InSession(options) {
         codexGroups.set(target.pluginId, group);
     }
     for (const group of codexGroups.values()) {
-        const scopes = [...new Set(group.map((target) => target.scope))].sort();
-        projectedTargets.push(await decorateTarget(group[0], scopes, group));
+        const decorated = await Promise.all(group.map((target) => decorateTarget(target, [target.scope], [target])));
+        const first = decorated[0];
+        const entry = selectedByPluginId.get(first.pluginId);
+        const desired = desiredTargetStates.get(desiredTargetKey(first.pluginId, 'codex'))
+            ?? { scopes: [], relation: 'none' };
+        const returnedScopes = new Set(decorated.map((target) => target.scope));
+        const desiredOverlapConflict = (entry?.codex?.extensionKinds.length ?? 0) > 0
+            && desired.scopes.includes('user')
+            && desired.scopes.includes('project')
+            && returnedScopes.has('user')
+            && returnedScopes.has('project');
+        const sharedComponents = [...new Map(decorated.flatMap((target) => target.components)
+                .filter((component) => component.kind === 'sharedNative' || component.kind === 'systemConsumer')
+                .map((component) => [`${component.kind}\0${component.key}`, component])).values()];
+        const sharedReason = (reason) => reason.code.startsWith('codexSharedNative') || reason.code === 'staleCacheObserved';
+        const sharedReasons = decorated.flatMap((target) => target.reasons.filter(sharedReason));
+        const placements = decorated.map((target) => ({
+            scope: target.scope,
+            state: target.state,
+            components: target.components.filter((component) => component.kind !== 'sharedNative' && component.kind !== 'systemConsumer'),
+            reasons: target.reasons.filter((reason) => !sharedReason(reason)),
+            recoveryActions: target.recoveryActions,
+        })).sort((left, right) => left.scope.localeCompare(right.scope, 'en'));
+        const reasons = [...new Map([
+                ...placements.flatMap((placement) => placement.reasons),
+                ...sharedReasons,
+                ...(desiredOverlapConflict ? [blocking('codexExtensionScopeConflict', `${first.pluginId} has AW extensions desired at user and project scope.`)] : []),
+            ]
+                .map((reason) => [`${reason.code}\0${reason.message}`, reason])).values()];
+        const conflictRecovery = desiredOverlapConflict ? statusRecovery({
+            state: 'blocked',
+            desired,
+            platform: 'codex',
+            pluginId: first.pluginId,
+            conflictRoots: rootIntentsForTarget({
+                pluginId: first.pluginId,
+                platform: 'codex',
+                userIntent,
+                projectIntent,
+                available,
+            }),
+            errorCodes: ['codexExtensionScopeConflict'],
+        }) : [];
+        const recoveryActions = [...new Map((desiredOverlapConflict
+                ? conflictRecovery
+                : placements.flatMap((placement) => placement.recoveryActions))
+                .map((action) => [
+                `${action.command}\0${action.scope ?? ''}\0${action.description}`,
+                action,
+            ])).values()];
+        const state = desiredOverlapConflict ? 'blocked'
+            : ['blocked', 'needsSync', 'orphaned', 'ready', 'absent']
+                .find((candidate) => placements.some((placement) => placement.state === candidate));
+        projectedTargets.push({
+            pluginName: first.pluginName,
+            sourceId: first.sourceId,
+            sourceIdentity: first.sourceIdentity,
+            pluginId: first.pluginId,
+            ...(first.version ? { version: first.version } : {}),
+            platform: 'codex',
+            cwd: first.cwd,
+            state,
+            components: sharedComponents,
+            reasons,
+            recoveryActions,
+            placements,
+        });
     }
-    projectedTargets.sort((left, right) => `${left.pluginId}\0${left.platform}\0${left.scope}`.localeCompare(`${right.pluginId}\0${right.platform}\0${right.scope}`, 'en'));
-    const targetRevisions = projectedTargets.map((target) => {
+    projectedTargets.sort((left, right) => `${left.pluginId}\0${left.platform}`.localeCompare(`${right.pluginId}\0${right.platform}`, 'en'));
+    const targetRevisions = projectedTargets.flatMap((target) => {
         const entry = selectedByPluginId.get(target.pluginId);
-        return {
+        const placements = target.platform === 'codex' ? target.placements : [target];
+        return placements.map((placement) => ({
             pluginId: target.pluginId,
             platform: target.platform,
-            scope: target.scope,
-            revision: projectTargetRevision(entry?.version, entry?.states[target.platform]?.[target.scope]?.installedVersion),
-        };
+            scope: placement.scope,
+            revision: projectTargetRevision(entry?.version, entry?.states[target.platform]?.[placement.scope]?.installedVersion),
+        }));
     });
     const publicConfigIssues = available.flatMap((entry) => (entry.configIssues ?? [])
         .filter((issue) => issue.type === 'configLayerUnsupported')
@@ -2213,7 +2553,7 @@ async function statusCommandV7InSession(options) {
         ...issue,
     })));
     const payload = {
-        schemaVersion: 7,
+        schemaVersion: 8,
         catalog: {
             primarySourceId: catalog.primarySourceId,
             configDigest: catalog.configDigest,
@@ -2243,7 +2583,7 @@ async function statusCommandV7InSession(options) {
         || payload.targets.some((target) => target.reasons.some((reason) => reason.severity === 'blocking'));
     return {
         payload,
-        output: options.json ? JSON.stringify(payload) : renderStatusV7(payload, options.verbose === true),
+        output: options.json ? JSON.stringify(payload) : renderStatusV8(payload, options.verbose === true),
         hasErrors,
         targetRevisions,
         pluginSummaries: available.map((entry) => {
@@ -2290,9 +2630,9 @@ async function statusCommandV7InSession(options) {
         }),
     };
 }
-export async function statusCommandV7(options) {
+export async function statusCommandV8(options) {
     if (options.codexObservationSession) {
-        return statusCommandV7InSession({
+        return statusCommandV8InSession({
             ...options,
             codexObservationSession: options.codexObservationSession,
         });
@@ -2304,7 +2644,7 @@ export async function statusCommandV7(options) {
         runner: options.nativeCliRunner ?? getDefaultNativeCliRunner(),
     });
     try {
-        return await statusCommandV7InSession({ ...options, codexObservationSession: session });
+        return await statusCommandV8InSession({ ...options, codexObservationSession: session });
     }
     finally {
         await session.dispose();