vgxness 1.20.4 → 1.20.6

package/dist/{mcp → adapters/claude/install}/client-install-claude-code.js

@@ -1,17 +1,24 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { createManagedProviderConfigBackup } from '../setup/backup-rollback-service.js';
+import { createManagedProviderConfigBackup } from '../../../setup/backup-rollback-service.js';
 import { parseClaudeAgentFrontmatter } from './claude-code-agent-config.js';
 import { runClaudeCodeCliCommand } from './claude-code-cli.js';
 import { createClaudeCodeMcpServerConfig, inspectClaudeCodeMcpConfig, mergeClaudeCodeMcpConfig } from './claude-code-config.js';
 import { inspectClaudeProjectMemory, mergeClaudeProjectMemory } from './claude-code-project-memory.js';
-import { expectedClaudeCodeRenderedAgents, expectedClaudeCodeRenderedUserAgents, planClaudeCodeMcpInstall } from './client-install-claude-code-contract.js';
 import { inspectClaudeCodeUserMcpConfig, mergeClaudeCodeUserMcpConfig } from './claude-code-user-config.js';
 import { inspectClaudeUserMemory, mergeClaudeUserMemory } from './claude-code-user-memory.js';
+import { expectedClaudeCodeRenderedAgents, expectedClaudeCodeRenderedUserAgents, planClaudeCodeMcpInstall, } from './client-install-claude-code-contract.js';
 export async function installClaudeCodeMcpClient(input) {
     const source = input.databasePathSource ?? 'flag';
     const server = createClaudeCodeMcpServerConfig(input.databasePath, source);
-    const plan = planClaudeCodeMcpInstall({ cwd: input.cwd, databasePath: input.databasePath, databasePathSource: source, ...(input.overwriteVgxness !== undefined ? { overwriteVgxness: input.overwriteVgxness } : {}), ...(input.scope !== undefined ? { scope: input.scope } : {}), ...(input.env !== undefined ? { env: input.env } : {}) });
+    const plan = planClaudeCodeMcpInstall({
+        cwd: input.cwd,
+        databasePath: input.databasePath,
+        databasePathSource: source,
+        ...(input.overwriteVgxness !== undefined ? { overwriteVgxness: input.overwriteVgxness } : {}),
+        ...(input.scope !== undefined ? { scope: input.scope } : {}),
+        ...(input.env !== undefined ? { env: input.env } : {}),
+    });
     if (plan.status === 'refused')
         return refusal(plan.reason, plan.message, plan, server, [], []);
     if (!input.confirmed)
@@ -45,7 +52,21 @@ export async function installClaudeCodeMcpClient(input) {
         const cliResult = { exitCode: cli.exitCode, stdout: cli.stdout, stderr: cli.stderr, preview: cli.command.preview };
         if (cli.exitCode !== 0)
             return refusal('preflight_failed', `Claude CLI MCP registration failed with exit code ${cli.exitCode ?? 'unknown'}.`, plan, server, [], [], cliResult);
-        return { version: 1, kind: 'mcp-client-install-claude-code', status: 'installed', targetPath: plan.targetPath, writtenPaths: [], backups: [], safety: applySafety(plan), server, warnings: plan.warnings, verificationHints: plan.verificationHints, agentNames: plan.agentNames, overwriteVgxness: plan.overwriteVgxness, cliResult };
+        return {
+            version: 1,
+            kind: 'mcp-client-install-claude-code',
+            status: 'installed',
+            targetPath: plan.targetPath,
+            writtenPaths: [],
+            backups: [],
+            safety: applySafety(plan),
+            server,
+            warnings: plan.warnings,
+            verificationHints: plan.verificationHints,
+            agentNames: plan.agentNames,
+            overwriteVgxness: plan.overwriteVgxness,
+            cliResult,
+        };
     }
     if (plan.canonicalClaudeScope === 'user')
         return applyUserInstall(input, plan, server, writtenPaths, backups);
@@ -76,7 +97,20 @@ export async function installClaudeCodeMcpClient(input) {
         return refusal('post_write_validation_failed', projectMemoryWrite.error.message, plan, server, writtenPaths, backups);
     if (projectMemoryWrite.value !== undefined)
         writtenPaths.push(projectMemoryWrite.value);
-    return { version: 1, kind: 'mcp-client-install-claude-code', status: 'installed', targetPath: plan.targetPath, writtenPaths, backups, safety: applySafety(plan), server, warnings: plan.warnings, verificationHints: plan.verificationHints, agentNames: plan.agentNames, overwriteVgxness: plan.overwriteVgxness };
+    return {
+        version: 1,
+        kind: 'mcp-client-install-claude-code',
+        status: 'installed',
+        targetPath: plan.targetPath,
+        writtenPaths,
+        backups,
+        safety: applySafety(plan),
+        server,
+        warnings: plan.warnings,
+        verificationHints: plan.verificationHints,
+        agentNames: plan.agentNames,
+        overwriteVgxness: plan.overwriteVgxness,
+    };
 }
 function writeMcpJson(cwd, plan, server) {
     const state = inspectClaudeCodeMcpConfig(cwd);
@@ -88,7 +122,9 @@ function writeMcpJson(cwd, plan, server) {
     mkdirSync(dirname(plan.targetPath), { recursive: true });
     writeFileSync(plan.targetPath, `${JSON.stringify(merged, null, 2)}\n`);
     const after = inspectClaudeCodeMcpConfig(cwd);
-    return after.status === 'configured' ? { ok: true, value: plan.targetPath } : { ok: false, error: { code: 'validation_failed', message: 'Claude .mcp.json did not validate after write.' } };
+    return after.status === 'configured'
+        ? { ok: true, value: plan.targetPath }
+        : { ok: false, error: { code: 'validation_failed', message: 'Claude .mcp.json did not validate after write.' } };
 }
 function writeUserMcpJson(env, plan, server) {
     const target = plan.targets.find((item) => item.kind === 'user-mcp-json');
@@ -107,7 +143,9 @@ function writeUserMcpJson(env, plan, server) {
     mkdirSync(dirname(target.path), { recursive: true });
     writeFileSync(target.path, `${JSON.stringify(merged, null, 2)}\n`);
     const after = inspectClaudeCodeUserMcpConfig(env);
-    return after.status === 'configured' ? { ok: true, value: target.path } : { ok: false, error: { code: 'validation_failed', message: 'Claude user ~/.claude.json did not validate after write.' } };
+    return after.status === 'configured'
+        ? { ok: true, value: target.path }
+        : { ok: false, error: { code: 'validation_failed', message: 'Claude user ~/.claude.json did not validate after write.' } };
 }
 function writeProjectMemory(plan) {
     const target = plan.targets.find((item) => item.kind === 'project-memory');
@@ -124,10 +162,13 @@ function writeProjectMemory(plan) {
     mkdirSync(dirname(target.path), { recursive: true });
     writeFileSync(target.path, merged.value.contents);
     const after = inspectClaudeProjectMemory(dirname(target.path));
-    return after.status === 'managed-current' ? { ok: true, value: target.path } : { ok: false, error: { code: 'validation_failed', message: 'Claude project memory did not validate as managed-current after write.' } };
+    return after.status === 'managed-current'
+        ? { ok: true, value: target.path }
+        : { ok: false, error: { code: 'validation_failed', message: 'Claude project memory did not validate as managed-current after write.' } };
 }
 async function applyUserInstall(input, plan, server, writtenPaths, backups) {
-    const existingTargets = plan.targets.filter((target) => target.kind !== 'cli-mcp-registration' && (target.action === 'merge' || target.action === 'update-vgxness' || target.action === 'append-managed-block' || target.action === 'update-managed-block'));
+    const existingTargets = plan.targets.filter((target) => target.kind !== 'cli-mcp-registration' &&
+        (target.action === 'merge' || target.action === 'update-vgxness' || target.action === 'append-managed-block' || target.action === 'update-managed-block'));
     for (const target of existingTargets) {
         const backup = createBackup(target.path, target.kind === 'user-memory' ? 'user-memory' : 'config', 'user', input.env?.HOME);
         if (!backup.ok)
@@ -154,7 +195,20 @@ async function applyUserInstall(input, plan, server, writtenPaths, backups) {
         return refusal('post_write_validation_failed', memoryWrite.error.message, plan, server, writtenPaths, backups);
     if (memoryWrite.value !== undefined)
         writtenPaths.push(memoryWrite.value);
-    return { version: 1, kind: 'mcp-client-install-claude-code', status: 'installed', targetPath: plan.targetPath, writtenPaths, backups, safety: applySafety(plan), server, warnings: plan.warnings, verificationHints: plan.verificationHints, agentNames: plan.agentNames, overwriteVgxness: plan.overwriteVgxness };
+    return {
+        version: 1,
+        kind: 'mcp-client-install-claude-code',
+        status: 'installed',
+        targetPath: plan.targetPath,
+        writtenPaths,
+        backups,
+        safety: applySafety(plan),
+        server,
+        warnings: plan.warnings,
+        verificationHints: plan.verificationHints,
+        agentNames: plan.agentNames,
+        overwriteVgxness: plan.overwriteVgxness,
+    };
 }
 function writeUserMemory(env, plan) {
     const target = plan.targets.find((item) => item.kind === 'user-memory');
@@ -171,7 +225,9 @@ function writeUserMemory(env, plan) {
     mkdirSync(dirname(target.path), { recursive: true });
     writeFileSync(target.path, merged.value.contents);
     const after = inspectClaudeUserMemory(env);
-    return after.status === 'managed-current' ? { ok: true, value: target.path } : { ok: false, error: { code: 'validation_failed', message: 'Claude user memory did not validate as managed-current after write.' } };
+    return after.status === 'managed-current'
+        ? { ok: true, value: target.path }
+        : { ok: false, error: { code: 'validation_failed', message: 'Claude user memory did not validate as managed-current after write.' } };
 }
 function createBackup(path, kind, scope = 'project', allowedManagedHome) {
     return createManagedProviderConfigBackup({
@@ -180,18 +236,46 @@ function createBackup(path, kind, scope = 'project', allowedManagedHome) {
         scope,
         createdByOperation: 'mcp-client-install-claude-code',
         reason: kind === 'project-memory' ? 'pre-project-memory-update-safety' : kind === 'user-memory' ? 'pre-user-memory-update-safety' : 'pre-merge-safety',
-        description: kind === 'project-memory' ? 'Backup existing Claude Code project memory before appending or updating the VGXNESS managed block.' : kind === 'user-memory' ? 'Backup existing Claude Code user memory before appending or updating the VGXNESS managed block.' : 'Backup existing Claude Code config before merging VGXNESS MCP or agent configuration.',
+        description: kind === 'project-memory'
+            ? 'Backup existing Claude Code project memory before appending or updating the VGXNESS managed block.'
+            : kind === 'user-memory'
+                ? 'Backup existing Claude Code user memory before appending or updating the VGXNESS managed block.'
+                : 'Backup existing Claude Code config before merging VGXNESS MCP or agent configuration.',
         ...(allowedManagedHome !== undefined ? { allowedManagedHome } : {}),
     });
 }
 function refusal(reason, message, plan, server, writtenPaths, backups, cliResult) {
-    return { version: 1, kind: 'mcp-client-install-claude-code', status: 'refused', reason, message, targetPath: plan.targetPath, writtenPaths, backups, safety: { ...plan.safety, operation: 'apply', mutating: false, writesProviderConfig: false }, server, warnings: plan.warnings, verificationHints: plan.verificationHints, agentNames: plan.agentNames, overwriteVgxness: plan.overwriteVgxness, ...(cliResult === undefined ? {} : { cliResult }) };
+    return {
+        version: 1,
+        kind: 'mcp-client-install-claude-code',
+        status: 'refused',
+        reason,
+        message,
+        targetPath: plan.targetPath,
+        writtenPaths,
+        backups,
+        safety: { ...plan.safety, operation: 'apply', mutating: false, writesProviderConfig: false },
+        server,
+        warnings: plan.warnings,
+        verificationHints: plan.verificationHints,
+        agentNames: plan.agentNames,
+        overwriteVgxness: plan.overwriteVgxness,
+        ...(cliResult === undefined ? {} : { cliResult }),
+    };
 }
 function applySafety(plan) {
     return { ...plan.safety, operation: 'apply', mutating: true, writesProviderConfig: true };
 }
 function toBackupSummary(backup) {
-    return { kind: 'managed', backupId: backup.backupId, backupPath: backup.backupPath, metadataPath: backup.metadataPath, scope: backup.scope, byteSize: backup.byteSize, contentHash: backup.contentHash };
+    return {
+        kind: 'managed',
+        backupId: backup.backupId,
+        backupPath: backup.backupPath,
+        metadataPath: backup.metadataPath,
+        scope: backup.scope,
+        byteSize: backup.byteSize,
+        contentHash: backup.contentHash,
+    };
 }
 function unique(values) {
     return [...new Set(values)];

package/dist/adapters/json/agent-renderer.js

@@ -0,0 +1,104 @@
+import { ok, validationFailure, } from '../provider-renderer.js';
+const previewSafety = {
+    executesProvider: false,
+    writesProviderConfig: false,
+    installable: false,
+    previewOnly: true,
+};
+const jsonCapabilities = {
+    supportedAgentFields: [
+        'id',
+        'project',
+        'scope',
+        'mode',
+        'name',
+        'description',
+        'instructions',
+        'capabilities',
+        'permissions',
+        'memory',
+        'workflows',
+        'skills',
+        'adapters',
+        'timestamps',
+        'parentAgentId',
+    ],
+    skillInjectionModes: ['preserved as registry metadata in neutral export'],
+    permissionCategories: ['preserved registry permission policy metadata'],
+    memoryInjectionModes: ['preserved registry memory scope metadata'],
+    delegationModel: 'preserves registry agent/subagent relationships without provider delegation execution',
+    lifecycleHooks: ['preview render/export only'],
+    configFileLocations: [],
+    limitations: [
+        'Generic debug/export output; it is not executable provider configuration.',
+        'Does not execute providers or run lifecycle hooks.',
+        'Does not install provider tooling.',
+        'Does not write provider configuration files.',
+    ],
+    render: {
+        format: 'neutral-json-export',
+        artifactContentTypes: ['application/json'],
+        installable: false,
+        previewOnly: true,
+    },
+};
+export class JsonAgentRenderer {
+    provider = 'json';
+    capabilities = jsonCapabilities;
+    render(input) {
+        const subagents = input.subagents ?? [];
+        const basePath = `rendered/json/${pathSegment(input.agent.project)}/${input.agent.scope}/${pathSegment(input.agent.name)}`;
+        const artifacts = [
+            jsonArtifact(`${basePath}.agent.json`, renderedDefinition(input.agent, this.provider)),
+            jsonArtifact(`${basePath}.manifest.json`, {
+                provider: this.provider,
+                installable: false,
+                safety: previewSafety,
+                rootAgentId: input.agent.id,
+                rootAgentName: input.agent.name,
+                subagentIds: subagents.map((subagent) => subagent.id),
+                artifacts: [`${basePath}.agent.json`, ...subagents.map((subagent) => `${basePath}.subagents/${pathSegment(subagent.name)}.json`)],
+            }),
+            ...subagents.map((subagent) => jsonArtifact(`${basePath}.subagents/${pathSegment(subagent.name)}.json`, renderedDefinition(subagent, this.provider))),
+        ];
+        const duplicatePath = firstDuplicate(artifacts.map((artifact) => artifact.relativePath));
+        if (duplicatePath !== undefined)
+            return validationFailure(`Rendered artifact path collision: ${duplicatePath}`);
+        return ok({
+            provider: this.provider,
+            installable: false,
+            artifacts,
+            warnings: ['Rendering returns preview artifacts only; it does not install or write provider configuration.'],
+        });
+    }
+}
+function renderedDefinition(agent, provider) {
+    const rendered = { agent, safety: previewSafety };
+    const selectedAdapter = agent.adapters[provider];
+    if (selectedAdapter !== undefined)
+        rendered.selectedAdapter = selectedAdapter;
+    return rendered;
+}
+function jsonArtifact(relativePath, value) {
+    return {
+        relativePath,
+        contentType: 'application/json',
+        contents: `${JSON.stringify(value, null, 2)}\n`,
+    };
+}
+function pathSegment(value) {
+    return (value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'unnamed');
+}
+function firstDuplicate(values) {
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value))
+            return value;
+        seen.add(value);
+    }
+    return undefined;
+}

package/dist/adapters/opencode/agent-renderer.js

@@ -0,0 +1,113 @@
+import { behaviorContractProjectionMetadata } from '../../behavior/behavior-contract-manifest.js';
+import { ok, validationFailure } from '../provider-renderer.js';
+const openCodeSchema = 'https://opencode.ai/config.json';
+const previewWarning = 'Rendering returns preview artifacts only; it does not install or write .opencode/, .claude/, or provider configuration.';
+const previewSafety = {
+    executesProvider: false,
+    writesProviderConfig: false,
+    installable: false,
+    previewOnly: true,
+};
+const openCodeCapabilities = {
+    supportedAgentFields: [
+        'name',
+        'description',
+        'instructions',
+        'mode',
+        'adapter model',
+        'adapter config keys: variant, temperature, top_p, hidden, options, color, steps, permission, tools',
+    ],
+    skillInjectionModes: ['external preview services may inject skill payloads before rendering; renderer does not resolve skills'],
+    permissionCategories: ['registry permission metadata mapped from adapter permission config'],
+    memoryInjectionModes: ['external preview services may inject memory payloads before rendering; renderer does not load memory'],
+    delegationModel: 'registry agents render as primary agents and registry subagents render as subagents without executing delegation',
+    lifecycleHooks: ['preview render/export only'],
+    configFileLocations: ['rendered/opencode/.../opencode.json'],
+    limitations: [
+        'Preview artifacts only; does not execute OpenCode or provider commands.',
+        'Does not install OpenCode or global tooling.',
+        'Does not write .opencode/, .claude/, or provider configuration.',
+        'Does not provide TUI support or sandbox/worktree enforcement.',
+    ],
+    render: {
+        format: 'opencode-json-preview',
+        artifactContentTypes: ['application/json'],
+        installable: false,
+        previewOnly: true,
+    },
+};
+export class OpenCodeAgentRenderer {
+    provider = 'opencode';
+    capabilities = openCodeCapabilities;
+    render(input) {
+        const agents = [input.agent, ...(input.subagents ?? [])];
+        const renderedAgents = {};
+        for (const agent of agents) {
+            const key = openCodeAgentKey(agent.name);
+            if (renderedAgents[key] !== undefined)
+                return validationFailure(`Rendered OpenCode agent key collision: ${key}`);
+            renderedAgents[key] = openCodeAgentConfig(agent);
+        }
+        const artifact = {
+            relativePath: `rendered/opencode/${pathSegment(input.agent.project)}/${input.agent.scope}/${pathSegment(input.agent.name)}/opencode.json`,
+            contentType: 'application/json',
+            contents: `${JSON.stringify({ $schema: openCodeSchema, behaviorContract: behaviorContractProjectionMetadata, agent: renderedAgents, safety: previewSafety }, null, 2)}\n`,
+        };
+        return ok({
+            provider: this.provider,
+            installable: false,
+            artifacts: [artifact],
+            warnings: [previewWarning, 'Top-level registry agents render as OpenCode primary agents by default; registry subagents render as OpenCode subagents.'],
+        });
+    }
+}
+function openCodeAgentConfig(agent) {
+    const adapter = agent.adapters.opencode;
+    const config = adapter?.config ?? {};
+    const rendered = {
+        ...(adapter?.model !== undefined ? { model: adapter.model } : {}),
+        description: agent.description,
+        prompt: agent.instructions.value,
+        mode: agent.mode === 'subagent' ? 'subagent' : 'primary',
+    };
+    copyString(config, rendered, 'variant');
+    copyNumber(config, rendered, 'temperature');
+    copyNumber(config, rendered, 'top_p');
+    copyBoolean(config, rendered, 'hidden');
+    copyJson(config, rendered, 'options');
+    copyString(config, rendered, 'color');
+    copyNumber(config, rendered, 'steps');
+    copyJson(config, rendered, 'permission');
+    copyJson(config, rendered, 'tools');
+    return rendered;
+}
+function copyString(source, target, key) {
+    const value = source[key];
+    if (typeof value === 'string')
+        target[key] = value;
+}
+function copyNumber(source, target, key) {
+    const value = source[key];
+    if (typeof value === 'number')
+        target[key] = value;
+}
+function copyBoolean(source, target, key) {
+    const value = source[key];
+    if (typeof value === 'boolean')
+        target[key] = value;
+}
+function copyJson(source, target, key) {
+    const value = source[key];
+    if (value !== undefined)
+        target[key] = value;
+}
+function openCodeAgentKey(value) {
+    return pathSegment(value);
+}
+function pathSegment(value) {
+    return (value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '') || 'unnamed');
+}

package/dist/{mcp → adapters/opencode/install}/client-install-opencode-contract.js

@@ -191,7 +191,7 @@ function refusal(reason, message, databasePath, source, scope, targetPath, extra
         ...(targetPath !== undefined ? { targetPath } : {}),
     };
 }
-function warningsForScope(scope, overwriteVgxness, agentPlan, bashPermissionPolicy) {
+function warningsForScope(_scope, overwriteVgxness, agentPlan, bashPermissionPolicy) {
     const overwriteWarnings = overwriteVgxness
         ? [
             `Reinstall/overwrite is enabled: existing VGXNESS-managed OpenCode entries will be replaced (${agentPlan.installsAgents ? 'mcp.vgxness, default_agent, instructions AGENTS.md, and known VGXNESS agents' : 'mcp.vgxness only'}); unrelated OpenCode config is preserved.`,
@@ -216,7 +216,7 @@ function createdConfigKeys(agentPlan) {
     const keys = agentPlan.installsAgents ? ['$schema', 'instructions', 'default_agent', 'agent', 'mcp'] : ['$schema', 'mcp'];
     return [...keys, 'permission'];
 }
-function manualTestForScope(scope, databasePath, source) {
+function manualTestForScope(_scope, databasePath, source) {
     return {
         restart: 'Restart OpenCode after the user config is installed.',
         verify: 'Open OpenCode and verify the vgxness MCP server is available from the user OpenCode config; project config may override it.',

package/dist/{mcp → adapters/opencode/install}/client-install-opencode.js

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
-import { createManagedProviderConfigBackup } from '../setup/backup-rollback-service.js';
+import { createManagedProviderConfigBackup } from '../../../setup/backup-rollback-service.js';
 import { findConflictingVgxnessAgents, planOpenCodeMcpInstall, } from './client-install-opencode-contract.js';
 import { createOpenCodeDefaultAgentConfig, createOpenCodeDefaultAgentInstallPlan, vgxnessOpenCodeInstructionsPath, } from './opencode-default-agent-config.js';
 const opencodeConfigSchema = 'https://opencode.ai/config.json';

package/dist/{mcp → adapters/opencode/install}/opencode-default-agent-config.js

@@ -1,5 +1,5 @@
-import { projectCanonicalAgentManifestToOpenCode, withEffectiveOpenCodeManagerInstructions, } from '../agents/canonical-agent-projection.js';
-import { canonicalDefaultAgentName, canonicalPromptContractVersion, canonicalSddSubagentNames, createCanonicalOpenCodeSddMcpToolPermissions, createCanonicalOpenCodeSddTaskPermissions, } from '../agents/canonical-agent-manifest.js';
+import { canonicalDefaultAgentName, canonicalPromptContractVersion, canonicalSddSubagentNames, createCanonicalOpenCodeSddMcpToolPermissions, createCanonicalOpenCodeSddTaskPermissions, } from '../../../agents/canonical-agent-manifest.js';
+import { projectCanonicalAgentManifestToOpenCode, withEffectiveOpenCodeManagerInstructions, } from '../../../agents/canonical-agent-projection.js';
 export const vgxnessOpenCodeDefaultAgent = canonicalDefaultAgentName;
 export const vgxnessOpenCodePromptContractVersion = canonicalPromptContractVersion;
 export const vgxnessOpenCodeInstructionsPath = 'AGENTS.md';

package/dist/{mcp → adapters/opencode/install}/opencode-handoff-preview.js

@@ -63,7 +63,10 @@ export class OpenCodeHandoffPreviewService {
             const reason = 'change is required to read SDD status/readiness';
             return { summary: { ...(input.phase === undefined ? {} : { phase: input.phase }), unavailableReason: reason }, inspection: notInspectedSdd(reason) };
         }
-        const summary = { change: input.change, ...(input.phase === undefined ? {} : { phase: input.phase }) };
+        const summary = {
+            change: input.change,
+            ...(input.phase === undefined ? {} : { phase: input.phase }),
+        };
         if (this.deps.sdd === undefined) {
             const reason = 'SDD service is unavailable';
             warnings.push('SDD service is unavailable; SDD status, next phase, and readiness were not queried.');
@@ -118,7 +121,14 @@ export class OpenCodeHandoffPreviewService {
             warnings.push('Provider status service is unavailable; provider status was not inspected.');
             return { ok: true, value: { inspection: { inspected: false, notInspectedReason: 'provider status service is unavailable' } } };
         }
-        const status = this.deps.providerStatus.getStatus({ project: input.project, scope, providerAdapter: 'opencode', workspaceRoot: input.workspaceRoot, ...(input.change === undefined ? {} : { change: input.change }), payloadMode: 'compact' });
+        const status = this.deps.providerStatus.getStatus({
+            project: input.project,
+            scope,
+            providerAdapter: 'opencode',
+            workspaceRoot: input.workspaceRoot,
+            ...(input.change === undefined ? {} : { change: input.change }),
+            payloadMode: 'compact',
+        });
         if (!status.ok)
             return status;
         return { ok: true, value: { value: status.value, inspection: { inspected: true } } };
@@ -138,7 +148,12 @@ function continuationReadinessValue(value, phase) {
     const record = asRecord(value);
     if (record === undefined)
         return undefined;
-    return readinessFromPhaseEntries(asRecord(record.cockpit)?.phases, phase) ?? readinessFromPhaseEntries(record.phases, phase) ?? readinessFromPhaseEntries(asRecord(record.readModel)?.phases, phase) ?? readinessFromReadinessMap(record.readinessByPhase, phase) ?? readinessFromReadinessMap(record.phaseReadiness, phase) ?? matchingReadiness(record.readiness, phase);
+    return (readinessFromPhaseEntries(asRecord(record.cockpit)?.phases, phase) ??
+        readinessFromPhaseEntries(record.phases, phase) ??
+        readinessFromPhaseEntries(asRecord(record.readModel)?.phases, phase) ??
+        readinessFromReadinessMap(record.readinessByPhase, phase) ??
+        readinessFromReadinessMap(record.phaseReadiness, phase) ??
+        matchingReadiness(record.readiness, phase));
 }
 function readinessFromPhaseEntries(value, phase) {
     if (!Array.isArray(value))
@@ -169,14 +184,52 @@ function asRecord(value) {
     return typeof value === 'object' && value !== null ? value : undefined;
 }
 function managerInput(input, scope) {
-    return { project: input.project, scope, agentName: input.agentName ?? 'vgxness-manager', ...(input.agentId === undefined ? {} : { agentId: input.agentId }), ...(input.workspaceRoot === undefined ? {} : { workspaceRoot: input.workspaceRoot }), ...(input.maxSourceBytes === undefined ? {} : { maxSourceBytes: input.maxSourceBytes }), payloadMode: 'compact' };
+    return {
+        project: input.project,
+        scope,
+        agentName: input.agentName ?? 'vgxness-manager',
+        ...(input.agentId === undefined ? {} : { agentId: input.agentId }),
+        ...(input.workspaceRoot === undefined ? {} : { workspaceRoot: input.workspaceRoot }),
+        ...(input.maxSourceBytes === undefined ? {} : { maxSourceBytes: input.maxSourceBytes }),
+        payloadMode: 'compact',
+    };
 }
 function context(input, scope, manager) {
-    return { project: input.project, scope, ...(input.change === undefined ? {} : { change: input.change }), ...(input.phase === undefined ? {} : { phase: input.phase }), ...(input.workspaceRoot === undefined ? {} : { workspaceRoot: input.workspaceRoot }), selectedAgent: manager.selection.agent };
+    return {
+        project: input.project,
+        scope,
+        ...(input.change === undefined ? {} : { change: input.change }),
+        ...(input.phase === undefined ? {} : { phase: input.phase }),
+        ...(input.workspaceRoot === undefined ? {} : { workspaceRoot: input.workspaceRoot }),
+        selectedAgent: manager.selection.agent,
+    };
 }
 function compactManager(payload) {
-    return { version: payload.version, provider: payload.provider, selection: payload.selection, payloadMode: payload.payloadMode, providerArtifacts: payload.providerArtifacts, ...(payload.skillDiagnostics === undefined ? {} : { skillDiagnostics: payload.skillDiagnostics }), safety: payload.safety, warnings: payload.warnings };
+    return {
+        version: payload.version,
+        provider: payload.provider,
+        selection: payload.selection,
+        payloadMode: payload.payloadMode,
+        providerArtifacts: payload.providerArtifacts,
+        ...(payload.skillDiagnostics === undefined ? {} : { skillDiagnostics: payload.skillDiagnostics }),
+        safety: payload.safety,
+        warnings: payload.warnings,
+    };
 }
 function compactProvider(status) {
-    return { version: status.version, kind: status.kind, project: status.project, providerAdapter: status.providerAdapter, scope: status.scope, workspaceRoot: status.workspaceRoot, status: status.status, overallStatus: status.overallStatus, summary: status.summary, nextAction: status.nextAction, issueCount: status.issueCount, warningCount: status.warningCount, safety: status.safety };
+    return {
+        version: status.version,
+        kind: status.kind,
+        project: status.project,
+        providerAdapter: status.providerAdapter,
+        scope: status.scope,
+        workspaceRoot: status.workspaceRoot,
+        status: status.status,
+        overallStatus: status.overallStatus,
+        summary: status.summary,
+        nextAction: status.nextAction,
+        issueCount: status.issueCount,
+        warningCount: status.warningCount,
+        safety: status.safety,
+    };
 }

package/dist/{mcp → adapters/opencode/install}/opencode-visibility.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
+import { SUPPORTED_VGX_MCP_TOOL_NAMES } from '../../../mcp/schema.js';
 import { resolveOpenCodeMcpInstallTarget } from './client-install-opencode-contract.js';
-import { SUPPORTED_VGX_MCP_TOOL_NAMES } from './schema.js';
 const serverName = 'vgxness';
 const expectedToolCount = SUPPORTED_VGX_MCP_TOOL_NAMES.length;
 export function createOpenCodeMcpVisibilityReport(options) {

package/dist/adapters/provider-renderer.js

@@ -0,0 +1,6 @@
+export function validationFailure(message) {
+    return { ok: false, error: { code: 'validation_failed', message } };
+}
+export function ok(value) {
+    return { ok: true, value };
+}