@taskforcehq/taskforce 0.3.326 → 0.3.327

package/dist/shared/taskforceAgentModels.js

@@ -0,0 +1,314 @@
+export const TASKFORCE_AGENT_PLATFORM = 'taskforce_hq';
+export const DEFAULT_TASKFORCE_AGENT_PROVIDER_KEY = 'anthropic';
+export const DEFAULT_TASKFORCE_AGENT_MODEL_KEY = 'anthropic.claude-sonnet-4-6';
+export const TASKFORCE_AGENT_MODEL_SOURCES = [
+    'taskforce_managed',
+    'bedrock',
+    'workspace_byom',
+    'personal_byom',
+    'subscription_dev',
+];
+export const TASKFORCE_AGENT_PROVIDER_OPTIONS = [
+    { key: 'anthropic', label: 'Anthropic' },
+    { key: 'openai', label: 'OpenAI' },
+    { key: 'google', label: 'Google' },
+    { key: 'xai', label: 'xAI' },
+    { key: 'deepseek', label: 'DeepSeek' },
+    { key: 'meta', label: 'Meta' },
+    { key: 'mistral', label: 'Mistral AI' },
+    { key: 'amazon', label: 'Amazon' },
+];
+export const TASKFORCE_AGENT_MODEL_OPTIONS = [
+    {
+        key: DEFAULT_TASKFORCE_AGENT_MODEL_KEY,
+        providerKey: 'anthropic',
+        label: 'Claude Sonnet 4.6',
+        source: 'bedrock',
+        runtime: 'bedrock-runtime',
+        defaultTier: 'balanced',
+        runtimeModelId: 'us.anthropic.claude-sonnet-4-6',
+        availability: 'verified',
+        visible: true,
+        supportsTemperature: true,
+        defaultMaxTokens: 512,
+    },
+    {
+        key: 'anthropic.claude-haiku-4-5',
+        providerKey: 'anthropic',
+        label: 'Claude Haiku 4.5',
+        source: 'bedrock',
+        runtime: 'bedrock-runtime',
+        defaultTier: 'fast',
+        runtimeModelId: 'us.anthropic.claude-haiku-4-5-20251001-v1:0',
+        availability: 'configured',
+        visible: true,
+        supportsTemperature: true,
+        defaultMaxTokens: 512,
+    },
+    {
+        key: 'anthropic.claude-sonnet-5',
+        providerKey: 'anthropic',
+        label: 'Claude Sonnet 5',
+        source: 'bedrock',
+        runtime: 'bedrock-anthropic-messages',
+        defaultTier: 'balanced',
+        runtimeModelId: 'anthropic.claude-sonnet-5',
+        availability: 'account_unavailable',
+        visible: false,
+        supportsTemperature: false,
+        defaultMaxTokens: 1024,
+    },
+    {
+        key: 'anthropic.claude-fable-5',
+        providerKey: 'anthropic',
+        label: 'Claude Fable 5',
+        source: 'bedrock',
+        runtime: 'bedrock-anthropic-messages',
+        defaultTier: 'advanced',
+        runtimeModelId: 'anthropic.claude-fable-5',
+        availability: 'account_unavailable',
+        visible: false,
+        supportsTemperature: false,
+        defaultMaxTokens: 1024,
+    },
+    {
+        key: 'anthropic.claude-opus-4-8',
+        providerKey: 'anthropic',
+        label: 'Claude Opus 4.8',
+        source: 'bedrock',
+        runtime: 'bedrock-anthropic-messages',
+        defaultTier: 'advanced',
+        runtimeModelId: 'anthropic.claude-opus-4-8',
+        availability: 'account_unavailable',
+        visible: false,
+        supportsTemperature: false,
+        defaultMaxTokens: 1024,
+    },
+    {
+        key: 'amazon.nova-lite',
+        providerKey: 'amazon',
+        label: 'Nova Lite',
+        source: 'bedrock',
+        runtime: 'bedrock-runtime',
+        defaultTier: 'fast',
+        runtimeModelId: 'us.amazon.nova-lite-v1:0',
+        availability: 'configured',
+        visible: true,
+        supportsTemperature: true,
+        defaultMaxTokens: 512,
+    },
+    {
+        key: 'amazon.nova-2-lite',
+        providerKey: 'amazon',
+        label: 'Nova 2 Lite',
+        source: 'bedrock',
+        runtime: 'bedrock-runtime',
+        defaultTier: 'fast',
+        runtimeModelId: 'us.amazon.nova-2-lite-v1:0',
+        availability: 'verified',
+        visible: true,
+        supportsTemperature: true,
+        defaultMaxTokens: 512,
+    },
+    {
+        key: 'amazon.nova-pro',
+        providerKey: 'amazon',
+        label: 'Nova Pro',
+        source: 'bedrock',
+        runtime: 'bedrock-runtime',
+        defaultTier: 'balanced',
+        runtimeModelId: 'us.amazon.nova-pro-v1:0',
+        availability: 'configured',
+        visible: true,
+        supportsTemperature: true,
+        defaultMaxTokens: 512,
+    },
+    {
+        key: 'deepseek.v3-2',
+        providerKey: 'deepseek',
+        label: 'DeepSeek V3.2',
+        source: 'bedrock',
+        runtime: 'bedrock-runtime',
+        defaultTier: 'balanced',
+        runtimeModelId: 'deepseek.v3.2',
+        availability: 'configured',
+        visible: true,
+        supportsTemperature: true,
+        defaultMaxTokens: 512,
+    },
+    {
+        key: 'google.gemma-3-12b-it',
+        providerKey: 'google',
+        label: 'Gemma 3 12B IT',
+        source: 'bedrock',
+        runtime: 'bedrock-runtime',
+        defaultTier: 'fast',
+        runtimeModelId: 'google.gemma-3-12b-it',
+        availability: 'configured',
+        visible: true,
+        supportsTemperature: true,
+        defaultMaxTokens: 512,
+    },
+    {
+        key: 'meta.llama-3-3-70b-instruct',
+        providerKey: 'meta',
+        label: 'Llama 3.3 70B Instruct',
+        source: 'bedrock',
+        runtime: 'bedrock-runtime',
+        defaultTier: 'balanced',
+        runtimeModelId: 'us.meta.llama3-3-70b-instruct-v1:0',
+        availability: 'configured',
+        visible: true,
+        supportsTemperature: true,
+        defaultMaxTokens: 512,
+    },
+    {
+        key: 'meta.llama-4-scout-17b-instruct',
+        providerKey: 'meta',
+        label: 'Llama 4 Scout 17B Instruct',
+        source: 'bedrock',
+        runtime: 'bedrock-runtime',
+        defaultTier: 'balanced',
+        runtimeModelId: 'us.meta.llama4-scout-17b-instruct-v1:0',
+        availability: 'verified',
+        visible: true,
+        supportsTemperature: true,
+        defaultMaxTokens: 512,
+    },
+    {
+        key: 'mistral.large-3',
+        providerKey: 'mistral',
+        label: 'Mistral Large 3',
+        source: 'bedrock',
+        runtime: 'bedrock-runtime',
+        defaultTier: 'balanced',
+        runtimeModelId: 'mistral.mistral-large-3-675b-instruct',
+        availability: 'configured',
+        visible: true,
+        supportsTemperature: true,
+        defaultMaxTokens: 512,
+    },
+    {
+        key: 'xai.grok-4-3',
+        providerKey: 'xai',
+        label: 'Grok 4.3',
+        source: 'bedrock',
+        runtime: 'bedrock-mantle',
+        defaultTier: 'advanced',
+        runtimeModelId: 'xai.grok-4.3',
+        availability: 'verified',
+        visible: true,
+        supportsTemperature: false,
+        defaultMaxTokens: 1024,
+    },
+    {
+        key: 'openai.gpt-oss-120b',
+        providerKey: 'openai',
+        label: 'gpt-oss-120b',
+        source: 'bedrock',
+        runtime: 'bedrock-runtime',
+        defaultTier: 'balanced',
+        runtimeModelId: 'openai.gpt-oss-120b-1:0',
+        availability: 'verified',
+        visible: true,
+        supportsTemperature: true,
+        defaultMaxTokens: 512,
+    },
+    {
+        key: 'openai.gpt-5-4',
+        providerKey: 'openai',
+        label: 'GPT-5.4',
+        source: 'bedrock',
+        runtime: 'bedrock-mantle',
+        defaultTier: 'advanced',
+        runtimeModelId: 'openai.gpt-5.4',
+        availability: 'account_unavailable',
+        visible: false,
+        supportsTemperature: false,
+        defaultMaxTokens: 1024,
+    },
+];
+export function isTaskforceAgentModelVisible(model) {
+    return model.visible && model.availability !== 'account_unavailable';
+}
+export function getTaskforceAgentModel(modelKey) {
+    const key = String(modelKey || '').trim();
+    return TASKFORCE_AGENT_MODEL_OPTIONS.find((model) => model.key === key) || null;
+}
+export function normalizeTaskforceAgentModelSource(value, fallback = 'bedrock') {
+    const source = String(value || '').trim();
+    if (isTaskforceAgentModelSource(source))
+        return source;
+    return fallback;
+}
+export function isTaskforceAgentModelSource(value) {
+    return TASKFORCE_AGENT_MODEL_SOURCES.includes(value);
+}
+export function normalizeTaskforceAgentConnectionScope(value) {
+    const scope = String(value || '').trim();
+    if (scope === 'taskforce'
+        || scope === 'workspace'
+        || scope === 'personal'
+        || scope === 'local_dev') {
+        return scope;
+    }
+    return undefined;
+}
+export function normalizeTaskforceAgentProviderKey(value) {
+    const key = String(value || '').trim().toLowerCase();
+    return TASKFORCE_AGENT_PROVIDER_OPTIONS.some((provider) => provider.key === key)
+        ? key
+        : DEFAULT_TASKFORCE_AGENT_PROVIDER_KEY;
+}
+export function modelsForTaskforceAgentProvider(providerKey) {
+    const normalizedProviderKey = normalizeTaskforceAgentProviderKey(providerKey);
+    return TASKFORCE_AGENT_MODEL_OPTIONS.filter((model) => (model.providerKey === normalizedProviderKey
+        && isTaskforceAgentModelAvailable(model)));
+}
+export function normalizeTaskforceAgentModelKey(value, providerKey) {
+    const key = String(value || '').trim();
+    const providerModels = modelsForTaskforceAgentProvider(providerKey ?? DEFAULT_TASKFORCE_AGENT_PROVIDER_KEY);
+    if (providerModels.some((model) => model.key === key))
+        return key;
+    return providerModels[0]?.key || '';
+}
+export function normalizeTaskforceAgentModelSelection(input) {
+    const providerKey = normalizeTaskforceAgentProviderKey(input.providerKey);
+    const modelKey = normalizeTaskforceAgentModelKey(input.modelKey, providerKey);
+    const model = getTaskforceAgentModel(modelKey);
+    if (!model)
+        return null;
+    if (input.modelSource !== undefined
+        && input.modelSource !== null
+        && !isTaskforceAgentModelSource(input.modelSource)) {
+        return null;
+    }
+    const modelSource = normalizeTaskforceAgentModelSource(input.modelSource, model.source);
+    if (modelSource !== model.source)
+        return null;
+    const connectionScope = normalizeTaskforceAgentConnectionScope(input.connectionScope);
+    if (input.connectionScope !== undefined
+        && input.connectionScope !== null
+        && !connectionScope) {
+        return null;
+    }
+    const connectionId = String(input.connectionId || '').trim();
+    return {
+        providerKey: model.providerKey,
+        modelKey: model.key,
+        modelSource,
+        ...(connectionScope ? { connectionScope } : {}),
+        ...(connectionId ? { connectionId } : {}),
+    };
+}
+export function isTaskforceAgentModelAvailable(model) {
+    return isTaskforceAgentModelVisible(model);
+}
+export function labelForTaskforceAgentProvider(providerKey) {
+    const normalizedProviderKey = normalizeTaskforceAgentProviderKey(providerKey);
+    return TASKFORCE_AGENT_PROVIDER_OPTIONS.find((provider) => provider.key === normalizedProviderKey)?.label || 'Anthropic';
+}
+export function labelForTaskforceAgentModel(modelKey) {
+    const key = String(modelKey || '').trim();
+    return TASKFORCE_AGENT_MODEL_OPTIONS.find((model) => model.key === key)?.label || key || 'No configured model';
+}

package/dist/shared/taskforceAgentRunContext.d.ts

@@ -0,0 +1,23 @@
+export type TaskforceAgentRunSource = 'agent-manager-test' | 'task-chat' | 'scheduled-trigger' | 'code-work';
+export interface TaskforceAgentRunContext {
+    source: TaskforceAgentRunSource;
+    workspaceId: string;
+    agentId: string | null;
+    conversationId: string | null;
+    taskId: string | null;
+    actorUserId: string | null;
+    mcp: {
+        connection: 'taskforce-managed';
+        toolProfile: 'managed-agent-default';
+        access: 'allowlisted';
+    };
+}
+export interface BuildTaskforceAgentRunContextInput {
+    source: TaskforceAgentRunSource;
+    workspaceId?: string | null;
+    agentId?: string | null;
+    conversationId?: string | null;
+    taskId?: string | null;
+    actorUserId?: string | null;
+}
+export declare function buildTaskforceAgentRunContext(input: BuildTaskforceAgentRunContextInput): TaskforceAgentRunContext;

package/dist/shared/taskforceAgentRunContext.js

@@ -0,0 +1,21 @@
+function normalizeId(value, maxLength = 160) {
+    const normalized = String(value || '').trim();
+    if (!normalized)
+        return null;
+    return normalized.length > maxLength ? normalized.slice(0, maxLength) : normalized;
+}
+export function buildTaskforceAgentRunContext(input) {
+    return {
+        source: input.source,
+        workspaceId: normalizeId(input.workspaceId, 160) || 'default',
+        agentId: normalizeId(input.agentId, 160),
+        conversationId: normalizeId(input.conversationId, 160),
+        taskId: normalizeId(input.taskId, 120),
+        actorUserId: normalizeId(input.actorUserId, 160),
+        mcp: {
+            connection: 'taskforce-managed',
+            toolProfile: 'managed-agent-default',
+            access: 'allowlisted',
+        },
+    };
+}

package/dist/shared/taskforceAgentRuntimeResolution.d.ts

@@ -0,0 +1,31 @@
+import { type AgentDefinitionV1, type AgentPromptProjection, type BehaviorReference, type CurrentPolicyReference } from './taskforceAgentDefinition.js';
+export interface ResolvedAgentConfigurationReference {
+    id: string;
+    revision?: number | string;
+    release?: string;
+    contentHash: string;
+    promptContent?: string;
+}
+export interface TaskforceAgentRuntimeReferenceResolvers {
+    resolveBehaviorReference?: (kind: 'role' | 'skill', reference: BehaviorReference) => ResolvedAgentConfigurationReference | null;
+    resolveMemoryPolicy?: (reference: CurrentPolicyReference) => ResolvedAgentConfigurationReference | null;
+}
+export interface ExecutableTaskforceAgentInput {
+    lifecycleStatus: string;
+    configurationState: string;
+    definition: AgentDefinitionV1 | null;
+}
+export interface ResolvedTaskforceAgentRuntimeConfiguration {
+    definition: AgentDefinitionV1;
+    promptProjection: AgentPromptProjection;
+    role: ResolvedAgentConfigurationReference | null;
+    skills: ResolvedAgentConfigurationReference[];
+    memoryPolicy: ResolvedAgentConfigurationReference | null;
+}
+export declare class TaskforceAgentRuntimeResolutionError extends Error {
+    readonly code: 'TASKFORCE_AGENT_NOT_ACTIVE' | 'TASKFORCE_AGENT_CONFIGURATION_UNAVAILABLE' | 'TASKFORCE_AGENT_REFERENCE_UNRESOLVED' | 'TASKFORCE_AGENT_GOVERNANCE_POLICY_UNRESOLVED';
+    readonly statusCode = 409;
+    constructor(message: string, code: 'TASKFORCE_AGENT_NOT_ACTIVE' | 'TASKFORCE_AGENT_CONFIGURATION_UNAVAILABLE' | 'TASKFORCE_AGENT_REFERENCE_UNRESOLVED' | 'TASKFORCE_AGENT_GOVERNANCE_POLICY_UNRESOLVED');
+}
+export declare function resolveTaskforceAgentRuntimeConfiguration(agent: ExecutableTaskforceAgentInput, resolvers?: TaskforceAgentRuntimeReferenceResolvers): ResolvedTaskforceAgentRuntimeConfiguration;
+export declare function buildResolvedTaskforceAgentSystemPrompt(resolved: ResolvedTaskforceAgentRuntimeConfiguration): string;

package/dist/shared/taskforceAgentRuntimeResolution.js

@@ -0,0 +1,72 @@
+import { projectAgentDefinitionForPrompt, } from './taskforceAgentDefinition.js';
+export class TaskforceAgentRuntimeResolutionError extends Error {
+    code;
+    statusCode = 409;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'TaskforceAgentRuntimeResolutionError';
+    }
+}
+export function resolveTaskforceAgentRuntimeConfiguration(agent, resolvers = {}) {
+    if (agent.lifecycleStatus !== 'active') {
+        throw new TaskforceAgentRuntimeResolutionError('This Taskforce Agent is not active.', 'TASKFORCE_AGENT_NOT_ACTIVE');
+    }
+    if (agent.configurationState !== 'valid' || !agent.definition) {
+        throw new TaskforceAgentRuntimeResolutionError('This Taskforce Agent configuration must be repaired before it can run.', 'TASKFORCE_AGENT_CONFIGURATION_UNAVAILABLE');
+    }
+    const definition = agent.definition;
+    const resolveBehavior = (kind, reference) => {
+        const resolved = resolvers.resolveBehaviorReference?.(kind, reference) || null;
+        if (!resolved) {
+            throw new TaskforceAgentRuntimeResolutionError(`Taskforce Agent ${kind} reference ${reference.id} could not be resolved.`, 'TASKFORCE_AGENT_REFERENCE_UNRESOLVED');
+        }
+        return resolved;
+    };
+    const role = definition.roleRef
+        ? resolveBehavior('role', definition.roleRef)
+        : null;
+    const skills = definition.skillRefs.map((reference) => (resolveBehavior('skill', reference)));
+    const memoryPolicy = definition.memoryPolicyRef
+        ? resolvers.resolveMemoryPolicy?.(definition.memoryPolicyRef) || null
+        : null;
+    if (definition.memoryPolicyRef && !memoryPolicy) {
+        throw new TaskforceAgentRuntimeResolutionError(`Taskforce Agent memory policy ${definition.memoryPolicyRef.id} could not be resolved.`, 'TASKFORCE_AGENT_GOVERNANCE_POLICY_UNRESOLVED');
+    }
+    return {
+        definition,
+        promptProjection: projectAgentDefinitionForPrompt(definition),
+        role,
+        skills,
+        memoryPolicy,
+    };
+}
+function descriptiveText(value) {
+    return [
+        value?.presetKey ? `Preset: ${value.presetKey}.` : '',
+        value?.customDescription || '',
+    ].filter(Boolean).join(' ');
+}
+export function buildResolvedTaskforceAgentSystemPrompt(resolved) {
+    const projection = resolved.promptProjection;
+    const personality = descriptiveText(projection.behavior.personality);
+    const responseStyle = descriptiveText(projection.behavior.responseStyle);
+    const resolvedCapabilityContent = [
+        resolved.role?.promptContent
+            ? `Primary role:\n${resolved.role.promptContent}`
+            : '',
+        ...resolved.skills
+            .filter((skill) => Boolean(skill.promptContent))
+            .map((skill) => `Skill ${skill.id}:\n${skill.promptContent}`),
+    ].filter(Boolean);
+    return [
+        ...resolvedCapabilityContent,
+        `You are ${projection.name}, a Taskforce Agent.`,
+        `Purpose:\n${projection.purpose}`,
+        personality ? `Personality:\n${personality}` : '',
+        responseStyle ? `Response style:\n${responseStyle}` : '',
+        projection.behavior.workingGuidelines
+            ? `Working guidelines:\n${projection.behavior.workingGuidelines}`
+            : '',
+    ].filter(Boolean).join('\n\n');
+}

package/dist/shared/taskforceAgentSkill.d.ts

@@ -0,0 +1,33 @@
+export declare const TASKFORCE_AGENT_SKILL_SCHEMA_VERSION: 1;
+export declare const TASKFORCE_AGENT_SKILL_PROMPT_MAX_CHARS = 20000;
+export interface TaskforceAgentSkillDefinitionV1 {
+    schemaVersion: typeof TASKFORCE_AGENT_SKILL_SCHEMA_VERSION;
+    name: string;
+    shortDescription: string;
+    purpose: string;
+    instructions: string;
+    expectedInputs: string[];
+    expectedOutputs: string[];
+    qualityChecks: string[];
+    exampleUseCases: string[];
+    recommendedCapabilityGroups: string[];
+}
+export interface TaskforceAgentSkillValidationIssue {
+    code: string;
+    path: string;
+    message: string;
+}
+export interface TaskforceAgentSkillInspection {
+    definition: TaskforceAgentSkillDefinitionV1 | null;
+    issues: TaskforceAgentSkillValidationIssue[];
+}
+export declare function compileTaskforceAgentSkillPrompt(definition: TaskforceAgentSkillDefinitionV1): string;
+export declare function inspectTaskforceAgentSkillDefinition(value: unknown): TaskforceAgentSkillInspection;
+export declare class TaskforceAgentSkillValidationError extends Error {
+    readonly issues: TaskforceAgentSkillValidationIssue[];
+    readonly statusCode = 400;
+    readonly code = "TASKFORCE_AGENT_SKILL_INVALID";
+    constructor(issues: TaskforceAgentSkillValidationIssue[]);
+}
+export declare function requireValidTaskforceAgentSkillDefinition(value: unknown): TaskforceAgentSkillDefinitionV1;
+export declare function serializeCanonicalTaskforceAgentSkillDefinition(definition: TaskforceAgentSkillDefinitionV1): string;

package/dist/shared/taskforceAgentSkill.js

@@ -0,0 +1,149 @@
+import { serializeCanonicalJson } from './taskforceAgentDefinition.js';
+export const TASKFORCE_AGENT_SKILL_SCHEMA_VERSION = 1;
+export const TASKFORCE_AGENT_SKILL_PROMPT_MAX_CHARS = 20_000;
+const LIMITS = {
+    name: 80,
+    shortDescription: 280,
+    purpose: 1_000,
+    instructions: 12_000,
+    listItems: 20,
+    listItem: 1_000,
+    capabilityGroup: 160,
+};
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function addIssue(issues, code, path, message) {
+    issues.push({ code, path, message });
+}
+function requiredString(value, path, maxLength, issues) {
+    if (typeof value !== 'string') {
+        addIssue(issues, 'required_string', path, 'A string value is required.');
+        return '';
+    }
+    const normalized = value.trim();
+    if (!normalized) {
+        addIssue(issues, 'required_string', path, 'A non-empty value is required.');
+    }
+    else if (normalized.length > maxLength) {
+        addIssue(issues, 'string_too_long', path, `Must be ${maxLength} characters or less.`);
+    }
+    return normalized;
+}
+function stringList(value, path, maxItemLength, issues) {
+    if (!Array.isArray(value)) {
+        addIssue(issues, 'required_array', path, 'An array of strings is required.');
+        return [];
+    }
+    if (value.length > LIMITS.listItems) {
+        addIssue(issues, 'too_many_items', path, `Must contain ${LIMITS.listItems} items or fewer.`);
+    }
+    const seen = new Set();
+    const result = [];
+    value.slice(0, LIMITS.listItems).forEach((item, index) => {
+        if (typeof item !== 'string') {
+            addIssue(issues, 'invalid_list_item', `${path}.${index}`, 'Must be a string.');
+            return;
+        }
+        const normalized = item.trim();
+        if (!normalized) {
+            addIssue(issues, 'empty_list_item', `${path}.${index}`, 'Must not be empty.');
+            return;
+        }
+        if (normalized.length > maxItemLength) {
+            addIssue(issues, 'string_too_long', `${path}.${index}`, `Must be ${maxItemLength} characters or less.`);
+        }
+        const duplicateKey = normalized.toLocaleLowerCase();
+        if (seen.has(duplicateKey)) {
+            addIssue(issues, 'duplicate_list_item', `${path}.${index}`, 'Duplicate items are not allowed.');
+            return;
+        }
+        seen.add(duplicateKey);
+        result.push(normalized);
+    });
+    return result;
+}
+export function compileTaskforceAgentSkillPrompt(definition) {
+    const sections = [
+        ['Instructions', definition.instructions],
+        ['Expected inputs', definition.expectedInputs.map((item, index) => `${index + 1}. ${item}`).join('\n')],
+        ['Expected outputs', definition.expectedOutputs.map((item, index) => `${index + 1}. ${item}`).join('\n')],
+        ['Quality checks', definition.qualityChecks.map((item, index) => `${index + 1}. ${item}`).join('\n')],
+    ];
+    return sections
+        .filter(([, content]) => Boolean(content))
+        .map(([heading, content]) => `${heading}:\n${content}`)
+        .join('\n\n');
+}
+export function inspectTaskforceAgentSkillDefinition(value) {
+    const issues = [];
+    if (!isPlainObject(value)) {
+        return {
+            definition: null,
+            issues: [{
+                    code: 'invalid_definition',
+                    path: 'definition',
+                    message: 'Skill definition must be an object.',
+                }],
+        };
+    }
+    const allowedKeys = new Set([
+        'schemaVersion',
+        'name',
+        'shortDescription',
+        'purpose',
+        'instructions',
+        'expectedInputs',
+        'expectedOutputs',
+        'qualityChecks',
+        'exampleUseCases',
+        'recommendedCapabilityGroups',
+    ]);
+    Object.keys(value).forEach((key) => {
+        if (!allowedKeys.has(key)) {
+            addIssue(issues, 'unknown_field', key, 'This field is not part of Agent Skill v1.');
+        }
+    });
+    if (value.schemaVersion !== TASKFORCE_AGENT_SKILL_SCHEMA_VERSION) {
+        addIssue(issues, 'unsupported_schema_version', 'schemaVersion', `schemaVersion must be ${TASKFORCE_AGENT_SKILL_SCHEMA_VERSION}.`);
+    }
+    const definition = {
+        schemaVersion: TASKFORCE_AGENT_SKILL_SCHEMA_VERSION,
+        name: requiredString(value.name, 'name', LIMITS.name, issues),
+        shortDescription: requiredString(value.shortDescription, 'shortDescription', LIMITS.shortDescription, issues),
+        purpose: requiredString(value.purpose, 'purpose', LIMITS.purpose, issues),
+        instructions: requiredString(value.instructions, 'instructions', LIMITS.instructions, issues),
+        expectedInputs: stringList(value.expectedInputs, 'expectedInputs', LIMITS.listItem, issues),
+        expectedOutputs: stringList(value.expectedOutputs, 'expectedOutputs', LIMITS.listItem, issues),
+        qualityChecks: stringList(value.qualityChecks, 'qualityChecks', LIMITS.listItem, issues),
+        exampleUseCases: stringList(value.exampleUseCases, 'exampleUseCases', LIMITS.listItem, issues),
+        recommendedCapabilityGroups: stringList(value.recommendedCapabilityGroups, 'recommendedCapabilityGroups', LIMITS.capabilityGroup, issues),
+    };
+    if (compileTaskforceAgentSkillPrompt(definition).length > TASKFORCE_AGENT_SKILL_PROMPT_MAX_CHARS) {
+        addIssue(issues, 'compiled_prompt_too_long', 'instructions', `Compiled runtime content must be ${TASKFORCE_AGENT_SKILL_PROMPT_MAX_CHARS} characters or less.`);
+    }
+    return {
+        definition: issues.length === 0 ? definition : null,
+        issues,
+    };
+}
+export class TaskforceAgentSkillValidationError extends Error {
+    issues;
+    statusCode = 400;
+    code = 'TASKFORCE_AGENT_SKILL_INVALID';
+    constructor(issues) {
+        super(issues[0]?.message || 'Skill definition is invalid.');
+        this.issues = issues;
+        this.name = 'TaskforceAgentSkillValidationError';
+    }
+}
+export function requireValidTaskforceAgentSkillDefinition(value) {
+    const inspected = inspectTaskforceAgentSkillDefinition(value);
+    if (!inspected.definition) {
+        throw new TaskforceAgentSkillValidationError(inspected.issues);
+    }
+    return inspected.definition;
+}
+export function serializeCanonicalTaskforceAgentSkillDefinition(definition) {
+    return serializeCanonicalJson(definition);
+}