@aiwg/cli 2026.10.10 → 2026.10.12

package/dist/src/skills/claude-surface-projection.js

@@ -0,0 +1,25 @@
+/** Inspection only: account-enabled skills are a separate delivery mechanism. */
+export function projectClaudeSkillSurfaces(body) {
+    const shell = /!`[^`]+`/.test(body);
+    return ['cli', 'desktop-code', 'cowork', 'cloud'].map((surface) => {
+        const local = surface === 'cli' || surface === 'desktop-code';
+        const shellStatus = local ? 'native' : surface === 'cowork' ? 'degraded' : 'unsupported';
+        return {
+            provider: 'claude',
+            surface,
+            status: local ? 'native' : 'unsupported',
+            ...(shell ? { shellInterpolation: shellStatus } : {}),
+            reasons: [
+                local
+                    ? 'Reads filesystem SKILL.md bundles from .claude/skills.'
+                    : 'Does not read local .claude/skills; requires skills enabled on the claude.ai account.',
+                ...(shell ? [local
+                        ? '! shell interpolation is native; AIWG does not execute it during validation or deploy.'
+                        : surface === 'cowork'
+                            ? '! shell interpolation is degraded to a policy notice for account-enabled Cowork skills.'
+                            : '! shell interpolation from a local skill is unsupported on cloud.'] : []),
+            ],
+        };
+    });
+}
+//# sourceMappingURL=claude-surface-projection.js.map

package/dist/src/skills/deployer.js

@@ -7,296 +7,15 @@
  * @implements #1879
  */
 import fs from 'node:fs';
-import os from 'node:os';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { stringify } from 'yaml';
-import { getProviderDefinition, normalizeProviderDefinitionId, } from '../providers/provider-definitions.js';
-import { AGENT_SKILLS_SIDECAR_SCHEMA, AIWG_SKILL_CONTROL_FIELDS, createAgentSkillSidecar, projectStrictAgentSkill, } from './agent-skills.js';
+import { normalizeProviderDefinitionId } from '../providers/provider-definitions.js';
+import { AGENT_SKILLS_SIDECAR_SCHEMA } from './agent-skills.js';
 import { getImportedAgentSkill } from './importer.js';
-import { validateAgentSkillContent } from './validator.js';
-import { resolveHermesHomePath } from '../providers/hermes-home.js';
-import { museXdgSkillsDirRemediation, resolveMuseXdgSkillsDir, } from '../providers/muse-paths.js';
-import { GROKBOT_SKILLS_DIR_ENV, grokbotMissingRootRemediation, resolveGrokbotSkillsDir, } from '../providers/grokbot-paths.js';
-export const AGENT_SKILL_MANAGED_MARKER = '.aiwg-managed';
-export const AGENT_SKILL_DEPLOYMENT_SIDECAR = '.aiwg-agent-skill.json';
-const MARKER_CONTENT = 'aiwg-agent-skill-v1\n';
-const STANDARD_FIELDS = [
-    'name',
-    'description',
-    'license',
-    'compatibility',
-    'metadata',
-    'allowed-tools',
-];
-const AIWG_FIELDS = new Set(AIWG_SKILL_CONTROL_FIELDS);
-export class AgentSkillDeploymentError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.code = code;
-        this.name = 'AgentSkillDeploymentError';
-    }
-}
-function fail(code, message) {
-    throw new AgentSkillDeploymentError(code, message);
-}
-function assertPortableName(name) {
-    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name) || name.length > 64) {
-        fail('AS_DEPLOY_NAME', 'Agent Skill name must be 1-64 lowercase ASCII letters, numbers, or single hyphens');
-    }
-}
-function resolvedHome(options) {
-    return path.resolve(options.homeDir ?? os.homedir());
-}
-function resolvePolicy(target, options) {
-    const provider = normalizeProviderDefinitionId(target);
-    if (!provider) {
-        fail('AS_DEPLOY_PROVIDER', `unknown Agent Skills target "${target}"`);
-    }
-    const definition = getProviderDefinition(provider);
-    if (!definition) {
-        fail('AS_DEPLOY_PROVIDER', `provider definition is unavailable for "${provider}"`);
-    }
-    const namespace = definition.skillNamespace;
-    const reasons = [];
-    const warnings = [];
-    let root = namespace.pathType === 'home-dir'
-        ? path.join(resolvedHome(options), namespace.skillsBaseDir)
-        : path.join(path.resolve(options.projectDir), namespace.skillsBaseDir);
-    let status = 'native';
-    let supported = true;
-    let appendToDescription;
-    let maxDescriptionLength;
-    switch (provider) {
-        case 'codex':
-            root = path.join(path.resolve(options.projectDir), '.agents', 'skills');
-            status = 'projected';
-            maxDescriptionLength = namespace.maxDescriptionLength;
-            reasons.push('uses the project .agents/skills compatibility surface without the legacy 100/500 truncation transform');
-            break;
-        case 'factory':
-            status = 'projected';
-            appendToDescription = namespace.appendToDescription;
-            reasons.push('applies the Factory description guidance before strict validation');
-            break;
-        case 'grokbot': {
-            // Fail closed: never invent ~/grokbot-skills or ~/.grokbot.
-            const configured = resolveGrokbotSkillsDir(process.env);
-            if (!configured) {
-                root = '';
-                status = 'unsupported';
-                supported = false;
-                reasons.push(grokbotMissingRootRemediation(process.env));
-                warnings.push(`Agent Skills deploy for grokbot requires absolute ${GROKBOT_SKILLS_DIR_ENV}; no filesystem root was invented`);
-            }
-            else {
-                root = configured;
-                reasons.push(`uses the operator-configured ${GROKBOT_SKILLS_DIR_ENV} skills root with strict managed ownership markers`);
-            }
-            break;
-        }
-        case 'hermes':
-            if (options.homeDir === undefined) {
-                root = resolveHermesHomePath('skills');
-            }
-            reasons.push('uses the active HERMES_HOME skills surface with strict managed ownership markers');
-            break;
-        case 'muse': {
-            // ADR scope rule 1: the default projection is the project
-            // <repo>/.agents/skills surface shared with antigravity, codex, and
-            // deepseek-harness. Muse reads both that root and its XDG user root,
-            // so writing the user root by default would list a skill twice.
-            // #234: an explicit user scope resolves the documented XDG root at
-            // deploy time — never ~/.muse — and bad XDG metadata fails closed.
-            if (options.scope === 'user') {
-                const home = resolvedHome(options);
-                const configured = resolveMuseXdgSkillsDir(process.env, home);
-                if (!configured) {
-                    root = '';
-                    status = 'unsupported';
-                    supported = false;
-                    reasons.push(museXdgSkillsDirRemediation(process.env, home));
-                    warnings.push('Agent Skills deploy for muse requires a valid absolute XDG_CONFIG_HOME; no filesystem root was invented');
-                }
-                else {
-                    root = configured;
-                    reasons.push('uses the Muse XDG user skills root ($XDG_CONFIG_HOME/muse/skills, default ~/.config/muse/skills) with strict managed ownership markers');
-                }
-            }
-            else {
-                reasons.push('uses the project .agents/skills surface shared with antigravity, codex, and deepseek-harness');
-            }
-            break;
-        }
-        case 'openhuman':
-            status = 'projected';
-            reasons.push('uses the verified global one-level ~/.openhuman/skills layout');
-            break;
-        case 'windsurf':
-            status = 'projected';
-            reasons.push('uses one skill bundle directly below the one-level .windsurf/skills surface');
-            break;
-        default:
-            reasons.push('provider exposes a native recursive Agent Skills bundle surface');
-    }
-    return {
-        provider,
-        root,
-        status,
-        supported,
-        reasons,
-        warnings,
-        appendToDescription,
-        maxDescriptionLength,
-    };
-}
-function assertSafeSourceEntry(sourceRoot, absolutePath, relativePath) {
-    const stat = fs.lstatSync(absolutePath);
-    if (stat.isSymbolicLink()) {
-        fail('AS_DEPLOY_SOURCE_SYMLINK', `managed source contains a symlink: ${relativePath}`);
-    }
-    if (!stat.isDirectory() && !stat.isFile()) {
-        fail('AS_DEPLOY_SOURCE_SPECIAL_FILE', `managed source contains a non-regular entry: ${relativePath}`);
-    }
-    const real = fs.realpathSync.native(absolutePath);
-    const relativeReal = path.relative(fs.realpathSync.native(sourceRoot), real);
-    if (relativeReal.startsWith('..') || path.isAbsolute(relativeReal)) {
-        fail('AS_DEPLOY_SOURCE_ESCAPE', `managed source entry escapes its root: ${relativePath}`);
-    }
-    return stat;
-}
-function collectSourceEntries(sourceRoot) {
-    const entries = [];
-    const walk = (current, prefix) => {
-        for (const entry of fs.readdirSync(current, { withFileTypes: true })
-            .sort((left, right) => left.name.localeCompare(right.name))) {
-            const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-            if (relativePath === AGENT_SKILL_MANAGED_MARKER
-                || relativePath === AGENT_SKILL_DEPLOYMENT_SIDECAR) {
-                fail('AS_DEPLOY_RESERVED_PATH', `managed source uses reserved deployment path "${relativePath}"`);
-            }
-            const absolutePath = path.join(current, entry.name);
-            const stat = assertSafeSourceEntry(sourceRoot, absolutePath, relativePath);
-            if (stat.isDirectory()) {
-                entries.push({ kind: 'directory', relativePath });
-                walk(absolutePath, relativePath);
-            }
-            else {
-                entries.push({
-                    kind: 'file',
-                    relativePath,
-                    bytes: fs.readFileSync(absolutePath),
-                });
-            }
-        }
-    };
-    walk(sourceRoot, '');
-    return entries;
-}
-function projectionDocument(record) {
-    const sourceEntries = collectSourceEntries(record.managedLocation);
-    const skillFile = sourceEntries.find((entry) => (entry.kind === 'file' && entry.relativePath === 'SKILL.md'));
-    if (!skillFile) {
-        fail('AS_DEPLOY_SKILL_MISSING', 'managed source does not contain SKILL.md');
-    }
-    const content = new TextDecoder('utf-8', { fatal: true }).decode(skillFile.bytes);
-    const validation = validateAgentSkillContent(content, {
-        profile: record.validationProfile,
-        file: path.join(record.managedLocation, 'SKILL.md'),
-        directoryName: record.name,
-        skillRoot: record.managedLocation,
-        checkResources: true,
-    });
-    if (!validation.valid || !validation.frontmatter) {
-        fail('AS_DEPLOY_SOURCE_INVALID', `managed source for "${record.name}" no longer passes ${record.validationProfile} validation`);
-    }
-    const standard = {};
-    for (const key of STANDARD_FIELDS) {
-        const value = validation.frontmatter[key];
-        if (value !== undefined) {
-            Object.assign(standard, { [key]: structuredClone(value) });
-        }
-    }
-    const aiwg = {};
-    for (const [key, value] of Object.entries(validation.frontmatter)) {
-        if (AIWG_FIELDS.has(key)) {
-            aiwg[key] = structuredClone(value);
-        }
-    }
-    return {
-        document: {
-            standard: standard,
-            body: validation.body,
-            resources: [],
-            aiwg,
-            unknownFields: [],
-        },
-        sourceEntries,
-    };
-}
-function strictSkillBytes(record, policy, document) {
-    const metadata = projectStrictAgentSkill(document);
-    if (policy.appendToDescription) {
-        const suffix = policy.appendToDescription;
-        if (!metadata.description.endsWith(suffix)) {
-            metadata.description = `${metadata.description.trimEnd()} ${suffix}`;
-        }
-    }
-    if (policy.maxDescriptionLength !== undefined
-        && metadata.description.length > policy.maxDescriptionLength) {
-        policy.status = 'degraded';
-        policy.supported = false;
-        policy.reasons.push(`description length ${metadata.description.length} exceeds the provider limit ${policy.maxDescriptionLength}; no truncation was applied`);
-        return undefined;
-    }
-    const frontmatter = stringify(metadata, {
-        lineWidth: 0,
-        sortMapEntries: false,
-    }).trimEnd();
-    const content = `---\n${frontmatter}\n---\n${document.body}`;
-    const validation = validateAgentSkillContent(content, {
-        profile: 'strict',
-        file: 'SKILL.md',
-        directoryName: record.name,
-    });
-    if (!validation.valid) {
-        policy.status = 'degraded';
-        policy.supported = false;
-        policy.reasons.push(`provider projection failed strict validation: ${validation.diagnostics
-            .filter((item) => item.severity === 'error')
-            .map((item) => item.code)
-            .join(', ')}`);
-        return undefined;
-    }
-    return Buffer.from(content, 'utf8');
-}
-function sidecarBytes(record, policy, document) {
-    const portableSidecar = createAgentSkillSidecar(document, {
-        sourceKind: record.source.kind,
-        locator: record.source.locator,
-        ...(record.source.kind === 'git'
-            ? {
-                requestedRevision: record.source.requestedRevision,
-                resolvedRevision: record.source.resolvedRevision,
-            }
-            : {}),
-        sourceDigest: record.digest,
-        importedAt: record.importedAt,
-        aiwgVersion: record.aiwgVersion,
-    }, record.validationProfile, record.trust);
-    return Buffer.from(`${JSON.stringify({
-        schemaVersion: 1,
-        kind: 'aiwg-managed-agent-skill-projection',
-        name: record.name,
-        provider: policy.provider,
-        projectionStatus: policy.status,
-        sourceDigest: record.digest,
-        reasons: policy.reasons,
-        warnings: policy.warnings,
-        portable: portableSidecar,
-    }, null, 2)}\n`, 'utf8');
-}
+import { resolvePolicy } from './deployment-policy.js';
+import { projectionDocument, providerSkillBytes, sidecarBytes } from './deployment-projection.js';
+import { AGENT_SKILL_MANAGED_MARKER, AGENT_SKILL_DEPLOYMENT_SIDECAR, MARKER_CONTENT, assertPortableName, fail, } from './deployment-types.js';
+export { AGENT_SKILL_MANAGED_MARKER, AGENT_SKILL_DEPLOYMENT_SIDECAR, AgentSkillDeploymentError, } from './deployment-types.js';
 function readDeploymentSidecar(targetPath, expectedName, expectedProvider) {
     try {
         const sidecarPath = path.join(targetPath, AGENT_SKILL_DEPLOYMENT_SIDECAR);
@@ -356,7 +75,8 @@ function buildProjectionPlan(record, options) {
         };
     }
     const { document, sourceEntries } = projectionDocument(record);
-    const skillBytes = strictSkillBytes(record, policy, document);
+    const original = sourceEntries.find((entry) => (entry.kind === 'file' && entry.relativePath === 'SKILL.md'));
+    const skillBytes = providerSkillBytes(record, policy, document, original?.bytes);
     if (!skillBytes) {
         return {
             policy,

package/dist/src/skills/deployment-policy.js

@@ -0,0 +1,114 @@
+// Resolve existing provider skill roots and projection limits.
+import os from 'node:os';
+import path from 'node:path';
+import { getProviderDefinition, normalizeProviderDefinitionId } from '../providers/provider-definitions.js';
+import { resolveHermesHomePath } from '../providers/hermes-home.js';
+import { museXdgSkillsDirRemediation, resolveMuseXdgSkillsDir } from '../providers/muse-paths.js';
+import { GROKBOT_SKILLS_DIR_ENV, grokbotMissingRootRemediation, resolveGrokbotSkillsDir } from '../providers/grokbot-paths.js';
+import { fail } from './deployment-types.js';
+function resolvedHome(options) {
+    return path.resolve(options.homeDir ?? os.homedir());
+}
+export function resolvePolicy(target, options) {
+    const provider = normalizeProviderDefinitionId(target);
+    if (!provider) {
+        fail('AS_DEPLOY_PROVIDER', `unknown Agent Skills target "${target}"`);
+    }
+    const definition = getProviderDefinition(provider);
+    if (!definition) {
+        fail('AS_DEPLOY_PROVIDER', `provider definition is unavailable for "${provider}"`);
+    }
+    const namespace = definition.skillNamespace;
+    const reasons = [];
+    const warnings = [];
+    let root = namespace.pathType === 'home-dir'
+        ? path.join(resolvedHome(options), namespace.skillsBaseDir)
+        : path.join(path.resolve(options.projectDir), namespace.skillsBaseDir);
+    let status = 'native';
+    let supported = true;
+    let appendToDescription;
+    let maxDescriptionLength;
+    switch (provider) {
+        case 'codex':
+            root = path.join(path.resolve(options.projectDir), '.agents', 'skills');
+            status = 'projected';
+            maxDescriptionLength = namespace.maxDescriptionLength;
+            reasons.push('uses the project .agents/skills compatibility surface without the legacy 100/500 truncation transform');
+            break;
+        case 'factory':
+            status = 'projected';
+            appendToDescription = namespace.appendToDescription;
+            reasons.push('applies the Factory description guidance before strict validation');
+            break;
+        case 'grokbot': {
+            // Fail closed: never invent ~/grokbot-skills or ~/.grokbot.
+            const configured = resolveGrokbotSkillsDir(process.env);
+            if (!configured) {
+                root = '';
+                status = 'unsupported';
+                supported = false;
+                reasons.push(grokbotMissingRootRemediation(process.env));
+                warnings.push(`Agent Skills deploy for grokbot requires absolute ${GROKBOT_SKILLS_DIR_ENV}; no filesystem root was invented`);
+            }
+            else {
+                root = configured;
+                reasons.push(`uses the operator-configured ${GROKBOT_SKILLS_DIR_ENV} skills root with strict managed ownership markers`);
+            }
+            break;
+        }
+        case 'hermes':
+            if (options.homeDir === undefined) {
+                root = resolveHermesHomePath('skills');
+            }
+            reasons.push('uses the active HERMES_HOME skills surface with strict managed ownership markers');
+            break;
+        case 'muse': {
+            // ADR scope rule 1: the default projection is the project
+            // <repo>/.agents/skills surface shared with antigravity, codex, and
+            // deepseek-harness. Muse reads both that root and its XDG user root,
+            // so writing the user root by default would list a skill twice.
+            // #234: an explicit user scope resolves the documented XDG root at
+            // deploy time — never ~/.muse — and bad XDG metadata fails closed.
+            if (options.scope === 'user') {
+                const home = resolvedHome(options);
+                const configured = resolveMuseXdgSkillsDir(process.env, home);
+                if (!configured) {
+                    root = '';
+                    status = 'unsupported';
+                    supported = false;
+                    reasons.push(museXdgSkillsDirRemediation(process.env, home));
+                    warnings.push('Agent Skills deploy for muse requires a valid absolute XDG_CONFIG_HOME; no filesystem root was invented');
+                }
+                else {
+                    root = configured;
+                    reasons.push('uses the Muse XDG user skills root ($XDG_CONFIG_HOME/muse/skills, default ~/.config/muse/skills) with strict managed ownership markers');
+                }
+            }
+            else {
+                reasons.push('uses the project .agents/skills surface shared with antigravity, codex, and deepseek-harness');
+            }
+            break;
+        }
+        case 'openhuman':
+            status = 'projected';
+            reasons.push('uses the verified global one-level ~/.openhuman/skills layout');
+            break;
+        case 'windsurf':
+            status = 'projected';
+            reasons.push('uses one skill bundle directly below the one-level .windsurf/skills surface');
+            break;
+        default:
+            reasons.push('provider exposes a native recursive Agent Skills bundle surface');
+    }
+    return {
+        provider,
+        root,
+        status,
+        supported,
+        reasons,
+        warnings,
+        appendToDescription,
+        maxDescriptionLength,
+    };
+}
+//# sourceMappingURL=deployment-policy.js.map

package/dist/src/skills/deployment-projection.js

@@ -0,0 +1,152 @@
+// Project immutable managed sources into provider frontmatter and sidecars.
+import fs from 'node:fs';
+import path from 'node:path';
+import { stringify } from 'yaml';
+import { createAgentSkillSidecar, projectStrictAgentSkill } from './agent-skills.js';
+import { agentSkillDocument, claudeSkillExtensions } from './provider-extensions.js';
+import { validateAgentSkillContent } from './validator.js';
+import { AGENT_SKILL_MANAGED_MARKER, AGENT_SKILL_DEPLOYMENT_SIDECAR, fail, } from './deployment-types.js';
+function assertSafeSourceEntry(sourceRoot, absolutePath, relativePath) {
+    const stat = fs.lstatSync(absolutePath);
+    if (stat.isSymbolicLink()) {
+        fail('AS_DEPLOY_SOURCE_SYMLINK', `managed source contains a symlink: ${relativePath}`);
+    }
+    if (!stat.isDirectory() && !stat.isFile()) {
+        fail('AS_DEPLOY_SOURCE_SPECIAL_FILE', `managed source contains a non-regular entry: ${relativePath}`);
+    }
+    const real = fs.realpathSync.native(absolutePath);
+    const relativeReal = path.relative(fs.realpathSync.native(sourceRoot), real);
+    if (relativeReal.startsWith('..') || path.isAbsolute(relativeReal)) {
+        fail('AS_DEPLOY_SOURCE_ESCAPE', `managed source entry escapes its root: ${relativePath}`);
+    }
+    return stat;
+}
+function collectSourceEntries(sourceRoot) {
+    const entries = [];
+    const walk = (current, prefix) => {
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })
+            .sort((left, right) => left.name.localeCompare(right.name))) {
+            const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (relativePath === AGENT_SKILL_MANAGED_MARKER
+                || relativePath === AGENT_SKILL_DEPLOYMENT_SIDECAR) {
+                fail('AS_DEPLOY_RESERVED_PATH', `managed source uses reserved deployment path "${relativePath}"`);
+            }
+            const absolutePath = path.join(current, entry.name);
+            const stat = assertSafeSourceEntry(sourceRoot, absolutePath, relativePath);
+            if (stat.isDirectory()) {
+                entries.push({ kind: 'directory', relativePath });
+                walk(absolutePath, relativePath);
+            }
+            else {
+                entries.push({
+                    kind: 'file',
+                    relativePath,
+                    bytes: fs.readFileSync(absolutePath),
+                });
+            }
+        }
+    };
+    walk(sourceRoot, '');
+    return entries;
+}
+export function projectionDocument(record) {
+    const sourceEntries = collectSourceEntries(record.managedLocation);
+    const skillFile = sourceEntries.find((entry) => (entry.kind === 'file' && entry.relativePath === 'SKILL.md'));
+    if (!skillFile) {
+        fail('AS_DEPLOY_SKILL_MISSING', 'managed source does not contain SKILL.md');
+    }
+    const content = new TextDecoder('utf-8', { fatal: true }).decode(skillFile.bytes);
+    const validation = validateAgentSkillContent(content, {
+        profile: record.validationProfile,
+        file: path.join(record.managedLocation, 'SKILL.md'),
+        directoryName: record.name,
+        skillRoot: record.managedLocation,
+        checkResources: true,
+    });
+    if (!validation.valid || !validation.frontmatter) {
+        fail('AS_DEPLOY_SOURCE_INVALID', `managed source for "${record.name}" no longer passes ${record.validationProfile} validation`);
+    }
+    return {
+        document: agentSkillDocument(validation.frontmatter, validation.body),
+        sourceEntries,
+    };
+}
+export function providerSkillBytes(record, policy, document, originalBytes) {
+    const metadata = { ...projectStrictAgentSkill(document) };
+    const extensions = claudeSkillExtensions(document);
+    if (policy.provider === 'claude') {
+        Object.assign(metadata, extensions);
+    }
+    else {
+        for (const field of Object.keys(extensions).sort()) {
+            const warning = `Claude skill field "${field}" is dropped for provider "${policy.provider}"; retained in providers.claude sidecar only`;
+            policy.warnings.push(warning);
+            policy.reasons.push(warning);
+            policy.status = 'degraded';
+        }
+    }
+    if (policy.appendToDescription) {
+        const suffix = policy.appendToDescription;
+        if (!metadata.description.endsWith(suffix)) {
+            metadata.description = `${metadata.description.trimEnd()} ${suffix}`;
+        }
+    }
+    if (policy.maxDescriptionLength !== undefined
+        && metadata.description.length > policy.maxDescriptionLength) {
+        policy.status = 'degraded';
+        policy.supported = false;
+        policy.reasons.push(`description length ${metadata.description.length} exceeds the provider limit ${policy.maxDescriptionLength}; no truncation was applied`);
+        return undefined;
+    }
+    const frontmatter = stringify(metadata, {
+        lineWidth: 0,
+        sortMapEntries: false,
+    }).trimEnd();
+    const content = `---\n${frontmatter}\n---\n${document.body}`;
+    const validation = validateAgentSkillContent(content, {
+        profile: policy.provider === 'claude' ? 'compatible' : 'strict',
+        file: 'SKILL.md',
+        directoryName: record.name,
+    });
+    if (!validation.valid) {
+        policy.status = 'degraded';
+        policy.supported = false;
+        policy.reasons.push(`provider projection failed validation: ${validation.diagnostics
+            .filter((item) => item.severity === 'error')
+            .map((item) => item.code)
+            .join(', ')}`);
+        return undefined;
+    }
+    if (policy.provider === 'claude' && originalBytes
+        && document.unknownFields.length === 0
+        && Object.keys(document.aiwg).every((key) => Object.hasOwn(extensions, key)))
+        return Buffer.from(originalBytes);
+    return Buffer.from(content, 'utf8');
+}
+export function sidecarBytes(record, policy, document) {
+    const portableSidecar = createAgentSkillSidecar(document, {
+        sourceKind: record.source.kind,
+        locator: record.source.locator,
+        ...(record.source.kind === 'git'
+            ? {
+                requestedRevision: record.source.requestedRevision,
+                resolvedRevision: record.source.resolvedRevision,
+            }
+            : {}),
+        sourceDigest: record.digest,
+        importedAt: record.importedAt,
+        aiwgVersion: record.aiwgVersion,
+    }, record.validationProfile, record.trust);
+    return Buffer.from(`${JSON.stringify({
+        schemaVersion: 1,
+        kind: 'aiwg-managed-agent-skill-projection',
+        name: record.name,
+        provider: policy.provider,
+        projectionStatus: policy.status,
+        sourceDigest: record.digest,
+        reasons: policy.reasons,
+        warnings: policy.warnings,
+        portable: portableSidecar,
+    }, null, 2)}\n`, 'utf8');
+}
+//# sourceMappingURL=deployment-projection.js.map

package/dist/src/skills/deployment-types.js

@@ -0,0 +1,20 @@
+export const AGENT_SKILL_MANAGED_MARKER = '.aiwg-managed';
+export const AGENT_SKILL_DEPLOYMENT_SIDECAR = '.aiwg-agent-skill.json';
+export const MARKER_CONTENT = 'aiwg-agent-skill-v1\n';
+export class AgentSkillDeploymentError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'AgentSkillDeploymentError';
+    }
+}
+export function fail(code, message) {
+    throw new AgentSkillDeploymentError(code, message);
+}
+export function assertPortableName(name) {
+    if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name) || name.length > 64) {
+        fail('AS_DEPLOY_NAME', 'Agent Skill name must be 1-64 lowercase ASCII letters, numbers, or single hyphens');
+    }
+}
+//# sourceMappingURL=deployment-types.js.map