@lesliechan721/aw 0.1.0-beta.8 → 0.1.0-beta.9

package/dist/src/commands/{status-v5.js → status-v6.js}

@@ -1,29 +1,35 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { hasCodexProjectManagedArtifacts } from '../utils/codex-project-surface.js';
+import { analyzeCodexSurface } from '../utils/codex-surface-analysis.js';
 import { catalogSourceErrorCode, sanitizeCatalogSourceError, } from '../utils/catalog-public-error.js';
 import { calculateCatalogSourceIdentity } from '../utils/catalog-source-identity.js';
 import { canonicalMarketplaceRegistrationNames, inventoryCatalogSourceReferences, inventoryLegacyOwnerReferences, } from '../utils/catalog-source-references.js';
 import { readCatalogSourcesConfigSnapshot, resolveCatalogSourceRef } from '../utils/catalog-sources.js';
 import { formatPluginId, parsePluginId, planPluginSelectorSourceIds, withResolvedMultiSourceCatalog, } from '../utils/multi-source-catalog.js';
 import { assertStrictSemVer, checkAwCapabilitySupport, compareStrictSemVer, readPluginManifest, tryParseStrictSemVer, } from '../utils/manifest.js';
-import { resolveCliPackageRoot } from '../utils/paths.js';
+import { resolveCliPackageRoot, resolveCodexPaths } from '../utils/paths.js';
 import { supportsPlatform } from '../utils/platform-support.js';
 import { parsePlatformValue, parseScopeValue } from './options.js';
-import { inspectRebuildTarget } from './rebuild-integration.js';
+import { inspectCodexNativeResidue, inspectCodexSharedNativeLive, inspectRebuildTarget, } from './rebuild-integration.js';
 import { createNoopReporter } from '../output/reporter.js';
 import { createNoopDebugLogger } from '../output/debug-log.js';
 import { getDefaultNativeCliRunner } from '../utils/native-cli.js';
 import { resolveAwHome } from '../utils/paths.js';
 import { codexProjectConfigAliasesUserHome, createProjectLocationKey, getClaudeHome, getCodexHome, resolveCanonicalRepoProjectKey, } from '../utils/state-paths.js';
 import { resolveEffectivePluginConfig } from '../utils/plugin-config.js';
+import { readCodexConfigFile } from '../utils/codex-config.js';
+import { readPluginIntentState, } from '../utils/plugin-intent-state.js';
 import { IMPLEMENTED_AW_CAPABILITIES } from './aw-capabilities.js';
+import { createDependencyPlacementPlan } from './dependency-operation-plan.js';
+import { calculateCodexSharedNativePayloadDigest } from '../utils/catalog-digests.js';
+import { getCodexOperationRequirement } from '../utils/agent-version.js';
+import { inspectSystemCodexFilesystem, } from '../utils/codex-manager.js';
 let dependencyInspectionHookForTests;
 export function setStatusDependencyInspectionHookForTests(hook) {
     dependencyInspectionHookForTests = hook;
 }
 export async function loadConsoleItemsResult(options = {}, runtime = {}) {
-    const result = await statusCommandV5({
+    const result = await statusCommandV6({
         cwd: options.cwd ?? process.cwd(),
         env: runtime.env,
         platform: options.platform,
@@ -89,13 +95,24 @@ function inventoryErrorMatchesSelection(options) {
             || selector.parsed.sourceId === undefined
             || selector.parsed.sourceId === relevance.sourceId));
 }
-function projectTargetError(error, env, cwd) {
+function finalizeTargetError(error, targetState) {
+    return {
+        ...error,
+        severity: error.code === 'artifactCollision'
+            || (targetState === 'error'
+                && error.code !== 'awCapabilityUnsupported'
+                && error.dependencyPluginId === undefined)
+            ? 'blocking'
+            : 'warning',
+    };
+}
+function projectTargetError(error, env, cwd, targetState) {
     const sanitized = sanitizeCatalogSourceError(new Error(error.message), env, [
         getCodexHome(env),
         getClaudeHome(env),
         path.resolve(cwd),
     ]);
-    return { ...error, message: sanitized.message };
+    return finalizeTargetError({ ...error, message: sanitized.message }, targetState);
 }
 function sourceRequestedRef(source, cliVersion) {
     return source.type === 'git' ? resolveCatalogSourceRef(source.refPolicy, cliVersion) : 'path';
@@ -107,6 +124,203 @@ function selectedPlatforms(value) {
 function selectedScopes(value) {
     return value === undefined ? ['user', 'project'] : [parseScopeValue(value)];
 }
+function emptyIntent() {
+    return {
+        schemaVersion: 1,
+        kind: 'aw-plugin-intents',
+        roots: [],
+        dependencyScopeOverrides: [],
+        managed: { codexPluginIds: [] },
+    };
+}
+function desiredTargetKey(pluginId, platform) {
+    return `${pluginId}\0${platform}`;
+}
+function calculateDesiredTargetStates(options) {
+    const desired = new Map();
+    const add = (pluginId, platform, scope, relation) => {
+        const key = desiredTargetKey(pluginId, platform);
+        const current = desired.get(key) ?? { scopes: new Set(), relation: 'none' };
+        current.scopes.add(scope);
+        if (relation === 'root' || (relation === 'dependency' && current.relation !== 'root')) {
+            current.relation = relation;
+        }
+        desired.set(key, current);
+    };
+    const byId = new Map(options.available.map((entry) => [
+        formatPluginId({ sourceId: entry.source.id, pluginName: entry.name }),
+        entry,
+    ]));
+    for (const [scope, intent] of [
+        ['user', options.userIntent],
+        ['project', options.projectIntent],
+    ]) {
+        for (const root of intent.roots) {
+            for (const platform of root.platforms)
+                add(root.pluginId, platform, scope, 'root');
+        }
+        for (const platform of ['codex', 'claude']) {
+            const platformRoots = intent.roots.filter((root) => root.platforms.includes(platform) && byId.has(root.pluginId));
+            const closure = new Set();
+            const visit = (pluginId) => {
+                if (closure.has(pluginId))
+                    return;
+                closure.add(pluginId);
+                const entry = byId.get(pluginId);
+                if (!entry)
+                    return;
+                for (const dependency of entry.dependencies) {
+                    visit(formatPluginId({ sourceId: entry.source.id, pluginName: dependency }));
+                }
+            };
+            for (const root of platformRoots)
+                visit(root.pluginId);
+            const nodes = [...closure].flatMap((pluginId) => {
+                const entry = byId.get(pluginId);
+                if (!entry || !entry.targets[platform].user && !entry.targets[platform].project)
+                    return [];
+                const allowedScopes = [
+                    ...(entry.targets[platform].project
+                        && (platform !== 'codex' || options.codexProjectAllowed) ? ['project'] : []),
+                    ...(entry.targets[platform].user ? ['user'] : []),
+                ];
+                return allowedScopes.length === 0 ? [] : [{
+                        pluginId,
+                        pluginName: entry.name,
+                        platform,
+                        relation: platformRoots.some((root) => root.pluginId === pluginId)
+                            ? 'requested'
+                            : 'dependency',
+                        depth: platformRoots.some((root) => root.pluginId === pluginId) ? 0 : 1,
+                        allowedScopes,
+                    }];
+            });
+            const nodeIds = new Set(nodes.map((node) => node.pluginId));
+            const roots = platformRoots.flatMap((root) => nodeIds.has(root.pluginId)
+                ? [{ pluginId: root.pluginId, platform, scope }]
+                : []);
+            if (roots.length === 0)
+                continue;
+            const edges = nodes.flatMap((node) => {
+                const entry = byId.get(node.pluginId);
+                return entry.dependencies.flatMap((dependency) => {
+                    const dependencyId = formatPluginId({
+                        sourceId: entry.source.id,
+                        pluginName: dependency,
+                    });
+                    return nodeIds.has(dependencyId)
+                        ? [{ from: node.pluginId, to: dependencyId, platform }]
+                        : [];
+                });
+            });
+            const plan = createDependencyPlacementPlan({
+                requestedPluginIds: roots.map((root) => root.pluginId),
+                nodes,
+                roots,
+                dependencyEdges: edges,
+                scopeOverrides: intent.dependencyScopeOverrides.filter((override) => nodeIds.has(override.pluginId)
+                    && (override.platform === undefined || override.platform === platform)),
+            });
+            for (const target of plan.targets) {
+                add(target.pluginId, target.platform, target.resolvedScope, target.relation === 'requested' ? 'root' : 'dependency');
+            }
+        }
+    }
+    for (const intent of [options.userIntent, options.projectIntent]) {
+        for (const codexPluginId of intent.managed.codexPluginIds) {
+            for (const [pluginId, entry] of byId) {
+                if (entry.codex?.pluginId !== codexPluginId)
+                    continue;
+                const key = desiredTargetKey(pluginId, 'codex');
+                if (!desired.has(key))
+                    desired.set(key, { scopes: new Set(), relation: 'managed' });
+            }
+        }
+    }
+    return new Map([...desired].map(([key, value]) => [key, {
+            scopes: [...value.scopes].sort(),
+            relation: value.relation,
+        }]));
+}
+function statusRecovery(options) {
+    if (options.errorCodes?.some((code) => code === 'codexProjectPluginVersionTooLow'
+        || code === 'codexProjectPluginUnsupported'
+        || code === 'codexSystemCliUnsupported')) {
+        return [{
+                command: 'manual',
+                description: '升级或修复官方 system Codex CLI 后重试原操作。',
+            }];
+    }
+    if (options.actual === 'ready' || options.actual === 'absent')
+        return [];
+    if (options.actual === 'orphaned') {
+        return [{ command: 'cleanup', description: '清理可证明属于 AW 的遗留输出。' }];
+    }
+    if (options.actual === 'unresolved') {
+        return [
+            { command: 'sync', description: '来源恢复后同步 desired intent。' },
+            { command: 'cleanup', description: '来源无法恢复时清理可证明属于 AW 的输出。' },
+        ];
+    }
+    if (options.actual === 'conflict') {
+        if (options.desired.scopes.includes('user') && options.desired.scopes.includes('project')) {
+            return ['user', 'project'].flatMap((scope) => (options.conflictRoots?.[scope] ?? []).map((rootPluginId) => ({
+                command: 'uninstall',
+                scope,
+                description: `运行 aw uninstall ${rootPluginId} --platform ${options.platform} --scope ${scope}，再运行 aw sync ${options.pluginId} --platform ${options.platform} --scope ${scope === 'user' ? 'project' : 'user'}。`,
+            })));
+        }
+        const collision = options.sharedNative?.state === 'foreign'
+            ? `Codex shared native ${options.sharedNative.pluginId}`
+            : `${options.pluginId} 的 foreign extension`;
+        return [
+            {
+                command: 'sync',
+                description: `先移除或重命名 ${collision}，再运行 aw sync ${options.pluginId} --platform ${options.platform}。cleanup 会保留 foreign 内容，不会删除该冲突。`,
+            },
+        ];
+    }
+    return [{
+            command: options.actual === 'drifted' ? 'reinstall' : 'sync',
+            ...(options.desired.scopes.length === 1 ? { scope: options.desired.scopes[0] } : {}),
+            description: options.actual === 'drifted'
+                ? '重新安装以修复手动修改或损坏的现场。'
+                : '同步 desired intent 和当前现场。',
+        }];
+}
+function rootIntentsForTarget(options) {
+    const byId = new Map(options.available.map((entry) => [
+        formatPluginId({ sourceId: entry.source.id, pluginName: entry.name }),
+        entry,
+    ]));
+    const result = {};
+    for (const [scope, intent] of [
+        ['user', options.userIntent],
+        ['project', options.projectIntent],
+    ]) {
+        const roots = intent.roots.filter((root) => {
+            if (!root.platforms.includes(options.platform))
+                return false;
+            const seen = new Set();
+            const reaches = (pluginId) => {
+                if (pluginId === options.pluginId)
+                    return true;
+                if (seen.has(pluginId))
+                    return false;
+                seen.add(pluginId);
+                const entry = byId.get(pluginId);
+                return entry?.dependencies.some((dependency) => reaches(formatPluginId({
+                    sourceId: entry.source.id,
+                    pluginName: dependency,
+                }))) === true;
+            };
+            return reaches(root.pluginId);
+        }).map((root) => root.pluginId).sort();
+        if (roots.length > 0)
+            result[scope] = roots;
+    }
+    return result;
+}
 function projectedLiveState(options) {
     if (options.inspection.state === 'error'
         || options.inspection.components.some((entry) => entry.state === 'error'))
@@ -144,7 +358,7 @@ export function projectTargetRevision(availableVersion, installedVersion) {
         return { state: 'upgradeAvailable', availableVersion, installedVersion };
     return { state: 'unknown', availableVersion, installedVersion };
 }
-function renderStatusV5(payload, verbose) {
+function renderStatusV6(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'}`);
@@ -153,7 +367,23 @@ function renderStatusV5(payload, verbose) {
         const errors = target.errors.length > 0
             ? ` [${target.errors.map((error) => `${error.code}: ${error.message}`).join('; ')}]`
             : '';
-        lines.push(`${target.pluginId} ${target.platform}/${target.scope}: ${target.state}${errors}`);
+        const desired = target.desired.enabled ? target.desired.scopes.join('+') : 'absent';
+        lines.push(`${target.pluginId} ${target.platform}: desired=${desired} actual=${target.actual.state}${errors}`);
+        if (target.sharedNative) {
+            lines.push(`  shared native ${target.sharedNative.pluginId}: ${target.sharedNative.state}`);
+        }
+        if (target.activation) {
+            lines.push(`  activation user=${String(target.activation.user)} project=${String(target.activation.project)} (${target.activation.evidence})`);
+            if (target.activation.systemConsumer) {
+                const version = 'detectedVersion' in target.activation.systemConsumer
+                    ? ` ${target.activation.systemConsumer.detectedVersion}`
+                    : '';
+                lines.push(`  system Codex consumer: ${target.activation.systemConsumer.state}${version}`);
+            }
+        }
+        if (target.extensions) {
+            lines.push(`  extensions ${target.extensions.kinds.join(',')}: ${target.extensions.state}`);
+        }
         if (verbose) {
             for (const component of target.components) {
                 const error = component.error
@@ -185,12 +415,47 @@ function collisionRootIssueId(options) {
         options.collision.artifactKey,
     ].join(':');
 }
-export async function statusCommandV5(options) {
+export async function statusCommandV6(options) {
     const env = options.env ?? process.env;
     const dependencyPluginCache = new Map();
     const dependencyInspectionCache = new Map();
     const cliVersion = options.cliVersion ?? assertStrictSemVer(JSON.parse(fs.readFileSync(path.join(resolveCliPackageRoot(), 'package.json'), 'utf8')).version, 'packages/cli/package.json version');
     const snapshot = await readCatalogSourcesConfigSnapshot(env);
+    const intentErrors = [];
+    const readIntent = async (scope) => {
+        try {
+            return await readPluginIntentState({ scope, cwd: options.cwd, env });
+        }
+        catch {
+            intentErrors.push({
+                code: 'pluginIntentStateInvalid',
+                message: `pluginIntentStateInvalid: ${scope} plugin intent state is invalid.`,
+            });
+            return emptyIntent();
+        }
+    };
+    const [userIntent, projectIntent] = await Promise.all([
+        readIntent('user'),
+        readIntent('project'),
+    ]);
+    const codexConfigErrors = [];
+    const readActivationConfig = async (scope) => {
+        try {
+            return await readCodexConfigFile(resolveCodexPaths(options.cwd, scope, env).configTomlPath);
+        }
+        catch {
+            codexConfigErrors.push({
+                scope,
+                code: 'codexActivationDrift',
+                message: `codexActivationDrift: ${scope} Codex activation config is unreadable.`,
+            });
+            return undefined;
+        }
+    };
+    const [userCodexConfig, projectCodexConfig] = await Promise.all([
+        readActivationConfig('user'),
+        readActivationConfig('project'),
+    ]);
     const currentProjectKey = await resolveCanonicalRepoProjectKey(options.cwd);
     const currentProjectLocationKey = createProjectLocationKey(currentProjectKey);
     const codexScopePathsAlias = codexProjectConfigAliasesUserHome(options.cwd, env);
@@ -212,6 +477,39 @@ export async function statusCommandV5(options) {
             relevance: error.relevance,
         });
     }
+    const nativeProbeCache = new Map();
+    const codexDesiredUserActivationIds = new Set();
+    const readOnlyNativeProbe = (probe) => async () => {
+        const key = [
+            probe.sourceIdentity,
+            probe.pluginName,
+            probe.platform,
+            probe.scope,
+            probe.marketplaceName,
+        ].join('\0');
+        let value = nativeProbeCache.get(key);
+        if (!value) {
+            value = probe.platform === 'codex'
+                ? inspectCodexNativeResidue({
+                    pluginName: probe.pluginName,
+                    cwd: options.cwd,
+                    env,
+                    marketplaceName: probe.marketplaceName,
+                    marketplaceRoot: probe.marketplaceRoot,
+                }).then((residue) => residue.state)
+                : Promise.resolve(ownerInventory.references.some((reference) => (reference.kind === 'namespacedOwner' || reference.kind === 'namespacedMarketplace')
+                    && reference.sourceId === probe.sourceId
+                    && reference.sourceIdentity === probe.sourceIdentity
+                    && reference.pluginName === probe.pluginName
+                    && reference.platform === probe.platform
+                    && reference.scope === probe.scope
+                    && (probe.scope === 'user' || reference.projectKey === currentProjectKey))
+                    ? 'present'
+                    : 'absent');
+            nativeProbeCache.set(key, value);
+        }
+        return value;
+    };
     const hasCurrentCodexProjectOwner = (sourceId, pluginName) => ownerInventory.references.some((reference) => reference.kind === 'namespacedOwner'
         && reference.sourceId === sourceId
         && reference.pluginName === pluginName
@@ -222,6 +520,19 @@ export async function statusCommandV5(options) {
     const requested = options.plugins ?? [];
     const platforms = selectedPlatforms(options.platform);
     const scopes = selectedScopes(options.scope);
+    const codexSystemConsumerInspections = new Map();
+    const inspectCodexSystemConsumer = (scope) => {
+        let inspection = codexSystemConsumerInspections.get(scope);
+        if (!inspection) {
+            inspection = inspectSystemCodexFilesystem({
+                cwd: options.cwd,
+                env,
+                operationRequirement: getCodexOperationRequirement(scope),
+            });
+            codexSystemConsumerInspections.set(scope, inspection);
+        }
+        return inspection;
+    };
     const selectorErrors = [];
     const parsedSelectors = [];
     const plannedSelectors = [];
@@ -296,16 +607,11 @@ export async function statusCommandV5(options) {
     const identities = new Map(identityEntries);
     const catalog = await withResolvedMultiSourceCatalog({
         cliVersion,
-        freshnessPolicy: 'cacheFirst',
         configSnapshot: snapshot,
         ...(plannedSourceIds === undefined ? {} : { sourceIds: plannedSourceIds }),
         ...(options.catalogOperationContext
             ? { operationContext: options.catalogOperationContext }
             : {}),
-        ...(options.bootstrapMissingActive === false ? { bootstrapMissingActive: false } : {}),
-        ...(options.catalogGenerationRuntime?.providers
-            ? { providers: options.catalogGenerationRuntime.providers }
-            : {}),
         env,
         consume: async (resolution) => ({
             primarySourceId: resolution.primarySourceId,
@@ -330,6 +636,43 @@ export async function statusCommandV5(options) {
                     };
                 }
                 try {
+                    const placementEntries = item.resolution.manifest.entries.map((entry) => {
+                        const products = entry.policy.products;
+                        const supports = (platform) => products === undefined
+                            || products.includes(platform === 'codex' ? 'CODEX' : 'CLAUDE');
+                        return {
+                            name: entry.name,
+                            dependencies: entry.dependencies,
+                            source: { id: item.resolution.sourceId },
+                            targets: {
+                                codex: { user: supports('codex'), project: supports('codex') },
+                                claude: { user: supports('claude'), project: supports('claude') },
+                            },
+                        };
+                    });
+                    const sourceDesired = calculateDesiredTargetStates({
+                        userIntent,
+                        projectIntent,
+                        available: placementEntries,
+                        codexProjectAllowed: !codexScopePathsAlias,
+                    });
+                    const registeredNames = canonicalMarketplaceRegistrationNames(ownerInventory.references, item.resolution.sourceId);
+                    if (registeredNames.length > 1) {
+                        throw new Error('marketplaceIdentityUnavailable: Multiple canonical native marketplace registrations match the source.');
+                    }
+                    const desiredMarketplaceName = registeredNames[0]
+                        ?? (item.resolution.sourceId === resolution.primarySourceId
+                            ? 'aw'
+                            : `aw-${item.resolution.sourceId}`);
+                    for (const entry of placementEntries) {
+                        const pluginId = formatPluginId({
+                            sourceId: item.resolution.sourceId,
+                            pluginName: entry.name,
+                        });
+                        if (sourceDesired.get(desiredTargetKey(pluginId, 'codex'))?.scopes.includes('user')) {
+                            codexDesiredUserActivationIds.add(`${entry.name}@${desiredMarketplaceName}`);
+                        }
+                    }
                     const plugins = await Promise.all(item.resolution.manifest.entries.map(async (entry) => {
                         const capabilitySupport = checkAwCapabilitySupport(entry.requires.aw.capabilities ?? [], IMPLEMENTED_AW_CAPABILITIES);
                         if (!capabilitySupport.supported) {
@@ -346,13 +689,14 @@ export async function statusCommandV5(options) {
                                     states[platform][scope] = {
                                         state: 'error',
                                         components: [],
-                                        errors: [{ code: 'awCapabilityUnsupported', message }],
+                                        errors: [finalizeTargetError({ code: 'awCapabilityUnsupported', message }, 'error')],
                                     };
                                 }
                             }
                             return {
                                 name: entry.name,
                                 version: entry.version,
+                                sharedNativePayloadDigest: entry.contentDigest,
                                 displayName: entry.interface?.displayName ?? entry.name,
                                 shortDescription: entry.interface?.shortDescription ?? entry.description,
                                 description: entry.description,
@@ -368,6 +712,10 @@ export async function statusCommandV5(options) {
                         const plugin = await readPluginManifest(path.join(item.resolution.rootDir, 'plugins', entry.name), { mode: 'bundle' });
                         const claude = supportsPlatform(plugin.manifest, 'claude');
                         const codex = supportsPlatform(plugin.manifest, 'codex');
+                        const codexSurface = analyzeCodexSurface(plugin.manifest);
+                        const sharedNativePayloadDigest = codexSurface.nativeKinds.length > 0
+                            ? await calculateCodexSharedNativePayloadDigest(plugin.rootDir)
+                            : entry.contentDigest;
                         plugin.sourceId = item.resolution.sourceId;
                         plugin.sourceIdentity = item.resolution.sourceIdentity;
                         plugin.pluginId = formatPluginId({ sourceId: item.resolution.sourceId, pluginName: entry.name });
@@ -423,7 +771,7 @@ export async function statusCommandV5(options) {
                                     continue;
                                 const supported = platform === 'claude'
                                     ? claude
-                                    : codex && (scope === 'user' || hasCodexProjectManagedArtifacts(plugin));
+                                    : codex && codexSurface.ok;
                                 if (!supported)
                                     continue;
                                 const changedOwner = ownerInventory.references.find((reference) => (reference.kind === 'namespacedOwner' || reference.kind === 'namespacedMarketplace')
@@ -438,10 +786,10 @@ export async function statusCommandV5(options) {
                                     states[platform][scope] = {
                                         state: 'error',
                                         components: [],
-                                        errors: [{
+                                        errors: [finalizeTargetError({
                                                 code: 'sourceChanged',
                                                 message: `sourceChanged: owner at ${changedOwner.location} has a different source identity.`,
-                                            }],
+                                            }, 'error')],
                                     };
                                     continue;
                                 }
@@ -467,13 +815,23 @@ export async function statusCommandV5(options) {
                                             reporter: createNoopReporter(),
                                             debugLogger: createNoopDebugLogger(),
                                         },
+                                        userActivationDesired: codexDesiredUserActivationIds,
+                                        nativeProbe: readOnlyNativeProbe({
+                                            pluginName: entry.name,
+                                            sourceId: item.resolution.sourceId,
+                                            sourceIdentity: item.resolution.sourceIdentity,
+                                            platform,
+                                            scope,
+                                            marketplaceName,
+                                            marketplaceRoot,
+                                        }),
                                     });
                                     const liveState = projectedLiveState({
                                         inspection: inspected.inspection,
                                         required: inspected.target.desiredOwnedComponents ?? inspected.target.ownedComponents,
                                         optional: inspected.target.optionalOwnedComponents ?? [],
                                     });
-                                    const collisionErrors = inspected.inspection.components.flatMap((component) => component.collision ? [{
+                                    const collisionErrors = inspected.inspection.components.flatMap((component) => component.collision ? [finalizeTargetError({
                                             code: 'artifactCollision',
                                             message: collisionMessage(component.collision),
                                             collision: component.collision,
@@ -487,7 +845,7 @@ export async function statusCommandV5(options) {
                                                 collision: component.collision,
                                             }),
                                             rootIssueCode: 'artifactCollision',
-                                        }] : []);
+                                        }, liveState)] : []);
                                     const dependencyErrors = [];
                                     const dependencyReadiness = [];
                                     const directDependencies = plugin.manifest.dependencies ?? [];
@@ -507,13 +865,13 @@ export async function statusCommandV5(options) {
                                                     rootIssueId,
                                                     rootIssueCode: 'dependencyMissing',
                                                 });
-                                                dependencyErrors.push({
+                                                dependencyErrors.push(finalizeTargetError({
                                                     code: 'dependencyMissing',
                                                     message: `dependencyMissing: ${dependencyId} is not available in the current source snapshot.`,
                                                     dependencyPluginId: dependencyId,
                                                     rootIssueId,
                                                     rootIssueCode: 'dependencyMissing',
-                                                });
+                                                }, 'partial'));
                                                 continue;
                                             }
                                             const dependencySupport = checkAwCapabilitySupport(dependencyEntry.requires.aw.capabilities ?? [], IMPLEMENTED_AW_CAPABILITIES);
@@ -525,13 +883,13 @@ export async function statusCommandV5(options) {
                                                     rootIssueId,
                                                     rootIssueCode: 'awCapabilityUnsupported',
                                                 });
-                                                dependencyErrors.push({
+                                                dependencyErrors.push(finalizeTargetError({
                                                     code: 'awCapabilityUnsupported',
                                                     message: `awCapabilityUnsupported: ${dependencyId} requires unsupported AW capabilities: ${dependencySupport.missing.join(', ')}.`,
                                                     dependencyPluginId: dependencyId,
                                                     rootIssueId,
                                                     rootIssueCode: 'awCapabilityUnsupported',
-                                                });
+                                                }, 'partial'));
                                                 continue;
                                             }
                                             const pluginCacheKey = [item.resolution.sourceIdentity, dependencyId].join('\0');
@@ -579,6 +937,16 @@ export async function statusCommandV5(options) {
                                                                 reporter: createNoopReporter(),
                                                                 debugLogger: createNoopDebugLogger(),
                                                             },
+                                                            userActivationDesired: codexDesiredUserActivationIds,
+                                                            nativeProbe: readOnlyNativeProbe({
+                                                                pluginName: dependencyName,
+                                                                sourceId: item.resolution.sourceId,
+                                                                sourceIdentity: item.resolution.sourceIdentity,
+                                                                platform,
+                                                                scope: dependencyScope,
+                                                                marketplaceName: dependencyMarketplaceName,
+                                                                marketplaceRoot,
+                                                            }),
                                                         });
                                                         const dependencyLiveState = projectedLiveState({
                                                             inspection: dependencyInspected.inspection,
@@ -651,16 +1019,16 @@ export async function statusCommandV5(options) {
                                                 ...dependencyResult,
                                             });
                                             if (dependencyResult.state === 'absent') {
-                                                dependencyErrors.push({
+                                                dependencyErrors.push(finalizeTargetError({
                                                     code: 'dependencyMissing',
                                                     message: `dependencyMissing: ${dependencyId} is absent from its required live placement.`,
                                                     dependencyPluginId: dependencyId,
                                                     rootIssueId: dependencyResult.rootIssueId,
                                                     rootIssueCode: dependencyResult.rootIssueCode,
-                                                });
+                                                }, 'partial'));
                                             }
                                             else if (dependencyResult.state !== 'ready') {
-                                                dependencyErrors.push({
+                                                dependencyErrors.push(finalizeTargetError({
                                                     code: 'dependencyNotReady',
                                                     message: `dependencyNotReady: ${dependencyId} is not ready at its required live placement.`,
                                                     dependencyPluginId: dependencyId,
@@ -670,38 +1038,36 @@ export async function statusCommandV5(options) {
                                                     ...(dependencyResult.rootIssueCode
                                                         ? { rootIssueCode: dependencyResult.rootIssueCode }
                                                         : {}),
-                                                });
+                                                }, 'partial'));
                                             }
                                         }
                                     }
                                     states[platform][scope] = {
-                                        state: dependencyErrors.length > 0 && liveState === 'present' ? 'partial' : liveState,
-                                        errors: [...inspected.inspection.errors.map((error) => ({
+                                        state: liveState,
+                                        errors: [...inspected.inspection.errors.map((error) => finalizeTargetError({
                                                 code: 'componentInspectionFailed',
                                                 message: `${error.label}: ${error.message}`,
-                                            })), ...collisionErrors, ...dependencyErrors],
+                                            }, liveState)), ...collisionErrors, ...dependencyErrors],
                                         ...(dependencyReadiness.length > 0 ? { dependencyReadiness } : {}),
-                                        components: options.verbose === true
-                                            ? inspected.inspection.components.map((component) => {
-                                                const projectedError = component.collision
+                                        components: inspected.inspection.components.map((component) => {
+                                            const projectedError = component.collision
+                                                ? projectTargetError({
+                                                    code: 'artifactCollision',
+                                                    message: collisionMessage(component.collision),
+                                                    collision: component.collision,
+                                                }, env, options.cwd, liveState)
+                                                : component.diagnostic
                                                     ? projectTargetError({
-                                                        code: 'artifactCollision',
-                                                        message: collisionMessage(component.collision),
-                                                        collision: component.collision,
-                                                    }, env, options.cwd)
-                                                    : component.diagnostic
-                                                        ? projectTargetError({
-                                                            code: 'componentInspectionFailed',
-                                                            message: component.diagnostic,
-                                                        }, env, options.cwd)
-                                                        : undefined;
-                                                return {
-                                                    key: component.component.identity.artifactKey,
-                                                    state: component.state,
-                                                    ...(projectedError ? { error: projectedError } : {}),
-                                                };
-                                            })
-                                            : [],
+                                                        code: 'componentInspectionFailed',
+                                                        message: component.diagnostic,
+                                                    }, env, options.cwd, liveState)
+                                                    : undefined;
+                                            return {
+                                                key: component.component.identity.artifactKey,
+                                                state: component.state,
+                                                ...(projectedError ? { error: projectedError } : {}),
+                                            };
+                                        }),
                                         ...(inspected.installedVersion
                                             ? { installedVersion: inspected.installedVersion }
                                             : {}),
@@ -709,18 +1075,96 @@ export async function statusCommandV5(options) {
                                 }
                                 catch (error) {
                                     const message = error instanceof Error ? error.message : String(error);
-                                    const code = message.split(':', 1)[0] || 'targetInspectionFailed';
+                                    const configErrorCode = platform === 'codex' && codexConfigErrors.length > 0
+                                        ? codexSurface.nativeKinds.length > 0
+                                            ? 'codexSharedNativeCorrupt'
+                                            : 'codexActivationDrift'
+                                        : undefined;
+                                    const code = configErrorCode
+                                        ?? message.split(':', 1)[0]
+                                        ?? 'targetInspectionFailed';
                                     states[platform][scope] = {
                                         state: 'error',
                                         components: [],
-                                        errors: [{ code, message }],
+                                        errors: [finalizeTargetError({
+                                                code,
+                                                message: configErrorCode
+                                                    ? `${configErrorCode}: Codex activation state is unreadable.`
+                                                    : message,
+                                            }, 'error')],
                                     };
                                 }
                             }
                         }
+                        let codexStatus;
+                        if (codex && codexSurface.ok) {
+                            const marketplaceName = marketplaceNameFor(entry.name, 'codex', 'user');
+                            const codexPluginId = `${entry.name}@${marketplaceName}`;
+                            let residueFailed = false;
+                            const managedByCurrentIntent = userIntent.managed.codexPluginIds.includes(codexPluginId)
+                                || projectIntent.managed.codexPluginIds.includes(codexPluginId);
+                            const sharedInspection = codexSurface.nativeKinds.length > 0
+                                ? await inspectCodexSharedNativeLive({
+                                    pluginName: entry.name,
+                                    desiredVersion: entry.version,
+                                    expectedPayloadDigest: sharedNativePayloadDigest,
+                                    cwd: options.cwd,
+                                    env,
+                                    managedByCurrentIntent,
+                                    marketplaceName,
+                                    marketplaceRoot,
+                                }).catch(() => {
+                                    residueFailed = true;
+                                    return undefined;
+                                })
+                                : undefined;
+                            const nativeState = sharedInspection?.sharedNative;
+                            const sharedNative = residueFailed
+                                ? { pluginId: codexPluginId, state: 'corrupt', shared: true }
+                                : !nativeState
+                                    ? undefined
+                                    : nativeState.state === 'foreign'
+                                        ? { pluginId: codexPluginId, state: 'foreign', shared: true }
+                                        : nativeState.state === 'absent'
+                                            ? { pluginId: codexPluginId, state: 'missing', shared: true }
+                                            : nativeState.state === 'corrupt'
+                                                ? { pluginId: codexPluginId, state: 'corrupt', shared: true }
+                                                : nativeState.state === 'outdated'
+                                                    ? {
+                                                        pluginId: codexPluginId,
+                                                        state: 'outdated',
+                                                        version: nativeState.version,
+                                                        shared: true,
+                                                    }
+                                                    : nativeState.state === 'present' || nativeState.state === 'claimable'
+                                                        ? {
+                                                            pluginId: codexPluginId,
+                                                            state: 'present',
+                                                            version: nativeState.version,
+                                                            shared: true,
+                                                        }
+                                                        : undefined;
+                            const userActivation = userCodexConfig?.snapshot.plugins[codexPluginId]?.enabled;
+                            const projectActivation = projectCodexConfig?.snapshot.plugins[codexPluginId]?.enabled;
+                            codexStatus = {
+                                pluginId: codexPluginId,
+                                nativeKinds: codexSurface.nativeKinds,
+                                extensionKinds: codexSurface.extensionKinds,
+                                ...(sharedNative ? { sharedNative } : {}),
+                                activation: {
+                                    ...(userActivation !== undefined ? { user: userActivation } : {}),
+                                    ...(projectActivation !== undefined ? { project: projectActivation } : {}),
+                                    ...((userActivation !== undefined || projectActivation !== undefined)
+                                        ? { effective: projectActivation === true || userActivation === true }
+                                        : {}),
+                                    evidence: 'assumed',
+                                },
+                            };
+                        }
                         return {
                             name: entry.name,
                             version: entry.version,
+                            sharedNativePayloadDigest,
                             displayName: plugin.manifest.interface?.displayName ?? entry.name,
                             shortDescription: plugin.manifest.interface?.shortDescription
                                 ?? plugin.manifest.description,
@@ -743,11 +1187,14 @@ export async function statusCommandV5(options) {
                                 claude: { user: claude, project: claude },
                                 codex: {
                                     user: codex,
-                                    project: codex && hasCodexProjectManagedArtifacts(plugin),
+                                    project: codex
+                                        && codexSurface.ok
+                                        && codexSurface.classification !== 'empty',
                                 },
                             },
                             states,
                             dependencies: plugin.manifest.dependencies ?? [],
+                            ...(codexStatus ? { codex: codexStatus } : {}),
                         };
                     }));
                     return {
@@ -755,7 +1202,7 @@ export async function statusCommandV5(options) {
                         resolvedCommit: item.resolution.resolvedCommit,
                         catalogVersion: item.resolution.manifest.catalogVersion,
                         channel: item.resolution.manifest.channel,
-                        freshness: item.resolution.source,
+                        freshness: 'active',
                         plugins,
                     };
                 }
@@ -773,6 +1220,12 @@ export async function statusCommandV5(options) {
     const available = catalog.sources.flatMap((source) => 'plugins' in source
         ? source.plugins.map((plugin) => ({ ...plugin, source }))
         : []);
+    const desiredTargetStates = calculateDesiredTargetStates({
+        userIntent,
+        projectIntent,
+        available,
+        codexProjectAllowed: !codexScopePathsAlias,
+    });
     const failedSourceIds = new Set(catalog.sources.filter((source) => 'error' in source).map((source) => source.id));
     const selectedById = new Map();
     if (requested.length === 0) {
@@ -852,10 +1305,10 @@ export async function statusCommandV5(options) {
             return [{
                     ...target,
                     state: 'error',
-                    errors: [{
+                    errors: [finalizeTargetError({
                             code: 'codexScopePathAlias',
                             message: 'codexScopePathAlias: Codex project config resolves to the user config directory. Run this command from an actual project directory.',
-                        }],
+                        }, 'error')],
                 }];
         }
         if (entry.targets[platform][scope]) {
@@ -867,10 +1320,10 @@ export async function statusCommandV5(options) {
                     ...target,
                     state: live?.state ?? 'error',
                     components: live?.components ?? [],
-                    errors: live?.errors ?? [{
+                    errors: live?.errors ?? [finalizeTargetError({
                             code: 'targetInspectionFailed',
                             message: `No live inspection result exists for ${entry.source.id}/${entry.name}.`,
-                        }],
+                        }, 'error')],
                     ...(live?.dependencyReadiness
                         ? { dependencyReadiness: live.dependencyReadiness }
                         : {}),
@@ -894,12 +1347,12 @@ export async function statusCommandV5(options) {
             return [{
                     ...target,
                     state: 'error',
-                    errors: [{
+                    errors: [finalizeTargetError({
                             code: sourceChanged ? 'sourceChanged' : 'noLongerSupported',
                             message: sourceChanged
                                 ? `sourceChanged: live state for ${target.pluginId} has a different source identity.`
                                 : `noLongerSupported: ${target.pluginId} has live state for ${platform}/${scope}, but the current bundle no longer supports that target.`,
-                        }],
+                        }, 'error')],
                 }];
         }
         if (!explicitTargetFilter)
@@ -907,10 +1360,14 @@ export async function statusCommandV5(options) {
         return [{
                 ...target,
                 state: 'error',
-                errors: [{
-                        code: 'unsupportedTarget',
-                        message: `${entry.source.id}/${entry.name} does not support ${platform}/${scope}.`,
-                    }],
+                errors: [finalizeTargetError({
+                        code: platform === 'codex' && scope === 'project'
+                            ? 'codexProjectPluginUnsupported'
+                            : 'unsupportedTarget',
+                        message: platform === 'codex' && scope === 'project'
+                            ? `codexProjectPluginUnsupported: ${entry.source.id}/${entry.name} cannot use the current Codex project plugin contract.`
+                            : `${entry.source.id}/${entry.name} does not support ${platform}/${scope}.`,
+                    }, 'error')],
             }];
     })));
     const referenceSelectors = [...plannedSelectors, ...liveOnlySelectors];
@@ -949,10 +1406,10 @@ export async function statusCommandV5(options) {
                 cwd: path.resolve(options.cwd),
                 state: 'error',
                 components: [],
-                errors: [{
+                errors: [finalizeTargetError({
                         code: 'sourceMissing',
                         message: `sourceMissing: catalog source "${reference.sourceId}" is not configured for ${pluginId}.`,
-                    }],
+                    }, 'error')],
             };
             return [[`${pluginId}\0${reference.platform}\0${reference.scope}`, target]];
         })).values()];
@@ -978,10 +1435,10 @@ export async function statusCommandV5(options) {
                 cwd: path.resolve(options.cwd),
                 state: 'error',
                 components: [],
-                errors: [{
+                errors: [finalizeTargetError({
                         code: 'catalogSourceUnavailable',
                         message: `catalogSourceUnavailable: catalog source "${reference.sourceId}" is unavailable for ${pluginId}.`,
-                    }],
+                    }, 'error')],
             };
             return [[`${pluginId}\0${reference.platform}\0${reference.scope}`, target]];
         })).values()];
@@ -1017,14 +1474,142 @@ export async function statusCommandV5(options) {
                 cwd: path.resolve(options.cwd),
                 state: 'error',
                 components: [],
-                errors: [{
+                errors: [finalizeTargetError({
                         code: 'bundleUnavailable',
                         message: `bundleUnavailable: ${pluginId} has live state but is not present in the current source snapshot.`,
-                    }],
+                    }, 'error')],
             };
             return [[`${pluginId}\0${reference.platform}\0${reference.scope}`, target]];
         })).values()];
     targets.push(...unavailableBundleTargets);
+    const targetKeys = new Set(targets.map((target) => `${target.pluginId}\0${target.platform}\0${target.scope}`));
+    for (const [scope, intent] of [
+        ['user', userIntent],
+        ['project', projectIntent],
+    ]) {
+        for (const root of intent.roots) {
+            const parsed = parsePluginId(root.pluginId);
+            if (!parsed.sourceId)
+                continue;
+            if (requested.length > 0 && !parsedSelectors.some((selector) => selector.parsed.pluginName === parsed.pluginName
+                && (selector.parsed.sourceId === undefined || selector.parsed.sourceId === parsed.sourceId))) {
+                continue;
+            }
+            for (const platform of root.platforms.filter((candidate) => platforms.includes(candidate))) {
+                if (!scopes.includes(scope))
+                    continue;
+                const key = `${root.pluginId}\0${platform}\0${scope}`;
+                if (targetKeys.has(key))
+                    continue;
+                targets.push({
+                    pluginName: parsed.pluginName,
+                    sourceId: parsed.sourceId,
+                    sourceIdentity: identities.get(parsed.sourceId)?.identity ?? 'unavailable',
+                    pluginId: root.pluginId,
+                    platform,
+                    scope,
+                    cwd: path.resolve(options.cwd),
+                    state: 'error',
+                    components: [],
+                    errors: [finalizeTargetError({
+                            code: 'codexIntentSourceUnavailable',
+                            message: `codexIntentSourceUnavailable: desired intent for ${root.pluginId} cannot be resolved from the current Catalog.`,
+                        }, 'partial')],
+                });
+                targetKeys.add(key);
+            }
+        }
+    }
+    if (platforms.includes('codex')) {
+        for (const [scope, intent] of [
+            ['user', userIntent],
+            ['project', projectIntent],
+        ]) {
+            if (!scopes.includes(scope))
+                continue;
+            for (const codexPluginId of intent.managed.codexPluginIds) {
+                const separator = codexPluginId.lastIndexOf('@');
+                if (separator <= 0 || separator === codexPluginId.length - 1)
+                    continue;
+                const pluginName = codexPluginId.slice(0, separator);
+                const marketplaceName = codexPluginId.slice(separator + 1);
+                const registration = ownerInventory.references.find((reference) => reference.kind === 'namespacedMarketplace'
+                    && reference.marketplaceName === marketplaceName
+                    && reference.sourceId);
+                const inferredSourceId = registration?.sourceId
+                    ?? (marketplaceName.startsWith('aw-') ? marketplaceName.slice(3) : undefined)
+                    ?? (snapshot.config.sources.length === 1
+                        ? snapshot.config.sources[0].id
+                        : undefined);
+                const sourceId = inferredSourceId || 'unavailable';
+                const pluginId = formatPluginId({ sourceId, pluginName });
+                if (requested.length > 0 && !parsedSelectors.some((selector) => selector.parsed.pluginName === pluginName
+                    && (selector.parsed.sourceId === undefined || selector.parsed.sourceId === sourceId))) {
+                    continue;
+                }
+                const key = `${pluginId}\0codex\0${scope}`;
+                if (targetKeys.has(key))
+                    continue;
+                const marketplaceRoot = path.join(resolveAwHome(env), 'marketplaces', sourceId);
+                const residue = await inspectCodexNativeResidue({
+                    pluginName,
+                    cwd: options.cwd,
+                    env,
+                    marketplaceName,
+                    marketplaceRoot,
+                }).catch(() => undefined);
+                const versions = [...new Set(residue?.versions ?? [])];
+                const sharedNative = residue?.state === 'foreign'
+                    ? { pluginId: codexPluginId, state: 'foreign', shared: true }
+                    : residue?.state === 'present' && versions.length === 0
+                        ? { pluginId: codexPluginId, state: 'corrupt', shared: true }
+                        : residue?.state === 'present'
+                            ? {
+                                pluginId: codexPluginId,
+                                state: 'present',
+                                version: versions[0],
+                                shared: true,
+                            }
+                            : { pluginId: codexPluginId, state: 'missing', shared: true };
+                const sourceErrorCode = configured.has(sourceId)
+                    ? 'catalogSourceUnavailable'
+                    : 'sourceMissing';
+                const userActivation = userCodexConfig?.snapshot.plugins[codexPluginId]?.enabled;
+                const projectActivation = projectCodexConfig?.snapshot.plugins[codexPluginId]?.enabled;
+                targets.push({
+                    pluginName,
+                    sourceId,
+                    sourceIdentity: registration?.sourceIdentity
+                        ?? identities.get(sourceId)?.identity
+                        ?? 'unavailable',
+                    pluginId,
+                    platform: 'codex',
+                    scope,
+                    cwd: path.resolve(options.cwd),
+                    state: residue?.state === 'absent' || residue === undefined ? 'absent' : 'present',
+                    components: [],
+                    errors: [finalizeTargetError({
+                            code: sourceErrorCode,
+                            message: `${sourceErrorCode}: managed Codex inventory for ${codexPluginId} cannot be resolved from the current Catalog.`,
+                        }, 'partial')],
+                    sharedNative,
+                    activation: {
+                        ...(userActivation !== undefined
+                            ? { user: userActivation }
+                            : {}),
+                        ...(projectActivation !== undefined
+                            ? { project: projectActivation }
+                            : {}),
+                        ...((userActivation !== undefined || projectActivation !== undefined)
+                            ? { effective: projectActivation === true || userActivation === true }
+                            : {}),
+                        evidence: 'assumed',
+                    },
+                });
+                targetKeys.add(key);
+            }
+        }
+    }
     const projectedInventoryErrors = [...new Map(selectedInventoryErrors.map((error) => [
             `${error.code}\0${error.message}`,
             { code: error.code, message: error.message },
@@ -1032,19 +1617,238 @@ export async function statusCommandV5(options) {
     const errors = [
         ...projectedInventoryErrors,
         ...selectorErrors,
+        ...intentErrors,
         ...legacyOwners.map((reference) => projectTargetError({
             code: 'legacyStateUnsupported',
             message: `legacyStateUnsupported: legacy live ${reference.kind} at ${reference.location}`,
-        }, env, options.cwd)),
+        }, env, options.cwd, 'error')),
     ];
-    const projectedTargets = targets.map((target) => ({
+    const draftTargets = targets.map((target) => ({
         ...target,
-        errors: target.errors.map((error) => projectTargetError(error, env, options.cwd)),
+        errors: target.errors.map((error) => projectTargetError(error, env, options.cwd, target.state)),
     }));
     const selectedByPluginId = new Map(selected.map((entry) => [
         formatPluginId({ sourceId: entry.source.id, pluginName: entry.name }),
         entry,
     ]));
+    const explicitScope = options.scope === undefined ? undefined : scopes[0];
+    const warning = (code, message) => ({
+        code,
+        message: `${code}: ${message}`,
+        severity: 'warning',
+    });
+    const decorateTarget = async (target, groupedScopes, groupedTargets) => {
+        const entry = selectedByPluginId.get(target.pluginId);
+        const codex = entry?.codex;
+        const managedCodexPluginId = codex?.pluginId ?? target.sharedNative?.pluginId;
+        const managedFallback = target.platform === 'codex'
+            && managedCodexPluginId !== undefined
+            && [...userIntent.managed.codexPluginIds, ...projectIntent.managed.codexPluginIds]
+                .includes(managedCodexPluginId);
+        const desiredAll = desiredTargetStates.get(desiredTargetKey(target.pluginId, target.platform))
+            ?? { scopes: [], relation: managedFallback ? 'managed' : 'none' };
+        const desired = target.platform === 'codex'
+            ? desiredAll
+            : {
+                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')
+            ? 'project'
+            : desired.scopes.includes('user')
+                ? 'user'
+                : explicitScope ?? (groupedScopes.includes('project') ? 'project' : 'user');
+        const inspectSystemConsumer = target.platform === 'codex'
+            && baseActivation !== undefined
+            && ((codex?.nativeKinds.length ?? 0) > 0 || target.sharedNative !== undefined);
+        const systemConsumer = inspectSystemConsumer
+            ? await inspectCodexSystemConsumer(consumerScope)
+            : undefined;
+        const activation = baseActivation && systemConsumer
+            ? {
+                ...baseActivation,
+                evidence: systemConsumer.state === 'missing' ? 'assumed' : 'unobserved',
+                systemConsumer,
+            }
+            : baseActivation;
+        const observationScopes = explicitScope
+            ? [explicitScope]
+            : desired.scopes.length > 0 ? desired.scopes : groupedScopes;
+        const scopedTargets = groupedTargets.filter((candidate) => observationScopes.includes(candidate.scope));
+        const observedTargets = scopedTargets.length > 0 ? scopedTargets : groupedTargets;
+        const ownershipState = observedTargets.some((candidate) => candidate.state === 'error')
+            ? 'error'
+            : observedTargets.some((candidate) => candidate.state === 'partial')
+                ? 'partial'
+                : observedTargets.some((candidate) => candidate.state === 'present')
+                    ? 'present'
+                    : 'absent';
+        const hasSourceError = observedTargets.some((candidate) => candidate.errors.some((error) => error.code === 'sourceMissing'
+            || error.code === 'catalogSourceUnavailable'
+            || error.code === 'bundleUnavailable'
+            || error.code === 'codexIntentSourceUnavailable'));
+        const desiredOverlapConflict = target.platform === 'codex'
+            && (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 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))));
+        const extensionComponents = observedTargets.flatMap((candidate) => candidate.components).filter((component) => component.key !== 'native'
+            && !component.key.startsWith('activation-')
+            && !component.key.startsWith('marketplace-'));
+        const extensions = target.platform !== 'codex'
+            || (codex?.extensionKinds.length ?? 0) === 0
+            ? undefined
+            : {
+                state: desiredOverlapConflict
+                    ? 'conflict'
+                    : extensionComponents.some((component) => component.error?.code === 'artifactCollision')
+                        ? 'conflict'
+                        : observedTargets.some((candidate) => candidate.state === 'partial' || candidate.state === 'error')
+                            ? 'drifted'
+                            : extensionComponents.some((component) => component.state === 'partial' || component.state === 'error')
+                                ? 'drifted'
+                                : desired.scopes.length > 0 && (extensionComponents.length === 0
+                                    || extensionComponents.every((component) => component.state === 'absent'))
+                                    ? 'missing'
+                                    : 'ready',
+                kinds: codex.extensionKinds,
+            };
+        const desiredEnabled = desired.scopes.length > 0;
+        const consumerIssue = activation?.systemConsumer?.state === 'incompatible'
+            || activation?.systemConsumer?.state === 'unresolved'
+            ? activation.systemConsumer
+            : undefined;
+        const consumerBlocking = consumerIssue !== undefined;
+        const managedCodexIds = [
+            ...(desired.scopes.includes('user') ? userIntent.managed.codexPluginIds : []),
+            ...(desired.scopes.includes('project') ? projectIntent.managed.codexPluginIds : []),
+        ];
+        const claimMissing = target.platform === 'codex'
+            && sharedNative?.state === 'present'
+            && desiredEnabled
+            && !managedCodexIds.includes(sharedNative.pluginId);
+        const actual = hasSourceError && desiredEnabled
+            ? 'unresolved'
+            : consumerBlocking && desiredEnabled
+                ? 'unresolved'
+                : desiredOverlapConflict
+                    ? 'conflict'
+                    : !desiredEnabled
+                        ? ownershipState !== 'absent' || desired.relation === 'managed'
+                            ? 'orphaned'
+                            : 'absent'
+                        : sharedNative?.state === 'foreign'
+                            ? 'conflict'
+                            : sharedNative?.state === 'corrupt'
+                                ? 'drifted'
+                                : sharedNative?.state === 'missing' || sharedNative?.state === 'outdated' || claimMissing
+                                    ? 'needsSync'
+                                    : activationDrift || extensions?.state === 'drifted'
+                                        ? 'drifted'
+                                        : extensions?.state === 'missing' || ownershipState === 'absent'
+                                            ? 'needsSync'
+                                            : ownershipState === 'partial' || ownershipState === 'error'
+                                                ? 'drifted'
+                                                : 'ready';
+        const baseTargetErrors = observedTargets.flatMap((candidate) => candidate.errors);
+        const stableErrors = [
+            ...(sharedNative?.state === 'foreign'
+                && !baseTargetErrors.some((error) => error.code === 'codexSharedNativeForeign')
+                ? [warning('codexSharedNativeForeign', `${sharedNative.pluginId} is foreign and was preserved.`)]
+                : []),
+            ...(sharedNative?.state === 'corrupt'
+                && !baseTargetErrors.some((error) => error.code === 'codexSharedNativeCorrupt')
+                ? [warning('codexSharedNativeCorrupt', `${sharedNative.pluginId} is corrupt.`)]
+                : []),
+            ...(sharedNative?.state === 'outdated'
+                ? [warning('codexSharedNativeUpdateRequired', `${sharedNative.pluginId} requires a shared update.`)]
+                : []),
+            ...(desiredOverlapConflict
+                ? [warning('codexExtensionScopeConflict', `${target.pluginId} has AW extensions desired at user and project scope.`)]
+                : []),
+            ...(activationDrift && sharedNative?.state !== 'missing'
+                ? [warning('codexActivationDrift', `${target.pluginId} activation differs from desired intent.`)]
+                : []),
+            ...(extensions?.state === 'drifted'
+                ? [warning('codexExtensionDrift', `${target.pluginId} extension projection has drifted.`)]
+                : []),
+            ...(target.platform === 'codex' && hasSourceError && desiredEnabled
+                ? [warning('codexIntentSourceUnavailable', `${target.pluginId} desired intent cannot be resolved from the current Catalog.`)]
+                : []),
+            ...(target.platform === 'codex' && consumerBlocking && desiredEnabled
+                ? [warning(consumerIssue.code, consumerIssue.diagnostic)]
+                : []),
+        ];
+        const targetErrors = [...baseTargetErrors, ...stableErrors];
+        const dedupedErrors = [...new Map(targetErrors.map((error) => [
+                `${error.code}\0${error.message}`,
+                error,
+            ])).values()];
+        const components = [...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));
+        return {
+            ...target,
+            scope: representativeScope,
+            state: ownershipState,
+            components,
+            errors: dedupedErrors,
+            desired: {
+                enabled: desiredEnabled,
+                scopes: desired.scopes,
+                relation: desired.relation,
+            },
+            actual: { state: actual },
+            recovery: statusRecovery({
+                actual,
+                desired,
+                platform: target.platform,
+                pluginId: target.pluginId,
+                ...(sharedNative ? { sharedNative } : {}),
+                conflictRoots: rootIntentsForTarget({
+                    pluginId: target.pluginId,
+                    platform: target.platform,
+                    userIntent,
+                    projectIntent,
+                    available,
+                }),
+                errorCodes: dedupedErrors.map((error) => error.code),
+            }),
+            ...(sharedNative ? { sharedNative } : {}),
+            ...(activation ? { activation } : {}),
+            ...(extensions ? { extensions } : {}),
+        };
+    };
+    const codexGroups = new Map();
+    const projectedTargets = [];
+    for (const target of draftTargets) {
+        if (target.platform !== 'codex') {
+            projectedTargets.push(await decorateTarget(target, [target.scope], [target]));
+            continue;
+        }
+        const group = codexGroups.get(target.pluginId) ?? [];
+        group.push(target);
+        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));
+    }
+    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) => {
         const entry = selectedByPluginId.get(target.pluginId);
         return {
@@ -1055,7 +1859,7 @@ export async function statusCommandV5(options) {
         };
     });
     const payload = {
-        schemaVersion: 5,
+        schemaVersion: 6,
         catalog: {
             primarySourceId: catalog.primarySourceId,
             configDigest: catalog.configDigest,
@@ -1081,11 +1885,10 @@ export async function statusCommandV5(options) {
     };
     const hasErrors = payload.catalog.sources.some((source) => source.error !== undefined)
         || payload.errors.length > 0
-        || payload.targets.some((target) => target.state === 'error'
-            && target.errors.some((error) => error.code !== 'awCapabilityUnsupported'));
+        || payload.targets.some((target) => target.errors.some((error) => error.severity === 'blocking'));
     return {
         payload,
-        output: options.json ? JSON.stringify(payload) : renderStatusV5(payload, options.verbose === true),
+        output: options.json ? JSON.stringify(payload) : renderStatusV6(payload, options.verbose === true),
         hasErrors,
         targetRevisions,
         pluginSummaries: available.map((entry) => {
@@ -1132,4 +1935,4 @@ export async function statusCommandV5(options) {
         }),
     };
 }
-//# sourceMappingURL=status-v5.js.map
+//# sourceMappingURL=status-v6.js.map