@lesliechan721/aw 0.1.0-beta.54 → 0.1.0-beta.55

package/dist/authoring/scripts/lib/plugin-version-check.mjs

@@ -10,7 +10,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { compareStrictSemVer, parseStrictSemVer } from './semver.mjs';
 import { assertAuthoringPluginPathFence, resolveAuthoringPluginRoot, } from './plugin-root.mjs';
 const execFileAsync = promisify(execFile);
-const EXPECTED_MANIFEST_CONTRACT_VERSION = 16;
+const EXPECTED_MANIFEST_CONTRACT_VERSION = 17;
 const PLUGIN_NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 const GIT_OBJECT_ID_PATTERN = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/u;
 const MAX_GIT_BLOB_BYTES = 50 * 1024 * 1024;

package/dist/authoring/scripts/validate-plugin.mjs

@@ -6,7 +6,7 @@ import { createRequire } from 'node:module';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { AW_RUNTIME_CONFIG_READER_PATH, createRuntimeConfigSnapshot, getPluginAuthoringAcceptedValues as getCorePluginAuthoringAcceptedValues, getSkillFrontmatterCapabilityRegistry, normalizePluginConfigDefinition, } from '@lesliechan721/aw-plugin-core/manifest';
+import { AW_RUNTIME_CONFIG_READER_PATH, createRuntimeConfigSnapshot, getPluginAuthoringAcceptedValues as getCorePluginAuthoringAcceptedValues, getSkillFrontmatterCapabilityRegistry, getManagedCommandArtifactTargets, normalizePluginConfigDefinition, parseManagedCommandPlaceholders, replaceManagedCommandPlaceholders, validateCommandEntryFiles, } from '@lesliechan721/aw-plugin-core/manifest';
 import { checkPluginVersions } from './lib/plugin-version-check.mjs';
 import { scanJavaScriptImportSpecifiers } from './lib/javascript-import-scanner.mjs';
 import { assertAuthoringPluginPathFence, assertCanonicalAuthoringPluginRoot, } from './lib/plugin-root.mjs';
@@ -18,7 +18,7 @@ const CLI_PACKAGE_ROOT = path.basename(authoringRuntimeRoot) === 'dist'
     : authoringRuntimeRoot;
 const errors = [];
 const warnings = [];
-const SOURCE_PLUGIN_MANIFEST_CONTRACT_VERSION = 16;
+const SOURCE_PLUGIN_MANIFEST_CONTRACT_VERSION = 17;
 let capabilityDiagnostic = null;
 const MAX_SKILL_NAME_LEN = 64;
 const MAX_SKILL_DESCRIPTION_LEN = 1024;
@@ -315,18 +315,25 @@ async function tryLoadCliManifestTools() {
     const manifestModulePath = path.join(CLI_PACKAGE_ROOT, 'dist', 'src', 'utils', 'manifest.js');
     const runtimeProjectionModulePath = path.join(CLI_PACKAGE_ROOT, 'dist', 'src', 'utils', 'catalog-runtime-projection.js');
     const capabilityModulePath = path.join(CLI_PACKAGE_ROOT, 'dist', 'src', 'commands', 'aw-capabilities.js');
+    const artifactPlanPath = path.join(CLI_PACKAGE_ROOT, 'dist', 'src', 'utils', 'artifact-plan.js');
+    const artifactRequestPath = path.join(CLI_PACKAGE_ROOT, 'dist', 'src', 'utils', 'artifact-request.js');
+    const commandMaterializationPath = path.join(CLI_PACKAGE_ROOT, 'dist', 'src', 'utils', 'managed-command-materialization.js');
     if (!fs.existsSync(manifestModulePath)
         || !fs.existsSync(runtimeProjectionModulePath)
         || !fs.existsSync(capabilityModulePath))
         return null;
     try {
-        const [manifestModule, runtimeProjectionModule, capabilityModule] = await Promise.all([
+        const [manifestModule, runtimeProjectionModule, capabilityModule, artifactPlanModule, artifactRequestModule, commandModule] = await Promise.all([
             import(pathToFileURL(manifestModulePath).href),
             import(pathToFileURL(runtimeProjectionModulePath).href),
             import(pathToFileURL(capabilityModulePath).href),
+            import(pathToFileURL(artifactPlanPath).href),
+            import(pathToFileURL(artifactRequestPath).href),
+            import(pathToFileURL(commandMaterializationPath).href),
         ]);
         if (manifestModule.SOURCE_PLUGIN_MANIFEST_CONTRACT_VERSION
-            !== SOURCE_PLUGIN_MANIFEST_CONTRACT_VERSION) {
+            !== SOURCE_PLUGIN_MANIFEST_CONTRACT_VERSION
+            || typeof artifactRequestModule.requiresNonSensitiveArtifactInput !== 'function') {
             return null;
         }
         return {
@@ -337,6 +344,11 @@ async function tryLoadCliManifestTools() {
             resolvePluginRequirements: manifestModule.resolvePluginRequirements ?? null,
             implementedCapabilities: capabilityModule.IMPLEMENTED_AW_CAPABILITIES ?? null,
             createRuntimeResolver: runtimeProjectionModule.createCatalogRuntimeImportResolver ?? null,
+            validateArtifactPlan: artifactPlanModule.validateArtifactPlan,
+            requiresNonSensitiveArtifactInput: artifactRequestModule.requiresNonSensitiveArtifactInput,
+            prepareManagedCommandPackageFiles: commandModule.prepareManagedCommandPackageFiles,
+            managedCommandProducerIdentity: commandModule.managedCommandProducerIdentity,
+            createManagedCommandReferenceResolver: commandModule.createManagedCommandReferenceResolver,
         };
     }
     catch {
@@ -505,6 +517,7 @@ function validateManifestLightweight(manifest) {
         'scripts',
         'config',
         'artifacts',
+        'managedCommands',
     ]);
     if (manifest.dependencies !== undefined) {
         if (!Array.isArray(manifest.dependencies)) {
@@ -2366,7 +2379,25 @@ function validateRenderedSkillTree(options) {
     }
     for (const [relativePath, content] of files) {
         const text = content.toString('utf8');
-        if (/\{\{[^{}]+\}\}/u.test(text)) {
+        let remaining = text;
+        if (relativePath.endsWith('.md')) {
+            try {
+                const placeholders = parseManagedCommandPlaceholders(text);
+                if (placeholders.length > 0 && !(manifest.requires?.aw?.capabilities ?? []).includes('aw.managed-commands.v1')) {
+                    error(`${fieldName} managed command references require aw.managed-commands.v1`);
+                }
+                if (declaration.target === 'agent-skills.skill' && placeholders.length > 0) {
+                    error(`${fieldName} managedCommandPortableUnsupported: Portable Skills cannot contain managed command references`);
+                }
+                else if (options.managedTrees) {
+                    remaining = replaceManagedCommandPlaceholders(text, () => `cmdp_${'0'.repeat(64)}`);
+                }
+            }
+            catch (cause) {
+                error(`${fieldName} ${cause.message}`);
+            }
+        }
+        if (/\{\{[^{}]+\}\}/u.test(remaining)) {
             error(`${fieldName} final file tree contains an unresolved template in "${relativePath}"`);
         }
     }
@@ -2385,6 +2416,7 @@ function validateRenderedSkillTree(options) {
     if (declaration.target === 'codex.skill' && files.has('agents/openai.yaml')) {
         validateOpenAiYaml(path.join(materializedRoot, 'agents', 'openai.yaml'), declaration.skillKey, true, manifest, materializedRoot, skillValidationTools);
     }
+    options.managedTrees?.push({ declaration, files, scope: options.managedScope });
 }
 function validateStaticPortableFinalTrees(pluginDir, manifest, runtimeImports, skillValidationTools) {
     const portableRoot = manifest.distributions?.agentSkills?.skills;
@@ -2444,6 +2476,12 @@ function validateRenderedArtifactPlan(plan, declarations, scopeLabel, options) {
         const entry = expectRecord(artifact, fieldName);
         if (!entry)
             return;
+        if (entry.target === 'aw.command-set' || entry.target === 'aw.command-package') {
+            const declaration = byKey.get(`${entry.id}:${entry.target}`);
+            if (declaration)
+                returned.add(`${entry.id}:${entry.target}`);
+            return; // Shared ArtifactPlan validation owns command response fields.
+        }
         validateAllowedKeys(entry, fieldName, [
             'id',
             'platform',
@@ -2550,6 +2588,8 @@ function validateRenderedArtifactPlan(plan, declarations, scopeLabel, options) {
                     runtimeImports: options.runtimeImports,
                     materializedRoot: path.join(options.tempRoot, `${declaration.platform ?? declaration.distribution}-${scopeLabel.split('/')[1]}-${index}`),
                     skillValidationTools: options.skillValidationTools,
+                    managedTrees: options.managedTrees,
+                    managedScope: scopeLabel.split('/')[1],
                 });
             }
         }
@@ -2564,7 +2604,7 @@ function validateRenderedArtifactPlan(plan, declarations, scopeLabel, options) {
         }
     }
 }
-function resolveArtifactRendererFixtureRequests(declarations, manifest) {
+function resolveArtifactRendererFixtureRequests(declarations, manifest, requiresNonSensitiveArtifactInput) {
     const awOwned = new Map();
     const codexNative = new Map();
     for (const declaration of declarations) {
@@ -2581,7 +2621,9 @@ function resolveArtifactRendererFixtureRequests(declarations, manifest) {
             codexNative.set(scope, request);
             continue;
         }
-        const surface = declaration.platform ?? declaration.distribution;
+        const surface = declaration.surface?.kind === 'aw'
+            ? declaration.surface.name
+            : declaration.platform ?? declaration.distribution;
         if (!surface)
             continue;
         for (const scope of declaration.scopes) {
@@ -2598,37 +2640,33 @@ function resolveArtifactRendererFixtureRequests(declarations, manifest) {
         }
     }
     const partitionedAwOwned = [...awOwned.values()].flatMap((request) => {
-        const hasSkill = request.declarations.some((declaration) => declaration.target === 'codex.skill'
-            || declaration.target === 'claude.skill'
-            || declaration.target === 'agent-skills.skill');
-        const hasSensitiveNonSkill = request.declarations.some((declaration) => declaration.target !== 'codex.skill'
-            && declaration.target !== 'claude.skill'
-            && declaration.target !== 'agent-skills.skill'
+        const hasNonSensitiveTarget = request.declarations.some(requiresNonSensitiveArtifactInput);
+        const hasSensitiveOtherTarget = request.declarations.some((declaration) => !requiresNonSensitiveArtifactInput(declaration)
             && declaration.refreshKeys.some((key) => configFieldContainsSensitiveValue(manifest.config?.fields?.[key])));
-        if (!hasSkill || !hasSensitiveNonSkill)
+        if (!hasNonSensitiveTarget || !hasSensitiveOtherTarget)
             return [request];
-        const skillDeclarations = request.declarations.filter((declaration) => declaration.target === 'codex.skill'
-            || declaration.target === 'claude.skill'
-            || declaration.target === 'agent-skills.skill');
-        const nonSkillDeclarations = request.declarations.filter((declaration) => !skillDeclarations.includes(declaration));
+        const nonSensitiveDeclarations = request.declarations.filter(requiresNonSensitiveArtifactInput);
+        const otherDeclarations = request.declarations.filter((declaration) => !requiresNonSensitiveArtifactInput(declaration));
         return [
-            { ...request, declarations: skillDeclarations },
-            { ...request, declarations: nonSkillDeclarations },
+            { ...request, declarations: nonSensitiveDeclarations },
+            { ...request, declarations: otherDeclarations },
         ];
     });
     return [...partitionedAwOwned, ...codexNative.values()];
 }
-function runArtifactRendererFixture(pluginDir, manifest, renderEntry, declarations, resolvedRuntimeImports, skillValidationTools) {
+async function runArtifactRendererFixture(pluginDir, manifest, renderEntry, declarations, resolvedRuntimeImports, skillValidationTools, managedContext, requiresNonSensitiveArtifactInput) {
     if (!renderEntry || declarations.length === 0)
-        return;
-    const requests = resolveArtifactRendererFixtureRequests(declarations, manifest);
+        return [];
+    const requests = resolveArtifactRendererFixtureRequests(declarations, manifest, requiresNonSensitiveArtifactInput);
     const values = defaultConfigValues(manifest);
     const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'aw-artifact-render-'));
+    const returnedArtifacts = [];
     try {
         for (const [requestIndex, request] of requests.entries()) {
             const { kind, surface, scope, configScope, declarations: scopedDeclarations, } = request;
             const distribution = surface === 'agent-skills' ? surface : undefined;
-            const platform = distribution ? undefined : surface;
+            const awSurface = surface === 'managed-commands';
+            const platform = distribution || awSurface ? undefined : surface;
             const event = distribution ? 'materialize' : 'install';
             const requestRoot = path.join(tempRoot, `${requestIndex}-${kind}-${surface}-${scope}`);
             const rendererAwHome = path.join(requestRoot, 'aw-home');
@@ -2636,7 +2674,7 @@ function runArtifactRendererFixture(pluginDir, manifest, renderEntry, declaratio
             const rendererClaudeHome = path.join(requestRoot, 'claude-home');
             fs.mkdirSync(requestRoot, { recursive: true });
             const contextPath = path.join(requestRoot, 'context.json');
-            const runtimeImports = scopedDeclarations.flatMap((target) => target.runtimeImports.map((runtimeImport, importIndex) => {
+            const runtimeImports = scopedDeclarations.flatMap((target) => (target.runtimeImports ?? []).map((runtimeImport, importIndex) => {
                 const resolved = resolvedRuntimeImports?.artifactImports.get(authorRuntimeImportKey(target.id, importIndex));
                 if (!resolved)
                     return null;
@@ -2684,7 +2722,7 @@ function runArtifactRendererFixture(pluginDir, manifest, renderEntry, declaratio
             }
             fs.writeFileSync(contextPath, JSON.stringify({
                 event,
-                surface: distribution
+                surface: awSurface ? { kind: 'aw', name: 'managed-commands' } : distribution
                     ? { kind: 'distribution', name: distribution }
                     : { kind: 'platform', name: platform },
                 ...(platform ? { platform } : {}),
@@ -2713,6 +2751,9 @@ function runArtifactRendererFixture(pluginDir, manifest, renderEntry, declaratio
                     target: target.target,
                     sourceDirs: target.sourceDirs.map((sourceDir) => path.join(pluginDir, normalizeRelativePath(sourceDir))),
                 })),
+                commandSources: (managedContext?.manifest.managedCommands?.packages ?? [])
+                    .filter((entry) => scopedDeclarations.some((target) => target.packageKey === entry.key))
+                    .map((entry) => ({ packageKey: entry.key, sourceDir: path.join(pluginDir, normalizeRelativePath(entry.sourceDir)) })),
                 runtimeImports,
                 paths: {
                     awHome: rendererAwHome,
@@ -2747,6 +2788,7 @@ function runArtifactRendererFixture(pluginDir, manifest, renderEntry, declaratio
                 AW_PLUGIN_EVENT: event,
                 ...(platform ? { AW_PLUGIN_PLATFORM: platform } : {}),
                 ...(distribution ? { AW_PLUGIN_DISTRIBUTION: distribution } : {}),
+                ...(awSurface ? { AW_PLUGIN_SURFACE: 'managed-commands' } : {}),
                 AW_PLUGIN_SCOPE: scope,
             };
             if (process.platform === 'win32') {
@@ -2793,24 +2835,153 @@ function runArtifactRendererFixture(pluginDir, manifest, renderEntry, declaratio
                 runtimeImports: resolvedRuntimeImports,
                 tempRoot,
                 skillValidationTools,
+                managedTrees: managedContext?.trees,
             });
+            if (managedContext) {
+                try {
+                    const validated = managedContext.tools.validateArtifactPlan({
+                        manifest: managedContext.manifest,
+                        plan,
+                        platform: surface,
+                        scope,
+                        requestedArtifactIds: scopedDeclarations.map((target) => target.id),
+                        renderConfig: { values: scopedValues, sources: Object.fromEntries(Object.keys(scopedValues).map((key) => [key, 'default'])), issues: [] },
+                    });
+                    returnedArtifacts.push(...validated.artifacts.map((artifact) => ({ artifact, scope, surface })));
+                }
+                catch (cause) {
+                    error(`${fieldName}: ${cause.message}`);
+                }
+            }
         }
     }
     finally {
         fs.rmSync(tempRoot, { recursive: true, force: true });
     }
+    return returnedArtifacts;
 }
-function validateDynamicArtifactsLightweight(pluginDir, manifest, renderEntry, runtimeImports, skillValidationTools) {
+async function validateDynamicArtifactsLightweight(pluginDir, manifest, renderEntry, runtimeImports, skillValidationTools, managedContext, requiresNonSensitiveArtifactInput) {
     const declarations = validateArtifactsConfigLightweight(pluginDir, manifest);
+    if (managedContext)
+        declarations.push(...getManagedCommandArtifactTargets(managedContext.manifest));
     const hasTargets = declarations.length > 0;
     const hasRenderer = Boolean(manifest.scripts?.artifacts?.render);
     if (hasTargets && !hasRenderer) {
         error('artifacts.targets requires scripts.artifacts.render');
     }
     if (hasRenderer && !hasTargets) {
-        error('scripts.artifacts.render requires artifacts.targets');
+        error('scripts.artifacts.render requires artifacts.targets or dynamic managedCommands targets');
+    }
+    return runArtifactRendererFixture(pluginDir, manifest, renderEntry, declarations, runtimeImports, skillValidationTools, managedContext, requiresNonSensitiveArtifactInput);
+}
+async function validateAuthorManagedCommands(pluginDir, manifest, rendered, context) {
+    const { tools, trees } = context;
+    const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'aw-author-commands-'));
+    const env = { AW_HOME: path.join(tempRoot, 'aw-home'), AW_CODEX_HOME: path.join(tempRoot, 'codex-home'), AW_CLAUDE_HOME: path.join(tempRoot, 'claude-home') };
+    const plugin = { manifest, rootDir: pluginDir, sourceId: 'authoring', sourceIdentity: `sha256:${'0'.repeat(64)}` };
+    const candidates = [];
+    const cleanups = [];
+    try {
+        const root = manifest.skills && path.join(pluginDir, normalizeRelativePath(manifest.skills));
+        if (root && fs.existsSync(root)) {
+            for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                for (const platform of targetedPlatforms(manifest)) {
+                    if ((manifest.artifacts?.targets ?? []).some((target) => target.platform === platform && target.kind === 'skill' && target.skillKey === entry.name))
+                        continue;
+                    const files = new Map();
+                    collectArtifactSourceFiles(path.join(root, entry.name), `static Skill ${entry.name}`, files);
+                    for (const [relative, bytes] of files) {
+                        if (isTemplateTextFile(relative))
+                            files.set(relative, Buffer.from(renderTemplateForPlatform(manifest, `${normalizeRelativePath(manifest.skills)}/${entry.name}/${relative}`, bytes.toString('utf8'), platform)));
+                    }
+                    const producer = await tools.managedCommandProducerIdentity({
+                        plugin,
+                        producer: { kind: 'static-skill', platform, skillKey: entry.name },
+                        scope: 'user',
+                        cwd: pluginDir,
+                    });
+                    trees.push({ declaration: { target: `${platform}.skill`, platform, skillKey: entry.name, staticSkill: true }, files, scope: producer.scope });
+                }
+            }
+        }
+        const setOutputs = (set, platform, scope) => {
+            if (set.mode === 'static')
+                return { set: set.set, state: 'present', entries: set.entries };
+            const output = rendered.find((entry) => entry.artifact.id === `command-set.${set.set}` && entry.scope === scope && entry.surface === platform)?.artifact;
+            if (!output)
+                throw new Error(`commandReferenceInvalid: dynamic command set ${set.set} was not returned`);
+            return { set: set.set, state: output.state, entries: output.entries };
+        };
+        for (const commandPackage of manifest.managedCommands?.packages ?? []) {
+            const sets = (manifest.managedCommands?.sets ?? [])
+                .filter((set) => set.producer.kind === 'package' && set.producer.packageKey === commandPackage.key)
+                .map((set) => setOutputs(set, 'managed-commands', commandPackage.scope));
+            const files = rendered.find((entry) => entry.artifact.id === `command-package.${commandPackage.key}`)?.artifact.files ?? {};
+            const prepared = await tools.prepareManagedCommandPackageFiles({ sourceRoot: path.join(pluginDir, normalizeRelativePath(commandPackage.sourceDir)), files, entries: sets.flatMap((set) => set.entries) });
+            cleanups.push(prepared.cleanup);
+            candidates.push({ producer: await tools.managedCommandProducerIdentity({ plugin, producer: { kind: 'package', packageKey: commandPackage.key }, scope: commandPackage.scope, cwd: pluginDir }), sets });
+        }
+        for (const [index, tree] of trees.entries()) {
+            const { declaration } = tree;
+            const scope = declaration.delivery?.mode === 'codex-native' ? 'user' : tree.scope;
+            if (!declaration.platform)
+                continue;
+            const producer = declaration.staticSkill
+                ? { kind: 'static-skill', platform: declaration.platform, skillKey: declaration.skillKey }
+                : { kind: 'artifact', artifactId: declaration.id };
+            const sets = (manifest.managedCommands?.sets ?? []).filter((set) => JSON.stringify(set.producer) === JSON.stringify(producer))
+                .map((set) => setOutputs(set, declaration.platform, scope));
+            const resourceRoot = path.join(tempRoot, `skill-${index}`);
+            for (const [relative, bytes] of tree.files) {
+                const target = path.join(resourceRoot, ...relative.split('/'));
+                fs.mkdirSync(path.dirname(target), { recursive: true });
+                fs.writeFileSync(target, bytes);
+            }
+            await validateCommandEntryFiles(resourceRoot, sets.flatMap((set) => set.entries));
+            candidates.push({ producer: await tools.managedCommandProducerIdentity({ plugin, producer, scope, cwd: pluginDir }), sets });
+        }
+        for (const tree of trees) {
+            if (!tree.declaration.platform)
+                continue;
+            const scope = tree.declaration.delivery?.mode === 'codex-native' ? 'user' : tree.scope;
+            const resolve = await tools.createManagedCommandReferenceResolver({ plugin, platform: tree.declaration.platform, scope, cwd: pluginDir, env, candidates });
+            for (const [relative, bytes] of tree.files) {
+                if (!relative.endsWith('.md'))
+                    continue;
+                const text = bytes.toString('utf8');
+                if (parseManagedCommandPlaceholders(text).length > 0 && !(manifest.requires?.aw?.capabilities ?? []).includes('aw.managed-commands.v1'))
+                    throw new Error('managed command references require aw.managed-commands.v1');
+                replaceManagedCommandPlaceholders(text, resolve);
+            }
+        }
+        for (const permission of manifest.extensions?.permissions ?? []) {
+            for (const platform of targetedPlatforms(manifest)) {
+                for (const scope of platform === 'codex' ? ['user'] : ['user', 'project']) {
+                    const resolve = await tools.createManagedCommandReferenceResolver({ plugin, platform, scope, cwd: pluginDir, env, candidates });
+                    const override = permission.agentOverrides?.[platform];
+                    if (override === null)
+                        continue;
+                    for (const decision of ['allow', 'ask', 'deny'])
+                        for (const rule of override?.[decision] ?? permission[decision] ?? [])
+                            if (typeof rule !== 'string')
+                                resolve(rule.command);
+                    if (platform === 'claude')
+                        for (const rule of override?.sandbox?.excludedCommands ?? [])
+                            resolve(rule.command);
+                }
+            }
+        }
+    }
+    catch (cause) {
+        error(`managed command authoring candidate: ${cause.message}`);
+    }
+    finally {
+        for (const cleanup of cleanups)
+            await cleanup();
+        fs.rmSync(tempRoot, { recursive: true, force: true });
     }
-    runArtifactRendererFixture(pluginDir, manifest, renderEntry, declarations, runtimeImports, skillValidationTools);
 }
 function validateScriptsLightweight(pluginDir, manifest) {
     validateConfigSchemaLightweight(manifest.config);
@@ -3404,8 +3575,9 @@ async function validatePluginDir(pluginDir, options) {
         }
     }
     const skillValidationTools = await tryLoadCliSkillValidationTools();
+    let normalizedManifest;
     try {
-        const normalizedManifest = await cliManifestTools.validateSourcePluginManifest(pluginDir, manifest);
+        normalizedManifest = await cliManifestTools.validateSourcePluginManifest(pluginDir, manifest);
         // Renderer fixtures consume the same compiled config as installed runtime consumers.
         if (normalizedManifest.config)
             manifest.config = normalizedManifest.config;
@@ -3448,7 +3620,12 @@ async function validatePluginDir(pluginDir, options) {
         cliManifestTools,
     });
     validateStaticPortableFinalTrees(pluginDir, manifest, runtimeImports, skillValidationTools);
-    validateDynamicArtifactsLightweight(pluginDir, manifest, artifactRenderEntry, runtimeImports, skillValidationTools);
+    const managedContext = normalizedManifest
+        ? { manifest: normalizedManifest, tools: cliManifestTools, trees: [] }
+        : undefined;
+    const rendered = await validateDynamicArtifactsLightweight(pluginDir, manifest, artifactRenderEntry, runtimeImports, skillValidationTools, managedContext, cliManifestTools.requiresNonSensitiveArtifactInput);
+    if (managedContext)
+        await validateAuthorManagedCommands(pluginDir, normalizedManifest, rendered ?? [], managedContext);
     validateMcpContent(pluginDir, manifest);
     validateAppsContent(pluginDir, manifest);
     warnCodexProjectScopeLimitations(manifest);