@lesliechan721/aw 0.1.0-beta.10

package/dist/src/tui/model.js

@@ -0,0 +1,1493 @@
+import { matchPluginConfigPreset, stablePluginConfigStringify, } from '@lesliechan721/aw-plugin-core/manifest';
+import { statusTargetActivation, statusTargetExtensions, statusTargetIntent, statusTargetOwnershipState, statusTargetSharedNative, } from '../commands/status-v6.js';
+import { buildAllowedLifecycleActions } from '../commands/operation-planner.js';
+import { safeDiagnosticCode, } from './diagnostics.js';
+import { projectCatalogSourceState } from './catalog-sources/projection.js';
+export function configObjectHasSensitiveChild(field) {
+    if (field.type !== 'object')
+        return false;
+    return Object.values(field.properties ?? {}).some((property) => property.sensitive === true)
+        || (field.additionalProperties !== false && field.additionalProperties?.sensitive === true);
+}
+function compareText(left, right) {
+    return left.localeCompare(right, 'en');
+}
+function targetHealth(target) {
+    if (target.state === 'ready')
+        return 'ready';
+    if (target.state === 'needsSync' || target.state === 'orphaned')
+        return 'incomplete';
+    return target.state === 'blocked' ? 'error' : 'incomplete';
+}
+export function isPureNativeCodexTarget(target) {
+    const sharedNative = statusTargetSharedNative(target);
+    const extensions = statusTargetExtensions(target);
+    return target.platform === 'codex'
+        && sharedNative !== undefined
+        && (extensions?.kinds.length ?? 0) === 0;
+}
+function isPureNativeCodexPlacement(placement) {
+    return placement.platform === 'codex'
+        && placement.state === 'installed'
+        && placement.sharedNative !== undefined
+        && (placement.extensions?.kinds.length ?? 0) === 0;
+}
+function parsedScopedUninstallRecovery(recovery, expectedPlatform) {
+    if (recovery.command !== 'uninstall' || !recovery.scope)
+        return undefined;
+    const match = /(?:^|\s)aw uninstall ([^\s]+) --platform (codex|claude) --scope (user|project)(?:，|,|\s|$)/u
+        .exec(recovery.description);
+    if (!match || match[2] !== expectedPlatform || match[3] !== recovery.scope)
+        return undefined;
+    return { pluginId: match[1], scope: recovery.scope, description: recovery.description };
+}
+function scopeConflictRecoveryMenuActions(placement) {
+    if (placement.actualState !== 'blocked')
+        return [];
+    return (placement.recovery ?? []).flatMap((recovery) => {
+        const parsed = parsedScopedUninstallRecovery(recovery, placement.platform);
+        return parsed ? [{
+                id: 'resolveScopeConflict',
+                pluginId: parsed.pluginId,
+                platform: placement.platform,
+                scope: parsed.scope,
+                keepScope: parsed.scope === 'user' ? 'project' : 'user',
+                description: parsed.description,
+            }] : [];
+    });
+}
+function missingPureNativeScopes(plugin, placement) {
+    if (!isPureNativeCodexPlacement(placement) || placement.actualState !== 'ready')
+        return [];
+    const supported = plugin.supportedScopes?.codex ?? ['user', 'project'];
+    return supported.filter((scope) => !placement.desiredScopes?.includes(scope) && placement.activation?.[scope] !== true);
+}
+function isInstalledScopeEvidence(target) {
+    return statusTargetIntent(target).enabled
+        || statusTargetOwnershipState(target) === 'present'
+        || statusTargetOwnershipState(target) === 'partial';
+}
+function dependencyAssignmentExplanation(assignmentSource, requiredBy) {
+    const consumer = requiredBy[0];
+    return {
+        root: '根插件位置',
+        default: '推荐使用当前项目',
+        existingWiderTarget: '复用健康的所有项目安装',
+        userOverride: '你选择的位置',
+        consumerPromotion: consumer
+            ? `因 ${consumer} 的位置而一并调整`
+            : '因上游依赖位置而一并调整',
+        platformRequirement: '平台只支持这个位置',
+    }[assignmentSource];
+}
+export function dependencyPlacementTargets(plan) {
+    return plan.targets.filter((target) => target.relation === 'dependency').map((target) => ({
+        key: `${target.pluginId}\0${target.platform}`,
+        pluginId: target.pluginId,
+        displayName: target.pluginName,
+        platform: target.platform,
+        relation: target.depth === 1 ? 'direct' : 'transitive',
+        scope: target.resolvedScope,
+        minimumScope: target.minimumScope,
+        allowedScopes: [...target.allowedScopes],
+        locked: target.locked && target.lockReason !== 'dependencyScopeOverride',
+        requiredBy: [...target.requiredBy],
+        assignmentSource: target.assignmentSource,
+        explanation: dependencyAssignmentExplanation(target.assignmentSource, target.requiredBy),
+        affectsOtherProjects: target.affectsOtherProjects,
+        action: target.action,
+    }));
+}
+function dependencyPluginIdFromMessage(message) {
+    return message.match(/(?:[a-z0-9]+(?:-[a-z0-9]+)*)\/(?:[a-z0-9]+(?:-[a-z0-9]+)*)/u)?.[0];
+}
+function rootPlacementFromIssueId(issueId, fallback) {
+    if (issueId) {
+        for (const platform of ['claude', 'codex']) {
+            for (const scope of ['project', 'user']) {
+                if (issueId.includes(`:${platform}:${scope}:`)
+                    || issueId.endsWith(`:${platform}:${scope}`))
+                    return { platform, scope };
+            }
+        }
+    }
+    return fallback;
+}
+function rootPluginIdFromIssueId(issueId, rootIssueCode) {
+    if (!issueId || !rootIssueCode || !issueId.startsWith(`${rootIssueCode}:`))
+        return undefined;
+    for (const platform of ['claude', 'codex']) {
+        for (const scope of ['project', 'user']) {
+            const marker = `:${platform}:${scope}`;
+            const markerIndex = issueId.indexOf(marker, rootIssueCode.length + 1);
+            if (markerIndex > rootIssueCode.length + 1) {
+                return issueId.slice(rootIssueCode.length + 1, markerIndex);
+            }
+        }
+    }
+    return undefined;
+}
+function targetIssueRelationship(options) {
+    const consumer = options.error?.rootIssueId !== undefined
+        && options.error.rootIssueCode !== undefined
+        && (options.error.code !== options.error.rootIssueCode
+            || options.dependencyPluginId !== undefined
+                && options.dependencyPluginId !== options.target.pluginId);
+    if (!consumer) {
+        return {
+            relationship: 'direct',
+            rootEntity: {
+                pluginId: options.target.pluginId,
+                platform: options.target.platform,
+                scope: options.target.scope,
+            },
+        };
+    }
+    const placement = rootPlacementFromIssueId(options.error?.rootIssueId, options.target);
+    return {
+        relationship: 'consumer',
+        rootEntity: {
+            pluginId: rootPluginIdFromIssueId(options.error?.rootIssueId, options.error?.rootIssueCode) ?? options.dependencyPluginId ?? options.target.pluginId,
+            ...placement,
+        },
+    };
+}
+export function projectPlatformPlacement(platform, targets, revisions = []) {
+    const revisionFor = (target) => revisions.find((entry) => entry.pluginId === target.pluginId
+        && entry.platform === target.platform
+        && entry.scope === target.scope)?.revision
+        ?? { state: 'unknown', ...(target.version ? { availableVersion: target.version } : {}) };
+    const supportedScopes = [...new Set(targets.map((target) => target.scope))];
+    const installed = targets.filter(isInstalledScopeEvidence);
+    if (installed.length === 0) {
+        if (targets.some((target) => target.reasons.some((reason) => reason.code === 'artifactCollision' && reason.severity === 'blocking'))) {
+            return { platform, state: 'blocked', supportedScopes, reason: 'artifactCollision' };
+        }
+        const errorTarget = targets.find((target) => target.state === 'blocked');
+        if (!errorTarget)
+            return { platform, state: 'notInstalled', supportedScopes };
+        return {
+            platform,
+            state: 'installed',
+            scope: errorTarget.scope,
+            health: 'error',
+            revision: revisionFor(errorTarget),
+        };
+    }
+    const target = installed.find((candidate) => candidate.state === 'blocked')
+        ?? installed.find((candidate) => candidate.state === 'needsSync')
+        ?? installed.find((candidate) => candidate.state === 'orphaned')
+        ?? installed[0];
+    const intent = statusTargetIntent(target);
+    const activation = statusTargetActivation(target);
+    const sharedNative = statusTargetSharedNative(target);
+    const extensions = statusTargetExtensions(target);
+    const blockingReason = target.reasons.some((reason) => reason.code === 'artifactCollision' && reason.severity === 'blocking')
+        ? 'artifactCollision'
+        : undefined;
+    return {
+        platform,
+        state: 'installed',
+        scope: target.scope,
+        health: targetHealth(target),
+        revision: revisionFor(target),
+        desiredScopes: [...intent.scopes],
+        relation: intent.relation,
+        actualState: target.state,
+        ...(activation ? { activation } : {}),
+        ...(sharedNative ? { sharedNative } : {}),
+        ...(extensions ? { extensions } : {}),
+        recovery: [...target.recoveryActions],
+        ...(blockingReason ? { blockingReason } : {}),
+    };
+}
+function hasIncompletePlacement(plugin) {
+    return plugin.installedPlacements.some((placement) => placement.state === 'scopeConflict'
+        || placement.state === 'installed'
+            && (placement.health !== 'ready' || placement.blockingReason !== undefined));
+}
+function hasMissingPlatform(plugin) {
+    return plugin.supportedPlatforms.some((platform) => plugin.installedPlacements.find((placement) => placement.platform === platform)?.state === 'notInstalled');
+}
+function allSupportedPlatformsBlocked(plugin) {
+    return plugin.supportedPlatforms.length > 0 && plugin.supportedPlatforms.every((platform) => plugin.installedPlacements.some((placement) => placement.platform === platform
+        && (placement.state === 'blocked'
+            || placement.state === 'installed' && placement.blockingReason === 'artifactCollision')));
+}
+function capabilityActions(plugin) {
+    return [
+        ...(plugin.portableSkills ? [{ id: 'portableSkills' }] : []),
+        ...((plugin.dependencySummary?.totalCount ?? 0) > 0 ? [{ id: 'dependencies' }] : []),
+        ...(plugin.configFieldCount > 0 ? [{ id: 'settings' }] : []),
+    ];
+}
+function capabilityUnavailableActions() {
+    return [{ id: 'upgradeAwCli' }, { id: 'capabilityTechnical' }];
+}
+function isCapabilityUnavailable(plugin) {
+    return plugin.capabilityUnsupported === true && plugin.sourceUnavailable !== true;
+}
+export function buildPluginPreviewActions(plugin) {
+    const installed = hasInstalledPlacement(plugin);
+    if (plugin.aggregateStatus === 'unavailable') {
+        if (isCapabilityUnavailable(plugin)) {
+            return [...capabilityUnavailableActions(), ...(installed ? [{ id: 'manage' }] : [])];
+        }
+        return [{ id: 'sourceProblem' }, ...(installed ? [{ id: 'manage' }] : [])];
+    }
+    if (allSupportedPlatformsBlocked(plugin)) {
+        return [
+            { id: 'outputCollision' },
+            ...(hasInstalledPlacement(plugin) ? [{ id: 'manage' }] : []),
+            { id: 'source' },
+            { id: 'about' },
+        ];
+    }
+    const collisionWithInstallablePlatform = hasMissingPlatform(plugin)
+        && plugin.installedPlacements.some((placement) => placement.state === 'blocked'
+            || placement.state === 'installed' && placement.blockingReason === 'artifactCollision');
+    const primary = collisionWithInstallablePlatform
+        ? { id: 'add' }
+        : hasIncompletePlacement(plugin) || (plugin.dependencySummary?.issueCount ?? 0) > 0
+            ? { id: 'repair' }
+            : installed && !hasMissingPlatform(plugin) ? { id: 'manage' } : { id: 'add' };
+    return [primary, ...capabilityActions(plugin), { id: 'source' }];
+}
+export function buildPluginDetailActions(plugin) {
+    if (plugin.aggregateStatus === 'unavailable') {
+        if (isCapabilityUnavailable(plugin)) {
+            return [
+                ...plugin.installedPlacements.flatMap((placement) => placement.state === 'notInstalled'
+                    ? []
+                    : [{ id: 'platform', platform: placement.platform }]),
+                ...capabilityUnavailableActions(),
+                { id: 'about' },
+            ];
+        }
+        return [
+            ...plugin.installedPlacements.flatMap((placement) => placement.state === 'notInstalled'
+                ? []
+                : [{ id: 'platform', platform: placement.platform }]),
+            { id: 'sourceProblem' },
+            { id: 'about' },
+        ];
+    }
+    return [
+        ...plugin.installedPlacements.flatMap((placement) => [
+            ...(placement.state === 'installed' ? scopeConflictRecoveryMenuActions(placement) : []),
+            placement.state === 'scopeConflict'
+                ? { id: 'scopeConflict', platform: placement.platform }
+                : { id: 'platform', platform: placement.platform },
+        ]),
+        ...((plugin.dependencySummary?.totalCount ?? 0) > 0 ? [{ id: 'dependencies' }] : []),
+        ...(plugin.portableSkills ? [{ id: 'portableSkills' }] : []),
+        ...(plugin.configFieldCount > 0 ? [{ id: 'settings' }] : []),
+        { id: 'about' },
+    ];
+}
+export function buildPlatformActions(plugin, platform) {
+    if (plugin.aggregateStatus === 'unavailable') {
+        if (isCapabilityUnavailable(plugin))
+            return capabilityUnavailableActions();
+        return [{ id: 'sourceProblem' }, { id: 'refreshSource' }];
+    }
+    const placement = plugin.installedPlacements.find((entry) => entry.platform === platform);
+    if (placement?.state === 'blocked') {
+        return [{ id: 'outputCollision' }, { id: 'source' }, { id: 'about' }];
+    }
+    if (!placement || placement.state === 'notInstalled')
+        return [{ id: 'add' }, { id: 'about' }];
+    if (placement.state === 'scopeConflict')
+        return [{ id: 'scopeConflict', platform }];
+    const scopedRecovery = scopeConflictRecoveryMenuActions(placement);
+    if (scopedRecovery.length > 0)
+        return [...scopedRecovery, { id: 'technical' }];
+    if (placement.blockingReason === 'artifactCollision') {
+        return [
+            { id: 'outputCollision' },
+            { id: 'remove', platform, scope: placement.scope },
+            { id: 'technical' },
+        ];
+    }
+    const lifecycleActions = buildAllowedLifecycleActions({
+        pluginId: plugin.pluginId,
+        platform,
+        scope: placement.scope,
+        state: placement.actualState ?? (placement.health === 'ready'
+            ? 'ready' : placement.health === 'incomplete' ? 'needsSync' : 'blocked'),
+        recoveryActions: placement.recovery ?? [],
+        revision: placement.revision,
+    }).flatMap((action) => {
+        if (action.id === 'install')
+            return [{ id: 'add' }];
+        if (action.id === 'refreshAndSync')
+            return [{
+                    id: 'refreshAndSync',
+                    platform: action.platform,
+                    scope: action.scope,
+                    availableVersion: action.availableVersion,
+                }];
+        if (action.id === 'sync')
+            return [{ id: 'sync' }];
+        if (action.id === 'reinstall')
+            return [{ id: 'reinstall', platform: action.platform, scope: action.scope }];
+        if (action.id === 'uninstall')
+            return [{ id: 'remove', platform: action.platform, scope: action.scope }];
+        return [{ id: 'cleanup', platform: action.platform, scope: action.scope }];
+    });
+    if (placement.health !== 'ready') {
+        return [...lifecycleActions, { id: 'technical' }, ...(lifecycleActions.length === 0 ? [{ id: 'back' }] : [])];
+    }
+    return [
+        ...missingPureNativeScopes(plugin, placement).map((scope) => ({
+            id: 'addScope', platform, scope,
+        })),
+        ...lifecycleActions,
+        { id: 'technical' },
+    ];
+}
+export function hasInstalledPlacement(plugin) {
+    return plugin.installedPlacements.some((placement) => placement.state === 'installed' || placement.state === 'scopeConflict');
+}
+function sourceIssue(health, impactedTargets = 0) {
+    if (health.state !== 'unavailable')
+        return undefined;
+    const issueId = health.issueId ?? `source:${health.sourceId}:unavailable`;
+    return {
+        issueId,
+        category: 'sourceUnavailable',
+        title: `${health.sourceId} · 来源不可用`,
+        explanation: '来源检查失败。',
+        impact: ['当前不能浏览或安装这个来源的插件。',
+            ...(impactedTargets > 0 ? [`${impactedTargets} 个安装位置受此来源根问题影响。`] : [])],
+        entity: { kind: 'source', id: health.sourceId },
+        sourceId: health.sourceId,
+        actions: [
+            { id: 'editSource', label: '编辑来源', description: '检查 URL、路径或 ref' },
+            { id: 'refreshSource', label: '稍后重试', description: '只重新检查来源' },
+            { id: 'viewTechnical', label: '技术详情' },
+        ],
+        technicalDetails: [{
+                code: 'catalogSourceUnavailable',
+                message: '来源检查失败。',
+            }],
+    };
+}
+function lifecycleIssueActions(target, options = {}) {
+    return buildAllowedLifecycleActions(target).flatMap((action) => {
+        if (options.dependency) {
+            if (action.id === 'install')
+                return [{
+                        id: 'installDependency',
+                        label: '补齐依赖插件',
+                        pluginId: action.pluginId,
+                        platform: action.platform,
+                        scope: action.scope,
+                        project: options.project,
+                        writeAction: 'install',
+                    }];
+            if (action.id === 'sync' || action.id === 'reinstall')
+                return [{
+                        id: 'reinstallDependency',
+                        label: action.label,
+                        description: action.description,
+                        pluginId: action.pluginId,
+                        platform: action.platform,
+                        scope: action.scope,
+                        project: options.project,
+                        writeAction: action.id,
+                    }];
+            return [];
+        }
+        const projection = {
+            install: { id: 'install', writeAction: 'install' },
+            sync: { id: 'sync', writeAction: 'sync' },
+            refreshAndSync: { id: 'refreshAndSync', writeAction: 'refreshAndSync' },
+            reinstall: { id: 'reinstall', writeAction: 'reinstall' },
+            uninstall: { id: 'remove', writeAction: 'uninstall' },
+            cleanup: { id: 'cleanup', writeAction: 'cleanup' },
+        }[action.id];
+        return [{
+                ...projection,
+                label: action.label,
+                description: action.description,
+                pluginId: action.pluginId,
+                platform: action.platform,
+                scope: action.scope,
+            }];
+    });
+}
+function targetIssues(payload) {
+    const issues = [];
+    const canonicalRootsByEntity = new Map();
+    for (const target of payload.targets) {
+        for (const error of target.reasons) {
+            if (!error.rootIssueId || !error.rootIssueCode)
+                continue;
+            const dependencyPluginId = error.dependencyPluginId
+                ?? dependencyPluginIdFromMessage(error.message);
+            const relationship = targetIssueRelationship({ target, error, dependencyPluginId });
+            if (relationship.relationship !== 'consumer')
+                continue;
+            const key = [
+                error.rootIssueCode,
+                relationship.rootEntity.pluginId,
+                relationship.rootEntity.platform,
+                relationship.rootEntity.scope,
+            ].join('\0');
+            const current = canonicalRootsByEntity.get(key);
+            if (!current || compareText(error.rootIssueId, current) < 0) {
+                canonicalRootsByEntity.set(key, error.rootIssueId);
+            }
+        }
+    }
+    for (const target of payload.targets) {
+        const intent = statusTargetIntent(target);
+        const scopedConflictRecovery = target.reasons.some((reason) => reason.code === 'codexExtensionScopeConflict')
+            ? target.recoveryActions.flatMap((recovery) => {
+                const parsed = parsedScopedUninstallRecovery(recovery, target.platform);
+                return parsed ? [{ ...parsed, keepScope: parsed.scope === 'user'
+                            ? 'project' : 'user' }] : [];
+            })
+            : [];
+        if (scopedConflictRecovery.length > 0) {
+            issues.push({
+                issueId: `scope:${target.pluginId}:${target.platform}`,
+                category: 'scopeConflict',
+                title: `${target.pluginId} · ${target.platform === 'codex' ? 'Codex' : 'Claude Code'} · 扩展位置冲突`,
+                explanation: 'AW-only 扩展不能同时使用所有项目和当前项目位置。',
+                impact: ['选择一条 root uninstall 路径，然后按该路径同步保留的 scope。'],
+                entity: { kind: 'plugin', id: target.pluginId },
+                pluginId: target.pluginId,
+                platform: target.platform,
+                scope: target.scope,
+                sourceId: target.sourceId,
+                sourceIdentity: target.sourceIdentity,
+                placements: [...intent.scopes].sort(compareText),
+                actions: [
+                    ...scopedConflictRecovery.map((recovery) => ({
+                        id: recovery.keepScope === 'user' ? 'keepUserScope' : 'keepProjectScope',
+                        label: `保留${recovery.keepScope === 'user' ? '所有项目' : '当前项目'}`,
+                        description: recovery.description,
+                        pluginId: recovery.pluginId,
+                        platform: target.platform,
+                        scope: recovery.scope,
+                        writeAction: 'uninstall',
+                    })),
+                    { id: 'viewTechnical', label: '查看冲突详情' },
+                ],
+                technicalDetails: [{
+                        code: 'codexExtensionScopeConflict',
+                        message: 'mixed 或 AW-only 扩展同时使用两个 scope。',
+                    }],
+            });
+        }
+        if (target.state !== 'needsSync' && target.state !== 'blocked'
+            && !target.reasons.some((error) => error.code === 'artifactCollision'
+                || error.dependencyPluginId !== undefined && error.rootIssueId !== undefined))
+            continue;
+        const codes = new Set(target.reasons.map((error) => error.code));
+        const sharedNativeRenderDrift = target.state === 'needsSync'
+            && codes.has('codexSharedNativeRenderDrift');
+        const dependencyCodes = [
+            'dependencyMissing',
+            'dependencyNotReady',
+            'dependencyTargetUnsupported',
+            'dependencyStillRequired',
+            'dependencyGraphInvalid',
+        ];
+        const dependencyRootMap = new Map();
+        for (const error of target.reasons) {
+            if (!dependencyCodes.includes(error.code))
+                continue;
+            if (error.rootIssueCode === 'artifactCollision') {
+                dependencyRootMap.set(error.rootIssueId ?? `artifactCollision\0${error.dependencyPluginId ?? ''}`, {
+                    code: 'artifactCollision',
+                    category: 'artifactCollision',
+                    mergeEligible: false,
+                    error,
+                    dependencyPluginId: error.dependencyPluginId,
+                });
+                continue;
+            }
+            const code = error.code;
+            const dependencyPluginId = error.dependencyPluginId ?? dependencyPluginIdFromMessage(error.message);
+            dependencyRootMap.set(`${code}\0${dependencyPluginId ?? ''}`, {
+                code,
+                category: code,
+                mergeEligible: false,
+                error,
+                dependencyPluginId,
+            });
+        }
+        const dependencyRoots = [...dependencyRootMap.values()];
+        const directCollision = target.reasons.find((error) => error.code === 'artifactCollision');
+        const projectedCollisionRoots = dependencyRoots.filter((root) => root.code === 'artifactCollision');
+        const ordinaryDependencyRoots = dependencyRoots.filter((root) => root.code !== 'artifactCollision');
+        const roots = codes.has('sourceMissing')
+            ? [{ code: 'sourceMissing', category: 'sourceMissing', mergeEligible: false }]
+            : directCollision || projectedCollisionRoots.length > 0
+                ? [{
+                        code: 'artifactCollision',
+                        category: 'artifactCollision',
+                        mergeEligible: false,
+                        error: directCollision ?? projectedCollisionRoots[0].error,
+                        dependencyPluginId: projectedCollisionRoots[0]?.dependencyPluginId,
+                    }]
+                : codes.has('sourceChanged')
+                    ? [{ code: 'sourceChanged', category: 'sourceIdentityChanged', mergeEligible: false }]
+                    : codes.has('catalogSourceUnavailable') || codes.has('bundleUnavailable')
+                        ? [
+                            ...(codes.has('catalogSourceUnavailable')
+                                ? [{ code: 'catalogSourceUnavailable', category: 'sourceUnavailable', mergeEligible: true }]
+                                : []),
+                            ...(codes.has('bundleUnavailable')
+                                ? [{ code: 'bundleUnavailable', category: 'sourceUnavailable', mergeEligible: false }]
+                                : []),
+                        ]
+                        : ordinaryDependencyRoots.length > 0
+                            ? ordinaryDependencyRoots
+                            : target.state === 'needsSync'
+                                ? [{ code: 'partial', category: 'incompleteInstallation', mergeEligible: false }]
+                                : [
+                                    { code: 'targetDiagnostic', category: 'diagnostic', mergeEligible: false },
+                                ];
+        for (const root of roots) {
+            const rootError = root.error ?? target.reasons.find((error) => error.code === root.code);
+            const dependencyPluginId = root.dependencyPluginId
+                ?? rootError?.dependencyPluginId
+                ?? (rootError ? dependencyPluginIdFromMessage(rootError.message) : undefined);
+            const dependencyPlatform = rootError?.dependencyPlatform;
+            const dependencyScope = rootError?.dependencyScope;
+            const dependencyProject = rootError?.dependencyProject;
+            const dependencyCategory = root.category.startsWith('dependency');
+            const dependencyTarget = dependencyPluginId && dependencyPlatform && dependencyScope
+                ? payload.targets.find((candidate) => candidate.pluginId === dependencyPluginId
+                    && candidate.platform === dependencyPlatform && candidate.scope === dependencyScope)
+                : undefined;
+            const dependencyLifecycleActions = dependencyPluginId && dependencyPlatform && dependencyScope
+                ? lifecycleIssueActions(dependencyTarget ?? {
+                    pluginId: dependencyPluginId,
+                    platform: dependencyPlatform,
+                    scope: dependencyScope,
+                    state: 'absent',
+                    recoveryActions: [],
+                }, { dependency: true, project: dependencyProject })
+                : [];
+            const directLifecycleActions = dependencyCategory ? [] : lifecycleIssueActions(target);
+            const actions = root.category === 'dependencyMissing'
+                ? [
+                    ...dependencyLifecycleActions,
+                    { id: 'viewDependencies', label: '查看依赖关系' },
+                    { id: 'viewTechnical', label: '技术详情' },
+                ]
+                : root.category === 'dependencyNotReady'
+                    ? [
+                        ...(dependencyPluginId ? [
+                            { id: 'viewDependencyIssue', label: '查看依赖插件问题', pluginId: dependencyPluginId },
+                        ] : []),
+                        ...dependencyLifecycleActions.filter((action) => action.id === 'reinstallDependency'),
+                        { id: 'viewDependencies', label: '查看依赖关系' },
+                        { id: 'viewTechnical', label: '技术详情' },
+                    ]
+                    : dependencyCategory
+                        ? [
+                            { id: 'viewDependencies', label: '查看依赖关系' },
+                            { id: 'viewTechnical', label: '技术详情' },
+                        ]
+                        : root.category === 'artifactCollision'
+                            ? [
+                                { id: 'viewTechnical', label: '查看冲突原因' },
+                                { id: 'retryLater', label: '处理冲突后重试' },
+                            ]
+                            : root.category === 'incompleteInstallation'
+                                ? [
+                                    ...directLifecycleActions,
+                                    { id: 'viewTechnical', label: '技术详情' },
+                                ]
+                                : root.category === 'sourceMissing'
+                                    ? [
+                                        ...directLifecycleActions,
+                                        { id: 'reAddSource', label: '重新添加同一来源', description: '保留来源 ID；来源类型和位置由你选择' },
+                                        { id: 'viewTechnical', label: '技术详情' },
+                                    ]
+                                    : root.category === 'sourceIdentityChanged'
+                                        ? [
+                                            { id: 'viewSourceChange', label: '查看来源变更', description: '不会自动覆盖现场状态' },
+                                            { id: 'viewTechnical', label: '技术详情' },
+                                        ]
+                                        : root.category === 'sourceUnavailable'
+                                            ? [
+                                                ...(root.code === 'bundleUnavailable' ? directLifecycleActions : []),
+                                                { id: 'editSource', label: '查看来源', description: root.code === 'bundleUnavailable' ? '检查当前 Catalog 或稍后重试' : '修复来源配置或稍后重试' },
+                                                { id: 'viewTechnical', label: '技术详情' },
+                                            ]
+                                            : [...directLifecycleActions,
+                                                { id: 'viewTechnical', label: '技术详情' },
+                                                { id: 'retryLater', label: '稍后重试' }];
+            const bundleUnavailable = root.code === 'bundleUnavailable';
+            const relationship = targetIssueRelationship({
+                target,
+                error: rootError,
+                dependencyPluginId,
+            });
+            const directRootCode = root.code === 'partial' ? 'incompleteInstallation'
+                : root.code === 'targetDiagnostic' ? 'diagnostic'
+                    : undefined;
+            const canonicalRoot = relationship.relationship === 'direct' && directRootCode
+                ? canonicalRootsByEntity.get([
+                    directRootCode,
+                    relationship.rootEntity.pluginId,
+                    relationship.rootEntity.platform,
+                    relationship.rootEntity.scope,
+                ].join('\0'))
+                : undefined;
+            const issueId = rootError?.rootIssueId
+                ?? canonicalRoot
+                ?? (directRootCode
+                    ? `${directRootCode}:${target.pluginId}:${target.platform}:${target.scope}`
+                    : `target:${target.pluginId}:${target.platform}:${target.scope}:${target.state}${roots.length > 1 ? `:${root.code}` : ''}${dependencyPluginId ? `:${dependencyPluginId}` : ''}`);
+            issues.push({
+                issueId,
+                category: root.category,
+                rootCode: root.code,
+                mergeEligible: root.mergeEligible,
+                relationship: relationship.relationship,
+                rootEntity: relationship.rootEntity,
+                affectedTargets: [{
+                        pluginId: target.pluginId,
+                        platform: target.platform,
+                        scope: target.scope,
+                        relationship: relationship.relationship,
+                    }],
+                title: `${target.pluginId} · ${target.platform === 'codex' ? 'Codex' : 'Claude Code'} · ${sharedNativeRenderDrift ? '共享 native 待同步' : root.category === 'artifactCollision' ? '输出冲突' : dependencyCategory ? {
+                    dependencyMissing: '缺少依赖',
+                    dependencyNotReady: '依赖安装不完整',
+                    dependencyTargetUnsupported: '依赖目标不兼容',
+                    dependencyStillRequired: '依赖仍被使用',
+                    dependencyGraphInvalid: '依赖关系无效',
+                }[root.category] : target.state === 'needsSync' ? '安装不完整' : bundleUnavailable ? '当前 Catalog 不再包含此插件' : '检查失败'}`,
+                explanation: root.category === 'artifactCollision'
+                    ? '目标位置已有不属于当前插件的内容。AW 不会覆盖或删除这些内容。'
+                    : dependencyCategory
+                        ? dependencyPluginId
+                            ? `${dependencyPluginId} 导致当前依赖检查不能通过。`
+                            : '当前依赖检查不能安全通过。'
+                        : sharedNativeRenderDrift
+                            ? '个人默认已变化。共享 Codex native Skill 尚未重新生成。'
+                            : target.state === 'needsSync'
+                                ? '必要内容缺失，插件可能不能稳定运行。'
+                                : bundleUnavailable
+                                    ? '当前 Catalog 不再包含此插件，但仍发现 AW 管理的已安装内容。'
+                                    : '当前目标不能安全分类为正常安装。',
+                impact: [sharedNativeRenderDrift
+                        ? '运行同步可恢复；这不是 cache 损坏。'
+                        : root.category === 'artifactCollision'
+                            ? '请先移除或迁移冲突内容，然后重试安装或重新安装。'
+                            : bundleUnavailable
+                                ? '可以清理可信的 AW 现场；这不表示来源整体可用。'
+                                : '写操作前需要重新检查这个目标。'],
+                entity: { kind: 'plugin', id: target.pluginId },
+                pluginId: target.pluginId,
+                ...(dependencyPluginId ? { dependencyPluginId } : {}),
+                ...(dependencyPlatform ? { dependencyPlatform } : {}),
+                ...(dependencyScope ? { dependencyScope } : {}),
+                ...(dependencyProject !== undefined ? { dependencyProject } : {}),
+                platform: target.platform,
+                scope: target.scope,
+                sourceId: target.sourceId,
+                sourceIdentity: target.sourceIdentity,
+                actions,
+                technicalDetails: target.reasons.length > 0
+                    ? target.reasons.filter((error) => root.code === 'targetDiagnostic'
+                        || root.code === 'partial'
+                        || error.code === root.code
+                        || error.rootIssueId === issueId)
+                        .map((error) => ({
+                        code: error.code,
+                        message: error.collision
+                            ? ({
+                                ownerMismatch: '目标由其他 owner 占用。',
+                                unownedContent: '目标包含没有 AW owner 标记的内容。',
+                                typeMismatch: '目标节点类型不符合预期。',
+                            })[error.collision.reason]
+                            : '状态检查报告了这个安全错误代码。',
+                    }))
+                    : [{ code: 'targetStateError', message: '目标状态异常。' }],
+            });
+        }
+    }
+    return issues;
+}
+function statusIssues(payload) {
+    const targetCodes = new Set(payload.targets.flatMap((target) => target.reasons.map((error) => error.code)));
+    const issues = new Map();
+    for (const error of payload.errors) {
+        if (targetCodes.has(error.code) || issues.has(error.code))
+            continue;
+        const projection = error.code === 'legacyStateUnsupported'
+            ? {
+                title: '发现旧版状态',
+                explanation: '当前状态使用不受支持的旧格式。',
+                impact: '在迁移或清理旧状态前，部分操作不可用。',
+            }
+            : error.code === 'nativeStateUnreadable'
+                ? {
+                    title: '平台状态不可读',
+                    explanation: '当前不能安全读取平台状态。',
+                    impact: '部分安装状态可能不可用。',
+                }
+                : {
+                    title: '状态清单不可用',
+                    explanation: '当前不能完成状态清单检查。',
+                    impact: '部分安装状态可能不可用。',
+                };
+        issues.set(error.code, {
+            issueId: `status:${error.code}`,
+            category: error.code === 'legacyStateUnsupported' ? 'legacyState' : 'diagnostic',
+            title: projection.title,
+            explanation: projection.explanation,
+            impact: [projection.impact],
+            entity: { kind: 'source', id: payload.catalog.primarySourceId },
+            sourceId: payload.catalog.primarySourceId,
+            actions: error.code === 'legacyStateUnsupported'
+                ? [
+                    { id: 'manualMigration', label: '查看手动处理说明', description: '当前没有安全的自动迁移' },
+                    { id: 'retryLater', label: '稍后重新检查' },
+                ]
+                : [{ id: 'retryLater', label: '稍后重试' }, { id: 'viewTechnical', label: '技术详情' }],
+            technicalDetails: [{ code: error.code, message: projection.explanation }],
+        });
+    }
+    return [...issues.values()];
+}
+function configIssues(pluginSummaries) {
+    return pluginSummaries.flatMap((summary) => {
+        const sourceId = summary.pluginId.slice(0, summary.pluginId.indexOf('/'));
+        const issues = [];
+        if (summary.configDiagnostic) {
+            issues.push({
+                issueId: `config:${summary.pluginId}:read`,
+                category: 'diagnostic',
+                title: `${summary.displayName ?? summary.pluginName} · 设置状态不可读`,
+                explanation: '当前不能安全读取这个插件的设置状态。',
+                impact: ['其他插件仍可检查；当前插件的设置值不会显示。'],
+                entity: { kind: 'plugin', id: summary.pluginId },
+                pluginId: summary.pluginId,
+                sourceId,
+                actions: [
+                    { id: 'retryLater', label: '稍后重新检查' },
+                    { id: 'viewTechnical', label: '查看技术详情' },
+                ],
+                technicalDetails: [{
+                        code: summary.configDiagnostic.code,
+                        message: '设置读取报告了这个安全错误代码。',
+                    }],
+            });
+        }
+        if (!summary.configIssues?.length)
+            return issues;
+        const types = new Set(summary.configIssues.map((issue) => issue.type));
+        const invalid = types.has('invalid-config') || types.has('sharedCompositeContainsLocalPath');
+        const sources = new Set(summary.configIssues.map((issue) => issue.source));
+        const onlySource = sources.size === 1 ? [...sources][0] : undefined;
+        const configLayer = onlySource === 'user'
+            ? { scope: 'user' }
+            : onlySource === 'project'
+                ? { scope: 'project' }
+                : undefined;
+        issues.push({
+            issueId: `config:${summary.pluginId}:${invalid ? 'invalid' : 'required'}`,
+            category: 'requiredConfigMissing',
+            title: `${summary.displayName ?? summary.pluginName} · ${invalid ? '设置值无效' : '缺少必填设置'}`,
+            explanation: invalid
+                ? '已有设置值不符合当前字段规则。'
+                : '插件缺少必填设置，写操作会在预检时被阻止。',
+            impact: [invalid ? '修正所列字段后才能稳定生成插件内容。' : '完成所列字段后才能稳定生成插件内容。'],
+            entity: { kind: 'plugin', id: summary.pluginId },
+            pluginId: summary.pluginId,
+            sourceId,
+            requiredFields: summary.configIssues.map(({ key, title, type, source, scope }) => ({
+                key, title, type, source, scope,
+            })),
+            ...(configLayer ? { configLayer } : {}),
+            actions: [
+                { id: 'openConfig', label: invalid ? '修正设置' : '完成设置', description: configLayer ? '进入建议的设置层' : '选择个人或项目设置层' },
+                { id: 'viewTechnical', label: '查看字段详情' },
+            ],
+            technicalDetails: summary.configIssues.map((entry) => ({
+                code: entry.type,
+                message: `${entry.title} · ${entry.scope} · ${entry.source}`,
+            })),
+        });
+        return issues;
+    });
+}
+function dependencyOverviewIssues(overviews, pluginSummaries, status) {
+    const summaryById = new Map(pluginSummaries.map((summary) => [summary.pluginId, summary]));
+    return overviews.flatMap((overview) => overview.blockers.flatMap((blocker) => {
+        if (blocker.code !== 'dependencyGraphInvalid'
+            && blocker.code !== 'dependencyTargetUnsupported')
+            return [];
+        if (status.targets.some((target) => target.pluginId === overview.pluginId
+            && target.reasons.some((error) => error.code === blocker.code)))
+            return [];
+        const summary = summaryById.get(overview.pluginId);
+        const sourceId = overview.pluginId.slice(0, overview.pluginId.indexOf('/'));
+        const category = blocker.code;
+        return [{
+                issueId: `dependency:${overview.pluginId}:${blocker.code}`,
+                category,
+                rootCode: category,
+                mergeEligible: false,
+                title: `${summary?.displayName ?? summary?.pluginName ?? overview.pluginId} · ${blocker.title}`,
+                explanation: blocker.explanation,
+                impact: [category === 'dependencyGraphInvalid'
+                        ? '修复依赖关系后才能安全计算安装顺序。'
+                        : '当前不能在所有声明的平台上安全安装这个插件。'],
+                entity: { kind: 'plugin', id: overview.pluginId },
+                pluginId: overview.pluginId,
+                sourceId,
+                actions: [
+                    { id: 'viewDependencies', label: '查看依赖关系' },
+                    { id: 'viewTechnical', label: '技术详情' },
+                ],
+                technicalDetails: [{ code: blocker.code, message: blocker.explanation }],
+            }];
+    }));
+}
+function issueDiagnostic(issue, sourceDetails) {
+    const source = issue.sourceId ? sourceDetails.get(issue.sourceId) : undefined;
+    const sourceUnavailable = issue.category === 'sourceUnavailable' && issue.entity.kind === 'source';
+    const configUnavailable = issue.category === 'diagnostic' && issue.issueId.startsWith('config:');
+    const configInvalid = issue.category === 'requiredConfigMissing';
+    const dependency = issue.category.startsWith('dependency');
+    const platformState = issue.issueId.startsWith('status:') || issue.rootCode === 'targetDiagnostic';
+    const preserved = sourceUnavailable
+        ? '已安装插件和已保存设置不会被删除。'
+        : configUnavailable
+            ? '已保存的设置保持不变。'
+            : '现有安装和已保存设置不会因本页自动改变。';
+    const impact = sourceUnavailable
+        ? [
+            { state: 'blocked', message: '当前不能浏览或安装这个来源中的插件。' },
+            { state: 'preserved', message: preserved },
+        ]
+        : [
+            ...issue.impact.map((message) => ({
+                state: dependency || configUnavailable || configInvalid || platformState ? 'blocked' : 'degraded',
+                message,
+            })),
+            { state: 'preserved', message: preserved },
+        ];
+    const primaryAction = issue.actions.find((action) => action.id !== 'viewTechnical');
+    const nextStep = primaryAction
+        ? `${primaryAction.label}，然后重新检查当前状态。`
+        : '打开技术详情，记录安全错误代码后重新检查。';
+    const sourceDiagnostic = sourceUnavailable;
+    const rawCode = sourceDiagnostic
+        ? source?.errorCode ?? issue.technicalDetails[0]?.code
+        : issue.technicalDetails[0]?.code;
+    const code = safeDiagnosticCode(rawCode, sourceUnavailable
+        ? 'catalogSourceUnavailable' : 'diagnosticUnavailable');
+    const stage = sourceUnavailable ? 'resolve-source'
+        : configUnavailable ? 'read-config'
+            : configInvalid ? 'validate-config'
+                : dependency ? 'resolve-dependencies'
+                    : platformState ? 'read-platform-state' : 'inspect-target';
+    const context = [
+        ...(issue.pluginId ? [{ key: 'pluginId', value: issue.pluginId }] : []),
+        ...(issue.dependencyPluginId
+            ? [{ key: 'dependencyPluginId', value: issue.dependencyPluginId }]
+            : []),
+        ...(issue.platform ? [{ key: 'platform', value: issue.platform }] : []),
+        ...(issue.scope ? [{ key: 'scope', value: issue.scope }] : []),
+        ...(issue.requiredFields?.slice(0, 1).map((field) => ({
+            key: 'field',
+            value: field.title,
+        })) ?? []),
+    ];
+    const checks = issue.category === 'legacyState'
+        ? [
+            '不自动迁移旧版状态。',
+            '运行 aw status --json，记录公开错误 code。',
+            '备份相关 AW 配置。',
+            '按技术详情使用受支持命令或人工处理。',
+            '再次运行状态检查。',
+        ]
+        : sourceUnavailable
+            ? ['检查 Git URL、ref 或本地目录。', '确认当前终端具备来源授权。', '运行“重新检查来源”验证修复。']
+            : dependency
+                ? ['检查依赖关系和依赖插件状态。', '完成恢复动作后重新检查根插件。']
+                : configUnavailable
+                    ? ['恢复插件来源和可信字段定义。', '重新检查来源后再次打开设置。']
+                    : configInvalid
+                        ? ['完成或修正列出的设置字段。', '重新检查插件设置。']
+                        : ['检查目标平台配置和访问权限。', '完成恢复动作后重新运行状态检查。'];
+    return {
+        severity: 'error',
+        title: issue.title,
+        userMessage: issue.explanation,
+        impact,
+        nextStep,
+        technical: {
+            code,
+            stage,
+            ...(sourceDiagnostic && issue.sourceId ? { sourceId: issue.sourceId } : {}),
+            ...(sourceDiagnostic && source?.requestedRef ? { requestedRef: source.requestedRef } : {}),
+            ...(sourceDiagnostic && source?.resolvedCommit ? { resolvedCommit: source.resolvedCommit } : {}),
+            ...(context.length > 0 ? { context } : {}),
+            checks,
+        },
+    };
+}
+const issueGroupOrder = {
+    sourceRemoved: 0,
+    artifactCollision: 1,
+    sourceUnavailable: 2,
+    dependency: 3,
+    scope: 4,
+    config: 5,
+    installation: 6,
+    diagnostic: 7,
+};
+function issueGroup(issue) {
+    if (issue.category === 'sourceMissing')
+        return 'sourceRemoved';
+    if (issue.category === 'artifactCollision')
+        return 'artifactCollision';
+    if (issue.category === 'sourceUnavailable'
+        || issue.category === 'sourceIdentityChanged')
+        return 'sourceUnavailable';
+    if (issue.category.startsWith('dependency'))
+        return 'dependency';
+    if (issue.category === 'scopeConflict')
+        return 'scope';
+    if (issue.category === 'requiredConfigMissing')
+        return 'config';
+    if (issue.category === 'incompleteInstallation')
+        return 'installation';
+    return 'diagnostic';
+}
+function primaryAttentionCode(issue) {
+    if (issue.category === 'requiredConfigMissing') {
+        return issue.requiredFields?.some((field) => field.type === 'invalid-config')
+            ? 'invalidConfig'
+            : 'requiredConfigMissing';
+    }
+    if (issue.category === 'incompleteInstallation')
+        return 'incompleteInstallation';
+    if (issue.category === 'sourceIdentityChanged')
+        return 'sourceUnavailable';
+    return issue.rootCode ?? issue.category;
+}
+function issueReasonPriority(issue) {
+    const code = primaryAttentionCode(issue);
+    return {
+        sourceMissing: 0,
+        artifactCollision: 1,
+        sourceUnavailable: 2,
+        catalogSourceUnavailable: 2,
+        bundleUnavailable: 2,
+        dependencyGraphInvalid: 3,
+        dependencyTargetUnsupported: 4,
+        dependencyNotReady: 5,
+        dependencyMissing: 5,
+        scopeConflict: 6,
+        requiredConfigMissing: 7,
+        invalidConfig: 7,
+        incompleteInstallation: 8,
+        diagnostic: 9,
+    }[code] ?? 9;
+}
+function collapseRootIssues(issues) {
+    const byId = new Map();
+    for (const issue of issues)
+        byId.set(issue.issueId, [...(byId.get(issue.issueId) ?? []), issue]);
+    return [...byId.values()].map((group) => {
+        const ordered = [...group].sort((left, right) => Number(right.relationship === 'direct') - Number(left.relationship === 'direct')
+            || compareText(left.pluginId ?? '', right.pluginId ?? '')
+            || compareText(left.platform ?? '', right.platform ?? '')
+            || compareText(left.scope ?? '', right.scope ?? ''));
+        const primary = ordered[0];
+        const direct = ordered.find((issue) => issue.relationship === 'direct');
+        const rootEntity = direct?.rootEntity ?? ordered.map((issue) => issue.rootEntity)
+            .filter((entity) => entity !== undefined)
+            .sort((left, right) => compareText(left.pluginId, right.pluginId)
+            || compareText(left.platform, right.platform)
+            || compareText(left.scope, right.scope))[0];
+        const affectedTargets = [...new Map(ordered.flatMap((issue) => issue.affectedTargets ?? [])
+                .map((target) => [`${target.pluginId}\0${target.platform}\0${target.scope}`, target])).values()]
+            .sort((left, right) => compareText(left.pluginId, right.pluginId)
+            || compareText(left.platform, right.platform)
+            || compareText(left.scope, right.scope));
+        const projected = rootEntity && !direct ? {
+            ...primary,
+            title: `${rootEntity.pluginId} · ${rootEntity.platform === 'codex' ? 'Codex' : 'Claude Code'} · ${primary.category === 'artifactCollision' ? '输出冲突' : primary.title.split(' · ').at(-1) ?? primary.title}`,
+            entity: { kind: 'plugin', id: rootEntity.pluginId },
+            pluginId: rootEntity.pluginId,
+            platform: rootEntity.platform,
+            scope: rootEntity.scope,
+            sourceId: rootEntity.pluginId.split('/', 1)[0],
+        } : primary;
+        return {
+            ...projected,
+            ...(rootEntity ? { rootEntity } : {}),
+            ...(affectedTargets.length > 0 ? { affectedTargets } : {}),
+            impact: [...new Set(ordered.flatMap((issue) => issue.impact))],
+            technicalDetails: [...new Map(ordered.flatMap((issue) => issue.technicalDetails)
+                    .map((detail) => [`${detail.code}\0${detail.message}`, detail])).values()],
+        };
+    });
+}
+export function buildTuiViewModel(options) {
+    const dependencyById = new Map((options.dependencyOverviews ?? [])
+        .map((overview) => [overview.pluginId, overview]));
+    const summaryById = new Map(options.pluginSummaries.map((summary) => [summary.pluginId, summary]));
+    const sourceById = new Map(options.status.catalog.sources.map((source) => [source.id, source]));
+    const targetsByPlugin = new Map();
+    for (const target of options.status.targets) {
+        targetsByPlugin.set(target.pluginId, [...(targetsByPlugin.get(target.pluginId) ?? []), target]);
+    }
+    const pluginIds = new Set([...summaryById.keys(), ...targetsByPlugin.keys()]);
+    const plugins = [...pluginIds].map((pluginId) => {
+        const summary = summaryById.get(pluginId);
+        const targets = targetsByPlugin.get(pluginId) ?? [];
+        const sourceId = targets[0]?.sourceId ?? pluginId.slice(0, pluginId.indexOf('/'));
+        const placements = ['codex', 'claude'].flatMap((platform) => {
+            const platformTargets = targets.filter((target) => target.platform === platform);
+            return platformTargets.length > 0
+                ? [projectPlatformPlacement(platform, platformTargets, options.targetRevisions)]
+                : [];
+        });
+        const attention = placements.some((placement) => placement.state === 'scopeConflict'
+            || (placement.state === 'installed'
+                && (placement.health !== 'ready' || placement.blockingReason !== undefined)));
+        const installed = placements.some((placement) => placement.state === 'installed' || placement.state === 'scopeConflict');
+        const sourceUnavailable = options.sourceHealth?.get(sourceId)?.state === 'unavailable'
+            || sourceById.get(sourceId)?.error !== undefined;
+        const capabilityTargets = targets.filter((target) => target.reasons.some((reason) => reason.code === 'awCapabilityUnsupported'));
+        const capabilityUnsupported = (summary?.missingCapabilities?.length ?? 0) > 0
+            || capabilityTargets.length > 0;
+        const capabilityRecovery = capabilityTargets.flatMap((target) => target.recoveryActions)
+            .find((action) => action.command === 'manual')?.description;
+        const unavailable = sourceUnavailable || capabilityUnsupported;
+        return {
+            pluginId,
+            sourceId,
+            displayName: summary?.displayName ?? summary?.pluginName ?? targets[0]?.pluginName ?? pluginId,
+            description: summary?.description ?? '',
+            ...(summary?.version ?? targets[0]?.version
+                ? { version: summary?.version ?? targets[0]?.version }
+                : {}),
+            configFieldCount: summary?.configFieldCount
+                ?? Object.keys(summary?.configSchema ?? {}).length,
+            sourceLabel: sourceId,
+            supportedPlatforms: summary?.supportedTargets
+                ? ['codex', 'claude'].filter((platform) => summary.supportedTargets[platform].length > 0)
+                : placements.map((placement) => placement.platform),
+            ...(summary?.supportedTargets ? { supportedScopes: {
+                    codex: [...summary.supportedTargets.codex],
+                    claude: [...summary.supportedTargets.claude],
+                } } : {}),
+            installedPlacements: placements,
+            aggregateStatus: unavailable ? 'unavailable' : attention ? 'needsAttention' : installed ? 'installed' : 'available',
+            portableSkills: options.portablePluginIds?.includes(pluginId) ?? false,
+            ...(summary?.missingCapabilities
+                ? { missingCapabilities: summary.missingCapabilities }
+                : {}),
+            ...(capabilityUnsupported ? { capabilityUnsupported: true } : {}),
+            ...(capabilityRecovery ? { capabilityRecovery } : {}),
+            ...(sourceUnavailable ? { sourceUnavailable: true } : {}),
+            ...(dependencyById.get(pluginId)
+                ? { dependencySummary: dependencyById.get(pluginId).summary }
+                : summary && (summary.dependencyTotalCount ?? 0) > 0
+                    ? { dependencySummary: {
+                            directCount: summary.dependencyDirectCount ?? 0,
+                            transitiveCount: Math.max(0, (summary.dependencyTotalCount ?? 0) - (summary.dependencyDirectCount ?? 0)),
+                            totalCount: summary.dependencyTotalCount ?? 0,
+                            readyCount: 0,
+                            missingCount: 0,
+                            issueCount: summary.dependencyIssueCount ?? 0,
+                        } }
+                    : {}),
+            technicalComponents: targets.flatMap((target) => target.components.map((component) => ({
+                platform: target.platform,
+                scope: target.scope,
+                key: component.key,
+                state: component.state,
+                ...(typeof component.metadata?.errorCode === 'string'
+                    ? { errorCode: component.metadata.errorCode }
+                    : {}),
+            }))),
+        };
+    }).sort((left, right) => compareText(left.displayName, right.displayName)
+        || compareText(left.sourceId, right.sourceId));
+    const sourceTabs = options.status.catalog.sources.map((source) => ({
+        id: source.id,
+        label: source.id,
+        count: plugins.filter((plugin) => plugin.sourceId === source.id).length,
+        primary: source.primary,
+        state: projectCatalogSourceState(source, options.sourceHealth?.get(source.id), options.catalogFreshness?.get(source.id), options.catalogGenerations?.get(source.id)),
+    }));
+    const sourceRootIds = new Set([...(options.sourceHealth?.values() ?? [])]
+        .filter((health) => health.state === 'unavailable')
+        .map((health) => health.sourceId));
+    const allTargetIssues = targetIssues(options.status);
+    const targetImpactCounts = new Map();
+    for (const issue of allTargetIssues) {
+        if (!issue.mergeEligible || !issue.sourceId || !sourceRootIds.has(issue.sourceId))
+            continue;
+        targetImpactCounts.set(issue.sourceId, (targetImpactCounts.get(issue.sourceId) ?? 0) + 1);
+    }
+    const sourceDetails = new Map((options.sourceDetails ?? []).map((detail) => [detail.id, detail]));
+    const issueDrafts = [
+        ...allTargetIssues.filter((issue) => !issue.mergeEligible
+            || !issue.sourceId || !sourceRootIds.has(issue.sourceId)),
+        ...statusIssues(options.status),
+        ...configIssues(options.pluginSummaries),
+        ...dependencyOverviewIssues(options.dependencyOverviews ?? [], options.pluginSummaries, options.status),
+        ...[...(options.sourceHealth?.values() ?? [])].flatMap((health) => sourceIssue(health, targetImpactCounts.get(health.sourceId) ?? 0) ?? []),
+    ];
+    const stableIssueDrafts = collapseRootIssues(issueDrafts).sort((left, right) => issueGroupOrder[issueGroup(left)] - issueGroupOrder[issueGroup(right)]
+        || issueReasonPriority(left) - issueReasonPriority(right)
+        || compareText(primaryAttentionCode(left), primaryAttentionCode(right))
+        || compareText(left.issueId, right.issueId));
+    const issues = stableIssueDrafts.map((issue) => ({
+        ...issue,
+        group: issueGroup(issue),
+        diagnostic: issueDiagnostic(issue, sourceDetails),
+    }));
+    const pluginsWithAttention = plugins.map((plugin) => {
+        const primary = stableIssueDrafts.filter((issue) => issue.pluginId === plugin.pluginId
+            || issue.dependencyPluginId === plugin.pluginId
+            || issue.affectedTargets?.some((target) => target.pluginId === plugin.pluginId)
+            || issue.entity.kind === 'source' && issue.sourceId === plugin.sourceId)
+            .sort((left, right) => issueReasonPriority(left) - issueReasonPriority(right)
+            || compareText(primaryAttentionCode(left), primaryAttentionCode(right))
+            || compareText(left.issueId, right.issueId))[0];
+        if (!primary)
+            return plugin;
+        return {
+            ...plugin,
+            primaryAttention: {
+                severity: 'error',
+                code: primaryAttentionCode(primary),
+                message: primary.explanation,
+            },
+        };
+    });
+    return {
+        plugins: pluginsWithAttention,
+        sourceTabs,
+        sourceDetails: (options.sourceDetails ?? []).map((detail) => ({
+            ...detail,
+            pluginCount: pluginsWithAttention.filter((plugin) => plugin.sourceId === detail.id).length,
+        })),
+        issues,
+        dependencyOverviews: options.dependencyOverviews ?? [],
+        home: {
+            availablePlugins: pluginsWithAttention.filter((plugin) => plugin.aggregateStatus === 'available').length,
+            installedPlugins: pluginsWithAttention.filter(hasInstalledPlacement).length,
+            issueCount: issues.length,
+            sourceCount: sourceTabs.length,
+            unavailableSourceCount: options.status.catalog.sources.filter((source) => source.error
+                || options.sourceHealth?.get(source.id)?.state === 'unavailable').length,
+            catalogUpdateCount: sourceTabs.filter((source) => source.state === 'update').length,
+            catalogRecoveryCount: sourceTabs.filter((source) => source.state === 'recovery'
+                || source.state === 'error').length,
+            catalogCheckingCount: sourceTabs.filter((source) => source.state === 'checking').length,
+        },
+    };
+}
+function displayConfigValue(options) {
+    if (!options.configured)
+        return options.inherited ? '继承' : '未设置';
+    if (options.privateValue)
+        return '已设置';
+    if (options.field.type === 'object'
+        && typeof options.value === 'object'
+        && options.value !== null
+        && !Array.isArray(options.value)) {
+        const object = options.value;
+        if (configObjectHasSensitiveChild(options.field)) {
+            const count = Object.keys(object).length;
+            return `已设置 · ${count === 0 ? '空对象' : `${count} 项`}`;
+        }
+        const preset = matchPluginConfigPreset(options.field, object);
+        const keys = Object.keys(object).sort((left, right) => left.localeCompare(right, 'en'));
+        const keySummary = keys.length === 0
+            ? '空对象'
+            : `${keys.length} 项${keys.length > 0 ? `（${keys.slice(0, 2).join('、')}${keys.length > 2 ? '…' : ''}）` : ''}`;
+        return preset ? `方案“${preset.title}” · ${keySummary}` : `自定义 · ${keySummary}`;
+    }
+    if (typeof options.value === 'string')
+        return options.value;
+    if (options.value === undefined || options.value === null)
+        return '已设置';
+    return String(options.value);
+}
+function configSourceLabel(source) {
+    if (!source)
+        return '未设置';
+    return {
+        default: '默认值',
+        user: '个人默认',
+        project: '当前项目',
+    }[source];
+}
+function configEditorDefinition(field) {
+    const definition = structuredClone(field);
+    delete definition.default;
+    return definition;
+}
+function configObjectChildChanges(field, before, after) {
+    const fixed = Object.keys(field.properties ?? {});
+    const summary = (property, value) => {
+        if (value === undefined)
+            return '未设置';
+        const definition = field.properties?.[property]
+            ?? (field.additionalProperties === false ? undefined : field.additionalProperties);
+        if (field.sensitive || definition?.sensitive)
+            return '已设置';
+        if (typeof value === 'boolean')
+            return value ? '开启' : '关闭';
+        return String(value);
+    };
+    return [...new Set([...Object.keys(before), ...Object.keys(after ?? {})])]
+        .sort((left, right) => {
+        const leftIndex = fixed.indexOf(left);
+        const rightIndex = fixed.indexOf(right);
+        if (leftIndex >= 0 || rightIndex >= 0) {
+            if (leftIndex < 0)
+                return 1;
+            if (rightIndex < 0)
+                return -1;
+            return leftIndex - rightIndex;
+        }
+        return left.localeCompare(right, 'en');
+    })
+        .filter((property) => before[property] !== after?.[property])
+        .map((property) => {
+        const definition = field.properties?.[property]
+            ?? (field.additionalProperties === false ? undefined : field.additionalProperties);
+        return {
+            property,
+            before: summary(property, before[property]),
+            after: summary(property, after?.[property]),
+            ...(field.sensitive || definition?.sensitive ? { private: true } : {}),
+        };
+    });
+}
+export function buildConfigGroups(options) {
+    const entryByKey = new Map(options.read.fields.map((field) => [field.key, field]));
+    const effectiveEntryByKey = new Map((options.effectiveRead ?? options.read).fields.map((field) => [field.key, field]));
+    const effectivePage = options.read.scope === 'effective';
+    const layerEntry = (layer, key) => options.layerReads?.[layer]?.fields.find((field) => field.key === key);
+    const fieldModel = (key) => {
+        const schema = options.schema.fields[key];
+        const entry = entryByKey.get(key);
+        const effectiveEntry = effectiveEntryByKey.get(key);
+        const inherited = effectivePage
+            ? false
+            : entry?.storedSourceLayer === undefined;
+        const configured = effectivePage
+            ? entry?.sourceLayer !== undefined
+                && entry.sourceLayer !== null
+                && entry.effectiveValue !== undefined
+                && entry.effectiveValue !== null
+                && (entry.valueState === 'configured' || entry.valueState === 'default')
+            : entry?.storedSourceLayer !== undefined;
+        const privateValue = schema.sensitive === true;
+        const choices = schema.choices;
+        const selectedValue = effectivePage ? entry?.effectiveValue : entry?.storedValue;
+        const selectedRawValue = effectivePage
+            ? options.effectiveRawValues?.[key]
+            : options.rawValues?.[key];
+        const selectedStoredInvalid = !effectivePage
+            && entry?.storedSourceLayer !== undefined
+            && entry.storedValue === undefined;
+        const invalidOverrideSourceCandidate = selectedStoredInvalid
+            ? (effectivePage ? entry?.invalidOverride?.sourceLayer : options.read.scope)
+            : entry?.invalidOverride?.sourceLayer;
+        const invalidOverrideSource = invalidOverrideSourceCandidate === 'user'
+            || invalidOverrideSourceCandidate === 'project'
+            ? invalidOverrideSourceCandidate
+            : undefined;
+        const invalidOverride = invalidOverrideSource !== undefined;
+        const invalidOverrideOwnedByLayer = !effectivePage
+            && invalidOverrideSource === options.read.scope;
+        const effectiveConfigured = effectiveEntry?.sourceLayer !== undefined
+            && effectiveEntry.sourceLayer !== null
+            && effectiveEntry.effectiveValue !== undefined
+            && effectiveEntry.effectiveValue !== null
+            && (effectiveEntry.valueState === 'configured' || effectiveEntry.valueState === 'default');
+        const omittedLayer = options.read.scope === 'user'
+            ? 'user'
+            : 'project';
+        const fallback = options.read.scope === 'user'
+            ? undefined
+            : ['project', 'user']
+                .filter((layer) => layer !== omittedLayer)
+                .map((layer) => ({ layer, entry: layerEntry(layer, key) }))
+                .find((candidate) => candidate.entry?.storedSourceLayer !== undefined);
+        const fallbackValue = fallback?.entry?.storedValue ?? schema.default;
+        const fallbackRawValue = fallback
+            ? options.rawLayerValues?.[fallback.layer]?.[key] ?? fallbackValue
+            : schema.default;
+        const fallbackConfigured = fallback !== undefined || schema.default !== undefined;
+        const fallbackSource = fallback?.layer ?? (schema.default !== undefined ? 'default' : undefined);
+        return {
+            key,
+            title: schema.title ?? key,
+            ...(schema.description ? { description: schema.description } : {}),
+            type: schema.type,
+            definition: configEditorDefinition(schema),
+            displayValue: selectedStoredInvalid ? '值无效' : displayConfigValue({
+                field: schema,
+                privateValue,
+                inherited,
+                configured,
+                value: schema.type === 'object' ? selectedRawValue ?? selectedValue : selectedValue,
+            }),
+            required: schema.required === true,
+            sensitive: schema.sensitive === true,
+            writable: entry?.writable ?? effectivePage,
+            dirty: options.dirtyKeys?.has(key) === true,
+            inherited,
+            configured,
+            sourceLabel: effectivePage
+                ? configSourceLabel(entry?.sourceLayer ?? null)
+                : configured ? '本层已设置' : '继承',
+            effectiveDisplayValue: displayConfigValue({
+                field: schema,
+                privateValue,
+                inherited: false,
+                configured: effectiveConfigured,
+                value: schema.type === 'object'
+                    ? options.effectiveRawValues?.[key] ?? effectiveEntry?.effectiveValue
+                    : effectiveEntry?.effectiveValue,
+            }),
+            effectiveSourceLabel: configSourceLabel(effectiveEntry?.sourceLayer ?? null),
+            ...(invalidOverride ? {
+                invalidOverrideOwnedByLayer,
+                invalidOverrideIssue: invalidOverrideOwnedByLayer
+                    ? schema.type === 'object'
+                        ? `字段“${schema.title ?? key}”在本层的对象值无效。请修改或删除此字段。`
+                        : `字段“${schema.title ?? key}”在本层的值无效。请修改或删除此字段。`
+                    : `字段“${schema.title ?? key}”在${configSourceLabel(invalidOverrideSource ?? null)}中的值无效。请切换到该设置层修改或删除此字段。`,
+            } : {}),
+            ...(!effectivePage && configured ? {
+                fallbackDisplayValue: displayConfigValue({
+                    field: schema,
+                    privateValue,
+                    inherited: false,
+                    configured: fallbackConfigured,
+                    value: schema.type === 'object' ? fallbackRawValue : fallbackValue,
+                }),
+                fallbackSourceLabel: fallbackSource ? configSourceLabel(fallbackSource) : '未设置',
+                ...(schema.type === 'object'
+                    && typeof (selectedRawValue ?? selectedValue) === 'object'
+                    && (selectedRawValue ?? selectedValue) !== null
+                    ? { fallbackObjectChanges: configObjectChildChanges(schema, (selectedRawValue ?? selectedValue), typeof fallbackRawValue === 'object' && fallbackRawValue !== null
+                            ? fallbackRawValue
+                            : undefined) }
+                    : {}),
+            } : {}),
+            ...(!privateValue && selectedValue !== undefined
+                ? { value: selectedValue }
+                : {}),
+            ...(!privateValue && effectiveEntry?.effectiveValue !== undefined && effectiveEntry.effectiveValue !== null
+                ? { effectiveValue: effectiveEntry.effectiveValue }
+                : {}),
+            ...(!privateValue && (effectivePage
+                ? options.effectiveRawValues?.[key]
+                : selectedRawValue ?? (schema.type === 'object' && !configured
+                    ? options.effectiveRawValues?.[key]
+                    : undefined)) !== undefined
+                ? { draftValue: (effectivePage
+                        ? options.effectiveRawValues?.[key]
+                        : selectedRawValue ?? options.effectiveRawValues?.[key]) }
+                : {}),
+            ...(!privateValue && schema.default !== undefined ? { defaultValue: schema.default } : {}),
+            ...(choices ? { choices: choices.presets } : {}),
+            allowCustom: choices?.allowCustom ?? true,
+            ...(!privateValue && !configObjectHasSensitiveChild(schema)
+                && (selectedRawValue ?? selectedValue) !== undefined && (selectedRawValue ?? selectedValue) !== null
+                && matchPluginConfigPreset(schema, (selectedRawValue ?? selectedValue))
+                ? { matchedPresetId: matchPluginConfigPreset(schema, (selectedRawValue ?? selectedValue)).id }
+                : {}),
+            ...(schema.type === 'number' && schema.validation?.minimum !== undefined ? { min: schema.validation.minimum } : {}),
+            ...(schema.type === 'number' && schema.validation?.maximum !== undefined ? { max: schema.validation.maximum } : {}),
+            advanced: false,
+            sharedNativeRender: options.sharedNativeRefreshKeys?.has(key) === true,
+        };
+    };
+    const assigned = new Set();
+    const groups = (options.schema.presentation?.groups ?? []).map((group) => {
+        group.fields.forEach((key) => assigned.add(key));
+        return {
+            id: group.id,
+            title: group.title,
+            ...(group.description ? { description: group.description } : {}),
+            advanced: group.advanced === true,
+            fields: group.fields.map(fieldModel),
+        };
+    });
+    const syntheticGroupId = (preferred) => {
+        const existing = new Set(groups.map((group) => group.id));
+        let id = preferred;
+        let suffix = 2;
+        while (existing.has(id)) {
+            id = `${preferred}-${suffix}`;
+            suffix += 1;
+        }
+        return id;
+    };
+    const remaining = Object.keys(options.schema.fields)
+        .filter((key) => !assigned.has(key));
+    if (!options.schema.presentation) {
+        groups.push({
+            id: 'general',
+            title: '插件设置',
+            advanced: false,
+            fields: Object.keys(options.schema.fields)
+                .map(fieldModel),
+        });
+    }
+    else {
+        const ordinary = remaining;
+        const advanced = [];
+        if (ordinary.length > 0) {
+            groups.push({
+                id: syntheticGroupId('general'),
+                title: groups.length === 0 ? '插件设置' : '其他设置',
+                advanced: false,
+                fields: ordinary.map(fieldModel),
+            });
+        }
+        if (advanced.length > 0) {
+            groups.push({
+                id: syntheticGroupId('advanced'),
+                title: '高级设置',
+                advanced: true,
+                fields: advanced.map(fieldModel),
+            });
+        }
+    }
+    return groups;
+}
+export function buildConfigPage(options) {
+    return {
+        pluginId: options.pluginId,
+        layer: { scope: options.read.scope },
+        groups: buildConfigGroups(options),
+        presets: [],
+        storedCount: options.read.fields.filter((field) => field.storedSourceLayer !== undefined).length,
+    };
+}
+export function configValuesEqual(left, right) {
+    return left !== undefined && right !== undefined
+        && stablePluginConfigStringify(left) === stablePluginConfigStringify(right);
+}
+//# sourceMappingURL=model.js.map