vgxness 0.1.0

package/dist/setup/backup-rollback-service.js

@@ -0,0 +1,76 @@
+import { accessSync, constants, copyFileSync, existsSync, mkdirSync, statSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+export function createConfigBackupPath(targetPath, label = 'backup') {
+    return `${targetPath}.${label}-${new Date().toISOString().replaceAll(/[-:.]/g, '')}`;
+}
+export function rollbackConfigBackup(input) {
+    const backupPath = input.backupPath;
+    const readable = validateReadableFile(backupPath, 'backup');
+    if (!readable.ok)
+        return readable;
+    const target = inferRollbackTarget(backupPath);
+    if (!target.ok)
+        return target;
+    try {
+        let preRollbackBackupPath;
+        if (existsSync(target.value)) {
+            const current = validateReadableFile(target.value, 'current target');
+            if (!current.ok)
+                return current;
+            preRollbackBackupPath = createConfigBackupPath(target.value, 'pre-rollback-backup');
+            copyFileSync(target.value, preRollbackBackupPath);
+        }
+        mkdirSync(dirname(target.value), { recursive: true });
+        copyFileSync(backupPath, target.value);
+        return {
+            ok: true,
+            value: {
+                version: 1,
+                kind: 'setup-rollback-result',
+                status: 'restored',
+                backupPath,
+                targetPath: target.value,
+                ...(preRollbackBackupPath === undefined ? {} : { preRollbackBackupPath }),
+                nextCommands: ['vgx doctor', 'Restart OpenCode and verify the vgxness MCP server is visible.'],
+            },
+        };
+    }
+    catch (cause) {
+        return { ok: false, error: { code: 'validation_failed', message: `Unable to restore backup ${backupPath} to ${target.value}; original backup was not deleted.`, cause } };
+    }
+}
+function validateReadableFile(path, label) {
+    try {
+        const stat = statSync(path);
+        if (!stat.isFile())
+            return { ok: false, error: { code: 'validation_failed', message: `${label} path is not a file: ${path}` } };
+        accessSync(path, constants.R_OK);
+        return { ok: true, value: undefined };
+    }
+    catch (cause) {
+        return { ok: false, error: { code: 'validation_failed', message: `Unable to read ${label} path: ${path}`, cause } };
+    }
+}
+function inferRollbackTarget(backupPath) {
+    const legacyMarker = '.backup-';
+    const legacyIndex = backupPath.lastIndexOf(legacyMarker);
+    if (legacyIndex > 0)
+        return { ok: true, value: backupPath.slice(0, legacyIndex) };
+    const preRollbackMarker = '.pre-rollback-backup-';
+    const preRollbackIndex = backupPath.lastIndexOf(preRollbackMarker);
+    if (preRollbackIndex > 0)
+        return { ok: true, value: backupPath.slice(0, preRollbackIndex) };
+    const name = basename(backupPath);
+    if (name === 'opencode.json')
+        return { ok: true, value: backupPath };
+    return {
+        ok: false,
+        error: {
+            code: 'validation_failed',
+            message: `Cannot infer rollback target for ${backupPath}. Expected a VGXNESS/OpenCode backup name such as opencode.json.backup-<timestamp>.`,
+        },
+    };
+}
+export function inferLegacyOpenCodeBackupPath(targetPath, timestamp) {
+    return join(dirname(targetPath), `${basename(targetPath)}.backup-${timestamp}`);
+}

package/dist/setup/index.js

@@ -0,0 +1,3 @@
+export * from './schema.js';
+export * from './setup-lifecycle-service.js';
+export * from './providers/index.js';

package/dist/setup/providers/antigravity-setup-adapter.js

@@ -0,0 +1,18 @@
+import { noWriteActionSafety } from './provider-setup-adapter.js';
+export const antigravitySetupAdapter = {
+    id: 'antigravity',
+    displayName: 'Antigravity',
+    supportLevel: 'placeholder',
+    capabilities: ['manual-guidance'],
+    targets: [{ kind: 'manual', label: 'Coming soon manual guidance', writableByDashboard: false }],
+    getStatus() {
+        return {
+            providerId: 'antigravity',
+            status: 'coming-soon',
+            summary: 'Antigravity setup is a placeholder and is coming soon.',
+            evidence: ['No install, doctor, visibility, or write actions are available for Antigravity.'],
+            guidance: ['Use this card as a non-mutating placeholder until provider support is implemented.'],
+            actions: [{ id: 'antigravity-coming-soon', label: 'Read coming-soon guidance', kind: 'manual-guidance', description: 'Placeholder guidance only; no target path or write action is exposed.', safety: noWriteActionSafety }],
+        };
+    },
+};

package/dist/setup/providers/claude-setup-adapter.js

@@ -0,0 +1,30 @@
+import { createMcpClientSetupPreview } from '../../mcp/client-setup-preview.js';
+import { noWriteActionSafety } from './provider-setup-adapter.js';
+export const claudeSetupAdapter = {
+    id: 'claude',
+    displayName: 'Claude',
+    supportLevel: 'preview-only',
+    capabilities: ['mcp-preview', 'manual-guidance'],
+    targets: [{ kind: 'manual', label: 'Claude MCP config snippet', writableByDashboard: false }],
+    getStatus(context) {
+        return {
+            providerId: 'claude',
+            status: 'preview-only',
+            summary: 'Claude setup is preview-only with manual MCP guidance.',
+            evidence: context.databasePath !== undefined ? ['Claude MCP preview can be generated from the selected database path.'] : ['Claude MCP preview uses a placeholder until a database path is selected.'],
+            guidance: ['Copy snippets manually after reviewing them. The dashboard does not install or apply Claude config.'],
+            actions: [{ id: 'claude-manual-guidance', label: 'Review Claude MCP snippet', kind: 'manual-guidance', description: 'Manual preview guidance only; no install/apply action is available.', safety: noWriteActionSafety }],
+        };
+    },
+    previewMcp(context) {
+        const preview = createMcpClientSetupPreview({ provider: 'claude', databasePath: context.databasePath ?? '<database-path>', ...(context.databasePathSource !== undefined ? { databasePathSource: context.databasePathSource } : {}) });
+        return {
+            providerId: 'claude',
+            label: 'Claude MCP preview',
+            readOnly: true,
+            writesProviderConfig: false,
+            snippets: preview.snippets,
+            warnings: preview.warnings,
+        };
+    },
+};

package/dist/setup/providers/custom-setup-adapter.js

@@ -0,0 +1,18 @@
+import { noWriteActionSafety } from './provider-setup-adapter.js';
+export const customSetupAdapter = {
+    id: 'custom',
+    displayName: 'Custom',
+    supportLevel: 'extension-point',
+    capabilities: ['manual-guidance'],
+    targets: [{ kind: 'extension', label: 'Custom provider extension point', writableByDashboard: false }],
+    getStatus() {
+        return {
+            providerId: 'custom',
+            status: 'unsupported',
+            summary: 'Custom providers are an extension point and default to safe manual guidance.',
+            evidence: ['No provider writes, executable calls, or install/apply actions are exposed by default.'],
+            guidance: ['Implement a dedicated adapter before exposing provider-specific capabilities.'],
+            actions: [{ id: 'custom-extension-guidance', label: 'Review custom provider guidance', kind: 'manual-guidance', description: 'Safe no-write extension guidance.', safety: noWriteActionSafety }],
+        };
+    },
+};

package/dist/setup/providers/index.js

@@ -0,0 +1,6 @@
+export * from './provider-setup-adapter.js';
+export * from './provider-setup-registry.js';
+export * from './opencode-setup-adapter.js';
+export * from './claude-setup-adapter.js';
+export * from './antigravity-setup-adapter.js';
+export * from './custom-setup-adapter.js';

package/dist/setup/providers/opencode-setup-adapter.js

@@ -0,0 +1,104 @@
+import { planOpenCodeMcpInstall } from '../../mcp/client-install-opencode-contract.js';
+import { createMcpClientSetupPreview } from '../../mcp/client-setup-preview.js';
+import { createOpenCodeMcpVisibilityReport } from '../../mcp/opencode-visibility.js';
+import { externalProviderWriteSafety, noWriteActionSafety } from './provider-setup-adapter.js';
+export const openCodeSetupAdapter = {
+    id: 'opencode',
+    displayName: 'OpenCode',
+    supportLevel: 'supported-primary',
+    capabilities: ['mcp-preview', 'mcp-install-plan', 'mcp-install-apply-external', 'agent-preview', 'doctor', 'visibility-check'],
+    targets: [
+        { kind: 'project-config', label: 'Project OpenCode config', path: '.opencode/opencode.json', writableByDashboard: false },
+        { kind: 'user-config', label: 'User OpenCode config', path: '$HOME/.config/opencode/opencode.json', writableByDashboard: false },
+    ],
+    getStatus(context) {
+        const visibility = this.getVisibility?.(context);
+        const plan = this.getInstallPlan?.(context);
+        return {
+            providerId: 'opencode',
+            status: visibility?.ready === true ? 'ready' : 'available',
+            summary: visibility?.ready === true ? 'OpenCode MCP visibility is ready.' : 'OpenCode is the supported primary provider; install/apply remains external and explicit.',
+            evidence: visibility?.evidence ?? ['OpenCode setup preview and install planning are available.'],
+            guidance: visibility?.guidance ?? ['Preview setup first, then copy and run external install commands only after review.'],
+            actions: plan?.actions ?? [],
+        };
+    },
+    previewMcp(context) {
+        const databasePath = databasePathOrPlaceholder(context);
+        const preview = createMcpClientSetupPreview({ provider: 'opencode', databasePath, ...(context.databasePathSource !== undefined ? { databasePathSource: context.databasePathSource } : {}) });
+        return {
+            providerId: 'opencode',
+            label: 'OpenCode MCP preview',
+            readOnly: true,
+            writesProviderConfig: false,
+            snippets: preview.snippets,
+            warnings: preview.warnings,
+        };
+    },
+    getInstallPlan(context) {
+        const databasePath = databasePathOrPlaceholder(context);
+        const contract = planOpenCodeMcpInstall({ cwd: context.workspaceRoot, databasePath, ...(context.databasePathSource !== undefined ? { databasePathSource: context.databasePathSource } : {}), ...(context.env !== undefined ? { env: context.env } : {}) });
+        const targetPath = 'targetPath' in contract ? contract.targetPath : undefined;
+        const actions = contract.status === 'would_install' ? [externalInstallAction(contract.scope, targetPath)] : [];
+        return {
+            providerId: 'opencode',
+            status: contract.status === 'would_install' ? 'available' : 'blocked',
+            readOnly: true,
+            mutating: false,
+            writesProviderConfig: false,
+            summary: contract.status === 'would_install' ? `OpenCode ${contract.action} plan is available for external application.` : contract.message,
+            ...(targetPath !== undefined ? { targetPath } : {}),
+            warnings: contract.warnings,
+            actions,
+            source: contract,
+        };
+    },
+    getVisibility(context) {
+        const report = createOpenCodeMcpVisibilityReport({ cwd: context.workspaceRoot, projectRoot: context.workspaceRoot, env: context.env });
+        return {
+            providerId: 'opencode',
+            readOnly: true,
+            writesProviderConfig: false,
+            ready: report.ready,
+            summary: report.ready ? 'OpenCode can see the vgxness MCP server.' : 'OpenCode MCP visibility is not ready yet.',
+            evidence: [
+                `Project config exists: ${String(report.targets.project.configExists)}.`,
+                `Project config has mcp.vgxness: ${String(report.targets.project.hasVgxnessServer)}.`,
+            ],
+            guidance: report.guidance,
+            source: report,
+        };
+    },
+};
+function databasePathOrPlaceholder(context) {
+    return context.databasePath ?? '<database-path>';
+}
+function externalInstallAction(scope, targetPath) {
+    return {
+        id: `opencode-mcp-install-${scope}`,
+        label: 'Copy external OpenCode install command',
+        kind: 'copy-command',
+        command: ['vgxness', 'mcp', 'install', 'opencode', '--scope', scope, '--yes'],
+        description: 'Copy and run this outside the dashboard only after reviewing the read-only plan.',
+        safety: externalProviderWriteSafety(targetPath),
+    };
+}
+export function createOpenCodeSetupPreview(context) {
+    return openCodeSetupAdapter.previewMcp?.(context) ?? {
+        providerId: 'opencode',
+        label: 'OpenCode MCP preview unavailable',
+        readOnly: true,
+        writesProviderConfig: false,
+        snippets: [],
+        warnings: ['OpenCode MCP preview is unavailable.'],
+    };
+}
+export function createOpenCodeManualGuidanceAction() {
+    return {
+        id: 'opencode-manual-guidance',
+        label: 'Review OpenCode manual guidance',
+        kind: 'manual-guidance',
+        description: 'Review OpenCode setup guidance without writing config.',
+        safety: noWriteActionSafety,
+    };
+}

package/dist/setup/providers/provider-setup-adapter.js

@@ -0,0 +1,15 @@
+export const noWriteActionSafety = {
+    mutating: false,
+    writesProviderConfig: false,
+    externalOnly: true,
+    requiresExplicitConfirmation: false,
+};
+export function externalProviderWriteSafety(targetPath) {
+    return {
+        mutating: true,
+        writesProviderConfig: true,
+        externalOnly: true,
+        requiresExplicitConfirmation: true,
+        ...(targetPath !== undefined ? { targetPath } : {}),
+    };
+}

package/dist/setup/providers/provider-setup-registry.js

@@ -0,0 +1,11 @@
+import { antigravitySetupAdapter } from './antigravity-setup-adapter.js';
+import { claudeSetupAdapter } from './claude-setup-adapter.js';
+import { customSetupAdapter } from './custom-setup-adapter.js';
+import { openCodeSetupAdapter } from './opencode-setup-adapter.js';
+export const builtInProviderSetupAdapters = [openCodeSetupAdapter, claudeSetupAdapter, antigravitySetupAdapter, customSetupAdapter];
+export function listProviderSetupAdapters() {
+    return builtInProviderSetupAdapters;
+}
+export function getProviderSetupAdapter(id) {
+    return builtInProviderSetupAdapters.find((adapter) => adapter.id === id);
+}

package/dist/setup/schema.js

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

package/dist/setup/setup-defaults.js

@@ -0,0 +1,11 @@
+export const vgxnessSetupDefaults = {
+    packageName: 'vgxness',
+    minimumNodeMajor: 22,
+    defaultProvider: 'opencode',
+    primaryProvider: 'opencode',
+    defaultDatabaseMode: 'global',
+    defaultOpenCodeScope: 'project',
+    defaultInstallMode: 'mcp-plus-agents',
+    alphaReleaseTag: 'alpha',
+    publicLanguage: 'en',
+};

package/dist/setup/setup-lifecycle-service.js

@@ -0,0 +1,175 @@
+import { listProviderSetupAdapters } from './providers/provider-setup-registry.js';
+const agentName = 'vgxness-manager';
+export class SetupLifecycleService {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    getStatus(input) {
+        const normalized = { ...input, scope: input.scope ?? 'project' };
+        const storeResult = this.dependencies.store(normalized);
+        const store = storeStatus(storeResult);
+        const project = projectStatus(normalized.project);
+        const environment = environmentStatus(normalized.projectRoot, store);
+        const mcpInput = store.path === '' ? normalized : { ...normalized, databasePath: store.path };
+        const mcp = mcpStatus(this.dependencies.mcp(mcpInput), store.status);
+        const defaults = normalized.project === undefined ? deferredDefaultContextStatus(normalized.scope) : defaultContextStatus(this.dependencies.defaultContext({ ...normalized, agentName }), normalized.scope);
+        const agents = agentsStatus(defaults, normalized.project !== undefined);
+        const providers = providerStatuses(this.dependencies.providers ?? listProviderSetupAdapters(), {
+            workspaceRoot: normalized.projectRoot,
+            ...(normalized.project === undefined ? {} : { project: normalized.project }),
+            ...(store.path === '' ? {} : { databasePath: store.path }),
+        });
+        const verification = verificationSummary(environment, project, providers, agents, mcp);
+        return {
+            ok: true,
+            value: {
+                version: 1,
+                kind: 'setup-status',
+                ...(input.project === undefined ? {} : { project: input.project }),
+                environment,
+                projectState: project,
+                store,
+                mcp,
+                defaults,
+                providers,
+                agents,
+                verification,
+                nextAction: nextAction(store, mcp, defaults, providers, normalized.project),
+                safety: { writesProviderConfig: false, executesProvider: false, localStoreMayBeCreated: true },
+            },
+        };
+    }
+}
+function environmentStatus(workspaceRoot, store) {
+    return {
+        status: store.status,
+        workspaceRoot,
+        store,
+        summary: store.status === 'ready' ? 'Environment checks are ready.' : `Environment is blocked: ${store.blocker ?? 'local store unavailable'}`,
+    };
+}
+function projectStatus(project) {
+    if (project === undefined) {
+        return {
+            status: 'deferred',
+            mode: 'none',
+            summary: 'No project selected; project-scoped setup checks are deferred, not failed.',
+        };
+    }
+    return {
+        status: 'ready',
+        mode: 'selected',
+        project,
+        summary: `Project ${project} is selected for project-scoped setup checks.`,
+    };
+}
+function storeStatus(result) {
+    if (result.ok)
+        return { status: 'ready', path: result.value.path };
+    return {
+        status: 'blocked',
+        path: '',
+        blocker: result.error.message,
+        recovery: 'Run `npm run cli -- doctor` and verify the configured local memory path is writable.',
+    };
+}
+function mcpStatus(result, storeReadiness) {
+    if (!result.ok) {
+        return { status: 'unknown', evidence: [result.error.message], nextAction: 'Review provider-specific MCP setup guidance.', writesProviderConfig: false };
+    }
+    if (storeReadiness !== 'ready') {
+        return { status: 'unknown', evidence: result.value.evidence, nextAction: 'Review provider-specific MCP setup guidance after the local store is ready.', writesProviderConfig: false };
+    }
+    return {
+        status: result.value.ready ? 'ready' : 'blocked',
+        evidence: result.value.evidence,
+        ...(result.value.ready ? {} : { nextAction: 'Review provider-specific MCP setup guidance from the provider status collection.' }),
+        writesProviderConfig: false,
+    };
+}
+function defaultContextStatus(result, scope) {
+    if (!result.ok) {
+        return {
+            status: 'blocked',
+            scope,
+            agentName,
+            blocker: result.error.message,
+            nextAction: 'Seed or inspect project agents before running guided workflows.',
+        };
+    }
+    return {
+        status: 'ready',
+        scope,
+        agentName,
+        agentId: result.value.agentId,
+        providerAdapter: result.value.providerAdapter,
+        model: result.value.model,
+        ...(result.value.profile === undefined ? {} : { profile: result.value.profile }),
+    };
+}
+function deferredDefaultContextStatus(scope) {
+    return {
+        status: 'unknown',
+        scope,
+        agentName,
+        blocker: 'No project selected; default manager/profile checks are deferred.',
+        nextAction: 'Select a project to verify the default manager/profile context.',
+    };
+}
+function agentsStatus(defaults, hasProject) {
+    return {
+        ...defaults,
+        projectScoped: true,
+        deferred: !hasProject,
+    };
+}
+function providerStatuses(adapters, context) {
+    return adapters.map((adapter) => {
+        const status = adapter.getStatus(context);
+        return {
+            ...status,
+            displayName: adapter.displayName,
+            supportLevel: adapter.supportLevel,
+            capabilities: adapter.capabilities,
+            targets: adapter.targets,
+        };
+    });
+}
+function verificationSummary(environment, project, providers, agents, mcp) {
+    const checks = [
+        { id: 'environment', label: 'Environment', status: environment.status, detail: environment.summary },
+        { id: 'project', label: 'Project', status: project.status, detail: project.summary },
+        { id: 'providers', label: 'Providers', status: providers.some((provider) => provider.supportLevel === 'supported-primary') ? 'ready' : 'unknown', detail: `${providers.length} provider targets are available for read-only setup status.` },
+        { id: 'agents', label: 'Agents', status: agents.deferred ? 'deferred' : agents.status, detail: agents.deferred ? agents.nextAction ?? 'Project-scoped agent checks are deferred.' : agents.blocker ?? 'Default manager/profile context checked.' },
+        { id: 'verification', label: 'Provider visibility', status: mcp.status, detail: mcp.nextAction ?? mcp.evidence[0] ?? 'Provider visibility check completed.' },
+    ];
+    const blocking = checks.find((check) => check.status === 'blocked');
+    return {
+        status: blocking === undefined ? 'ready' : 'blocked',
+        summary: blocking === undefined ? 'Setup checks are ready or safely deferred.' : `${blocking.label} is blocked: ${blocking.detail}`,
+        checks,
+    };
+}
+function nextAction(store, mcp, defaults, providers, project) {
+    if (store.status !== 'ready') {
+        return { command: 'npm run cli -- doctor', reason: `Local store is blocked: ${store.blocker ?? 'local store is unavailable'}` };
+    }
+    if (defaults.status !== 'ready') {
+        if (defaults.blocker?.startsWith('No project selected') === true) {
+            return { command: 'npm run cli -- dashboard interactive --project <project>', reason: defaults.nextAction ?? 'Select a project to verify project-scoped setup checks.' };
+        }
+        return { command: 'npm run cli -- agents seed --scope project', reason: `Default context is blocked: ${defaults.blocker ?? 'default context is unavailable'}` };
+    }
+    if (mcp.status !== 'ready') {
+        const providerSummary = providers.length === 0 ? 'provider registry returned no setup targets' : `${providers.length} provider setup targets are available for provider-specific guidance`;
+        return {
+            command: setupStatusCommand(project),
+            reason: `Provider MCP status is not ready; review the Providers section for provider-specific preview/install guidance (${providerSummary}).`,
+        };
+    }
+    return { command: 'npm run cli -- runs list', reason: 'Project setup is ready; continue with normal vgxness usage.' };
+}
+function setupStatusCommand(project) {
+    return project === undefined ? 'npm run cli -- setup status' : `npm run cli -- setup status --project ${project}`;
+}

package/dist/setup/setup-plan.js

@@ -0,0 +1,105 @@
+import { join, resolve } from 'node:path';
+import { resolveMemoryDatabasePath } from '../memory/storage-paths.js';
+import { planOpenCodeMcpInstall } from '../mcp/client-install-opencode-contract.js';
+import { vgxnessSetupDefaults } from './setup-defaults.js';
+export function createSetupPlan(input) {
+    const mode = input.databaseMode ?? vgxnessSetupDefaults.defaultDatabaseMode;
+    const database = resolveSetupDatabase({ workspaceRoot: input.workspaceRoot, env: input.env, mode, ...(input.databasePath === undefined ? {} : { databasePath: input.databasePath }) });
+    if (!database.ok)
+        return database;
+    const project = input.project?.trim() || basenameFallback(input.workspaceRoot);
+    const provider = input.provider ?? vgxnessSetupDefaults.defaultProvider;
+    const installMode = input.installMode ?? vgxnessSetupDefaults.defaultInstallMode;
+    const scope = input.scope ?? vgxnessSetupDefaults.defaultOpenCodeScope;
+    const common = {
+        version: 1,
+        kind: 'setup-plan',
+        project,
+        workspaceRoot: input.workspaceRoot,
+        db: database.value,
+        provider,
+        safety: { mutating: false, writesProviderConfig: false, requiresConfirmationForApply: true },
+    };
+    if (provider === 'none') {
+        return {
+            ok: true,
+            value: {
+                ...common,
+                status: 'ready',
+                actions: [{ id: 'manual-provider', description: 'No provider config will be written; use manual MCP configuration if needed.', mutating: false, backupRequired: false }],
+                conflicts: [],
+                backupsPlanned: [],
+                nextCommands: ['vgxness mcp start', 'vgxness setup status'],
+            },
+        };
+    }
+    if (provider !== 'opencode')
+        return { ok: false, error: { code: 'validation_failed', message: 'Provider must be opencode or none for the alpha setup plan.' } };
+    const opencode = planOpenCodeMcpInstall({
+        cwd: input.workspaceRoot,
+        databasePath: database.value.path,
+        databasePathSource: database.value.planSource,
+        scope,
+        env: input.env,
+        mcpOnly: installMode === 'mcp-only',
+    });
+    return { ok: true, value: setupPlanFromOpenCode({ ...common, provider: 'opencode', installMode, scope, opencode }) };
+}
+function setupPlanFromOpenCode(input) {
+    const db = { mode: input.db.mode, path: input.db.path, source: input.db.source };
+    if (input.opencode.status === 'refused') {
+        return {
+            ...input,
+            db,
+            status: input.opencode.reason === 'unsupported_jsonc' ? 'manual-required' : 'conflict',
+            opencode: { scope: input.scope, action: 'none', ...(input.opencode.targetPath === undefined ? {} : { targetPath: input.opencode.targetPath }), installsAgents: input.opencode.installsAgents, agentNames: input.opencode.agentNames },
+            actions: [],
+            conflicts: [{ id: input.opencode.reason, severity: 'blocking', message: input.opencode.message, ...(input.opencode.targetPath === undefined ? {} : { targetPath: input.opencode.targetPath }), recovery: 'Inspect the OpenCode config, resolve the conflict, then rerun `vgx setup plan`.' }],
+            backupsPlanned: [],
+            nextCommands: ['vgx setup plan', 'vgxness mcp doctor opencode'],
+        };
+    }
+    return {
+        ...input,
+        db,
+        status: 'ready',
+        opencode: {
+            scope: input.scope,
+            action: input.opencode.action,
+            targetPath: input.opencode.targetPath,
+            mcpServer: input.opencode.server,
+            installsAgents: input.opencode.installsAgents,
+            agentNames: input.opencode.agentNames,
+        },
+        actions: [
+            {
+                id: `opencode-${input.opencode.action}`,
+                description: `${input.opencode.action === 'create' ? 'Create' : 'Merge'} OpenCode config with mcp.vgxness using vgxness mcp start${input.installMode === 'mcp-plus-agents' ? ' and manager/SDD agents' : ''}.`,
+                mutating: false,
+                targetPath: input.opencode.targetPath,
+                backupRequired: input.opencode.backupRequired,
+            },
+        ],
+        conflicts: [],
+        backupsPlanned: input.opencode.backupRequired ? [{ targetPath: input.opencode.targetPath, reason: 'Existing OpenCode config would be backed up before merge.' }] : [],
+        nextCommands: ['vgx setup apply --yes', 'vgx doctor', 'Restart OpenCode and verify the vgxness MCP server is visible.'],
+    };
+}
+function resolveSetupDatabase(input) {
+    if (input.mode === 'global') {
+        const resolved = resolveMemoryDatabasePath({ cwd: input.workspaceRoot, env: input.env });
+        return resolved.ok ? { ok: true, value: { mode: 'global', path: resolved.value.path, source: resolved.value.source, planSource: resolved.value.source } } : resolved;
+    }
+    if (input.mode === 'project-local') {
+        const path = join(input.workspaceRoot, '.vgx', 'memory.sqlite');
+        return { ok: true, value: { mode: 'project-local', path, source: 'project-local', planSource: 'flag' } };
+    }
+    if (input.databasePath === undefined || input.databasePath.trim().length === 0)
+        return { ok: false, error: { code: 'validation_failed', message: '--db custom requires --db-path <path>.' } };
+    return { ok: true, value: { mode: 'custom', path: resolve(input.workspaceRoot, input.databasePath), source: 'custom', planSource: 'flag' } };
+}
+function basenameFallback(path) {
+    const normalized = path.replace(/[\\/]+$/, '');
+    const name = normalized.split(/[\\/]/).pop();
+    return name === undefined || name.length === 0 ? 'vgxness' : name;
+}