vgxness 1.9.0 → 1.9.2

package/dist/agents/repositories/agent-seed-history.js

@@ -0,0 +1,128 @@
+import { randomUUID } from 'node:crypto';
+export class AgentSeedHistoryRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    append(input) {
+        const validation = validate(input);
+        if (!validation.ok)
+            return validation;
+        try {
+            const id = randomUUID();
+            const appliedAt = new Date().toISOString();
+            this.db.connection
+                .prepare(`
+        INSERT INTO agent_seed_history(id, applied_at, from_version, to_version, agent_name, project, scope, outcome, reason, source)
+        VALUES (@id, @appliedAt, @fromVersion, @toVersion, @agentName, @project, @scope, @outcome, @reason, @source)
+      `)
+                .run({
+                id,
+                appliedAt,
+                fromVersion: input.fromVersion,
+                toVersion: input.toVersion,
+                agentName: input.agentName,
+                project: input.project,
+                scope: input.scope,
+                outcome: input.outcome,
+                reason: input.reason ?? null,
+                source: input.source,
+            });
+            const entry = {
+                id,
+                appliedAt,
+                fromVersion: input.fromVersion,
+                toVersion: input.toVersion,
+                agentName: input.agentName,
+                project: input.project,
+                scope: input.scope,
+                outcome: input.outcome,
+                reason: input.reason ?? null,
+                source: input.source,
+            };
+            return ok(entry);
+        }
+        catch (cause) {
+            return fail('Failed to append agent_seed_history entry', cause);
+        }
+    }
+    listRecent(filters = {}) {
+        try {
+            const where = [];
+            const parameters = {};
+            for (const [key, column] of [
+                ['project', 'project'],
+                ['scope', 'scope'],
+                ['agentName', 'agent_name'],
+            ]) {
+                const value = filters[key];
+                if (value !== undefined) {
+                    where.push(`${column}=@${key}`);
+                    parameters[key] = value;
+                }
+            }
+            const limit = Math.max(1, Math.min(filters.limit ?? 100, 1000));
+            const rows = this.db.connection
+                .prepare(`
+        SELECT * FROM agent_seed_history
+        ${where.length ? `WHERE ${where.join(' AND ')}` : ''}
+        ORDER BY applied_at DESC
+        LIMIT ${limit}
+      `)
+                .all(parameters);
+            return ok(rows.map(map));
+        }
+        catch (cause) {
+            return fail('Failed to list agent_seed_history entries', cause);
+        }
+    }
+}
+function validate(input) {
+    if (!input.project.trim())
+        return validationFailure('agent_seed_history project is required');
+    if (input.scope !== 'project' && input.scope !== 'personal')
+        return validationFailure('agent_seed_history scope is invalid');
+    if (!input.agentName.trim())
+        return validationFailure('agent_seed_history agentName is required');
+    if (!Number.isInteger(input.toVersion) || input.toVersion <= 0)
+        return validationFailure('agent_seed_history toVersion must be a positive integer');
+    if (input.fromVersion !== null && (!Number.isInteger(input.fromVersion) || input.fromVersion < 0))
+        return validationFailure('agent_seed_history fromVersion must be null or non-negative integer');
+    if (!input.source.trim())
+        return validationFailure('agent_seed_history source is required');
+    if (input.outcome !== 'created' &&
+        input.outcome !== 'upgraded' &&
+        input.outcome !== 'noop' &&
+        input.outcome !== 'overwrote-custom-instructions' &&
+        input.outcome !== 'validation_failed' &&
+        input.outcome !== 'db_error') {
+        return validationFailure(`agent_seed_history outcome is invalid: ${input.outcome}`);
+    }
+    return ok(undefined);
+}
+function map(row) {
+    return {
+        id: String(row.id),
+        appliedAt: String(row.applied_at),
+        fromVersion: row.from_version === null || row.from_version === undefined ? null : Number(row.from_version),
+        toVersion: Number(row.to_version),
+        agentName: String(row.agent_name),
+        project: String(row.project),
+        scope: row.scope,
+        outcome: String(row.outcome),
+        reason: row.reason === null || row.reason === undefined ? null : String(row.reason),
+        source: String(row.source),
+    };
+}
+function ok(value) {
+    return { ok: true, value };
+}
+function validationFailure(message) {
+    return { ok: false, error: { code: 'validation_failed', message } };
+}
+function fail(message, cause) {
+    const error = { code: 'validation_failed', message };
+    if (cause !== undefined)
+        error.cause = cause;
+    return { ok: false, error };
+}

package/dist/behavior/behavior-contract-manifest.js

@@ -0,0 +1,42 @@
+export const canonicalBehaviorContractName = 'vgxness-manager-behavior-contract';
+export const canonicalBehaviorContractVersion = '1.0.0';
+export const criticalBehaviorContractInvariantIds = [
+    'sdd.acceptance.human-only',
+    'sdd.draft-is-not-accepted',
+    'sdd.readiness-before-advance',
+    'provider.preview-status-doctor-readonly',
+    'provider.config-writes-explicit-consent',
+    'run.risky-effects-preflight',
+    'delegation.deny-by-default',
+    'delegation.no-wildcard',
+    'context.manager-compact-default',
+    'context.progressive-disclosure',
+    'flow.provider-native-no-terminal-sdd-daily',
+    'scope.exclude-vgxcode-runtime',
+    'worktree.preserve-unrelated-user-work',
+];
+export const behaviorContractManifest = {
+    name: canonicalBehaviorContractName,
+    contractVersion: canonicalBehaviorContractVersion,
+    excludedTargets: ['vgxcode', 'src/code/runtime/*', 'src/code/prompts/*'],
+    invariants: [
+        { id: 'sdd.acceptance.human-only', category: 'sdd', severity: 'critical', summary: 'SDD acceptance is recorded only from explicit human acceptance.' },
+        { id: 'sdd.draft-is-not-accepted', category: 'sdd', severity: 'critical', summary: 'Draft, rejected, superseded, legacy, or unaccepted artifacts are not accepted prerequisites.' },
+        { id: 'sdd.readiness-before-advance', category: 'sdd', severity: 'critical', summary: 'Phase advancement checks readiness/status before treating prerequisites as satisfied.' },
+        { id: 'provider.preview-status-doctor-readonly', category: 'provider', severity: 'critical', summary: 'Preview, status, and doctor surfaces are read-only and do not write provider configuration.' },
+        { id: 'provider.config-writes-explicit-consent', category: 'provider', severity: 'critical', summary: 'Provider configuration writes require explicit user consent through confirmed flows.' },
+        { id: 'run.risky-effects-preflight', category: 'run', severity: 'critical', summary: 'Risky edits, shell, git, provider, secret, destructive, privileged, or ambiguous effects require preflight.' },
+        { id: 'delegation.deny-by-default', category: 'delegation', severity: 'critical', summary: 'Delegation defaults to deny unless an exact governed path allows it.' },
+        { id: 'delegation.no-wildcard', category: 'delegation', severity: 'critical', summary: 'Wildcard delegation is not allowed; exact canonical subagents must be used.' },
+        { id: 'context.manager-compact-default', category: 'context', severity: 'critical', summary: 'Manager-facing context defaults to compact payloads.' },
+        { id: 'context.progressive-disclosure', category: 'context', severity: 'critical', summary: 'Expanded and verbose context are requested only when needed.' },
+        { id: 'flow.provider-native-no-terminal-sdd-daily', category: 'flow', severity: 'critical', summary: 'Daily SDD progression happens provider-natively through conversation and MCP, not mandatory terminal phase commands.' },
+        { id: 'scope.exclude-vgxcode-runtime', category: 'scope', severity: 'critical', summary: 'This behavior contract excludes vgxcode and src/code runtime/prompt implementation targets.' },
+        { id: 'worktree.preserve-unrelated-user-work', category: 'worktree', severity: 'critical', summary: 'Unrelated user work and dirty files are preserved.' },
+    ],
+};
+export const behaviorContractProjectionMetadata = {
+    behaviorContractName: canonicalBehaviorContractName,
+    behaviorContractVersion: canonicalBehaviorContractVersion,
+    criticalInvariantIds: criticalBehaviorContractInvariantIds,
+};

package/dist/behavior/behavior-contract-schema.js

@@ -0,0 +1 @@
+export {};

package/dist/behavior/behavior-contract-validation.js

@@ -0,0 +1,42 @@
+import { behaviorContractManifest, criticalBehaviorContractInvariantIds } from './behavior-contract-manifest.js';
+export function validateBehaviorContractManifest(manifest = behaviorContractManifest) {
+    const errors = [];
+    if (!manifest.name.trim())
+        errors.push('behavior contract name is required');
+    if (!manifest.contractVersion.trim())
+        errors.push('behavior contract version is required');
+    const seen = new Set();
+    for (const invariant of manifest.invariants) {
+        if (!invariant.id.trim())
+            errors.push('invariant id is required');
+        if (seen.has(invariant.id))
+            errors.push(`duplicate invariant id: ${invariant.id}`);
+        seen.add(invariant.id);
+        if (!invariant.summary.trim())
+            errors.push(`invariant ${invariant.id} summary is required`);
+    }
+    for (const id of criticalBehaviorContractInvariantIds) {
+        const invariant = manifest.invariants.find((candidate) => candidate.id === id);
+        if (invariant === undefined)
+            errors.push(`missing critical invariant: ${id}`);
+        else if (invariant.severity !== 'critical')
+            errors.push(`critical invariant ${id} must have severity critical`);
+    }
+    for (const target of ['vgxcode', 'src/code/runtime/*', 'src/code/prompts/*']) {
+        if (!manifest.excludedTargets.includes(target))
+            errors.push(`missing excluded target: ${target}`);
+    }
+    return { ok: errors.length === 0, errors };
+}
+export function validateBehaviorContractProjection(metadata, manifest = behaviorContractManifest) {
+    const errors = [];
+    if (metadata.behaviorContractName !== manifest.name)
+        errors.push(`behavior contract name mismatch: ${metadata.behaviorContractName}`);
+    if (metadata.behaviorContractVersion !== manifest.contractVersion)
+        errors.push(`behavior contract version mismatch: ${metadata.behaviorContractVersion}`);
+    for (const id of criticalBehaviorContractInvariantIds) {
+        if (!metadata.criticalInvariantIds.includes(id))
+            errors.push(`projection missing critical invariant reference: ${id}`);
+    }
+    return { ok: errors.length === 0, errors };
+}

package/dist/cli/commands/mcp-dispatcher.js

@@ -6,7 +6,9 @@ import { createMcpClientSetupPreview, isMcpClientSetupProvider } from '../../mcp
 import { createMcpDoctorReport } from '../../mcp/doctor.js';
 import { createOpenCodeMcpVisibilityReport } from '../../mcp/opencode-visibility.js';
 import { resolveClaudeCodeScope } from '../../mcp/claude-code-scope.js';
+import { computeEffectiveManagerInstructions } from '../../agents/manager-profile-overlay-service.js';
 import { RunService } from '../../runs/run-service.js';
+import { isTerminalRunStatus } from '../../runs/schema.js';
 import { databasePathFor, databasePathSelectionFor, opencodeInstallScopeFlag, optionalNumberFlag, optionalStringFlag } from '../cli-flags.js';
 import { usageFailure, validationFailure } from '../cli-help.js';
 import { jsonResult, openCliDatabase, resultFailure } from '../cli-helpers.js';
@@ -42,6 +44,7 @@ export function runMcpInstallCommand(parsed, environment) {
                 return resultFailure(opened);
             try {
                 const preflight = createClaudeCodeInstallPreflight(parsed, opened.value, environment);
+                const effectiveManagerInstructions = computeEffectiveManagerInstructions(opened.value);
                 const result = await installClaudeCodeMcpClient({
                     cwd: environment.cwd,
                     databasePath: databasePath.value.path,
@@ -50,6 +53,7 @@ export function runMcpInstallCommand(parsed, environment) {
                     overwriteVgxness,
                     scope: claudeScope.value,
                     preflight,
+                    ...(effectiveManagerInstructions === undefined ? {} : { effectiveManagerInstructions }),
                 });
                 return result.status === 'installed' ? jsonResult({ ok: true, value: result }) : resultFailure({ ok: false, error: { code: 'validation_failed', message: `${result.reason}: ${result.message}` } });
             }
@@ -107,6 +111,9 @@ function createClaudeCodeInstallPreflight(parsed, database, environment) {
         const details = service.getRun(runId);
         if (!details.ok)
             return details;
+        if (isTerminalRunStatus(details.value.status)) {
+            return validationFailure(`VGXNESS run ${runId} is in terminal state '${details.value.status}'; Claude Code provider config writes require a live run (created/planned/running/needs-human). Start a new run with \`vgxness run start\` and pass its --run-id.`);
+        }
         const phase = optionalStringFlag(parsed.flags, 'phase') ?? details.value.phase;
         const agentId = optionalStringFlag(parsed.flags, 'agent-id') ?? details.value.selectedAgentId;
         const preflight = service.preflightOperation({

package/dist/cli/dispatcher.js

@@ -4,6 +4,7 @@ import { isWorkflowId } from '../workflows/schema.js';
 import { databasePathFor, parseArgs, requiredFlag } from './cli-flags.js';
 import { okText, usageFailure, visibleHelpText } from './cli-help.js';
 import { openCliDatabase, resultFailure } from './cli-helpers.js';
+import { runBootAgentSeedUpgrade } from '../agents/boot-upgrade.js';
 import { runAgentCommand, runApprovalsCommand, runCodeCliCommand, runDefaultInteractiveEntrypoint, runDoctorAliasCommand, runInitCommand, runMcpDoctorCommand, runMcpInstallCommand, runMcpSetupCommand, runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runPermissionsCommand, runRunsCommand, runSddCommand, runSetupApplyCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupRollbackCommand, runSkillCommand, runSubagentCommand, runVerificationPlanCommand, runVerificationReportCommand, runWorkflowExecuteCommand, runWorkflowPreviewCommand, runWorkflowRunCommand, } from './commands/index.js';
 const _promptBuffers = new WeakMap();
 const require = createRequire(import.meta.url);
@@ -48,6 +49,7 @@ export function dispatchCli(argv, environment) {
     const opened = openCliDatabase(databasePath);
     if (!opened.ok)
         return resultFailure(opened);
+    runBootAgentSeedUpgrade(opened.value, environment.env);
     try {
         if (isWorkflowId(area) && command === 'run')
             return runWorkflowRunCommand(area, parsed, opened.value);

package/dist/mcp/client-install-claude-code-contract.js

@@ -1,3 +1,4 @@
+import { withEffectiveManagerInstructions } from '../agents/canonical-agent-projection.js';
 import { expectedClaudeCodeAgentFiles, inspectClaudeCodeAgents, renderClaudeCodeAgentMarkdown } from './claude-code-agent-config.js';
 import { buildClaudeCodeMcpAddCommand } from './claude-code-cli.js';
 import { createClaudeCodeMcpDoctorCommand, createClaudeCodeMcpServerConfig, inspectClaudeCodeMcpConfig, resolveClaudeCodeMcpJsonPath } from './claude-code-config.js';
@@ -63,11 +64,25 @@ export function planClaudeCodeMcpInstall(input) {
         status: 'would_install',
     };
 }
-export function expectedClaudeCodeRenderedAgents(workspaceRoot) {
-    return expectedClaudeCodeAgentFiles(workspaceRoot).map((agent) => ({ path: agent.path, agentName: agent.name, contents: renderClaudeCodeAgentMarkdown(agent) }));
+export function expectedClaudeCodeRenderedAgents(workspaceRoot, options) {
+    const files = expectedClaudeCodeAgentFiles(workspaceRoot);
+    const projection = withEffectiveManagerInstructions({ defaultAgent: 'vgxness-manager', agents: files.map(({ path: _path, ...rest }) => rest) }, options?.effectiveManagerInstructions);
+    return projection.agents.map((agent) => {
+        const file = files.find((entry) => entry.name === agent.name);
+        if (file === undefined)
+            throw new Error(`Expected Claude agent file missing for ${agent.name}`);
+        return { path: file.path, agentName: agent.name, contents: renderClaudeCodeAgentMarkdown(agent) };
+    });
 }
-export function expectedClaudeCodeRenderedUserAgents(workspaceRoot, env) {
-    return expectedClaudeCodeAgentFiles({ workspaceRoot, scope: 'user', ...(env === undefined ? {} : { env }) }).map((agent) => ({ path: agent.path, agentName: agent.name, contents: renderClaudeCodeAgentMarkdown(agent) }));
+export function expectedClaudeCodeRenderedUserAgents(workspaceRoot, env, options) {
+    const files = expectedClaudeCodeAgentFiles({ workspaceRoot, scope: 'user', ...(env === undefined ? {} : { env }) });
+    const projection = withEffectiveManagerInstructions({ defaultAgent: 'vgxness-manager', agents: files.map(({ path: _path, ...rest }) => rest) }, options?.effectiveManagerInstructions);
+    return projection.agents.map((agent) => {
+        const file = files.find((entry) => entry.name === agent.name);
+        if (file === undefined)
+            throw new Error(`Expected Claude user agent file missing for ${agent.name}`);
+        return { path: file.path, agentName: agent.name, contents: renderClaudeCodeAgentMarkdown(agent) };
+    });
 }
 function planUserInstall(input, server, overwriteVgxness, cliCommand, scopeWarnings) {
     const mcpState = inspectClaudeCodeUserMcpConfig(input.env);

package/dist/mcp/client-install-claude-code.js

@@ -62,7 +62,7 @@ export async function installClaudeCodeMcpClient(input) {
     if (!mcpWrite.ok)
         return refusal('post_write_validation_failed', mcpWrite.error.message, plan, server, writtenPaths, backups);
     writtenPaths.push(mcpWrite.value);
-    for (const agent of expectedClaudeCodeRenderedAgents(input.cwd)) {
+    for (const agent of expectedClaudeCodeRenderedAgents(input.cwd, { effectiveManagerInstructions: input.effectiveManagerInstructions })) {
         const target = plan.targets.find((item) => item.kind === 'agent-file' && item.path === agent.path);
         if (target?.action !== 'create' && target?.action !== 'update-vgxness')
             continue;
@@ -140,7 +140,7 @@ async function applyUserInstall(input, plan, server, writtenPaths, backups) {
     if (!mcpWrite.ok)
         return refusal('post_write_validation_failed', mcpWrite.error.message, plan, server, writtenPaths, backups);
     writtenPaths.push(mcpWrite.value);
-    for (const agent of expectedClaudeCodeRenderedUserAgents(input.cwd, input.env)) {
+    for (const agent of expectedClaudeCodeRenderedUserAgents(input.cwd, input.env, { effectiveManagerInstructions: input.effectiveManagerInstructions })) {
         const target = plan.targets.find((item) => item.kind === 'agent-file' && item.path === agent.path);
         if (target?.action !== 'create' && target?.action !== 'update-vgxness')
             continue;

package/dist/mcp/control-plane-snapshot-service.js

@@ -0,0 +1,272 @@
+import { ContextBudgetService } from '../payload/context-budget-service.js';
+export const contextCockpitSnapshotLevels = ['compact', 'expanded', 'verbose'];
+export class ContextCockpitSnapshotService {
+    dependencies;
+    budget;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        this.budget = dependencies.budget ?? new ContextBudgetService();
+    }
+    build(input) {
+        const level = input.level ?? 'compact';
+        const legacyInput = {
+            project: input.project,
+            ...(input.directory === undefined ? {} : { directory: input.directory }),
+            ...(input.limit === undefined ? {} : { limit: input.limit }),
+        };
+        const legacy = this.dependencies.memory.getContextCockpit(legacyInput);
+        if (!legacy.ok)
+            return legacy;
+        const sddResult = input.change === undefined ? undefined : this.buildSddSection({ project: input.project, change: input.change }, level);
+        if (sddResult !== undefined && !sddResult.ok)
+            return sddResult;
+        const sdd = sddResult?.value;
+        const integratesSdd = sdd !== undefined;
+        const optionalSectionsOmitted = omittedSections(legacy.value.optionalSectionsOmitted, integratesSdd ? ['provider'] : ['sdd', 'provider'], integratesSdd ? ['sdd'] : []);
+        const snapshotWithoutBudget = {
+            ...legacy.value,
+            optionalSectionsOmitted,
+            ...(sdd === undefined ? {} : { sdd }),
+            snapshotVersion: 2,
+            level,
+            references: [
+                {
+                    id: 'legacy-context-cockpit',
+                    kind: 'legacy-context-cockpit',
+                    description: 'Wrapped output from the existing no-trace context cockpit path.',
+                },
+            ],
+            warnings: [
+                ...(integratesSdd ? [] : ['sdd-snapshot-omitted:no-change']),
+                'provider-snapshot-omitted:no-workspace-root',
+            ],
+            safety: {
+                ...legacy.value.safety,
+                readOnly: true,
+                recordsTraces: false,
+                noTrace: true,
+                mutatesSessions: false,
+                noSessionMutation: true,
+                mutatesMemories: false,
+                noMemoryMutation: true,
+                mutatesArtifacts: false,
+                noArtifactMutation: true,
+                mutatesRuns: false,
+                noCheckpoints: true,
+                writesProviderConfig: false,
+                noProviderConfigWrites: true,
+                mutatesRepository: false,
+                executesProvider: false,
+                mutatesProviderConfig: false,
+                createsRun: false,
+                createsCheckpoint: false,
+                recordsTimelineEvent: false,
+                integratesSdd,
+                integratesProvider: false,
+            },
+        };
+        const report = this.budget.reportJson(budgetIdForLevel(level), snapshotWithoutBudget);
+        return {
+            ok: true,
+            value: {
+                ...snapshotWithoutBudget,
+                budget: {
+                    level,
+                    policy: budgetIdForLevel(level),
+                    report,
+                    memoryPreviewLimit: input.limit ?? legacy.value.memoryPreviews.length,
+                    includesSdd: integratesSdd,
+                    includesProvider: false,
+                    omittedSections: [
+                        ...(integratesSdd ? [] : ['sdd']),
+                        'provider',
+                        'runs',
+                        'memory-content',
+                        'session-transcripts',
+                        'provider-config-contents',
+                        'run-checkpoint-details',
+                    ],
+                    heavyContentPolicy: 'references-only',
+                    notes: ['Budget measured with ContextBudgetService.reportJson before adding the final budget section.'],
+                },
+            },
+        };
+    }
+    buildSddSection(input, level) {
+        if (this.dependencies.sdd === undefined) {
+            return { ok: false, error: { code: 'validation_failed', message: 'SDD cockpit service is not available' } };
+        }
+        const cockpit = this.dependencies.sdd.getCockpit(input);
+        if (!cockpit.ok)
+            return cockpit;
+        return { ok: true, value: toSddSection(cockpit.value, level) };
+    }
+}
+function toSddSection(cockpit, level) {
+    switch (level) {
+        case 'compact':
+            return toCompactSddSection(cockpit);
+        case 'expanded':
+            return toExpandedSddSection(cockpit);
+        case 'verbose':
+            return toVerboseSddSection(cockpit);
+    }
+}
+function toCompactSddSection(cockpit) {
+    return {
+        projection: 'compact',
+        project: cockpit.project,
+        change: cockpit.change,
+        recommendedAction: cockpit.recommendedAction,
+        ...(cockpit.actionablePhase === undefined ? {} : { actionablePhase: cockpit.actionablePhase }),
+        next: {
+            status: cockpit.next.status,
+            ...(cockpit.next.nextPhase === undefined ? {} : { nextPhase: cockpit.next.nextPhase }),
+            reason: cockpit.next.reason,
+        },
+        phases: cockpit.phases.map((phase) => ({
+            phase: phase.phase,
+            topicKey: phase.topicKey,
+            present: phase.present,
+            accepted: phase.accepted,
+            legacy: phase.legacy,
+            state: phase.state,
+            readinessReady: phase.readiness.ready,
+            blockerCount: phase.blockers.length,
+        })),
+        counts: {
+            phases: cockpit.phases.length,
+            artifacts: cockpit.artifacts.length,
+            accepted: cockpit.acceptedCount,
+            legacy: cockpit.legacyCount,
+            blockers: cockpit.aggregateBlockers.length,
+        },
+    };
+}
+function toExpandedSddSection(cockpit) {
+    return {
+        projection: 'expanded',
+        project: cockpit.project,
+        change: cockpit.change,
+        recommendedAction: cockpit.recommendedAction,
+        ...(cockpit.actionablePhase === undefined ? {} : { actionablePhase: cockpit.actionablePhase }),
+        next: {
+            status: cockpit.next.status,
+            ...(cockpit.next.nextPhase === undefined ? {} : { nextPhase: cockpit.next.nextPhase }),
+            reason: cockpit.next.reason,
+        },
+        phases: cockpit.phases.map(toExpandedSddPhase),
+        counts: {
+            phases: cockpit.phases.length,
+            artifacts: cockpit.artifacts.length,
+            accepted: cockpit.acceptedCount,
+            legacy: cockpit.legacyCount,
+            blockers: cockpit.aggregateBlockers.length,
+        },
+        blockers: cockpit.aggregateBlockers.map(toSddBlocker),
+    };
+}
+function toVerboseSddSection(cockpit) {
+    return {
+        projection: 'verbose',
+        project: cockpit.project,
+        change: cockpit.change,
+        recommendedAction: cockpit.recommendedAction,
+        ...(cockpit.actionablePhase === undefined ? {} : { actionablePhase: cockpit.actionablePhase }),
+        next: {
+            status: cockpit.next.status,
+            ...(cockpit.next.nextPhase === undefined ? {} : { nextPhase: cockpit.next.nextPhase }),
+            reason: cockpit.next.reason,
+        },
+        phases: cockpit.phases.map(toExpandedSddPhase),
+        counts: {
+            phases: cockpit.phases.length,
+            artifacts: cockpit.artifacts.length,
+            accepted: cockpit.acceptedCount,
+            legacy: cockpit.legacyCount,
+            blockers: cockpit.aggregateBlockers.length,
+        },
+        blockers: cockpit.aggregateBlockers.map(toSddBlocker),
+        artifacts: cockpit.artifacts.map(toArtifactMetadata),
+    };
+}
+function toExpandedSddPhase(phase) {
+    return {
+        phase: phase.phase,
+        topicKey: phase.topicKey,
+        present: phase.present,
+        accepted: phase.accepted,
+        legacy: phase.legacy,
+        state: phase.state,
+        readinessReady: phase.readiness.ready,
+        blockerCount: phase.blockers.length,
+        readiness: toReadinessMetadata(phase.readiness),
+        ...(phase.artifact === undefined ? {} : { artifact: toArtifactMetadata(phase.artifact) }),
+        blockers: phase.blockers.map(toSddBlocker),
+    };
+}
+function toReadinessMetadata(readiness) {
+    return {
+        change: readiness.change,
+        phase: readiness.phase,
+        ready: readiness.ready,
+        satisfiedPrerequisites: readiness.satisfiedPrerequisites,
+        missingArtifactTopicKeys: readiness.missingArtifactTopicKeys,
+        blockedPrerequisites: (readiness.blockedPrerequisites ?? []).map(toPrerequisiteBlocker),
+    };
+}
+function toPrerequisiteBlocker(blocker) {
+    return {
+        phase: blocker.phase,
+        topicKey: blocker.topicKey,
+        reason: blocker.reason,
+        ...(blocker.artifactId === undefined ? {} : { artifactId: blocker.artifactId }),
+    };
+}
+function toArtifactMetadata(artifact) {
+    return {
+        phase: artifact.phase,
+        topicKey: artifact.topicKey,
+        present: artifact.present,
+        accepted: artifact.accepted,
+        legacy: artifact.legacy,
+        state: artifact.state,
+        ...(artifact.artifactId === undefined ? {} : { artifactId: artifact.artifactId }),
+        ...(artifact.createdAt === undefined ? {} : { createdAt: artifact.createdAt }),
+        ...(artifact.updatedAt === undefined ? {} : { updatedAt: artifact.updatedAt }),
+        ...(artifact.acceptance === undefined ? {} : { acceptance: toAcceptanceMetadata(artifact.acceptance) }),
+    };
+}
+function toAcceptanceMetadata(acceptance) {
+    return {
+        actor: {
+            type: acceptance.actor.type,
+            id: acceptance.actor.id,
+            ...(acceptance.actor.displayName === undefined ? {} : { displayName: acceptance.actor.displayName }),
+        },
+        acceptedAt: acceptance.acceptedAt,
+    };
+}
+function toSddBlocker(blocker) {
+    return {
+        kind: blocker.kind,
+        phase: blocker.phase,
+        topicKey: blocker.topicKey,
+        reason: blocker.reason,
+        ...(blocker.artifactId === undefined ? {} : { artifactId: blocker.artifactId }),
+    };
+}
+function budgetIdForLevel(level) {
+    switch (level) {
+        case 'compact':
+            return 'snapshotCompact';
+        case 'expanded':
+            return 'snapshotExpanded';
+        case 'verbose':
+            return 'subagentVerbosePayload';
+    }
+}
+function omittedSections(legacy, required, resolved = []) {
+    const resolvedSet = new Set(resolved);
+    return [...new Set([...legacy, ...required])].filter((section) => !resolvedSet.has(section));
+}

package/dist/mcp/control-plane.js

@@ -12,6 +12,7 @@ import { SddWorkflowService } from '../sdd/sdd-workflow-service.js';
 import { SkillRegistryService } from '../skills/skill-registry-service.js';
 import { VerificationPlanService } from '../verification/index.js';
 import { ProviderChangePlanService } from './provider-change-plan.js';
+import { ContextCockpitSnapshotService } from './control-plane-snapshot-service.js';
 import { ProviderDoctorService } from './provider-doctor.js';
 import { ProviderStatusService } from './provider-status.js';
 import { errorEnvelope, successEnvelope, } from './schema.js';
@@ -31,7 +32,9 @@ export function callVgxTool(call, services) {
         case 'vgxness_sdd_save_artifact':
             return auditedEnvelope(validated.tool, services.sdd.saveArtifact(validated.input), services, sddSaveAuditPayload(validated.input));
         case 'vgxness_sdd_accept_artifact':
-            return auditedEnvelope(validated.tool, services.sdd.acceptArtifact(toAcceptArtifactServiceInput(validated.input)), services, sddAcceptanceAuditPayload(validated.input));
+            return auditedEnvelope(validated.tool, services.sdd.acceptArtifact(validated.input), services, sddAcceptanceAuditPayload(validated.input));
+        case 'vgxness_sdd_reopen_artifact':
+            return auditedEnvelope(validated.tool, services.sdd.reopenArtifact(validated.input), services, sddReopenAuditPayload(validated.input));
         case 'vgxness_sdd_get_artifact':
             return toEnvelope(validated.tool, services.sdd.getArtifact(validated.input));
         case 'vgxness_sdd_list_artifacts':
@@ -64,7 +67,7 @@ export function callVgxTool(call, services) {
         case 'vgxness_session_restore':
             return toEnvelope(validated.tool, services.memory.restoreSession(validated.input));
         case 'vgxness_context_cockpit':
-            return toEnvelope(validated.tool, services.memory.getContextCockpit(validated.input));
+            return toEnvelope(validated.tool, new ContextCockpitSnapshotService({ memory: services.memory, sdd: services.sdd }).build(validated.input));
         case 'vgxness_agent_resolve':
             return toEnvelope(validated.tool, services.agents.resolveAgents(validated.input));
         case 'vgxness_agent_activate':
@@ -116,10 +119,6 @@ export function callVgxTool(call, services) {
     }
     return errorEnvelope('validation_failed', 'Tool dispatch is not implemented');
 }
-function toAcceptArtifactServiceInput(input) {
-    const note = input.note ?? input.notes ?? input.rationale;
-    return note === undefined ? input : { ...input, note };
-}
 function auditedEnvelope(tool, result, services, audit) {
     if (result.ok && audit.runId !== undefined) {
         services.runs.appendEvent({
@@ -170,6 +169,24 @@ function sddAcceptanceAuditPayload(input) {
         }),
     };
 }
+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,
@@ -236,6 +253,7 @@ export function createVgxMcpControlPlane(options = {}) {
     let closed = false;
     return {
         callVgxTool: (tool, input) => callVgxTool({ tool, input }, services),
+        database,
         close: () => {
             if (closed)
                 return;