vgxness 1.20.4 → 1.20.6

package/dist/interfaces/mcp/control-plane/handlers/agents.js

@@ -0,0 +1,38 @@
+import { errorEnvelope, successEnvelope, } from '../../schema.js';
+function toEnvelope(tool, result) {
+    return result.ok ? successEnvelope(tool, result.value) : errorEnvelope(result.error.code, result.error.message, tool);
+}
+export function agentResolveEnvelope(input, services) {
+    return toEnvelope('vgxness_agent_resolve', services.agents.resolveAgents(input));
+}
+export function agentActivateEnvelope(input, services) {
+    return toEnvelope('vgxness_agent_activate', services.activation.activate(input));
+}
+export function managerProfileGetEnvelope(input, services) {
+    if (services.managerProfiles === undefined)
+        return errorEnvelope('validation_failed', 'Manager profile service is not available', 'vgxness_manager_profile_get');
+    return toEnvelope('vgxness_manager_profile_get', services.managerProfiles.resolveEffectiveManager({
+        project: input.project,
+        scope: input.scope ?? 'project',
+        managerName: input.managerName ?? 'vgxness-manager',
+    }));
+}
+export function managerProfileSetEnvelope(input, services) {
+    if (services.managerProfiles === undefined)
+        return errorEnvelope('validation_failed', 'Manager profile service is not available', 'vgxness_manager_profile_set');
+    const baseline = services.managerProfiles.resolveEffectiveManager({ project: input.project, scope: input.scope, managerName: input.managerName });
+    if (!baseline.ok)
+        return errorEnvelope(baseline.error.code, baseline.error.message, 'vgxness_manager_profile_set');
+    const saved = services.managerProfiles.save(input);
+    if (!saved.ok)
+        return errorEnvelope(saved.error.code, saved.error.message, 'vgxness_manager_profile_set');
+    return toEnvelope('vgxness_manager_profile_set', services.managerProfiles.resolveEffectiveManager({ project: input.project, scope: input.scope, managerName: input.managerName }));
+}
+export function opencodeManagerPayloadEnvelope(input, services) {
+    return toEnvelope('vgxness_opencode_manager_payload', services.opencodeManagerPayload.build(input));
+}
+export function opencodeHandoffPreviewEnvelope(input, services) {
+    if (services.opencodeHandoffPreview === undefined)
+        return errorEnvelope('validation_failed', 'OpenCode handoff preview service is not available', 'vgxness_opencode_handoff_preview');
+    return toEnvelope('vgxness_opencode_handoff_preview', services.opencodeHandoffPreview.build(input));
+}

package/dist/interfaces/mcp/control-plane/handlers/context.js

@@ -0,0 +1,12 @@
+import { ContextCockpitSnapshotService } from '../../../../mcp/control-plane-snapshot-service.js';
+import { ResumeContextGateService } from '../../../../mcp/resume-context-gate-service.js';
+import { errorEnvelope, successEnvelope } from '../../schema.js';
+function toEnvelope(tool, result) {
+    return result.ok ? successEnvelope(tool, result.value) : errorEnvelope(result.error.code, result.error.message, tool);
+}
+export function contextCockpitEnvelope(input, services) {
+    return toEnvelope('vgxness_context_cockpit', new ContextCockpitSnapshotService({ memory: services.memory, sdd: services.sdd }).build(input));
+}
+export function resumeContextEnvelope(input, services) {
+    return toEnvelope('vgxness_resume_context', new ResumeContextGateService({ memory: services.memory, runs: services.runs }).build(input));
+}

package/dist/interfaces/mcp/control-plane/handlers/memory.js

@@ -0,0 +1,95 @@
+import { AgentMemoryCaptureService } from '../../../../memory/agent-memory-capture-service.js';
+import { errorEnvelope, successEnvelope, } from '../../schema.js';
+function memoryContext(sessionId) {
+    const context = { actor: 'mcp-control-plane' };
+    if (sessionId !== undefined)
+        context.sessionId = sessionId;
+    return context;
+}
+function toEnvelope(tool, result) {
+    return result.ok ? successEnvelope(tool, result.value) : errorEnvelope(result.error.code, result.error.message, tool);
+}
+function auditedMemoryEnvelope(tool, result, services, audit) {
+    if (result.ok && audit.runId !== undefined) {
+        services.runs.appendEvent({
+            runId: audit.runId,
+            kind: 'timeline',
+            title: audit.title,
+            payload: audit.payload(result.value),
+            relatedType: audit.relatedType,
+            ...(audit.relatedId === undefined ? {} : { relatedId: audit.relatedId }),
+        });
+    }
+    return toEnvelope(tool, result);
+}
+function sddSaveAuditPayload(input) {
+    return {
+        runId: input.runId,
+        title: 'Audit: sdd-artifact-saved',
+        relatedType: 'sdd-artifact',
+        relatedId: `${input.change}:${input.phase}`,
+        payload: (value) => ({
+            eventType: 'sdd-artifact-saved',
+            project: input.project,
+            change: input.change,
+            phase: input.phase,
+            topicKey: value.topicKey,
+            artifactId: value.id,
+            ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+        }),
+    };
+}
+function isMemorySddArtifactSaveInput(input) {
+    return 'kind' in input && input.kind === 'sdd-artifact';
+}
+function isMemorySddArtifactGetInput(input) {
+    return 'kind' in input && input.kind === 'sdd-artifact';
+}
+function memoryCapturePolicyErrorEnvelope(tool, decision) {
+    return errorEnvelope('validation_failed', `Memory capture policy rejected explicit durable memory write. Reason codes: ${decision.reasonCodes.join(', ')}`, tool, {
+        policy: {
+            service: 'AgentMemoryCaptureService',
+            version: decision.version,
+            allowed: decision.allowed,
+            severity: decision.severity,
+            persisted: decision.persisted,
+            reasonCodes: decision.reasonCodes,
+            warnings: decision.warnings,
+            redactions: decision.redactions,
+        },
+    });
+}
+export function memorySaveEnvelope(input, services) {
+    if (isMemorySddArtifactSaveInput(input)) {
+        const { kind: _kind, ...artifactInput } = input;
+        return auditedMemoryEnvelope('vgxness_memory_save', services.sdd.saveArtifact(artifactInput), services, sddSaveAuditPayload(artifactInput));
+    }
+    const policy = new AgentMemoryCaptureService().validateExplicitMemorySave(input);
+    if (!policy.ok)
+        return errorEnvelope(policy.error.code, policy.error.message, 'vgxness_memory_save');
+    if (!policy.value.allowed)
+        return memoryCapturePolicyErrorEnvelope('vgxness_memory_save', policy.value);
+    return toEnvelope('vgxness_memory_save', services.memory.saveObservation({ ...input, scope: input.scope ?? 'project' }, memoryContext()));
+}
+export function memorySearchEnvelope(input, services) {
+    return toEnvelope('vgxness_memory_search', services.memory.searchObservations(input, memoryContext()));
+}
+export function memoryGetEnvelope(input, services) {
+    if (isMemorySddArtifactGetInput(input)) {
+        const { kind: _kind, ...artifactInput } = input;
+        return toEnvelope('vgxness_memory_get', services.sdd.getArtifact(artifactInput));
+    }
+    return toEnvelope('vgxness_memory_get', services.memory.getObservation(input.id, memoryContext()));
+}
+export function memoryUpdateEnvelope(input, services) {
+    if (isMemorySddArtifactSaveInput(input)) {
+        const { kind: _kind, ...artifactInput } = input;
+        return auditedMemoryEnvelope('vgxness_memory_update', services.sdd.saveArtifact(artifactInput), services, sddSaveAuditPayload(artifactInput));
+    }
+    const policy = new AgentMemoryCaptureService().validateExplicitMemoryUpdate(input);
+    if (!policy.ok)
+        return errorEnvelope(policy.error.code, policy.error.message, 'vgxness_memory_update');
+    if (!policy.value.allowed)
+        return memoryCapturePolicyErrorEnvelope('vgxness_memory_update', policy.value);
+    return toEnvelope('vgxness_memory_update', services.memory.updateObservation(input, memoryContext()));
+}

package/dist/interfaces/mcp/control-plane/handlers/providers.js

@@ -0,0 +1,19 @@
+import { errorEnvelope, successEnvelope, } from '../../schema.js';
+function toEnvelope(tool, result) {
+    return result.ok ? successEnvelope(tool, result.value) : errorEnvelope(result.error.code, result.error.message, tool);
+}
+export function providerStatusEnvelope(input, services) {
+    if (services.providerStatus === undefined)
+        return errorEnvelope('validation_failed', 'Provider status service is not available', 'vgxness_provider_status');
+    return toEnvelope('vgxness_provider_status', services.providerStatus.getStatus(input));
+}
+export function providerDoctorEnvelope(input, services) {
+    if (services.providerDoctor === undefined)
+        return errorEnvelope('validation_failed', 'Provider doctor service is not available', 'vgxness_provider_doctor');
+    return toEnvelope('vgxness_provider_doctor', services.providerDoctor.getDoctor(input));
+}
+export function providerChangePlanEnvelope(input, services) {
+    if (services.providerChangePlan === undefined)
+        return errorEnvelope('validation_failed', 'Provider change plan service is not available', 'vgxness_provider_change_plan');
+    return toEnvelope('vgxness_provider_change_plan', services.providerChangePlan.getPlan(input));
+}

package/dist/interfaces/mcp/control-plane/handlers/runs.js

@@ -0,0 +1,134 @@
+import { AgentMemoryCaptureService } from '../../../../memory/agent-memory-capture-service.js';
+import { errorEnvelope, successEnvelope, } from '../../schema.js';
+function toEnvelope(tool, result) {
+    return result.ok ? successEnvelope(tool, result.value) : errorEnvelope(result.error.code, result.error.message, tool);
+}
+export function runListEnvelope(input, services) {
+    const { limit, ...filters } = input;
+    const result = services.runs.listRuns(filters);
+    return result.ok
+        ? successEnvelope('vgxness_run_list', result.value.slice(0, limit))
+        : errorEnvelope(result.error.code, result.error.message, 'vgxness_run_list');
+}
+export function runGetEnvelope(input, services) {
+    return toEnvelope('vgxness_run_get', services.runs.getRun(input.id));
+}
+export function runPreflightEnvelope(input, services) {
+    return toEnvelope('vgxness_run_preflight', services.runs.preflightOperation(input));
+}
+export function runTaskGrantCreateEnvelope(input, services) {
+    if (services.runs.taskScopedCommandGrantService === undefined)
+        return errorEnvelope('validation_failed', 'Task-scoped command grant service is not available', 'vgxness_run_task_grant_create');
+    const { creationReason, approvedScopeSummary, ...grantInput } = input;
+    return toEnvelope('vgxness_run_task_grant_create', services.runs.taskScopedCommandGrantService().create({
+        ...grantInput,
+        audit: { creationReason, approvedScopeSummary },
+    }));
+}
+export function runTaskGrantListEnvelope(input, services) {
+    if (services.runs.taskScopedCommandGrantService === undefined)
+        return errorEnvelope('validation_failed', 'Task-scoped command grant service is not available', 'vgxness_run_task_grant_list');
+    const { limit, ...filters } = input;
+    const result = services.runs.taskScopedCommandGrantService().list(filters);
+    return result.ok
+        ? successEnvelope('vgxness_run_task_grant_list', limit === undefined ? result.value : result.value.slice(0, limit))
+        : errorEnvelope(result.error.code, result.error.message, 'vgxness_run_task_grant_list');
+}
+export function runTaskGrantGetEnvelope(input, services) {
+    if (services.runs.taskScopedCommandGrantService === undefined)
+        return errorEnvelope('validation_failed', 'Task-scoped command grant service is not available', 'vgxness_run_task_grant_get');
+    return toEnvelope('vgxness_run_task_grant_get', services.runs.taskScopedCommandGrantService().get(input.grantId));
+}
+export function runTaskGrantRevokeEnvelope(input, services) {
+    if (services.runs.taskScopedCommandGrantService === undefined)
+        return errorEnvelope('validation_failed', 'Task-scoped command grant service is not available', 'vgxness_run_task_grant_revoke');
+    return toEnvelope('vgxness_run_task_grant_revoke', services.runs.taskScopedCommandGrantService().revoke(input));
+}
+export function runTaskGrantPreviewMatchEnvelope(input, services) {
+    if (services.runs.taskScopedCommandGrantService === undefined)
+        return errorEnvelope('validation_failed', 'Task-scoped command grant service is not available', 'vgxness_run_task_grant_preview_match');
+    return toEnvelope('vgxness_run_task_grant_preview_match', services.runs.taskScopedCommandGrantService().previewMatch(input));
+}
+export function runStartEnvelope(input, services) {
+    return toEnvelope('vgxness_run_start', services.runs.createRun(input));
+}
+export function runCheckpointEnvelope(input, services) {
+    return toEnvelope('vgxness_run_checkpoint', services.runs.appendCheckpoint(input));
+}
+export function runFinalizeEnvelope(input, services) {
+    const finalized = services.runs.updateFinalStatus(input);
+    if (!finalized.ok)
+        return errorEnvelope(finalized.error.code, finalized.error.message, 'vgxness_run_finalize');
+    const memoryCapture = runFinalizeMemoryCapture(input, finalized.value);
+    const envelope = { ok: true, tool: 'vgxness_run_finalize', value: finalized.value };
+    if (memoryCapture !== undefined)
+        envelope.memoryCapture = memoryCapture;
+    return envelope;
+}
+function runFinalizeMemoryCapture(input, run) {
+    try {
+        const boundedEvidence = [
+            { kind: 'run-finalization', ref: run.id, note: 'Derived from bounded run finalization response fields only.' },
+        ];
+        if (run.latestCheckpointId !== undefined) {
+            boundedEvidence.push({ kind: 'run-checkpoint', ref: run.latestCheckpointId, note: 'Checkpoint id reference only; checkpoint state omitted.' });
+        }
+        const captureInput = {
+            project: run.project,
+            runId: run.id,
+            workflow: run.workflow,
+            phase: run.phase,
+            status: run.status,
+            outcome: run.outcome ?? input.outcome,
+            boundedEvidence,
+        };
+        const outcomeReason = run.outcomeReason ?? input.outcomeReason;
+        if (outcomeReason !== undefined)
+            captureInput.outcomeReason = outcomeReason;
+        const result = new AgentMemoryCaptureService().captureFromRunFinalize(captureInput);
+        return result.ok ? result.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function runResumeCandidatesEnvelope(input, services) {
+    const limit = input.limit ?? 5;
+    const result = services.runs.listRecentInterruptedRuns({ project: input.project, limit });
+    if (!result.ok)
+        return errorEnvelope(result.error.code, result.error.message, 'vgxness_run_resume_candidates');
+    return successEnvelope('vgxness_run_resume_candidates', {
+        kind: 'run-resume-candidates',
+        version: 1,
+        project: input.project,
+        statuses: ['failed', 'blocked', 'needs-human'],
+        limit,
+        candidates: result.value.map((candidate) => ({
+            ...candidate,
+            recommendation: 'Inspect this interrupted run before deciding whether to continue manually.',
+            inspectTool: 'run_resume_inspect',
+            inspectInput: { runId: candidate.runId },
+            resumeCommand: `vgxness resume --project ${input.project} --run-id ${candidate.runId}`,
+        })),
+        nextStep: result.value.length === 0
+            ? 'No interrupted run candidates were found for this project. Start from the current project status or a known runId.'
+            : 'Call run_resume_inspect with a candidate runId, then use run_resume_gate only when inspect returns a relevant approvalId.',
+        safety: {
+            readOnly: true,
+            runMutation: false,
+            retryAdmitted: false,
+            providerInvoked: false,
+            writesProviderConfig: false,
+            writesArtifacts: false,
+            writesOpenSpec: false,
+            createsSandbox: false,
+            createsWorktree: false,
+        },
+    });
+}
+export function runResumeInspectEnvelope(input, services) {
+    return toEnvelope('vgxness_run_resume_inspect', services.runs.getRunOperatorResumePlan(input.runId));
+}
+export function runResumeGateEnvelope(input, services) {
+    return toEnvelope('vgxness_run_resume_gate', services.runs.getRunResumeOrchestrationPlan(input));
+}

package/dist/interfaces/mcp/control-plane/handlers/sdd.js

@@ -0,0 +1,225 @@
+import { GovernanceReportBuilder } from '../../../../governance/index.js';
+import { AgentMemoryCaptureService } from '../../../../memory/agent-memory-capture-service.js';
+import { buildSddCockpitSurfaceResponse } from '../../../../sdd/cockpit-read-model.js';
+import { sddContinuationPlanFrom } from '../../../../sdd/sdd-continuation-plan.js';
+import { errorEnvelope, successEnvelope, } from '../../schema.js';
+function toEnvelope(tool, result) {
+    return result.ok ? successEnvelope(tool, result.value) : errorEnvelope(result.error.code, result.error.message, tool);
+}
+function auditedEnvelope(tool, result, services, audit) {
+    if (result.ok && audit.runId !== undefined) {
+        services.runs.appendEvent({
+            runId: audit.runId,
+            kind: 'timeline',
+            title: audit.title,
+            payload: audit.payload(result.value),
+            relatedType: audit.relatedType,
+            ...(audit.relatedId === undefined ? {} : { relatedId: audit.relatedId }),
+        });
+    }
+    return toEnvelope(tool, result);
+}
+export function sddStatusEnvelope(input, services) {
+    return toEnvelope('vgxness_sdd_status', services.sdd.getStatus(input));
+}
+export function sddReadyEnvelope(input, services) {
+    return auditedEnvelope('vgxness_sdd_ready', services.sdd.getReady(input), services, sddReadinessAuditPayload(input));
+}
+export function sddGetReadinessEnvelope(input, services) {
+    return auditedEnvelope('vgxness_sdd_get_readiness', services.sdd.getReady(input), services, sddReadinessAuditPayload(input));
+}
+export function sddSaveArtifactEnvelope(input, services) {
+    return auditedEnvelope('vgxness_sdd_save_artifact', services.sdd.saveArtifact(input), services, sddSaveAuditPayload(input));
+}
+export function sddAcceptArtifactEnvelope(input, services) {
+    const accepted = auditedEnvelope('vgxness_sdd_accept_artifact', services.sdd.acceptArtifact(input), services, sddAcceptanceAuditPayload(input));
+    if (!accepted.ok)
+        return accepted;
+    const memoryCapture = sddReferenceMemoryCapture(input, accepted.value);
+    if (memoryCapture !== undefined)
+        accepted.memoryCapture = memoryCapture;
+    return accepted;
+}
+export function sddReopenArtifactEnvelope(input, services) {
+    return auditedEnvelope('vgxness_sdd_reopen_artifact', services.sdd.reopenArtifact(input), services, sddReopenAuditPayload(input));
+}
+export function sddGetArtifactEnvelope(input, services) {
+    return toEnvelope('vgxness_sdd_get_artifact', services.sdd.getArtifact(input));
+}
+export function sddListArtifactsEnvelope(input, services) {
+    return toEnvelope('vgxness_sdd_list_artifacts', services.sdd.listArtifacts(input));
+}
+export function sddNextEnvelope(input, services) {
+    return toEnvelope('vgxness_sdd_next', services.sdd.getNext(input));
+}
+export function sddCockpitEnvelope(input, services) {
+    return toEnvelope('vgxness_sdd_cockpit', sddCockpitSurfaceResponse(input, services));
+}
+export function sddContinueEnvelope(input, services) {
+    const context = services.sdd.getContinuationContext({ project: input.project, change: input.change });
+    if (!context.ok)
+        return errorEnvelope(context.error.code, context.error.message, 'vgxness_sdd_continue');
+    const relatedRun = services.runs.findRelatedInterruptedSddRun({ project: input.project, change: input.change });
+    if (!relatedRun.ok)
+        return errorEnvelope(relatedRun.error.code, relatedRun.error.message, 'vgxness_sdd_continue');
+    return successEnvelope('vgxness_sdd_continue', sddContinuationPlanFrom({
+        project: input.project,
+        next: context.value.next,
+        cockpit: context.value.cockpit,
+        ...(relatedRun.value === undefined ? {} : { relatedRunContext: relatedRun.value }),
+    }));
+}
+export function governanceReportEnvelope(input, services) {
+    return auditedEnvelope('vgxness_governance_report', new GovernanceReportBuilder({
+        sdd: governanceSddServices(services.sdd),
+        runs: services.runs,
+        agents: services.agents,
+        ...(services.managerProfiles === undefined ? {} : { managerProfiles: services.managerProfiles }),
+    }).build(input), services, governanceReportAuditPayload(input));
+}
+function sddReadinessAuditPayload(input) {
+    return {
+        runId: input.runId,
+        title: 'Audit: sdd-readiness-evaluated',
+        relatedType: 'sdd-readiness',
+        relatedId: `${input.change}:${input.phase}`,
+        payload: (value) => ({
+            eventType: 'sdd-readiness-evaluated',
+            project: input.project,
+            change: input.change,
+            phase: input.phase,
+            ready: value.ready,
+            satisfiedPrerequisites: [...value.satisfiedPrerequisites],
+            missingArtifactTopicKeys: [...value.missingArtifactTopicKeys],
+            blockedPrerequisites: (value.blockedPrerequisites ?? []).map((blocker) => ({ phase: blocker.phase, topicKey: blocker.topicKey, reason: blocker.reason })),
+            ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+        }),
+    };
+}
+function sddAcceptanceAuditPayload(input) {
+    return {
+        runId: input.runId,
+        title: 'Audit: sdd-artifact-accepted',
+        relatedType: 'sdd-artifact',
+        relatedId: `${input.change}:${input.phase}`,
+        payload: (value) => ({
+            eventType: 'sdd-artifact-accepted',
+            project: input.project,
+            change: input.change,
+            phase: input.phase,
+            topicKey: value.topicKey,
+            artifactId: value.id,
+            acceptedBy: { type: 'human', id: input.acceptedBy?.id ?? 'unknown-human' },
+            ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+        }),
+    };
+}
+function sddReopenAuditPayload(input) {
+    return {
+        runId: input.runId,
+        title: 'Audit: sdd-artifact-reopened',
+        relatedType: 'sdd-artifact',
+        relatedId: `${input.change}:${input.phase}`,
+        payload: (value) => ({
+            eventType: 'sdd-artifact-reopened',
+            project: input.project,
+            change: input.change,
+            phase: input.phase,
+            topicKey: value.topicKey,
+            artifactId: value.id,
+            reopenedBy: { type: 'human', id: input.reopenedBy.id },
+            ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+        }),
+    };
+}
+function sddSaveAuditPayload(input) {
+    return {
+        runId: input.runId,
+        title: 'Audit: sdd-artifact-saved',
+        relatedType: 'sdd-artifact',
+        relatedId: `${input.change}:${input.phase}`,
+        payload: (value) => ({
+            eventType: 'sdd-artifact-saved',
+            project: input.project,
+            change: input.change,
+            phase: input.phase,
+            topicKey: value.topicKey,
+            artifactId: value.id,
+            ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+        }),
+    };
+}
+function sddReferenceMemoryCapture(input, artifact) {
+    try {
+        const captureInput = {
+            source: input.phase === 'archive' ? 'sdd_archive' : 'sdd_acceptance',
+            project: artifact.project,
+            change: input.change,
+            phase: input.phase,
+            artifactId: artifact.id,
+            topicKey: artifact.topicKey,
+            artifactState: 'accepted',
+        };
+        if (input.acceptedBy?.type !== undefined && input.acceptedBy.id !== undefined) {
+            captureInput.acceptedBy = {
+                type: input.acceptedBy.type,
+                id: input.acceptedBy.id,
+                ...(input.acceptedBy.displayName === undefined ? {} : { displayName: input.acceptedBy.displayName }),
+            };
+        }
+        if (input.acceptedAt !== undefined)
+            captureInput.acceptedAt = input.acceptedAt;
+        if (input.runId !== undefined)
+            captureInput.runId = input.runId;
+        if (input.agentId !== undefined)
+            captureInput.agentId = input.agentId;
+        const result = new AgentMemoryCaptureService().captureFromSddReferenceEvent(captureInput);
+        return result.ok ? result.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function governanceReportAuditPayload(input) {
+    return {
+        runId: input.runId,
+        title: 'Audit: governance-report-generated',
+        relatedType: 'governance-report',
+        relatedId: input.change,
+        payload: (value) => ({
+            eventType: 'governance-report-generated',
+            project: value.project,
+            ...(value.change === undefined ? {} : { change: value.change }),
+            ...(value.runId === undefined ? {} : { runId: value.runId }),
+            ...(value.workflow === undefined ? {} : { workflow: value.workflow }),
+            ...(value.phase === undefined ? {} : { phase: value.phase }),
+            artifactCount: value.sdd.artifacts?.length ?? 0,
+            payloadMode: value.payloadMode,
+            readinessReady: value.sdd.readiness?.ready ?? null,
+            warningCount: value.warnings.length,
+            openCodeMode: value.openCode.mode,
+            overlayPresent: value.overlay.present,
+            ...(value.overlay.source === undefined ? {} : { overlaySource: value.overlay.source }),
+            ...(value.overlay.fingerprint === undefined ? {} : { overlayFingerprint: value.overlay.fingerprint }),
+        }),
+    };
+}
+function governanceSddServices(services) {
+    return {
+        getStatus: services.getStatus.bind(services),
+        getReady: services.getReady.bind(services),
+        listArtifacts: (input) => {
+            const result = services.listArtifacts({ ...input, payloadMode: 'verbose' });
+            return result;
+        },
+    };
+}
+function sddCockpitSurfaceResponse(input, services) {
+    const cockpit = services.sdd.getCockpit(input);
+    if (!cockpit.ok)
+        return cockpit;
+    const operationalEvidence = services.runs.getSddOperationalEvidence({ project: input.project, change: input.change });
+    if (!operationalEvidence.ok)
+        return { ok: true, value: buildSddCockpitSurfaceResponse(cockpit.value) };
+    return { ok: true, value: buildSddCockpitSurfaceResponse(cockpit.value, { operationalEvidenceByPhase: operationalEvidence.value }) };
+}

package/dist/interfaces/mcp/control-plane/handlers/sessions.js

@@ -0,0 +1,39 @@
+import { AgentMemoryCaptureService } from '../../../../memory/agent-memory-capture-service.js';
+import { errorEnvelope, successEnvelope, } from '../../schema.js';
+function memoryContext(sessionId) {
+    const context = { actor: 'mcp-control-plane' };
+    if (sessionId !== undefined)
+        context.sessionId = sessionId;
+    return context;
+}
+function toEnvelope(tool, result) {
+    return result.ok ? successEnvelope(tool, result.value) : errorEnvelope(result.error.code, result.error.message, tool);
+}
+export function sessionStartEnvelope(input, services) {
+    return toEnvelope('vgxness_session_start', services.memory.saveSession(input, memoryContext(input.id)));
+}
+export function sessionAppendActivityEnvelope(input, services) {
+    return toEnvelope('vgxness_session_append_activity', services.memory.appendActivity(input, memoryContext(input.sessionId)));
+}
+export function sessionRestoreEnvelope(input, services) {
+    return toEnvelope('vgxness_session_restore', services.memory.restoreSession(input));
+}
+export function sessionCloseEnvelope(input, services) {
+    const closed = services.memory.closeSession(input, memoryContext(input.sessionId));
+    if (!closed.ok)
+        return errorEnvelope(closed.error.code, closed.error.message, 'vgxness_session_close');
+    const memoryCapture = sessionCloseMemoryCapture(input, closed.value);
+    const envelope = { ok: true, tool: 'vgxness_session_close', value: closed.value };
+    if (memoryCapture !== undefined)
+        envelope.memoryCapture = memoryCapture;
+    return envelope;
+}
+function sessionCloseMemoryCapture(input, session) {
+    const result = new AgentMemoryCaptureService().captureFromSessionClose({
+        project: session.project,
+        sessionId: session.id,
+        ...(session.directory === undefined ? {} : { directory: session.directory }),
+        summary: input.summary,
+    });
+    return result.ok ? result.value : undefined;
+}

package/dist/interfaces/mcp/control-plane/handlers/skills.js

@@ -0,0 +1,82 @@
+import { errorEnvelope, successEnvelope, } from '../../schema.js';
+function toEnvelope(tool, result) {
+    return result.ok ? successEnvelope(tool, result.value) : errorEnvelope(result.error.code, result.error.message, tool);
+}
+export function skillIndexEnvelope(input, services) {
+    if (services.skillIndex === undefined)
+        return errorEnvelope('validation_failed', 'Skill index service is not available', 'vgxness_skill_index');
+    return toEnvelope('vgxness_skill_index', services.skillIndex.getIndex(input));
+}
+export function skillSearchEnvelope(input, services) {
+    if (services.skills.searchSkills === undefined)
+        return errorEnvelope('validation_failed', 'Skill search service is not available', 'vgxness_skill_search');
+    return toEnvelope('vgxness_skill_search', services.skills.searchSkills(input));
+}
+export function skillGetEnvelope(input, services) {
+    if (services.skills.getSkill === undefined)
+        return errorEnvelope('validation_failed', 'Skill get service is not available', 'vgxness_skill_get');
+    return toEnvelope('vgxness_skill_get', services.skills.getSkill(input));
+}
+export function skillStatusEnvelope(input, services) {
+    if (services.skillStatus === undefined)
+        return errorEnvelope('validation_failed', 'Skill status service is not available', 'vgxness_skill_status');
+    return toEnvelope('vgxness_skill_status', services.skillStatus.getStatus(input));
+}
+export function skillPayloadEnvelope(input, services) {
+    const seeded = services.seedBuiltInSkills?.();
+    if (seeded !== undefined && !seeded.ok)
+        return errorEnvelope(seeded.error.code, seeded.error.message, 'vgxness_skill_payload');
+    const { workspaceRoot, maxSourceBytes, mode, ...resolverInput } = input;
+    const options = { workspaceRoot, ...(maxSourceBytes === undefined ? {} : { maxSourceBytes }), ...(mode === undefined ? {} : { mode }) };
+    return toEnvelope('vgxness_skill_payload', services.skills.buildSkillPayload(resolverInput, options));
+}
+export function skillActivateEnvelope(input, services) {
+    if (services.skills.activateSkill === undefined)
+        return errorEnvelope('validation_failed', 'Skill activation service is not available', 'vgxness_skill_activate');
+    return toEnvelope('vgxness_skill_activate', services.skills.activateSkill(input));
+}
+export function skillRecordUsageEnvelope(input, services) {
+    if (services.skills.recordSkillUsage === undefined)
+        return errorEnvelope('validation_failed', 'Skill usage service is not available', 'vgxness_skill_record_usage');
+    return toEnvelope('vgxness_skill_record_usage', services.skills.recordSkillUsage(input));
+}
+export function skillProposeImprovementEnvelope(input, services) {
+    if (services.skills.proposeSkillImprovement === undefined)
+        return errorEnvelope('validation_failed', 'Skill improvement proposal service is not available', 'vgxness_skill_propose_improvement');
+    return toEnvelope('vgxness_skill_propose_improvement', services.skills.proposeSkillImprovement(input));
+}
+export function skillListImprovementProposalsEnvelope(input, services) {
+    if (services.skills.listSkillImprovementProposals === undefined)
+        return errorEnvelope('validation_failed', 'Skill improvement proposal list service is not available', 'vgxness_skill_list_improvement_proposals');
+    return toEnvelope('vgxness_skill_list_improvement_proposals', services.skills.listSkillImprovementProposals(input));
+}
+export function skillRequestEvaluationEnvelope(input, services) {
+    if (services.skills.requestSkillEvaluation === undefined)
+        return errorEnvelope('validation_failed', 'Skill evaluation request service is not available', 'vgxness_skill_request_evaluation');
+    return toEnvelope('vgxness_skill_request_evaluation', services.skills.requestSkillEvaluation(input));
+}
+export function skillListEvaluationsEnvelope(input, services) {
+    if (services.skills.listSkillEvaluations === undefined)
+        return errorEnvelope('validation_failed', 'Skill evaluation list service is not available', 'vgxness_skill_list_evaluations');
+    return toEnvelope('vgxness_skill_list_evaluations', services.skills.listSkillEvaluations(input));
+}
+export function skillGetEvaluationEnvelope(input, services) {
+    if (services.skills.getSkillEvaluationRequest === undefined)
+        return errorEnvelope('validation_failed', 'Skill evaluation get service is not available', 'vgxness_skill_get_evaluation');
+    return toEnvelope('vgxness_skill_get_evaluation', services.skills.getSkillEvaluationRequest(input));
+}
+export function skillCreateDraftEnvelope(input, services) {
+    if (services.skills.createSkillDraft === undefined)
+        return errorEnvelope('validation_failed', 'Skill draft creation service is not available', 'vgxness_skill_create_draft');
+    return toEnvelope('vgxness_skill_create_draft', services.skills.createSkillDraft(input));
+}
+export function skillUpdateDraftEnvelope(input, services) {
+    if (services.skills.updateSkillDraft === undefined)
+        return errorEnvelope('validation_failed', 'Skill draft update service is not available', 'vgxness_skill_update_draft');
+    return toEnvelope('vgxness_skill_update_draft', services.skills.updateSkillDraft(input));
+}
+export function skillPublishVersionEnvelope(input, services) {
+    if (services.skills.publishSkillVersion === undefined)
+        return errorEnvelope('validation_failed', 'Skill version publication service is not available', 'vgxness_skill_publish_version');
+    return toEnvelope('vgxness_skill_publish_version', services.skills.publishSkillVersion(input));
+}

package/dist/interfaces/mcp/control-plane/handlers/verification.js

@@ -0,0 +1,11 @@
+import { errorEnvelope, successEnvelope } from '../../schema.js';
+function toEnvelope(result) {
+    return result.ok
+        ? successEnvelope('vgxness_verification_plan', result.value)
+        : errorEnvelope(result.error.code, result.error.message, 'vgxness_verification_plan');
+}
+export function verificationPlanEnvelope(input, services) {
+    if (services.verificationPlan === undefined)
+        return errorEnvelope('validation_failed', 'Verification plan service is not available', 'vgxness_verification_plan');
+    return toEnvelope(services.verificationPlan.getPlan(input.changeType));
+}