vgxness 1.20.4 → 1.20.6

package/dist/interfaces/cli/commands/agent-skill-dispatcher.js

@@ -0,0 +1,700 @@
+import { AgentRegistryService } from '../../../agents/agent-registry-service.js';
+import { AgentSeedService } from '../../../agents/agent-seed-service.js';
+import { ManagerProfileOverlayService } from '../../../agents/manager-profile-overlay-service.js';
+import { getProviderRenderer } from '../../../agents/renderers/index.js';
+import { ManagerProfileOverlayRepository } from '../../../agents/repositories/manager-profile-overlays.js';
+import { createAgentRegistryToolHandlers } from '../../../harness/tools/agents.js';
+import { runBootSkillSeed } from '../../../skills/boot-seed.js';
+import { SkillExportService } from '../../../skills/skill-export-service.js';
+import { SkillIndexService } from '../../../skills/skill-index-service.js';
+import { SkillRegistryService } from '../../../skills/skill-registry-service.js';
+import { SkillStatusService } from '../../../skills/skill-status-service.js';
+import { csvFlag, instructionKindFlag, jsonFlag, optionalJsonFlag, optionalModeFlag, optionalScopeFlag, optionalSkillEvaluationResultStatusFlag, optionalSkillImprovementProposalStatusFlag, optionalSkillResolutionUsageFlag, optionalSkillTargetTypeFlag, optionalSkillVersionStatusFlag, optionalStringFlag, requiredFlag, scopeFlag, skillEvaluationResultStatusFlag, skillSourceFromFlags, skillTargetTypeFlag, skillUsageOutcomeFlag, } from '../cli-flags.js';
+import { usageFailure, validationFailure } from '../cli-help.js';
+import { jsonResult, readJsonFile, resultFailure } from '../cli-helpers.js';
+function resolveSkill(parsed, registry) {
+    const id = optionalStringFlag(parsed.flags, 'id');
+    if (id !== undefined)
+        return registry.getSkill(id);
+    const project = requiredFlag(parsed.flags, 'project');
+    const scope = scopeFlag(parsed.flags, 'scope', 'project');
+    const name = requiredFlag(parsed.flags, 'name');
+    if (!project.ok)
+        return project;
+    if (!scope.ok)
+        return scope;
+    if (!name.ok)
+        return name;
+    return registry.getSkillByName(project.value, scope.value, name.value);
+}
+function resolveSkillsInput(flags) {
+    const scope = optionalScopeFlag(flags, 'scope');
+    if (!scope.ok)
+        return scope;
+    const recordUsage = optionalSkillResolutionUsageFlag(flags, 'record-usage');
+    if (!recordUsage.ok)
+        return recordUsage;
+    const input = {};
+    const project = optionalStringFlag(flags, 'project');
+    const agentId = optionalStringFlag(flags, 'agent-id');
+    const agentName = optionalStringFlag(flags, 'agent');
+    const workflow = optionalStringFlag(flags, 'workflow');
+    const phase = optionalStringFlag(flags, 'phase');
+    const intentSignals = csvFlag(flags, 'intent-signals');
+    const providerAdapter = optionalStringFlag(flags, 'provider');
+    const runId = optionalStringFlag(flags, 'run');
+    if (project !== undefined)
+        input.project = project;
+    if (scope.value !== undefined)
+        input.scope = scope.value;
+    if (agentId !== undefined)
+        input.agentId = agentId;
+    if (agentName !== undefined)
+        input.agentName = agentName;
+    if (workflow !== undefined)
+        input.workflow = workflow;
+    if (phase !== undefined)
+        input.phase = phase;
+    if (intentSignals.length > 0)
+        input.intentSignals = intentSignals;
+    if (providerAdapter !== undefined)
+        input.providerAdapter = providerAdapter;
+    if (runId !== undefined)
+        input.runId = runId;
+    if (recordUsage.value !== undefined)
+        input.recordUsage = recordUsage.value;
+    if (input.recordUsage !== undefined && input.runId === undefined)
+        return validationFailure('--run is required when --record-usage is set');
+    return { ok: true, value: input };
+}
+function skillStatusInput(flags) {
+    const project = requiredFlag(flags, 'project');
+    const scope = scopeFlag(flags, 'scope', 'project');
+    const mode = optionalModeFlag(flags, 'mode');
+    if (!project.ok)
+        return project;
+    if (!scope.ok)
+        return scope;
+    if (!mode.ok)
+        return mode;
+    const provider = optionalStringFlag(flags, 'provider') ?? 'opencode';
+    const agent = optionalStringFlag(flags, 'agent');
+    return {
+        ok: true,
+        value: {
+            project: project.value,
+            scope: scope.value,
+            provider,
+            ...(mode.value !== undefined ? { mode: mode.value } : {}),
+            ...(agent !== undefined ? { agent } : {}),
+        },
+    };
+}
+function skillIndexInput(flags) {
+    const project = requiredFlag(flags, 'project');
+    const scope = requiredFlag(flags, 'scope');
+    if (!project.ok)
+        return project;
+    if (!scope.ok)
+        return scope;
+    if (scope.value !== 'project' && scope.value !== 'personal')
+        return validationFailure('--scope must be project or personal');
+    return { ok: true, value: { project: project.value, scope: scope.value } };
+}
+function skillPayloadInput(flags) {
+    if (flags['record-usage'] !== undefined)
+        return validationFailure('skills payload is read-only; use skills resolve with --record-usage for explicit usage writes');
+    const input = resolveSkillsInput(flags);
+    if (!input.ok)
+        return input;
+    return { ok: true, value: input.value };
+}
+function proposalActorInput(flags) {
+    const proposalId = requiredFlag(flags, 'proposal');
+    const actor = requiredFlag(flags, 'actor');
+    if (!proposalId.ok)
+        return proposalId;
+    if (!actor.ok)
+        return actor;
+    const reason = optionalStringFlag(flags, 'reason');
+    return { ok: true, value: { proposalId: proposalId.value, actor: actor.value, ...(reason !== undefined ? { reason } : {}) } };
+}
+function scenarioNameFlag(flags) {
+    const scenarioName = optionalStringFlag(flags, 'scenario-name');
+    if (scenarioName !== undefined)
+        return { ok: true, value: scenarioName };
+    const id = optionalStringFlag(flags, 'id');
+    if (id !== undefined)
+        return requiredFlag(flags, 'name');
+    return validationFailure('Missing required --scenario-name');
+}
+function registerPayload(parsed, environment, subagent) {
+    const file = optionalStringFlag(parsed.flags, 'file');
+    if (file !== undefined) {
+        const mergeValidation = validateFileInputIsComplete(parsed.flags, subagent);
+        if (!mergeValidation.ok)
+            return mergeValidation;
+        return readJsonFile(file, environment);
+    }
+    const project = requiredFlag(parsed.flags, 'project');
+    const scope = scopeFlag(parsed.flags, 'scope', 'project');
+    const name = requiredFlag(parsed.flags, 'name');
+    const description = requiredFlag(parsed.flags, 'description');
+    const instructionKind = instructionKindFlag(parsed.flags);
+    const instructions = requiredFlag(parsed.flags, 'instructions');
+    if (!project.ok)
+        return project;
+    if (!scope.ok)
+        return scope;
+    if (!name.ok)
+        return name;
+    if (!description.ok)
+        return description;
+    if (!instructionKind.ok)
+        return instructionKind;
+    if (!instructions.ok)
+        return instructions;
+    const payload = {
+        project: project.value,
+        scope: scope.value,
+        name: name.value,
+        description: description.value,
+        instructions: { kind: instructionKind.value, value: instructions.value },
+    };
+    const capabilities = csvFlag(parsed.flags, 'capabilities');
+    if (capabilities.length)
+        payload.capabilities = capabilities;
+    const skills = csvFlag(parsed.flags, 'skills');
+    if (skills.length)
+        payload.skills = skills;
+    if (subagent) {
+        const parentAgentId = requiredFlag(parsed.flags, 'parent-agent-id');
+        if (!parentAgentId.ok)
+            return parentAgentId;
+        payload.parentAgentId = parentAgentId.value;
+    }
+    return { ok: true, value: payload };
+}
+function expectAgentMode(result, mode) {
+    if (!result.ok)
+        return result;
+    if (result.value.mode === mode)
+        return result;
+    return validationFailure(`Expected ${mode}, found ${result.value.mode}`);
+}
+function validateFileInputIsComplete(flags, subagent) {
+    const definitionFlags = ['project', 'scope', 'name', 'description', 'instructions', 'instructions-kind', 'capabilities'];
+    if (subagent)
+        definitionFlags.push('parent-agent-id');
+    const mixed = definitionFlags.filter((name) => flags[name] !== undefined);
+    return mixed.length
+        ? validationFailure(`--file is a complete definition; do not combine it with ${mixed.map((name) => `--${name}`).join(', ')}`)
+        : { ok: true, value: undefined };
+}
+function resolveAgentForRender(parsed, registry, managerProfiles) {
+    const id = optionalStringFlag(parsed.flags, 'id');
+    if (id !== undefined)
+        return registry.getAgent(id);
+    const project = requiredFlag(parsed.flags, 'project');
+    const scope = scopeFlag(parsed.flags, 'scope', 'project');
+    const name = requiredFlag(parsed.flags, 'name');
+    if (!project.ok)
+        return project;
+    if (!scope.ok)
+        return scope;
+    if (!name.ok)
+        return name;
+    if (name.value === 'vgxness-manager' && managerProfiles !== undefined) {
+        const effective = managerProfiles.resolveEffectiveManager({ project: project.value, scope: scope.value, managerName: name.value });
+        return effective.ok ? { ok: true, value: effective.value.manager } : effective;
+    }
+    return registry.getAgentByName(project.value, scope.value, name.value);
+}
+function resolveSubagentsForRender(agent, registry) {
+    if (agent.mode !== 'agent')
+        return { ok: true, value: [] };
+    const summaries = registry.listSubagents(agent.id);
+    if (!summaries.ok)
+        return summaries;
+    const subagents = [];
+    for (const summary of summaries.value) {
+        const subagent = registry.getAgent(summary.id);
+        if (!subagent.ok)
+            return subagent;
+        subagents.push(subagent.value);
+    }
+    return { ok: true, value: subagents };
+}
+function resolveAgentsInput(flags) {
+    const scope = optionalScopeFlag(flags, 'scope');
+    if (!scope.ok)
+        return scope;
+    const mode = optionalModeFlag(flags, 'mode');
+    if (!mode.ok)
+        return mode;
+    const input = {};
+    const project = optionalStringFlag(flags, 'project');
+    const taskDescription = optionalStringFlag(flags, 'task') ?? optionalStringFlag(flags, 'task-description');
+    const intent = optionalStringFlag(flags, 'intent');
+    const desiredCapabilities = csvFlag(flags, 'capabilities');
+    const workflow = optionalStringFlag(flags, 'workflow');
+    const phase = optionalStringFlag(flags, 'phase');
+    const providerAdapter = optionalStringFlag(flags, 'provider') ?? optionalStringFlag(flags, 'provider-adapter');
+    if (project !== undefined)
+        input.project = project;
+    if (scope.value !== undefined)
+        input.scope = scope.value;
+    if (taskDescription !== undefined)
+        input.taskDescription = taskDescription;
+    if (intent !== undefined)
+        input.intent = intent;
+    if (desiredCapabilities.length > 0)
+        input.desiredCapabilities = desiredCapabilities;
+    if (workflow !== undefined)
+        input.workflow = workflow;
+    if (phase !== undefined)
+        input.phase = phase;
+    if (providerAdapter !== undefined)
+        input.providerAdapter = providerAdapter;
+    if (mode.value !== undefined)
+        input.mode = mode.value;
+    return { ok: true, value: input };
+}
+function managerProfileInput(flags) {
+    const scope = scopeFlag(flags, 'scope', 'project');
+    if (!scope.ok)
+        return scope;
+    return {
+        ok: true,
+        value: {
+            project: optionalStringFlag(flags, 'project') ?? 'vgxness',
+            scope: scope.value,
+            managerName: optionalStringFlag(flags, 'manager') ?? 'vgxness-manager',
+        },
+    };
+}
+function managerProfileOverlayInput(flags) {
+    return managerProfileInput(flags);
+}
+export function runAgentCommand(command, parsed, database, environment) {
+    const handlers = createAgentRegistryToolHandlers({ service: new AgentRegistryService(database) });
+    const registry = new AgentRegistryService(database);
+    const managerProfiles = new ManagerProfileOverlayService({ agents: registry, overlays: new ManagerProfileOverlayRepository(database) });
+    if (command === 'seed') {
+        if (parsed.positionals[2] !== 'load')
+            return usageFailure('agents seed requires load');
+        const file = optionalStringFlag(parsed.flags, 'file');
+        const seed = new AgentSeedService(database);
+        if (file === undefined)
+            return jsonResult(seed.loadBuiltInDefaults());
+        const manifest = readJsonFile(file, environment);
+        if (!manifest.ok)
+            return resultFailure(manifest);
+        return jsonResult(seed.loadManifest(manifest.value));
+    }
+    if (command === 'register') {
+        const payload = registerPayload(parsed, environment, false);
+        return payload.ok ? jsonResult(handlers.registerAgent(payload.value)) : resultFailure(payload);
+    }
+    if (command === 'list') {
+        const filters = {};
+        const project = optionalStringFlag(parsed.flags, 'project');
+        if (project !== undefined)
+            filters.project = project;
+        const scope = optionalScopeFlag(parsed.flags, 'scope');
+        if (!scope.ok)
+            return resultFailure(scope);
+        if (scope.value !== undefined)
+            filters.scope = scope.value;
+        const mode = optionalModeFlag(parsed.flags, 'mode');
+        if (!mode.ok)
+            return resultFailure(mode);
+        filters.mode = mode.value ?? 'agent';
+        return jsonResult(handlers.listAgents(filters));
+    }
+    if (command === 'get') {
+        const id = optionalStringFlag(parsed.flags, 'id');
+        if (id !== undefined)
+            return jsonResult(expectAgentMode(handlers.getAgent({ id }), 'agent'));
+        const project = requiredFlag(parsed.flags, 'project');
+        const scope = scopeFlag(parsed.flags, 'scope', 'project');
+        const name = requiredFlag(parsed.flags, 'name');
+        if (!project.ok)
+            return resultFailure(project);
+        if (!scope.ok)
+            return resultFailure(scope);
+        if (!name.ok)
+            return resultFailure(name);
+        return jsonResult(expectAgentMode(handlers.getAgentByName({ project: project.value, scope: scope.value, name: name.value }), 'agent'));
+    }
+    if (command === 'resolve') {
+        const input = resolveAgentsInput(parsed.flags);
+        return input.ok ? jsonResult(registry.resolveAgents(input.value)) : resultFailure(input);
+    }
+    if (command === 'manager-profile') {
+        const action = parsed.positionals[2];
+        if (action !== 'get' && action !== 'set')
+            return usageFailure('agents manager-profile requires get or set');
+        const input = managerProfileInput(parsed.flags);
+        if (!input.ok)
+            return resultFailure(input);
+        if (action === 'get')
+            return jsonResult(managerProfiles.resolveEffectiveManager(input.value));
+        const baseline = managerProfiles.resolveEffectiveManager(input.value);
+        if (!baseline.ok)
+            return resultFailure(baseline);
+        const instructions = requiredFlag(parsed.flags, 'instructions');
+        if (!instructions.ok)
+            return resultFailure(instructions);
+        const saved = managerProfiles.save({ ...input.value, instructions: instructions.value });
+        if (!saved.ok)
+            return resultFailure(saved);
+        return jsonResult(managerProfiles.resolveEffectiveManager(input.value));
+    }
+    if (command === 'render') {
+        const provider = requiredFlag(parsed.flags, 'provider');
+        if (!provider.ok)
+            return resultFailure(provider);
+        const renderer = getProviderRenderer(provider.value);
+        if (!renderer.ok)
+            return resultFailure(renderer);
+        const agent = resolveAgentForRender(parsed, registry, managerProfiles);
+        if (!agent.ok)
+            return resultFailure(agent);
+        const subagents = resolveSubagentsForRender(agent.value, registry);
+        if (!subagents.ok)
+            return resultFailure(subagents);
+        return jsonResult(renderer.value.render({ agent: agent.value, subagents: subagents.value }));
+    }
+    return usageFailure(`Unknown agents command: ${command}`);
+}
+export function runSubagentCommand(command, parsed, database, environment) {
+    const handlers = createAgentRegistryToolHandlers({ service: new AgentRegistryService(database) });
+    if (command === 'register') {
+        const payload = registerPayload(parsed, environment, true);
+        return payload.ok ? jsonResult(handlers.registerSubagent(payload.value)) : resultFailure(payload);
+    }
+    if (command === 'list') {
+        const parentAgentId = requiredFlag(parsed.flags, 'parent-agent-id');
+        if (!parentAgentId.ok)
+            return resultFailure(parentAgentId);
+        return jsonResult(handlers.listSubagents({ parentAgentId: parentAgentId.value }));
+    }
+    if (command === 'get') {
+        const id = optionalStringFlag(parsed.flags, 'id');
+        if (id !== undefined)
+            return jsonResult(expectAgentMode(handlers.getAgent({ id }), 'subagent'));
+        const project = requiredFlag(parsed.flags, 'project');
+        const scope = scopeFlag(parsed.flags, 'scope', 'project');
+        const name = requiredFlag(parsed.flags, 'name');
+        if (!project.ok)
+            return resultFailure(project);
+        if (!scope.ok)
+            return resultFailure(scope);
+        if (!name.ok)
+            return resultFailure(name);
+        return jsonResult(expectAgentMode(handlers.getAgentByName({ project: project.value, scope: scope.value, name: name.value }), 'subagent'));
+    }
+    return usageFailure(`Unknown subagents command: ${command}`);
+}
+export function runSkillCommand(command, parsed, database, environment) {
+    const registry = new SkillRegistryService(database);
+    if (command === 'register') {
+        const project = requiredFlag(parsed.flags, 'project');
+        const scope = scopeFlag(parsed.flags, 'scope', 'project');
+        const name = requiredFlag(parsed.flags, 'name');
+        const description = requiredFlag(parsed.flags, 'description');
+        if (!project.ok)
+            return resultFailure(project);
+        if (!scope.ok)
+            return resultFailure(scope);
+        if (!name.ok)
+            return resultFailure(name);
+        if (!description.ok)
+            return resultFailure(description);
+        return jsonResult(registry.registerSkill({ project: project.value, scope: scope.value, name: name.value, description: description.value }));
+    }
+    if (command === 'list') {
+        const filters = {};
+        const project = optionalStringFlag(parsed.flags, 'project');
+        if (project !== undefined)
+            filters.project = project;
+        const scope = optionalScopeFlag(parsed.flags, 'scope');
+        if (!scope.ok)
+            return resultFailure(scope);
+        if (scope.value !== undefined)
+            filters.scope = scope.value;
+        return jsonResult(registry.listSkills(filters));
+    }
+    if (command === 'get') {
+        const skill = resolveSkill(parsed, registry);
+        return skill.ok ? jsonResult(registry.getSkillDetails(skill.value.id)) : resultFailure(skill);
+    }
+    if (command === 'add-version') {
+        const skill = resolveSkill(parsed, registry);
+        if (!skill.ok)
+            return resultFailure(skill);
+        const version = requiredFlag(parsed.flags, 'version');
+        const source = skillSourceFromFlags(parsed.flags);
+        const status = optionalSkillVersionStatusFlag(parsed.flags, 'status');
+        if (!version.ok)
+            return resultFailure(version);
+        if (!source.ok)
+            return resultFailure(source);
+        if (!status.ok)
+            return resultFailure(status);
+        const compatibility = optionalJsonFlag(parsed.flags, 'compatibility');
+        if (!compatibility.ok)
+            return resultFailure(compatibility);
+        return jsonResult(registry.addSkillVersion({
+            skillId: skill.value.id,
+            version: version.value,
+            source: source.value,
+            ...(compatibility.value !== undefined ? { compatibility: compatibility.value } : {}),
+            ...(status.value !== undefined ? { status: status.value } : {}),
+            ...(parsed.flags.activate === true ? { activate: true } : {}),
+        }));
+    }
+    if (command === 'attach') {
+        const skill = resolveSkill(parsed, registry);
+        const targetType = skillTargetTypeFlag(parsed.flags, 'target-type');
+        const targetKey = requiredFlag(parsed.flags, 'target-key');
+        if (!skill.ok)
+            return resultFailure(skill);
+        if (!targetType.ok)
+            return resultFailure(targetType);
+        if (!targetKey.ok)
+            return resultFailure(targetKey);
+        const versionId = optionalStringFlag(parsed.flags, 'version-id') ?? skill.value.currentVersionId;
+        const metadata = jsonFlag(parsed.flags, 'metadata', {});
+        if (!metadata.ok)
+            return resultFailure(metadata);
+        return jsonResult(registry.attachSkill({
+            skillId: skill.value.id,
+            targetType: targetType.value,
+            targetKey: targetKey.value,
+            ...(versionId !== undefined ? { versionId } : {}),
+            metadata: metadata.value,
+        }));
+    }
+    if (command === 'detach') {
+        const skill = resolveSkill(parsed, registry);
+        const targetType = skillTargetTypeFlag(parsed.flags, 'target-type');
+        const targetKey = requiredFlag(parsed.flags, 'target-key');
+        if (!skill.ok)
+            return resultFailure(skill);
+        if (!targetType.ok)
+            return resultFailure(targetType);
+        if (!targetKey.ok)
+            return resultFailure(targetKey);
+        return jsonResult(registry.detachSkill(skill.value.id, targetType.value, targetKey.value));
+    }
+    if (command === 'record-usage') {
+        const skill = resolveSkill(parsed, registry);
+        const outcome = skillUsageOutcomeFlag(parsed.flags, 'outcome');
+        if (!skill.ok)
+            return resultFailure(skill);
+        if (!outcome.ok)
+            return resultFailure(outcome);
+        const targetType = optionalSkillTargetTypeFlag(parsed.flags, 'target-type');
+        if (!targetType.ok)
+            return resultFailure(targetType);
+        const targetKey = optionalStringFlag(parsed.flags, 'target-key');
+        const versionId = optionalStringFlag(parsed.flags, 'version-id') ?? skill.value.currentVersionId;
+        const runId = optionalStringFlag(parsed.flags, 'run-id');
+        const notes = optionalStringFlag(parsed.flags, 'notes');
+        return jsonResult(registry.recordSkillUsage({
+            skillId: skill.value.id,
+            ...(versionId !== undefined ? { versionId } : {}),
+            ...(runId !== undefined ? { runId } : {}),
+            ...(targetType.value !== undefined ? { targetType: targetType.value } : {}),
+            ...(targetKey !== undefined ? { targetKey } : {}),
+            outcome: outcome.value,
+            ...(notes !== undefined ? { notes } : {}),
+        }));
+    }
+    if (command === 'resolve') {
+        const input = resolveSkillsInput(parsed.flags);
+        return input.ok ? jsonResult(registry.resolveSkills(input.value)) : resultFailure(input);
+    }
+    if (command === 'index') {
+        const input = skillIndexInput(parsed.flags);
+        if (!input.ok)
+            return resultFailure(input);
+        return jsonResult(new SkillIndexService(registry).getIndex(input.value));
+    }
+    if (command === 'export') {
+        const input = skillIndexInput(parsed.flags);
+        if (!input.ok)
+            return resultFailure(input);
+        return jsonResult(new SkillExportService(new SkillIndexService(registry)).export(input.value));
+    }
+    if (command === 'status') {
+        const input = skillStatusInput(parsed.flags);
+        if (!input.ok)
+            return resultFailure(input);
+        return jsonResult(new SkillStatusService(registry, new AgentRegistryService(database)).getStatus(input.value));
+    }
+    if (command === 'propose') {
+        const skill = resolveSkill(parsed, registry);
+        if (!skill.ok)
+            return resultFailure(skill);
+        const baseVersionId = optionalStringFlag(parsed.flags, 'base-version-id') ?? skill.value.currentVersionId;
+        if (baseVersionId === undefined)
+            return resultFailure(validationFailure('Missing required --base-version-id because the skill has no current version'));
+        const proposedVersion = requiredFlag(parsed.flags, 'proposed-version');
+        const proposedSource = skillSourceFromFlags(parsed.flags);
+        const rationale = requiredFlag(parsed.flags, 'rationale');
+        const compatibility = optionalJsonFlag(parsed.flags, 'compatibility');
+        const sourceSignal = jsonFlag(parsed.flags, 'source-signal', {});
+        if (!proposedVersion.ok)
+            return resultFailure(proposedVersion);
+        if (!proposedSource.ok)
+            return resultFailure(proposedSource);
+        if (!rationale.ok)
+            return resultFailure(rationale);
+        if (!compatibility.ok)
+            return resultFailure(compatibility);
+        if (!sourceSignal.ok)
+            return resultFailure(sourceSignal);
+        return jsonResult(registry.createSkillImprovementProposal({
+            skillId: skill.value.id,
+            baseVersionId,
+            proposedVersion: proposedVersion.value,
+            proposedSource: proposedSource.value,
+            ...(compatibility.value !== undefined ? { proposedCompatibility: compatibility.value } : {}),
+            rationale: rationale.value,
+            sourceSignal: sourceSignal.value,
+        }));
+    }
+    if (command === 'proposals') {
+        const filters = {};
+        const skillId = optionalStringFlag(parsed.flags, 'skill-id');
+        if (skillId !== undefined)
+            filters.skillId = skillId;
+        const status = optionalSkillImprovementProposalStatusFlag(parsed.flags, 'status');
+        if (!status.ok)
+            return resultFailure(status);
+        if (status.value !== undefined)
+            filters.status = status.value;
+        return jsonResult(registry.listSkillImprovementProposals(filters));
+    }
+    if (command === 'create-scenario') {
+        const skill = resolveSkill(parsed, registry);
+        if (!skill.ok)
+            return resultFailure(skill);
+        const name = scenarioNameFlag(parsed.flags);
+        const criteria = jsonFlag(parsed.flags, 'criteria', {});
+        const createdBy = requiredFlag(parsed.flags, 'created-by');
+        if (!name.ok)
+            return resultFailure(name);
+        if (!criteria.ok)
+            return resultFailure(criteria);
+        if (!createdBy.ok)
+            return resultFailure(createdBy);
+        const proposalId = optionalStringFlag(parsed.flags, 'proposal');
+        const versionId = optionalStringFlag(parsed.flags, 'version-id');
+        return jsonResult(registry.createSkillEvaluationScenario({
+            skillId: skill.value.id,
+            name: name.value,
+            criteria: criteria.value,
+            createdBy: createdBy.value,
+            ...(proposalId !== undefined ? { proposalId } : {}),
+            ...(versionId !== undefined ? { versionId } : {}),
+        }));
+    }
+    if (command === 'list-scenarios') {
+        const skill = resolveSkill(parsed, registry);
+        if (!skill.ok)
+            return resultFailure(skill);
+        const proposalId = optionalStringFlag(parsed.flags, 'proposal');
+        const versionId = optionalStringFlag(parsed.flags, 'version-id');
+        return jsonResult(registry.listSkillEvaluationScenarios({
+            skillId: skill.value.id,
+            ...(proposalId !== undefined ? { proposalId } : {}),
+            ...(versionId !== undefined ? { versionId } : {}),
+        }));
+    }
+    if (command === 'record-evaluation-result') {
+        const scenarioId = requiredFlag(parsed.flags, 'scenario');
+        const status = skillEvaluationResultStatusFlag(parsed.flags, 'status');
+        const result = jsonFlag(parsed.flags, 'result', {});
+        const observedBehavior = requiredFlag(parsed.flags, 'observed-behavior');
+        const evaluator = requiredFlag(parsed.flags, 'evaluator');
+        if (!scenarioId.ok)
+            return resultFailure(scenarioId);
+        if (!status.ok)
+            return resultFailure(status);
+        if (!result.ok)
+            return resultFailure(result);
+        if (!observedBehavior.ok)
+            return resultFailure(observedBehavior);
+        if (!evaluator.ok)
+            return resultFailure(evaluator);
+        const proposalId = optionalStringFlag(parsed.flags, 'proposal');
+        const versionId = optionalStringFlag(parsed.flags, 'version-id');
+        const notes = optionalStringFlag(parsed.flags, 'notes');
+        return jsonResult(registry.recordSkillEvaluationResult({
+            scenarioId: scenarioId.value,
+            status: status.value,
+            result: result.value,
+            observedBehavior: observedBehavior.value,
+            evaluator: evaluator.value,
+            ...(proposalId !== undefined ? { proposalId } : {}),
+            ...(versionId !== undefined ? { versionId } : {}),
+            ...(notes !== undefined ? { notes } : {}),
+        }));
+    }
+    if (command === 'list-evaluation-results') {
+        const status = optionalSkillEvaluationResultStatusFlag(parsed.flags, 'status');
+        if (!status.ok)
+            return resultFailure(status);
+        const scenarioId = optionalStringFlag(parsed.flags, 'scenario');
+        const skillId = optionalStringFlag(parsed.flags, 'skill-id');
+        const proposalId = optionalStringFlag(parsed.flags, 'proposal');
+        const versionId = optionalStringFlag(parsed.flags, 'version-id');
+        const evaluator = optionalStringFlag(parsed.flags, 'evaluator');
+        return jsonResult(registry.listSkillEvaluationResults({
+            ...(scenarioId !== undefined ? { scenarioId } : {}),
+            ...(skillId !== undefined ? { skillId } : {}),
+            ...(proposalId !== undefined ? { proposalId } : {}),
+            ...(versionId !== undefined ? { versionId } : {}),
+            ...(evaluator !== undefined ? { evaluator } : {}),
+            ...(status.value !== undefined ? { status: status.value } : {}),
+        }));
+    }
+    if (command === 'get-proposal') {
+        const proposalId = requiredFlag(parsed.flags, 'proposal');
+        return proposalId.ok ? jsonResult(registry.getSkillImprovementProposal(proposalId.value)) : resultFailure(proposalId);
+    }
+    if (command === 'submit-proposal' ||
+        command === 'approve-proposal' ||
+        command === 'reject-proposal' ||
+        command === 'cancel-proposal' ||
+        command === 'apply-proposal') {
+        const input = proposalActorInput(parsed.flags);
+        if (!input.ok)
+            return resultFailure(input);
+        if (command === 'submit-proposal')
+            return jsonResult(registry.submitSkillImprovementProposal(input.value));
+        if (command === 'approve-proposal')
+            return jsonResult(registry.approveSkillImprovementProposal(input.value));
+        if (command === 'reject-proposal')
+            return jsonResult(registry.rejectSkillImprovementProposal(input.value));
+        if (command === 'cancel-proposal')
+            return jsonResult(registry.cancelSkillImprovementProposal(input.value));
+        return jsonResult(registry.applySkillImprovementProposal(input.value));
+    }
+    if (command === 'payload') {
+        const input = skillPayloadInput(parsed.flags);
+        if (!input.ok)
+            return resultFailure(input);
+        const seeded = runBootSkillSeed(database, environment.env);
+        if (!seeded.ok)
+            return resultFailure(seeded);
+        return jsonResult(registry.buildSkillPayload(input.value, { workspaceRoot: environment.cwd }));
+    }
+    return usageFailure(`Unknown skills command: ${command}`);
+}
+// Re-export helpers for external use
+export { expectAgentMode, managerProfileInput, managerProfileOverlayInput, proposalActorInput, registerPayload, resolveAgentForRender, resolveAgentsInput, resolveSkill, resolveSkillsInput, resolveSubagentsForRender, scenarioNameFlag, skillIndexInput, skillPayloadInput, skillStatusInput, validateFileInputIsComplete, };