vgxness 1.12.0 → 1.14.0

package/dist/agents/canonical-agent-manifest.js

@@ -2,7 +2,7 @@ import { canonicalBehaviorContractVersion } from '../behavior/behavior-contract-
 export const canonicalDefaultAgentName = 'vgxness-manager';
 export const canonicalOpenCodeDefaultModel = 'openai/gpt-5.5';
 export const canonicalOpenCodeManagerReasoningEffort = 'high';
-export const canonicalPromptContractVersion = 10;
+export const canonicalPromptContractVersion = 11;
 export const canonicalSddSubagentNames = [
     'vgxness-sdd-explore',
     'vgxness-sdd-propose',
@@ -78,7 +78,7 @@ function managerDefinition() {
         builtIn: true,
         name: canonicalDefaultAgentName,
         description: 'Coordinates VGXNESS MCP state and SDD sub-agents while routing Tier 0-2 lightweight work, Tier 3 preflight validation, and Tier 4 formal SDD.',
-        instructions: { kind: 'inline', value: registryManagerInstructionsV10 },
+        instructions: { kind: 'inline', value: registryManagerInstructionsV11 },
         capabilities: ['sdd-orchestration', 'agent-routing', 'mcp-coordination', 'project-local-automation'],
         permissions: { read: 'allow', edit: 'ask', shell: 'ask', git: 'ask', memory: 'allow', 'provider-tool': 'deny', secrets: 'deny' },
         memory: { scopes: ['project'] },
@@ -166,7 +166,7 @@ Coordinate SDD; keep chat thin, use VGXNESS MCP as durable state, delegate to sm
 Use the lightest safe path: Tier 0-2 direct; Tier 3 preflight; Tier 4 formal SDD for governance, permissions, acceptance, architecture/security, or cross-surface behavior. Provider status/doctor/preview/handoff are read-only/audit-only; writes stay gated.
 
 ## Provider-native daily flow
-Daily SDD happens inside OpenCode through conversation, VGXNESS MCP, and hidden SDD subagents. Do not tell users to run terminal SDD phase commands for normal flow. CLI is an escape hatch for bootstrap, doctor, recovery, setup gaps, or explicit request.
+SDD happens in OpenCode via conversation, VGXNESS MCP, and SDD subagents. No terminal SDD phase commands for normal flow. CLI is an escape hatch for bootstrap, doctor, recovery, setup gaps, or explicit request.
 
 ## MCP playbook
 - For starting, resuming, or recovering context: prefer \`vgxness_context_cockpit\`; treat \`vgxness_session_restore\` as one signal, not truth. For ending, pausing, handing off, or compacting: \`vgxness_session_close\` with current session id and actor \`manager\`; if no id, do not invent one and summarize.
@@ -174,9 +174,9 @@ Daily SDD happens inside OpenCode through conversation, VGXNESS MCP, and hidden
 - Trusted draft autorun: when the exact \`proposal\` artifact is already accepted, you may run exactly \`spec -> design -> tasks\` without extra human confirmation via exact hidden subagents and save drafts with \`vgxness_sdd_save_artifact\`. This is draft-only planning, not acceptance or completion. Do not use for explore/proposal/apply-progress/verify/archive, rejected/superseded artifacts, accepted overwrites, or risky side effects (provider config, edits, shell/tests, git, secrets, external/destructive/privileged/ambiguous). Re-check status/readiness before and after; generated spec/design drafts may feed downstream design/tasks but remain unaccepted.
 - Acceptance/readiness: check SDD status/readiness for the exact project/change/phase, confirm explicit human acceptance of that exact artifact, call \`vgxness_sdd_accept_artifact\` directly with audit context (\`acceptedBy.type: "human"\`, non-empty \`acceptedBy.id\`, runId, agentId), then re-check status/readiness before reporting state. Do not add \`vgxness_run_preflight\` solely for that exact direct acceptance call. Ambiguous replies count only when tied to an immediate exact acceptance prompt. Use \`vgxness_governance_report\` for readiness, artifact states, preflight posture, and audit warnings.
 - Memory: call \`vgxness_memory_search\`/\`vgxness_memory_get\` for prior work or unclear context; call \`vgxness_memory_save\` for durable discoveries, decisions, bug fixes, config, patterns, or preferences; use \`vgxness_memory_update\` only to correct/evolve a known id. Do not duplicate full SDD artifacts as memory.
-- Agents/profile/payloads: resolve exact phase with \`vgxness_agent_resolve\`. \`vgxness_agent_activate\`, \`vgxness_opencode_manager_payload\`, and \`vgxness_skill_payload\` are preview context only; agent_activate does not execute a provider or write provider config. Use \`vgxness_manager_profile_get\` before behavior changes; \`vgxness_manager_profile_set\` requires explicit human authorization.
-- Runs/recovery: use \`vgxness_run_start\`/\`vgxness_run_list\`/\`vgxness_run_get\` for run work; checkpoint with \`vgxness_run_checkpoint\`, preflight with \`vgxness_run_preflight\`, and close with \`vgxness_run_finalize\`. Unknown runId: \`vgxness_run_resume_candidates\`. For interrupted runs, inspect with \`vgxness_run_resume_inspect\`, then call \`vgxness_run_resume_gate\` with approvalId from pendingApprovals/inspect before advice; never pass runId as approvalId
-- Provider diagnostics: \`vgxness_provider_status\`/\`vgxness_provider_doctor\` are read-only reports.
+- Agents/profile/payloads: resolve phase with \`vgxness_agent_resolve\`. Preview mode does not execute a provider or write provider config for \`vgxness_agent_activate\`, \`vgxness_opencode_manager_payload\`, or \`vgxness_skill_payload\`. Use \`vgxness_manager_profile_get\` before changes; \`vgxness_manager_profile_set\` requires explicit human authorization.
+- Runs/recovery: use \`vgxness_run_start\`/\`vgxness_run_list\`/\`vgxness_run_get\` for run work; checkpoint with \`vgxness_run_checkpoint\`, preflight with \`vgxness_run_preflight\`, and close with \`vgxness_run_finalize\`. Unknown runId: \`vgxness_run_resume_candidates\`. For interrupted runs, inspect with \`vgxness_run_resume_inspect\`, then call \`vgxness_run_resume_gate\` with approvalId from pendingApprovals/inspect before advice; never pass runId as approvalId. Follow safe \`recommendedActions[]\`.
+- Provider diagnostics: \`vgxness_provider_status\`/\`vgxness_provider_doctor\` read-only; report \`providerEvidence.evidenceLevel\`/\`hostToolPresenceVerified\` limits.
 
 ## Minimum flows
 - Simple answer: inline; memory only for prior context; no run by default.
@@ -196,11 +196,12 @@ Be concise: delegated work, results, files/decisions, evidence/tests, risks, nex
  * render baselines, and manager profile overlay baselines; they are
  * intentionally distinct from the provider runtime prompt above.
  */
-const registryManagerInstructionsV10 = [
+const registryManagerInstructionsV11 = [
     'You are the VGXNESS SDD coordinator, not a monolithic executor. Coach briefly while coordinating: explain useful tradeoffs, be realistic about risks and unknowns, respectfully challenge weak assumptions with better options, keep the user comfortable and in control, and stay concise.',
     'Default to delegation for SDD phase-shaped work, repository exploration beyond one narrow lookup, implementation, verification, incident recovery, or multi-step analysis. Inline only conversational guidance, single-fact lookup, MCP/status/readiness checks, and trivial mechanical edits when safe. When uncertain between inline work and subagent work, delegate to the exact smallest SDD subagent.',
     'Use VGXNESS MCP as the durable control plane: restore session context with vgxness_session_restore before inferring start/resume state from chat, and close/pause/compact with vgxness_session_close using actor manager plus an actionable summary when a current session id exists.',
     'Check SDD status/next/ready/cockpit, read prerequisites with sdd_get_artifact or sdd_list_artifacts, use public sdd_continue/internal vgxness_sdd_continue first for advisory read-only continuation plans, use sdd_reopen_artifact only for rejected artifacts returning to draft with explicit human actor/audit context, save phase output with sdd_save_artifact only by governance; when proposal is accepted, spec/design/tasks may run sequentially as draft-only autorun without extra confirmation, while acceptance remains human-only. Search/get/save/update memory only for reusable knowledge, resolve exact SDD subagents before substantial phase work, use runs/checkpoints/preflight/finalize for significant implementation or verification, use run_resume_candidates for unknown runId, inspect interrupted runs by runId with run_resume_inspect, then call run_resume_gate with approvalId from pendingApprovals/inspect; never pass runId as approvalId; use vgxness_provider_status for configured/phase/next questions plus vgxness_provider_doctor for read-only OpenCode MCP/manager health.',
+    'When sdd_continue/vgxness_sdd_continue returns recommendedActions, prefer the first safe action with agentCallable true and humanOnly false; use targetTool plus suggestedArgs as the starting point, and stop for requiresHumanConfirmation, requiresProviderWriteConsent, requiresPreflight, ambiguous, destructive, privileged, external, or outside-approval actions. For readiness, use cockpit/status/readiness to distinguish missing, draft, ready, blocked, and accepted; never infer acceptance. For provider evidence, report providerEvidence.evidenceLevel, hostToolPresenceVerified, notes, and limitations; do not claim true host presence unless evidence explicitly verifies it.',
     'Prefer payloadMode=compact for manager-facing status/context reads, SDD artifact reads/lists, and activation handoffs so the primary context stays clean; request payloadMode=verbose only when full artifact contents, provider payloads, or skill context are actually needed, preferably inside delegated phase subagents.',
     'MCP sdd_continue must not execute providers, create runs, mutate artifacts, write provider config/openspec, bypass human acceptance, or treat draft-run as apply-progress.',
     'CLI is an escape hatch for bootstrap, doctor, rollback, recovery, MCP unavailable/setup missing, or explicit user request; do not tell users to run terminal SDD phase commands for normal daily flow. CLI vgxness sdd continue is a human/manual fallback only; vgxness resume --project is for candidate runs. The removed experimental vgxness code runtime is not an SDD fallback.',

package/dist/cli/cli-flags.js

@@ -180,13 +180,13 @@ function skillTargetTypeFlag(flags, name) {
         return value;
     return isSkillTargetType(value.value)
         ? { ok: true, value: value.value }
-        : validationFailure(`--${name} must be agent, subagent, workflow-phase, or provider-adapter`);
+        : validationFailure(`--${name} must be agent, subagent, workflow-phase, provider-adapter, or intent-signal`);
 }
 function optionalSkillTargetTypeFlag(flags, name) {
     const value = optionalStringFlag(flags, name);
     if (value === undefined)
         return { ok: true, value: undefined };
-    return isSkillTargetType(value) ? { ok: true, value } : validationFailure(`--${name} must be agent, subagent, workflow-phase, or provider-adapter`);
+    return isSkillTargetType(value) ? { ok: true, value } : validationFailure(`--${name} must be agent, subagent, workflow-phase, provider-adapter, or intent-signal`);
 }
 function skillUsageOutcomeFlag(flags, name) {
     const value = requiredFlag(flags, name);
@@ -228,7 +228,7 @@ function isSkillEvaluationResultStatus(value) {
     return value === 'passed' || value === 'failed' || value === 'needs-review' || value === 'not-applicable';
 }
 function isSkillTargetType(value) {
-    return value === 'agent' || value === 'subagent' || value === 'workflow-phase' || value === 'provider-adapter';
+    return value === 'agent' || value === 'subagent' || value === 'workflow-phase' || value === 'provider-adapter' || value === 'intent-signal';
 }
 function instructionKindFlag(flags) {
     const value = optionalStringFlag(flags, 'instructions-kind') ?? 'inline';

package/dist/cli/cli-help.js

@@ -77,12 +77,12 @@ Areas:
   skills list [--project <name>] [--scope project|personal]
   skills get --id <id> | --project <name> --name <name> [--scope project|personal]
   skills add-version (--id <id> | --project <name> --name <name>) --version <version> --source-kind path|url|inline [--source-path <path>] [--source-url <url>] [--inline-metadata <json>] [--activate]
-  skills attach (--id <id> | --project <name> --name <name>) --target-type agent|subagent|workflow-phase|provider-adapter --target-key <key>
-  skills detach (--id <id> | --project <name> --name <name>) --target-type agent|subagent|workflow-phase|provider-adapter --target-key <key>
+  skills attach (--id <id> | --project <name> --name <name>) --target-type agent|subagent|workflow-phase|provider-adapter|intent-signal --target-key <key>
+  skills detach (--id <id> | --project <name> --name <name>) --target-type agent|subagent|workflow-phase|provider-adapter|intent-signal --target-key <key>
   skills record-usage (--id <id> | --project <name> --name <name>) --outcome selected|injected|helped|failed|neutral [--run-id <id>]
-  skills resolve [--agent <name> | --agent-id <id>] [--project <name>] [--workflow <name>] [--phase <name>] [--provider <name>] [--run <id>] [--record-usage selected|injected]
+  skills resolve [--agent <name> | --agent-id <id>] [--project <name>] [--workflow <name>] [--phase <name>] [--intent-signals a,b] [--provider <name>] [--run <id>] [--record-usage selected|injected]
   skills status --project <name> [--scope project|personal] [--provider opencode] [--mode agent|subagent] [--agent <name-or-id>]
-  skills payload [--agent <name> | --agent-id <id>] [--project <name>] [--workflow <name>] [--phase <name>] [--provider <name>]
+  skills payload [--agent <name> | --agent-id <id>] [--project <name>] [--workflow <name>] [--phase <name>] [--intent-signals a,b] [--provider <name>]
   skills propose (--id <id> | --project <name> --name <name>) --proposed-version <version> --source-kind path|url|inline --rationale <text>
   skills proposals [--skill-id <id>] [--status draft|pending-approval|approved|rejected|cancelled|applied]
   skills create-scenario (--id <id> --name <scenario> | --project <name> --name <skill> --scenario-name <scenario>) --criteria <json> --created-by <actor> [--proposal <id>] [--version-id <id>]

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

@@ -4,6 +4,7 @@ import { ManagerProfileOverlayService } from '../../agents/manager-profile-overl
 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 { 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';
@@ -37,6 +38,7 @@ function resolveSkillsInput(flags) {
     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)
@@ -51,6 +53,8 @@ function resolveSkillsInput(flags) {
         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)
@@ -658,7 +662,12 @@ export function runSkillCommand(command, parsed, database, environment) {
     }
     if (command === 'payload') {
         const input = skillPayloadInput(parsed.flags);
-        return input.ok ? jsonResult(registry.buildSkillPayload(input.value, { workspaceRoot: environment.cwd })) : resultFailure(input);
+        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}`);
 }

package/dist/mcp/control-plane.js

@@ -11,6 +11,7 @@ import { RunService } from '../runs/run-service.js';
 import { sddContinuationPlanFrom } from '../sdd/sdd-continuation-plan.js';
 import { buildSddCockpitSurfaceResponse } from '../sdd/cockpit-read-model.js';
 import { SddWorkflowService } from '../sdd/sdd-workflow-service.js';
+import { runBootSkillSeed } from '../skills/boot-seed.js';
 import { SkillRegistryService } from '../skills/skill-registry-service.js';
 import { VerificationPlanService } from '../verification/index.js';
 import { ProviderChangePlanService } from './provider-change-plan.js';
@@ -312,6 +313,7 @@ function createServices(database) {
         agents,
         managerProfiles,
         skills,
+        seedBuiltInSkills: () => runBootSkillSeed(database),
         opencodeManagerPayload,
         opencodeHandoffPreview: new OpenCodeHandoffPreviewService({ managerPayload: opencodeManagerPayload, sdd, providerStatus }),
         activation: new AgentActivationService({ agents, managerProfiles, runs, opencodeManagerPayload }),
@@ -358,6 +360,9 @@ function memoryContext(sessionId) {
     return context;
 }
 function buildSkillPayloadEnvelope(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));

package/dist/mcp/provider-doctor.js

@@ -7,7 +7,7 @@ import { inspectClaudeCodeUserMcpConfig } from './claude-code-user-config.js';
 import { inspectClaudeUserMemory } from './claude-code-user-memory.js';
 import { vgxnessOpenCodeDefaultAgent, vgxnessOpenCodeSddSubagents } from './opencode-default-agent-config.js';
 import { buildCanonicalAgentManifestDiagnostic } from './provider-canonical-agent-manifest.js';
-import { normalizeProviderHealthInput, PROVIDER_HEALTH_SAFETY, CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES, classifyProviderConfigPaths, providerHealthFailure, providerRuntimeContext, isUserGlobalScope, REQUIRED_PROVIDER_NATIVE_MCP_TOOLS, rollupProviderDoctor, } from './provider-health-types.js';
+import { normalizeProviderHealthInput, PROVIDER_HEALTH_SAFETY, CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES, classifyProviderConfigPaths, providerEvidence, providerHealthFailure, providerRuntimeContext, isUserGlobalScope, REQUIRED_PROVIDER_NATIVE_MCP_TOOLS, rollupProviderDoctor, } from './provider-health-types.js';
 import { inspectOpenCodeConfigPaths } from './provider-status.js';
 export class ProviderDoctorService {
     deps;
@@ -28,6 +28,7 @@ export class ProviderDoctorService {
         const before = snapshotPaths(paths.map((path) => path.path), normalized.workspaceRoot);
         const readableJson = paths.filter((path) => path.parsed);
         const config = readFirstConfig(readableJson[0]?.path);
+        const evidence = providerEvidence({ staticManifestKnown: true, renderedConfigExpected: true, configPathInspected: paths.length > 0 });
         const checks = [
             {
                 id: 'workspace-root',
@@ -42,7 +43,7 @@ export class ProviderDoctorService {
             subagentsCheck(config),
             delegationCheck(config),
             { id: 'mcp-current-call', status: 'pass', detail: 'Current MCP call reached the VGXNESS control-plane.' },
-            { id: 'mcp-required-tools', status: 'pass', detail: `Required provider-native tools are registered: ${REQUIRED_PROVIDER_NATIVE_MCP_TOOLS.join(', ')}.` },
+            { id: 'mcp-required-tools', status: 'pass', detail: `Static VGXNESS manifest expects provider-native tools: ${REQUIRED_PROVIDER_NATIVE_MCP_TOOLS.join(', ')}. MCP host tool presence was not verified.` },
             promptContractCheck(config, normalized.expectedPromptContractVersion),
             readonlySafetyCheck(before, snapshotPaths(paths.map((path) => path.path), normalized.workspaceRoot)),
         ];
@@ -54,8 +55,8 @@ export class ProviderDoctorService {
             : paths.filter((path) => path.exists || path.status !== 'not-configured').map((path) => path.path);
         const failedChecks = checks.filter((check) => check.status === 'fail').map((check) => check.id);
         const recommendations = checks.flatMap((check) => (check.remediation === undefined ? [] : [check.remediation]));
-        const originalBytes = Buffer.byteLength(JSON.stringify({ checks, checkedPaths: paths.map((path) => path.path) }), 'utf8');
-        const compactBytes = Buffer.byteLength(JSON.stringify({ checks: compactChecksValue, checkedPaths }), 'utf8');
+        const originalBytes = Buffer.byteLength(JSON.stringify({ checks, checkedPaths: paths.map((path) => path.path), providerEvidence: evidence }), 'utf8');
+        const compactBytes = Buffer.byteLength(JSON.stringify({ checks: compactChecksValue, checkedPaths, providerEvidence: evidence }), 'utf8');
         return {
             ok: true,
             value: {
@@ -80,6 +81,7 @@ export class ProviderDoctorService {
                 recommendations,
                 checks: compactChecksValue,
                 checkedPaths,
+                providerEvidence: evidence,
                 bytes: { originalBytes, compactBytes },
                 verboseAvailable: normalized.payloadMode === 'compact',
                 fullContentRef: `provider-doctor:${normalized.providerAdapter}:${normalized.workspaceRoot}`,
@@ -99,6 +101,7 @@ export class ProviderDoctorService {
         const projectMemory = inspectClaudeProjectMemory(normalized.workspaceRoot);
         const advisoryPaths = claudeAdvisoryPaths(normalized.workspaceRoot);
         const checkedPathList = [mcp.path, agents.directoryPath, ...agents.agents.map((agent) => agent.path), projectMemory.path, ...advisoryPaths];
+        const evidence = providerEvidence({ staticManifestKnown: true, renderedConfigExpected: true, configPathInspected: checkedPathList.length > 0 });
         const before = snapshotPaths(checkedPathList, normalized.workspaceRoot);
         const missingAgents = agents.agents.filter((agent) => agent.status === 'missing');
         const blockingAgents = agents.agents.filter((agent) => agent.status === 'conflicting' || agent.status === 'invalid');
@@ -133,13 +136,14 @@ export class ProviderDoctorService {
         const checkedPaths = normalized.payloadMode === 'verbose' ? checkedPathList : checkedPathList.filter((path) => existsSync(path) || path === mcp.path);
         const failedChecks = checks.filter((check) => check.status === 'fail').map((check) => check.id);
         const recommendations = checks.flatMap((check) => (check.remediation === undefined ? [] : [check.remediation]));
-        return { ok: true, value: { version: 1, kind: 'provider-doctor', project: normalized.project, providerAdapter: 'claude', scope: normalized.scope, workspaceRoot: normalized.workspaceRoot, runtimeContext: providerRuntimeContext(normalized), configClassification: externalProjectClassification(checkedPathList), status, payloadMode: normalized.payloadMode, overallStatus: status, checkCount: checks.length, passedCount: checks.filter((check) => check.status === 'pass').length, warningCount: checks.filter((check) => check.status === 'warn' || check.status === 'not-configured').length, errorCount: failedChecks.length, skippedCount: checks.filter((check) => check.status === 'skip').length, failedChecks, summary: summarizeDoctor(status, failedChecks.length, recommendations.length), recommendations, checks: compactChecksValue, checkedPaths, bytes: { originalBytes: Buffer.byteLength(JSON.stringify({ checks, checkedPaths: checkedPathList }), 'utf8'), compactBytes: Buffer.byteLength(JSON.stringify({ checks: compactChecksValue, checkedPaths }), 'utf8') }, verboseAvailable: normalized.payloadMode === 'compact', fullContentRef: `provider-doctor:claude:${normalized.workspaceRoot}`, generatedAt: 'read-only-snapshot', safety: PROVIDER_HEALTH_SAFETY } };
+        return { ok: true, value: { version: 1, kind: 'provider-doctor', project: normalized.project, providerAdapter: 'claude', scope: normalized.scope, workspaceRoot: normalized.workspaceRoot, runtimeContext: providerRuntimeContext(normalized), configClassification: externalProjectClassification(checkedPathList), status, payloadMode: normalized.payloadMode, overallStatus: status, checkCount: checks.length, passedCount: checks.filter((check) => check.status === 'pass').length, warningCount: checks.filter((check) => check.status === 'warn' || check.status === 'not-configured').length, errorCount: failedChecks.length, skippedCount: checks.filter((check) => check.status === 'skip').length, failedChecks, summary: summarizeDoctor(status, failedChecks.length, recommendations.length), recommendations, checks: compactChecksValue, checkedPaths, providerEvidence: evidence, bytes: { originalBytes: Buffer.byteLength(JSON.stringify({ checks, checkedPaths: checkedPathList, providerEvidence: evidence }), 'utf8'), compactBytes: Buffer.byteLength(JSON.stringify({ checks: compactChecksValue, checkedPaths, providerEvidence: evidence }), 'utf8') }, verboseAvailable: normalized.payloadMode === 'compact', fullContentRef: `provider-doctor:claude:${normalized.workspaceRoot}`, generatedAt: 'read-only-snapshot', safety: PROVIDER_HEALTH_SAFETY } };
     }
     getClaudeUserGlobalDoctor(normalized, canonicalScope = 'user', scopeWarnings = []) {
         const mcp = inspectClaudeCodeUserMcpConfig(normalized.env);
         const agents = inspectClaudeCodeAgents({ workspaceRoot: normalized.workspaceRoot, scope: 'user', env: normalized.env });
         const userMemory = inspectClaudeUserMemory(normalized.env);
         const checkedPathList = [mcp.path, agents.directoryPath, ...agents.agents.map((agent) => agent.path), userMemory.path];
+        const evidence = providerEvidence({ staticManifestKnown: true, renderedConfigExpected: true, configPathInspected: checkedPathList.length > 0 });
         const before = snapshotPaths(checkedPathList, normalized.workspaceRoot);
         const missingAgents = agents.agents.filter((agent) => agent.status === 'missing');
         const blockingAgents = agents.agents.filter((agent) => agent.status === 'conflicting' || agent.status === 'invalid');
@@ -164,7 +168,7 @@ export class ProviderDoctorService {
         const failedChecks = checks.filter((check) => check.status === 'fail').map((check) => check.id);
         const recommendations = checks.flatMap((check) => (check.remediation === undefined ? [] : [check.remediation]));
         const checkedPaths = normalized.payloadMode === 'verbose' ? checkedPathList : checkedPathList.filter((path) => existsSync(path) || path === mcp.path || path === userMemory.path);
-        return { ok: true, value: { version: 1, kind: 'provider-doctor', project: normalized.project, providerAdapter: 'claude', scope: normalized.scope, workspaceRoot: normalized.workspaceRoot, runtimeContext: providerRuntimeContext(normalized), configClassification: managedUserGlobalClassification(checkedPathList), status, payloadMode: normalized.payloadMode, overallStatus: status, checkCount: checks.length, passedCount: checks.filter((check) => check.status === 'pass').length, warningCount: checks.filter((check) => check.status === 'warn' || check.status === 'not-configured').length, errorCount: failedChecks.length, skippedCount: checks.filter((check) => check.status === 'skip').length, failedChecks, summary: summarizeDoctor(status, failedChecks.length, recommendations.length), recommendations, checks: compactChecksValue, checkedPaths, bytes: { originalBytes: Buffer.byteLength(JSON.stringify({ checks, checkedPaths: checkedPathList }), 'utf8'), compactBytes: Buffer.byteLength(JSON.stringify({ checks: compactChecksValue, checkedPaths }), 'utf8') }, verboseAvailable: normalized.payloadMode === 'compact', fullContentRef: `provider-doctor:claude:${canonicalScope}:${normalized.workspaceRoot}`, generatedAt: 'read-only-snapshot', safety: { ...PROVIDER_HEALTH_SAFETY, scopeCapabilities: CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES } } };
+        return { ok: true, value: { version: 1, kind: 'provider-doctor', project: normalized.project, providerAdapter: 'claude', scope: normalized.scope, workspaceRoot: normalized.workspaceRoot, runtimeContext: providerRuntimeContext(normalized), configClassification: managedUserGlobalClassification(checkedPathList), status, payloadMode: normalized.payloadMode, overallStatus: status, checkCount: checks.length, passedCount: checks.filter((check) => check.status === 'pass').length, warningCount: checks.filter((check) => check.status === 'warn' || check.status === 'not-configured').length, errorCount: failedChecks.length, skippedCount: checks.filter((check) => check.status === 'skip').length, failedChecks, summary: summarizeDoctor(status, failedChecks.length, recommendations.length), recommendations, checks: compactChecksValue, checkedPaths, providerEvidence: evidence, bytes: { originalBytes: Buffer.byteLength(JSON.stringify({ checks, checkedPaths: checkedPathList, providerEvidence: evidence }), 'utf8'), compactBytes: Buffer.byteLength(JSON.stringify({ checks: compactChecksValue, checkedPaths, providerEvidence: evidence }), 'utf8') }, verboseAvailable: normalized.payloadMode === 'compact', fullContentRef: `provider-doctor:claude:${canonicalScope}:${normalized.workspaceRoot}`, generatedAt: 'read-only-snapshot', safety: { ...PROVIDER_HEALTH_SAFETY, scopeCapabilities: CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES } } };
     }
 }
 function externalProjectClassification(paths) {

package/dist/mcp/provider-health-types.js

@@ -34,6 +34,26 @@ export function classifyProviderConfigPaths(paths) {
         detectedExternalUserConfig: paths.filter((path) => path.diagnostics.ownership === 'external-user' && path.exists).map((path) => path.path),
     };
 }
+export function providerEvidence(input) {
+    const hostIntrospectionAvailable = input.hostIntrospectionAvailable ?? false;
+    const hostToolPresenceVerified = input.hostToolPresenceVerified ?? false;
+    return {
+        staticManifestKnown: input.staticManifestKnown,
+        renderedConfigExpected: input.renderedConfigExpected,
+        configPathInspected: input.configPathInspected,
+        hostIntrospectionAvailable,
+        hostToolPresenceVerified,
+        evidenceLevel: hostIntrospectionAvailable ? 'host-introspection' : input.configPathInspected ? 'config-inspection' : 'static-manifest',
+        notes: [
+            'VGXNESS inspected static provider manifests and expected provider configuration metadata only.',
+            input.configPathInspected
+                ? 'VGXNESS inspected provider config paths as read-only diagnostics.'
+                : 'VGXNESS did not inspect provider config paths; evidence is limited to static manifests.',
+            'No provider host process was launched during this diagnostic.',
+            'MCP host tool presence is not verified by provider status/doctor.',
+        ],
+    };
+}
 export const REQUIRED_PROVIDER_MCP_TOOLS = ['vgxness_provider_status', 'vgxness_provider_doctor', 'vgxness_provider_change_plan'];
 export const REQUIRED_PROVIDER_NATIVE_MCP_TOOLS = [
     'vgxness_provider_status',

package/dist/mcp/provider-status.js

@@ -9,7 +9,7 @@ import { inspectClaudeUserMemory } from './claude-code-user-memory.js';
 import { resolveOpenCodeMcpInstallTarget } from './client-install-opencode-contract.js';
 import { vgxnessOpenCodeDefaultAgent, vgxnessOpenCodePromptContractVersion, vgxnessOpenCodeSddSubagents } from './opencode-default-agent-config.js';
 import { buildCanonicalAgentManifestDiagnostic } from './provider-canonical-agent-manifest.js';
-import { normalizeProviderHealthInput, PROVIDER_HEALTH_SAFETY, CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES, classifyProviderConfigPaths, providerConfigPathDiagnostics, providerRuntimeContext, providerHealthFailure, isUserGlobalScope, REQUIRED_PROVIDER_MCP_TOOLS, rollupProviderHealth, } from './provider-health-types.js';
+import { normalizeProviderHealthInput, PROVIDER_HEALTH_SAFETY, CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES, classifyProviderConfigPaths, providerConfigPathDiagnostics, providerRuntimeContext, providerEvidence, providerHealthFailure, isUserGlobalScope, REQUIRED_PROVIDER_MCP_TOOLS, rollupProviderHealth, } from './provider-health-types.js';
 const projectConfigTargets = ['.opencode/opencode.json', 'opencode.json', '.opencode/opencode.jsonc', 'opencode.jsonc'];
 export class ProviderStatusService {
     deps;
@@ -29,6 +29,7 @@ export class ProviderStatusService {
         const managerConfigured = hasConfiguredManager(providerConfig);
         const subagentsConfigured = hasConfiguredSubagents(providerConfig);
         const tools = requiredToolPresence();
+        const evidence = providerEvidence({ staticManifestKnown: true, renderedConfigExpected: true, configPathInspected: paths.length > 0 });
         const configStatus = resolveConfigStatus(paths, mcpEntry, managerConfigured, subagentsConfigured);
         const status = rollupProviderHealth([canonicalAgentManifest.status, configStatus, ...tools.map((tool) => (tool.present ? 'pass' : 'fail'))]);
         const sdd = normalized.change.length > 0 ? this.readSdd(normalized.project, normalized.change) : undefined;
@@ -39,12 +40,14 @@ export class ProviderStatusService {
         const verboseShape = {
             config: { status: configStatus, paths, mcpEntry },
             canonicalAgentManifest,
+            providerEvidence: evidence,
             sdd,
             mcpRequiredTools: tools,
         };
         const compactShape = {
             config: { status: configStatus, paths: compactPaths(paths, 'compact'), mcpEntry: compactMcpEntry(mcpEntry, 'compact') },
             canonicalAgentManifest,
+            providerEvidence: evidence,
             sdd: sdd === undefined ? undefined : compactSdd(sdd, 'compact'),
             mcpRequiredTools: tools,
         };
@@ -70,6 +73,7 @@ export class ProviderStatusService {
             nextAction: nextActionFor(status, mcpEntry, sdd?.next),
             checkedPaths,
             canonicalAgentManifest,
+            providerEvidence: evidence,
             ...(sdd === undefined ? {} : { sdd: compactSdd(sdd, normalized.payloadMode) }),
             mcpRequiredTools: tools,
             originalBytes,
@@ -112,8 +116,9 @@ export class ProviderStatusService {
         const sdd = normalized.change.length > 0 ? this.readSdd(normalized.project, normalized.change) : undefined;
         const checkedPaths = normalized.payloadMode === 'verbose' ? [mcpState.path, agents.directoryPath, ...agents.agents.map((agent) => agent.path), projectMemory.path, ...claudeAdvisoryPaths(normalized.workspaceRoot)] : [mcpState.path, projectMemory.path, ...agents.agents.filter((agent) => agent.exists || agent.status !== 'missing').map((agent) => agent.path), ...advisory];
         const tools = [...requiredToolPresence(), { tool: 'claude-cli', present: false, diagnostic: 'Read-only status does not execute `claude --version`; CLI presence is checked during explicit apply/preflight only.' }];
-        const verboseShape = { config: { status: configStatus, paths, mcpEntry }, canonicalAgentManifest, agents, projectMemory, advisory, sdd, mcpRequiredTools: tools };
-        const compactShape = { config: { status: configStatus, paths: compactPaths(paths, 'compact'), mcpEntry: compactMcpEntry(mcpEntry, 'compact') }, canonicalAgentManifest, agentSummary: summarizeClaudeAgents(agents), projectMemory: { status: projectMemory.status, action: projectMemory.action }, advisory, sdd: sdd === undefined ? undefined : compactSdd(sdd, 'compact'), mcpRequiredTools: tools };
+        const evidence = providerEvidence({ staticManifestKnown: true, renderedConfigExpected: true, configPathInspected: paths.length > 0 });
+        const verboseShape = { config: { status: configStatus, paths, mcpEntry }, canonicalAgentManifest, providerEvidence: evidence, agents, projectMemory, advisory, sdd, mcpRequiredTools: tools };
+        const compactShape = { config: { status: configStatus, paths: compactPaths(paths, 'compact'), mcpEntry: compactMcpEntry(mcpEntry, 'compact') }, canonicalAgentManifest, providerEvidence: evidence, agentSummary: summarizeClaudeAgents(agents), projectMemory: { status: projectMemory.status, action: projectMemory.action }, advisory, sdd: sdd === undefined ? undefined : compactSdd(sdd, 'compact'), mcpRequiredTools: tools };
         const originalBytes = Buffer.byteLength(JSON.stringify(verboseShape), 'utf8');
         const compactBytes = Buffer.byteLength(JSON.stringify(compactShape), 'utf8');
         const issueCount = [canonicalAgentManifest.status, configStatus, ...agentStatuses].filter((item) => item === 'fail' || item === 'not-configured').length;
@@ -136,6 +141,7 @@ export class ProviderStatusService {
             nextAction: nextActionFor(status, mcpEntry, sdd?.next),
             checkedPaths,
             canonicalAgentManifest,
+            providerEvidence: evidence,
             ...(sdd === undefined ? {} : { sdd: compactSdd(sdd, normalized.payloadMode) }),
             mcpRequiredTools: tools,
             originalBytes,
@@ -163,11 +169,12 @@ export class ProviderStatusService {
         const agentStatuses = agents.agents.map((agent) => (agent.status === 'managed' ? 'pass' : agent.status === 'missing' ? 'not-configured' : 'fail'));
         const configStatus = claudeConfigHealthStatus([...paths.map((path) => path.status), ...agentStatuses]);
         const tools = [...requiredToolPresence(), { tool: 'claude-cli', present: false, diagnostic: 'Read-only status does not execute `claude --version`; no Claude Code process was launched.' }];
+        const evidence = providerEvidence({ staticManifestKnown: true, renderedConfigExpected: true, configPathInspected: paths.length > 0 });
         const status = rollupProviderHealth([canonicalAgentManifest.status, configStatus]);
         const sdd = normalized.change.length > 0 ? this.readSdd(normalized.project, normalized.change) : undefined;
         const checkedPaths = normalized.payloadMode === 'verbose' ? [mcpState.path, agents.directoryPath, ...agents.agents.map((agent) => agent.path), userMemory.path] : [mcpState.path, userMemory.path, ...agents.agents.filter((agent) => agent.exists || agent.status !== 'missing').map((agent) => agent.path)];
-        const verboseShape = { config: { status: configStatus, paths, mcpEntry }, canonicalAgentManifest, agents, userMemory: { status: userMemory.status, action: userMemory.action }, scopeCapabilities: CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES, scopeWarnings, sdd, mcpRequiredTools: tools };
-        const compactShape = { config: { status: configStatus, paths: compactPaths(paths, 'compact'), mcpEntry: compactMcpEntry(mcpEntry, 'compact') }, canonicalAgentManifest, agentSummary: summarizeClaudeAgents(agents), userMemory: { status: userMemory.status, action: userMemory.action }, scopeCapabilities: CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES, sdd: sdd === undefined ? undefined : compactSdd(sdd, 'compact'), mcpRequiredTools: tools };
+        const verboseShape = { config: { status: configStatus, paths, mcpEntry }, canonicalAgentManifest, providerEvidence: evidence, agents, userMemory: { status: userMemory.status, action: userMemory.action }, scopeCapabilities: CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES, scopeWarnings, sdd, mcpRequiredTools: tools };
+        const compactShape = { config: { status: configStatus, paths: compactPaths(paths, 'compact'), mcpEntry: compactMcpEntry(mcpEntry, 'compact') }, canonicalAgentManifest, providerEvidence: evidence, agentSummary: summarizeClaudeAgents(agents), userMemory: { status: userMemory.status, action: userMemory.action }, scopeCapabilities: CLAUDE_USER_GLOBAL_SCOPE_CAPABILITIES, sdd: sdd === undefined ? undefined : compactSdd(sdd, 'compact'), mcpRequiredTools: tools };
         const originalBytes = Buffer.byteLength(JSON.stringify(verboseShape), 'utf8');
         const compactBytes = Buffer.byteLength(JSON.stringify(compactShape), 'utf8');
         const reportBase = {
@@ -188,6 +195,7 @@ export class ProviderStatusService {
             nextAction: nextActionFor(status, mcpEntry, sdd?.next),
             checkedPaths,
             canonicalAgentManifest,
+            providerEvidence: evidence,
             ...(sdd === undefined ? {} : { sdd: compactSdd(sdd, normalized.payloadMode) }),
             mcpRequiredTools: tools,
             originalBytes,
@@ -335,7 +343,11 @@ function inspectOpenCodeMcpEntry(paths) {
     }
 }
 function requiredToolPresence() {
-    return REQUIRED_PROVIDER_MCP_TOOLS.map((tool) => ({ tool, present: true }));
+    return REQUIRED_PROVIDER_MCP_TOOLS.map((tool) => ({
+        tool,
+        present: true,
+        diagnostic: 'Static VGXNESS manifest expects this MCP tool; provider host tool presence was not verified.',
+    }));
 }
 function resolveConfigStatus(paths, mcpEntry, managerConfigured, subagentsConfigured) {
     if (paths.some((path) => path.status === 'fail') || mcpEntry.status === 'fail')

package/dist/mcp/schema.js

@@ -109,7 +109,125 @@ const contextCockpitLevels = ['compact', 'expanded', 'verbose'];
 const providerChangePlanProviders = ['opencode', 'claude', 'antigravity', 'custom'];
 const providerChangePlanTypes = ['opencode-mcp-install', 'claude-mcp-install', 'setup', 'install', 'config-preparation'];
 const sddPhaseInputSchema = z.union([z.enum(sddPhases), z.literal('apply')]);
+const sddPhaseSchema = z.enum(sddPhases);
 const jsonValueSchema = z.lazy(() => z.union([z.string(), z.number().finite(), z.boolean(), z.null(), z.array(jsonValueSchema), z.record(z.string(), jsonValueSchema)]));
+const providerEvidenceOutputSchema = z
+    .object({
+    staticManifestKnown: z.boolean(),
+    renderedConfigExpected: z.boolean(),
+    configPathInspected: z.boolean(),
+    hostIntrospectionAvailable: z.boolean(),
+    hostToolPresenceVerified: z.boolean(),
+    evidenceLevel: z.enum(['static-manifest', 'config-inspection', 'host-introspection']),
+    notes: z.array(z.string()),
+})
+    .passthrough();
+const sddPhaseGateOutputSchema = z
+    .object({
+    phase: sddPhaseSchema,
+    topicKey: z.string(),
+    artifactPresent: z.boolean(),
+    artifactStatus: z.enum(['missing', 'draft', 'accepted', 'rejected', 'superseded']),
+    artifactState: z.enum(['missing', 'draft', 'accepted', 'rejected', 'superseded', 'legacy']),
+    accepted: z.boolean(),
+    acceptedByHuman: z.boolean(),
+    agentCallable: z.boolean(),
+    requiresHumanAcceptance: z.boolean(),
+    draftPresent: z.boolean(),
+    contentFrozen: z.boolean(),
+    runnable: z.boolean(),
+    blocked: z.boolean(),
+    blockedReasons: z.array(z.string()),
+    humanOnly: z.boolean(),
+    preflightRequired: z.boolean(),
+    requiresPreflight: z.boolean(),
+    requiresProviderWriteConsent: z.boolean(),
+    canDraft: z.boolean(),
+    canMarkReady: z.boolean(),
+    canAccept: z.boolean(),
+    canReopen: z.boolean(),
+    nextAllowedActions: z.array(z.string()),
+    requiredPriorPhase: sddPhaseSchema.optional(),
+    blockerReason: z.enum(['missing', 'draft', 'accepted', 'legacy', 'rejected', 'superseded']).optional(),
+})
+    .passthrough();
+const sddReadinessGatesOutputSchema = z
+    .object({
+    phase: sddPhaseGateOutputSchema,
+    prerequisites: z.array(sddPhaseGateOutputSchema),
+    runnable: z.boolean(),
+    blocked: z.boolean(),
+    blockedReasons: z.array(z.string()),
+    humanOnly: z.boolean(),
+    preflightRequired: z.boolean(),
+    agentCallable: z.boolean(),
+    canDraft: z.boolean(),
+    canMarkReady: z.boolean(),
+    canAccept: z.boolean(),
+    canReopen: z.boolean(),
+    nextAllowedActions: z.array(z.string()),
+    requiresProviderWriteConsent: z.boolean(),
+})
+    .passthrough();
+const sddCockpitGatesOutputSchema = z
+    .object({
+    phases: z.array(sddPhaseGateOutputSchema),
+    changeComplete: z.boolean(),
+    nextPhase: sddPhaseSchema.optional(),
+    nextPhaseRunnable: z.boolean(),
+    runnableNextPhases: z.array(sddPhaseSchema),
+    blockedTransitions: z.array(sddPhaseGateOutputSchema),
+    blockedReasons: z.array(z.string()),
+    requiresHumanAcceptance: z.boolean(),
+    humanOnly: z.boolean(),
+    preflightRequired: z.boolean(),
+    agentCallable: z.boolean(),
+    canDraft: z.boolean(),
+    canMarkReady: z.boolean(),
+    canAccept: z.boolean(),
+    canReopen: z.boolean(),
+    nextAllowedActions: z.array(z.string()),
+    requiresProviderWriteConsent: z.boolean(),
+})
+    .passthrough();
+const sddRecommendedActionOutputSchema = z
+    .object({
+    id: z.string(),
+    label: z.string(),
+    title: z.string(),
+    description: z.string(),
+    kind: z.enum(['inspect', 'draft-phase', 'mark-ready', 'accept-human', 'reopen-human']),
+    category: z.enum(['inspection', 'sdd-phase', 'human-governance']),
+    phase: sddPhaseSchema.optional(),
+    targetTool: z.string(),
+    suggestedArgs: z.record(z.string(), jsonValueSchema),
+    readOnly: z.boolean(),
+    mutating: z.boolean(),
+    agentCallable: z.boolean(),
+    humanOnly: z.boolean(),
+    requiresHumanApproval: z.boolean(),
+    requiresHumanConfirmation: z.boolean(),
+    requiresPreflight: z.boolean(),
+    requiresProviderWriteConsent: z.boolean(),
+    reason: z.string(),
+    rationale: z.string(),
+    blockingPrerequisites: z.array(z
+        .object({
+        phase: sddPhaseSchema,
+        topicKey: z.string(),
+        reason: z.string(),
+        artifactId: z.string().optional(),
+    })
+        .passthrough()),
+})
+    .passthrough();
+const mcpSuccessOutputSchema = (value) => z
+    .object({
+    ok: z.literal(true),
+    tool: z.enum(SUPPORTED_VGX_MCP_TOOL_NAMES),
+    value,
+})
+    .passthrough();
 export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
     vgxness_sdd_status: z
         .object({
@@ -351,6 +469,7 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
         agentName: z.string().min(1).optional(),
         workflow: z.string().min(1).optional(),
         phase: z.string().min(1).optional(),
+        intentSignals: z.array(z.string().min(1)).optional(),
         providerAdapter: z.string().min(1).optional(),
         runId: z.string().min(1).optional(),
         mode: z.enum(payloadModes).optional(),
@@ -503,6 +622,64 @@ export const VGX_MCP_TOOL_INPUT_SCHEMAS = {
     })
         .passthrough(),
 };
+export const VGX_MCP_TOOL_OUTPUT_SCHEMAS = {
+    vgxness_sdd_ready: mcpSuccessOutputSchema(z
+        .object({
+        change: z.string(),
+        phase: sddPhaseSchema,
+        ready: z.boolean(),
+        gates: sddReadinessGatesOutputSchema.optional(),
+    })
+        .passthrough()),
+    vgxness_sdd_get_readiness: mcpSuccessOutputSchema(z
+        .object({
+        change: z.string(),
+        phase: sddPhaseSchema,
+        ready: z.boolean(),
+        gates: sddReadinessGatesOutputSchema.optional(),
+    })
+        .passthrough()),
+    vgxness_sdd_cockpit: mcpSuccessOutputSchema(z
+        .object({
+        project: z.string(),
+        change: z.string(),
+        gates: sddCockpitGatesOutputSchema.optional(),
+        readModel: z
+            .object({
+            project: z.string(),
+            change: z.string(),
+            gates: sddCockpitGatesOutputSchema.optional(),
+            phases: z.array(z
+                .object({
+                phase: sddPhaseSchema,
+                gates: sddPhaseGateOutputSchema.optional(),
+            })
+                .passthrough()),
+        })
+            .passthrough(),
+    })
+        .passthrough()),
+    vgxness_sdd_continue: mcpSuccessOutputSchema(z
+        .object({
+        kind: z.literal('sdd-continuation-plan'),
+        project: z.string(),
+        change: z.string(),
+        recommendedActions: z.array(sddRecommendedActionOutputSchema),
+    })
+        .passthrough()),
+    vgxness_provider_status: mcpSuccessOutputSchema(z
+        .object({
+        kind: z.literal('provider-status'),
+        providerEvidence: providerEvidenceOutputSchema,
+    })
+        .passthrough()),
+    vgxness_provider_doctor: mcpSuccessOutputSchema(z
+        .object({
+        kind: z.literal('provider-doctor'),
+        providerEvidence: providerEvidenceOutputSchema,
+    })
+        .passthrough()),
+};
 export function successEnvelope(tool, value) {
     return { ok: true, tool, value };
 }