@lesliechan721/aw 0.1.0-beta.23 → 0.1.0-beta.24

package/dist/src/commands/review-inspection.js

@@ -1,12 +1,35 @@
 import path from 'node:path';
-import { computeCaseCorpusDigest, computeSkillDigest, } from '@lesliechan721/agent-skill-eval';
+import { canonicalJson, computeCaseCorpusDigest, computeSkillDigest, } from '@lesliechan721/agent-skill-eval';
 import { calculateCatalogWorkspaceSourceIdentity, DEFAULT_CATALOG_OUTPUT_PATH, GENERATED_OUTPUT_MARKER_FILENAME, readCatalogWorkspace, resolveSupportedPlatforms, validateCatalogSnapshotComplete, } from '@lesliechan721/aw-plugin-core';
 import fs from 'fs-extra';
 import { readAwSkillEvalManifest, } from '../eval/manifest-v1.js';
 import { CLI_RESERVED_IMPORTS } from '../utils/manifest.js';
 import { resolveCatalogWorkspaceRoot, } from './catalog-workspace-resolution.js';
 import { computeReviewComponentDigest } from './review-publication.js';
-import { computeAwSourceBindingSelectedCasesDigest, computeAwSourceBindingSuiteDefaultsDigest, readAwSourceBinding, resolveEvalProfileBindingInput, selectAwSourceBindingEvalCases, validateAwSourceBindingForWorkspace, } from '../review/source-binding.js';
+import { computeAwSourceBindingSelectedCasesDigest, computeAwSourceBindingSuiteDefaultsDigest, readAwSourceBinding, resolvePortablePluginProfileConfig, resolveEvalProfileBindingInput, selectAwSourceBindingEvalCases, validateAwSourceBindingForWorkspace, } from '../review/source-binding.js';
+import { resolveReviewDynamicSkillSource, resolveReviewSelection, reviewBindingMatchesSelection, } from '../review/review-selection.js';
+import { resolveEffectivePluginConfigFromStores, } from '../utils/plugin-config.js';
+export class ReviewInspectionInputError extends Error {
+    code;
+    exitCode = 2;
+    constructor(code, message) {
+        super(`${code}: ${message}`);
+        this.name = 'ReviewInspectionInputError';
+        this.code = code;
+    }
+}
+class ReviewInspectionResolvedTargetError extends Error {
+    code;
+    exitCode;
+    reviewTarget;
+    constructor(error, target) {
+        super(error instanceof Error ? error.message : String(error), { cause: error });
+        this.name = 'ReviewInspectionResolvedTargetError';
+        this.code = getReviewInspectionErrorCode(error);
+        this.exitCode = getReviewInspectionExitCode(error);
+        this.reviewTarget = target;
+    }
+}
 const compareText = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 function stripDotSlash(value) {
     return value.startsWith('./') ? value.slice(2) : value;
@@ -14,8 +37,13 @@ function stripDotSlash(value) {
 function relativeWorkspacePath(workspaceRoot, filePath) {
     return path.relative(workspaceRoot, filePath).split(path.sep).join('/') || '.';
 }
-function sourceKey(plugin, skill, kind) {
-    return `source:${plugin}:${skill}:${kind}`;
+function sourceKey(options) {
+    const sourcePaths = options.roots.map((root) => relativeWorkspacePath(options.workspaceRoot, root));
+    const sourceIdentity = encodeURIComponent(JSON.stringify({
+        primary: sourcePaths[0],
+        sources: [...sourcePaths].sort(compareText),
+    }));
+    return `source:${options.plugin}:${options.skill}:${options.kind}:${sourceIdentity}`;
 }
 function requiredFinalKey(seed) {
     return [
@@ -39,6 +67,13 @@ function materializationIdentityKey(options) {
 function scopeFromProfile(profile) {
     return profile.endsWith('-project') ? 'project' : 'user';
 }
+function finalProfileFromBinding(profile) {
+    if (profile.kind === 'eval')
+        return `codex-${profile.scope}`;
+    if (profile.kind === 'portable')
+        return `agent-skills-${profile.scope}`;
+    return `${profile.platform}-${profile.scope}`;
+}
 async function directSkillDirectories(root) {
     const entries = await fs.readdir(root, { withFileTypes: true });
     const result = [];
@@ -48,7 +83,7 @@ async function directSkillDirectories(root) {
         if (stat.isSymbolicLink() || !stat.isDirectory()) {
             throw new Error(`Skill collection direct child must be a regular directory: ${entryPath}`);
         }
-        result.push({ name: entry.name, root: entryPath });
+        result.push({ name: entry.name, root: await fs.realpath(entryPath) });
     }
     return result;
 }
@@ -126,7 +161,13 @@ async function inspectSnapshot(workspace, workspaceSourceIdentity) {
     }
 }
 async function addSourceSubject(options) {
-    const key = sourceKey(options.plugin.manifest.name, options.skill, options.kind);
+    const key = sourceKey({
+        workspaceRoot: options.workspace.workspaceRoot,
+        plugin: options.plugin.manifest.name,
+        skill: options.skill,
+        kind: options.kind,
+        roots: options.sourceRoots ?? [options.root],
+    });
     if (options.subjects.some((subject) => subject.key === key))
         return key;
     const digest = options.kind === 'artifact-source'
@@ -155,8 +196,6 @@ async function inventoryPluginSource(options) {
     const portableSkills = plugin.manifest.distributions?.agentSkills?.skills
         ? await directSkillDirectories(path.join(plugin.rootDir, stripDotSlash(plugin.manifest.distributions.agentSkills.skills)))
         : [];
-    const nativeByName = new Map(nativeSkills.map((entry) => [entry.name, entry]));
-    const portableByName = new Map(portableSkills.map((entry) => [entry.name, entry]));
     const nativeDynamicByPlatform = new Map([
         ['claude', new Set()],
         ['codex', new Set()],
@@ -203,7 +242,13 @@ async function inventoryPluginSource(options) {
                     skill: skill.name,
                     profile: `${platform}-${scope}`,
                     targetId: null,
-                    sourceSubjectKey: sourceKey(plugin.manifest.name, skill.name, 'source-skill'),
+                    sourceSubjectKey: sourceKey({
+                        workspaceRoot: workspace.workspaceRoot,
+                        plugin: plugin.manifest.name,
+                        skill: skill.name,
+                        kind: 'source-skill',
+                        roots: [skill.root],
+                    }),
                     dynamic: false,
                 });
             }
@@ -219,7 +264,13 @@ async function inventoryPluginSource(options) {
                     skill: skill.name,
                     profile: `agent-skills-${scope}`,
                     targetId: null,
-                    sourceSubjectKey: sourceKey(plugin.manifest.name, skill.name, 'portable-source-skill'),
+                    sourceSubjectKey: sourceKey({
+                        workspaceRoot: workspace.workspaceRoot,
+                        plugin: plugin.manifest.name,
+                        skill: skill.name,
+                        kind: 'portable-source-skill',
+                        roots: [skill.root],
+                    }),
                     dynamic: false,
                 });
             }
@@ -232,27 +283,22 @@ async function inventoryPluginSource(options) {
         const platform = target.target === 'agent-skills.skill'
             ? 'agent-skills'
             : target.target === 'codex.skill' ? 'codex' : 'claude';
-        const sourceEntry = target.target === 'agent-skills.skill'
-            ? portableByName.get(skill) ?? nativeByName.get(skill)
-            : nativeByName.get(skill);
-        let sourceSubjectKey = target.target === 'agent-skills.skill' && portableByName.has(skill)
-            ? sourceKey(plugin.manifest.name, skill, 'portable-source-skill')
-            : sourceKey(plugin.manifest.name, skill, 'source-skill');
-        if (!sourceEntry) {
-            const declaredSource = target.sourceDirs?.[0];
-            const sourceRoot = declaredSource
-                ? path.join(plugin.rootDir, stripDotSlash(declaredSource))
-                : path.join(plugin.rootDir, stripDotSlash(plugin.manifest.scripts?.artifacts?.render?.path ?? '.agents-plugin'));
-            sourceSubjectKey = await addSourceSubject({
-                workspace,
-                subjects,
-                plugin,
-                skill,
-                root: sourceRoot,
-                kind: 'artifact-source',
-            });
-            sourceSubjectKeys.push(sourceSubjectKey);
-        }
+        const source = await resolveReviewDynamicSkillSource({
+            plugin,
+            target,
+            nativeSkillPaths: nativeSkills.map((entry) => entry.root),
+            portableSkillPaths: portableSkills.map((entry) => entry.root),
+        });
+        const sourceSubjectKey = await addSourceSubject({
+            workspace,
+            subjects,
+            plugin,
+            skill,
+            root: source.sourcePath,
+            sourceRoots: source.sourcePaths,
+            kind: source.sourceKind,
+        });
+        sourceSubjectKeys.push(sourceSubjectKey);
         for (const scope of target.scopes) {
             seeds.push({
                 plugin,
@@ -414,8 +460,11 @@ async function resolveTarget(options) {
     }
     const candidate = path.resolve(options.cwd, options.target);
     const stat = await fs.lstat(candidate).catch(() => null);
-    if (!stat?.isDirectory() || stat.isSymbolicLink()) {
-        throw new Error('Review inspection target must be a canonical Plugin or Catalog Workspace directory.');
+    if (!stat) {
+        throw new ReviewInspectionInputError('targetNotFound', `Review target was not found: ${candidate}`);
+    }
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        throw new ReviewInspectionInputError('invalidArguments', 'The release view requires a canonical Plugin or Catalog Workspace directory.');
     }
     const real = await fs.realpath(candidate);
     if (real === options.workspace.workspaceRoot) {
@@ -428,7 +477,7 @@ async function resolveTarget(options) {
     }
     const plugin = options.workspace.plugins.find((entry) => entry.rootDir === real);
     if (!plugin) {
-        throw new Error('Review inspection target is not a canonical Plugin in the selected Catalog Workspace.');
+        throw new ReviewInspectionInputError('invalidArguments', 'The release view requires the complete Plugin or Catalog target.');
     }
     return { kind: 'plugin', id: plugin.manifest.name, path: real, plugins: [plugin] };
 }
@@ -444,7 +493,8 @@ async function inspectMaterializations(options) {
             sourceIdentity: options.workspaceSourceIdentity,
         },
     };
-    for (const bindingPath of options.paths) {
+    const bindingPaths = [...new Set(options.paths.map((entry) => path.resolve(entry)))].sort(compareText);
+    for (const bindingPath of bindingPaths) {
         let parsed = null;
         try {
             parsed = await readAwSourceBinding(bindingPath);
@@ -468,33 +518,36 @@ async function inspectMaterializations(options) {
                 state: validation.state,
                 plugin: validation.binding?.subject.plugin ?? null,
                 skill: validation.binding?.subject.skill ?? null,
-                profile: validation.binding
-                    ? validation.binding.profile.kind === 'eval'
-                        ? `codex-${validation.binding.profile.scope}`
-                        : `agent-skills-${validation.binding.profile.scope}`
-                    : null,
+                profile: validation.binding ? finalProfileFromBinding(validation.binding.profile) : null,
                 finalKeys: [],
                 verifiedBinding: null,
                 issues: validation.issues.map((issue) => issue.message),
             });
             continue;
         }
-        const profile = validation.binding.profile.kind === 'eval'
-            ? `codex-${validation.binding.profile.scope}`
-            : `agent-skills-${validation.binding.profile.scope}`;
+        const profile = finalProfileFromBinding(validation.binding.profile);
         const finalKeys = [];
         for (const output of validation.outputs) {
-            if (output.kind !== 'eval-target' && output.kind !== 'portable-skill')
+            if (output.kind !== 'eval-target'
+                && output.kind !== 'portable-skill'
+                && output.kind !== 'review-skill')
                 continue;
-            const outputPlugin = output.kind === 'portable-skill'
+            const outputPlugin = output.kind === 'portable-skill' || output.kind === 'review-skill'
                 ? output.plugin
                 : validation.binding.subject.plugin;
             if (!targetPluginNames.has(outputPlugin))
                 continue;
-            const belongsToSelectedPlugin = options.requiredFinals.some((required) => required.plugin === outputPlugin
+            const compatibleRequired = options.requiredFinals.filter((required) => required.plugin === outputPlugin
                 && required.skill === output.skill
-                && required.profile === profile);
-            if (!belongsToSelectedPlugin) {
+                && required.profile === profile
+                && (validation.binding.profile.kind !== 'eval'
+                    || required.targetId === null
+                    || options.targetPlugins
+                        .find((plugin) => plugin.manifest.name === required.plugin)
+                        ?.manifest.artifacts?.targets
+                        ?.find((target) => target.id === required.targetId)
+                        ?.delivery?.mode !== 'codex-native'));
+            if (compatibleRequired.length === 0) {
                 options.issues.push({
                     category: 'unknown',
                     code: 'materializedOutputOwnerUnknown',
@@ -549,6 +602,7 @@ async function inspectMaterializations(options) {
                     identityKey,
                     path: output.path,
                     digest: output.digest,
+                    requiredKeys: compatibleRequired.map((required) => required.key).sort(compareText),
                 });
             }
         }
@@ -587,11 +641,325 @@ async function inspectMaterializations(options) {
         finals: [...finals.values()].sort((left, right) => compareText(left.key, right.key)),
     };
 }
-export async function inspectReviewTarget(options) {
+function sameResolvedConfig(left, right) {
+    return canonicalJson({ values: left.values, sources: left.sources })
+        === canonicalJson({ values: right.values, sources: right.sources });
+}
+function selectResolvedConfig(config, keys) {
+    return {
+        values: Object.fromEntries(keys.flatMap((key) => Object.hasOwn(config.values, key) ? [[key, config.values[key]]] : [])),
+        sources: Object.fromEntries(keys.flatMap((key) => Object.hasOwn(config.sources, key) ? [[key, config.sources[key]]] : [])),
+    };
+}
+function selectedSkillConfig(profile, skill) {
+    const entries = profile.pluginConfigs.filter((entry) => entry.pluginName === skill.pluginName);
+    if (entries.length === 0)
+        return skill.refreshKeys.length === 0 ? { values: {}, sources: {} } : null;
+    const values = Object.assign({}, ...entries.map((entry) => entry.values));
+    const sources = Object.assign({}, ...entries.map((entry) => entry.sources));
+    return selectResolvedConfig({ values, sources }, skill.refreshKeys);
+}
+function legacyProfileStore(scope, values) {
+    return {
+        path: `<legacy-${scope}-profile>`,
+        exists: Object.keys(values).length > 0,
+        state: 'ready',
+        values,
+        issues: [],
+    };
+}
+async function legacyBindingMatchesSelection(options) {
+    const { binding, requestedProfile, skill } = options;
+    if (binding.profile.scope !== requestedProfile.scope)
+        return false;
+    if (binding.profile.kind === 'eval') {
+        if (requestedProfile.platform !== 'codex'
+            || !binding.subject.skill
+            || skill.delivery === 'codex-native')
+            return false;
+        const plugin = options.selection.workspace.plugins.find((entry) => entry.manifest.name === binding.subject.plugin);
+        if (!plugin)
+            return false;
+        const loaded = await readAwSkillEvalManifest({ plugin, skill: binding.subject.skill });
+        const evalProfile = loaded.manifest.profiles.find((entry) => entry.id === binding.profile.id);
+        if (!evalProfile)
+            return false;
+        const config = Object.fromEntries(evalProfile.plugins.map((entry) => [entry.name, entry.config]));
+        try {
+            const requested = selectedSkillConfig(requestedProfile, skill);
+            if (!requested)
+                return false;
+            const overrides = config[skill.pluginName] ?? {};
+            const userValues = binding.profile.scope === 'user' ? overrides : {};
+            const effective = await resolveEffectivePluginConfigFromStores({
+                pluginName: skill.pluginName,
+                manifest: skill.plugin.manifest,
+                targetScope: binding.profile.scope,
+                projectRoot: options.selection.workspace.workspaceRoot,
+                stores: {
+                    user: legacyProfileStore('user', userValues),
+                    ...(binding.profile.scope === 'project'
+                        ? { project: legacyProfileStore('project', overrides) }
+                        : {}),
+                },
+            });
+            return sameResolvedConfig(requested, selectResolvedConfig(effective, skill.refreshKeys));
+        }
+        catch {
+            return false;
+        }
+    }
+    if (binding.profile.kind !== 'portable' || requestedProfile.platform !== 'agent-skills') {
+        return false;
+    }
+    try {
+        const requested = selectedSkillConfig(requestedProfile, skill);
+        if (!requested)
+            return false;
+        const current = await resolvePortablePluginProfileConfig({
+            plugin: skill.plugin,
+            scope: skill.configScope,
+            cwd: options.selection.workspace.workspaceRoot,
+            env: options.env,
+        });
+        return sameResolvedConfig(requested, selectResolvedConfig(current.config, skill.refreshKeys));
+    }
+    catch {
+        return false;
+    }
+}
+function bindingOutputIdentity(binding, artifact) {
+    if (artifact.kind === 'eval-target') {
+        return { plugin: binding.subject.plugin, skill: artifact.skill };
+    }
+    if (artifact.kind === 'portable-skill' || artifact.kind === 'review-skill') {
+        return { plugin: artifact.plugin, skill: artifact.skill };
+    }
+    return null;
+}
+async function inspectNavigationBindings(options) {
+    const candidates = new Map();
+    const issues = [];
+    const context = {
+        workspace: options.selection.workspace,
+        source: {
+            kind: 'workspace',
+            workspaceIdentity: options.selection.workspace.workspaceIdentity,
+            sourceIdentity: options.selection.sourceIdentity,
+        },
+    };
+    const bindingPaths = [...new Set(options.materializations.map((entry) => path.resolve(entry)))]
+        .sort(compareText);
+    for (const bindingPath of bindingPaths) {
+        let binding;
+        try {
+            binding = await readAwSourceBinding(bindingPath);
+        }
+        catch (error) {
+            throw new ReviewInspectionInputError('sourceBindingInvalid', error instanceof Error ? error.message : String(error));
+        }
+        const validation = await validateAwSourceBindingForWorkspace({
+            bindingPath,
+            context,
+            expectedSubject: binding.subject,
+            cwd: options.selection.workspace.workspaceRoot,
+            env: options.env,
+        });
+        if (validation.state === 'invalid' || validation.state === 'incomplete') {
+            throw new ReviewInspectionInputError('sourceBindingInvalid', validation.issues.map((entry) => entry.message).join('; '));
+        }
+        let selected = false;
+        for (const requestedProfile of options.selection.profiles) {
+            const profileMatches = binding.profile.kind === 'review'
+                ? binding.profile.platform === requestedProfile.platform
+                    && binding.profile.scope === requestedProfile.scope
+                : binding.profile.kind === 'eval'
+                    ? requestedProfile.platform === 'codex'
+                    : requestedProfile.platform === 'agent-skills';
+            if (!profileMatches)
+                continue;
+            for (const artifact of binding.artifacts) {
+                const identity = bindingOutputIdentity(binding, artifact);
+                if (!identity)
+                    continue;
+                const skill = requestedProfile.skills.find((entry) => entry.pluginName === identity.plugin && entry.name === identity.skill);
+                if (!skill)
+                    continue;
+                if (binding.profile.kind === 'review'
+                    && !await reviewBindingMatchesSelection({
+                        workspace: options.selection.workspace,
+                        bindingProfile: binding.profile,
+                        requestedProfile,
+                        pluginName: identity.plugin,
+                        skill: identity.skill,
+                    }))
+                    continue;
+                if (binding.profile.kind !== 'review'
+                    && !await legacyBindingMatchesSelection({
+                        selection: options.selection,
+                        requestedProfile,
+                        skill,
+                        binding,
+                        env: options.env,
+                    }))
+                    continue;
+                selected = true;
+                const key = `${identity.plugin}\0${identity.skill}\0${requestedProfile.platform}\0${requestedProfile.scope}`;
+                const candidate = {
+                    path: path.resolve(path.dirname(bindingPath), ...artifact.path.split('/')),
+                    digest: artifact.digest,
+                    evidencePath: bindingPath,
+                    state: validation.state === 'verified' ? 'ready' : 'stale',
+                };
+                candidates.set(key, [...(candidates.get(key) ?? []), candidate]);
+            }
+        }
+        if (!selected) {
+            issues.push({
+                code: 'materializationNotSelected',
+                path: bindingPath,
+                message: 'The source binding does not match the selected Skill, profile, and config input.',
+            });
+        }
+        else if (validation.state === 'drifted') {
+            issues.push({
+                code: 'sourceBindingDrifted',
+                path: bindingPath,
+                message: validation.issues.map((entry) => entry.message).join('; '),
+            });
+        }
+    }
+    return { candidates, issues };
+}
+function navigationSkillKey(skill, profile) {
+    return `${skill.pluginName}\0${skill.name}\0${profile.platform}\0${profile.scope}`;
+}
+async function inspectNavigationTarget(options) {
+    const selection = await resolveReviewSelection({
+        cwd: options.cwd,
+        target: options.target,
+        ...(options.workspaceRoot === undefined ? {} : { workspaceRoot: options.workspaceRoot }),
+        ...(options.skills === undefined ? {} : { skills: options.skills }),
+        ...(options.platform === undefined ? {} : { platform: options.platform }),
+        ...(options.scope === undefined ? {} : { scope: options.scope }),
+        ...(options.configFile === undefined ? {} : { configFile: options.configFile }),
+        ...(options.env === undefined ? {} : { env: options.env }),
+    });
+    try {
+        const snapshot = await inspectSnapshot(selection.workspace, selection.sourceIdentity);
+        const binding = await inspectNavigationBindings({
+            selection,
+            materializations: options.materializations ?? [],
+            env: options.env,
+        });
+        const skills = [];
+        const issues = [...binding.issues];
+        if (snapshot.receipt.state === 'invalid' || snapshot.receipt.state === 'stale') {
+            issues.push({
+                code: snapshot.receipt.state === 'invalid' ? 'snapshotInvalid' : 'snapshotStale',
+                path: snapshot.receipt.path,
+                message: snapshot.receipt.state === 'invalid'
+                    ? 'The existing Catalog snapshot is invalid.'
+                    : 'The existing Catalog snapshot is not bound to the current Workspace source.',
+            });
+        }
+        for (const profile of selection.profiles) {
+            for (const skill of profile.skills) {
+                const key = navigationSkillKey(skill, profile);
+                const candidates = [...(binding.candidates.get(key) ?? [])];
+                if (snapshot.root
+                    && !skill.dynamic
+                    && profile.platform !== 'agent-skills') {
+                    const finalPath = path.join(snapshot.root, 'plugins', skill.pluginName, profile.platform, 'skills', skill.name);
+                    try {
+                        candidates.push({
+                            path: finalPath,
+                            digest: await computeSkillDigest(finalPath),
+                            evidencePath: snapshot.receipt.path,
+                            state: 'ready',
+                        });
+                    }
+                    catch {
+                        // Complete snapshot validation reports invalid final content through its own state.
+                    }
+                }
+                const ready = candidates.filter((entry) => entry.state === 'ready');
+                const readyDigests = new Set(ready.map((entry) => entry.digest));
+                let state = 'missing';
+                let chosen = null;
+                if (readyDigests.size > 1) {
+                    state = 'invalid';
+                    issues.push({
+                        code: 'materializationAmbiguous',
+                        path: null,
+                        message: `Current materializations have different digests for ${skill.pluginName}/${skill.name}/${profile.profile.id}.`,
+                    });
+                }
+                else if (ready.length > 0) {
+                    state = 'ready';
+                    chosen = ready.sort((left, right) => compareText(`${left.evidencePath}\0${left.path}`, `${right.evidencePath}\0${right.path}`))[0];
+                }
+                else {
+                    const stale = candidates.filter((entry) => entry.state === 'stale')
+                        .sort((left, right) => compareText(left.evidencePath, right.evidencePath));
+                    if (stale.length > 0) {
+                        state = 'stale';
+                        chosen = stale[0];
+                    }
+                }
+                if (state === 'missing') {
+                    issues.push({
+                        code: 'requiredFinalMissing',
+                        path: skill.sourcePath,
+                        message: `No current final is available for ${skill.pluginName}/${skill.name}/${profile.profile.id}.`,
+                    });
+                }
+                skills.push({
+                    skill: skill.name,
+                    sourcePath: skill.sourcePath,
+                    profile: {
+                        platform: profile.platform,
+                        scope: profile.scope,
+                        inputDigest: profile.profile.inputDigest,
+                    },
+                    finalPath: chosen?.path ?? null,
+                    digest: chosen?.digest ?? null,
+                    state,
+                    evidencePath: chosen?.evidencePath ?? null,
+                });
+            }
+        }
+        skills.sort((left, right) => compareText(`${left.skill}\0${left.profile.platform}\0${left.profile.scope}\0${left.sourcePath}`, `${right.skill}\0${right.profile.platform}\0${right.profile.scope}\0${right.sourcePath}`));
+        issues.sort((left, right) => compareText(`${left.code}\0${left.path ?? ''}\0${left.message}`, `${right.code}\0${right.path ?? ''}\0${right.message}`));
+        return {
+            schemaVersion: 2,
+            command: 'review:inspect',
+            view: 'review',
+            ok: true,
+            target: { kind: selection.target.kind, path: selection.target.path },
+            sources: [...new Set(selection.sources.map((entry) => path.resolve(entry)))].sort(compareText),
+            ...(selection.target.kind === 'catalog'
+                ? { snapshot: { path: snapshot.receipt.path, state: snapshot.receipt.state } }
+                : {}),
+            skills,
+            issues,
+        };
+    }
+    catch (error) {
+        throw new ReviewInspectionResolvedTargetError(error, {
+            kind: selection.target.kind,
+            path: selection.target.path,
+        });
+    }
+}
+async function inspectReleaseTarget(options) {
     const targetCandidate = options.target === 'catalog' ? null : path.resolve(options.cwd, options.target);
     const targetCandidateStat = targetCandidate
         ? await fs.lstat(targetCandidate).catch(() => null)
         : null;
+    if (targetCandidateStat && (!targetCandidateStat.isDirectory() || targetCandidateStat.isSymbolicLink())) {
+        throw new ReviewInspectionInputError('invalidArguments', 'The release view requires a canonical Plugin or Catalog Workspace directory.');
+    }
     const resolution = await resolveCatalogWorkspaceRoot({
         cwd: options.workspaceRoot === undefined && targetCandidateStat?.isDirectory()
             ? targetCandidate
@@ -728,7 +1096,8 @@ export async function inspectReviewTarget(options) {
     for (const final of binding.finals) {
         const candidates = requiredFinals.filter((required) => required.plugin === final.plugin
             && required.skill === final.skill
-            && required.profile === final.profile);
+            && required.profile === final.profile
+            && final.requiredKeys.includes(required.key));
         if (candidates.length === 1) {
             const required = candidates[0];
             bindingFinalsByRequiredKey.set(required.key, [...(bindingFinalsByRequiredKey.get(required.key) ?? []), final]);
@@ -814,7 +1183,8 @@ export async function inspectReviewTarget(options) {
                 .map((materialization) => materialization.path))]
             .sort(compareText);
         if (required.materializedFinalKeys.length === 0) {
-            const snapshotFinal = requiredByKey.get(required.requiredFinalKey)?.matchedFinalKeys ?? [];
+            const snapshotFinal = (requiredByKey.get(required.requiredFinalKey)?.matchedFinalKeys ?? [])
+                .filter((key) => subjects.some((subject) => subject.key === key && subject.origin === 'catalog-snapshot'));
             required.materializedFinalKeys = [...snapshotFinal];
         }
     }
@@ -872,8 +1242,9 @@ export async function inspectReviewTarget(options) {
     subjects.sort((left, right) => compareText(left.key, right.key));
     const ok = !issues.some((issue) => issue.blocking);
     return {
-        schemaVersion: 1,
+        schemaVersion: 2,
         command: 'review:inspect',
+        view: 'release',
         ok,
         completeness: ok && requiredFinals.every((entry) => entry.status === 'resolved')
             ? 'complete' : 'incomplete',
@@ -900,18 +1271,71 @@ export async function inspectReviewTarget(options) {
         issues,
     };
 }
-export function createReviewInspectionFailure(error, code = 'reviewInspectionFailed') {
+export async function inspectReviewTarget(options) {
+    const view = options.view ?? 'review';
+    if (view === 'release') {
+        if ((options.skills !== undefined && options.skills.length > 0)
+            || options.platform !== undefined
+            || options.scope !== undefined
+            || options.configFile !== undefined) {
+            throw new ReviewInspectionInputError('invalidArguments', 'The release view requires the complete Plugin or Catalog target and does not accept selection options.');
+        }
+        return await inspectReleaseTarget(options);
+    }
+    return await inspectNavigationTarget(options);
+}
+export function getReviewInspectionErrorCode(error, fallback = 'reviewInspectionFailed') {
+    if (error && typeof error === 'object' && 'code' in error) {
+        const code = error.code;
+        if (typeof code === 'string' && code !== '')
+            return code;
+    }
+    return fallback;
+}
+export function getReviewInspectionExitCode(error) {
+    if (error && typeof error === 'object' && 'exitCode' in error) {
+        const exitCode = error.exitCode;
+        if (exitCode === 2 || exitCode === 3)
+            return exitCode;
+    }
+    return 1;
+}
+function getReviewInspectionResolvedTarget(error) {
+    if (!error || typeof error !== 'object' || !('reviewTarget' in error))
+        return null;
+    const target = error.reviewTarget;
+    if (!target || typeof target !== 'object')
+        return null;
+    const kind = target.kind;
+    const targetPath = target.path;
+    if ((kind !== 'skill' && kind !== 'plugin' && kind !== 'catalog')
+        || typeof targetPath !== 'string'
+        || targetPath === '')
+        return null;
+    return { kind, path: targetPath };
+}
+export function createReviewInspectionFailure(error, view = 'review', fallbackCode = 'reviewInspectionFailed') {
+    const code = getReviewInspectionErrorCode(error, fallbackCode);
+    const message = error instanceof Error ? error.message : String(error);
+    if (view === 'release') {
+        return {
+            schemaVersion: 2,
+            command: 'review:inspect',
+            view,
+            ok: false,
+            completeness: 'incomplete',
+            issues: [{ category: 'invalid', code, message, blocking: true }],
+        };
+    }
     return {
-        schemaVersion: 1,
+        schemaVersion: 2,
         command: 'review:inspect',
+        view,
         ok: false,
-        completeness: 'incomplete',
-        issues: [{
-                category: 'invalid',
-                code,
-                message: error instanceof Error ? error.message : String(error),
-                blocking: true,
-            }],
+        target: getReviewInspectionResolvedTarget(error),
+        sources: [],
+        skills: [],
+        issues: [{ code, path: null, message }],
     };
 }
 //# sourceMappingURL=review-inspection.js.map