vgxness 1.20.4 → 1.20.6

package/dist/interfaces/cli/commands/index.js

@@ -0,0 +1,9 @@
+export { runAgentCommand, runSkillCommand, runSubagentCommand } from './agent-skill-dispatcher.js';
+export { runDefaultInteractiveEntrypoint } from './interactive-entrypoint-dispatcher.js';
+export { runDoctorAliasCommand, runMcpDoctorCommand, runMcpDoctorOpenCodeCommand, runMcpInstallCommand, runMcpSetupCommand } from './mcp-dispatcher.js';
+export { runMemoryCommand, runMemoryImportCommand, runOpenCodeCommand, runOrchestratorCommand, runSddCommand } from './memory-sdd-dispatcher.js';
+export { runApprovalsCommand, runPermissionsCommand, runRunsCommand } from './run-permission-dispatcher.js';
+export { applySetupPlanInput, collectRunDetails, collectRunInsights, createSetupLifecycleService, promptSetupWizard, readSetupStatus, runHomeTuiCommand, runInitCommand, runSetupApplyCommand, runSetupBackupCommand, runSetupLifecycleCommand, runSetupPlanCommand, runSetupReinstallApplyCommand, runSetupReinstallCommand, runSetupRollbackCommand, setupMcpEvidence, setupPlanInputFromFlags, } from './setup-dispatcher.js';
+export { runProductNextCommand, runProductResumeCommand, runProductStatusCommand } from './status-dispatcher.js';
+export { runVerificationPlanCommand, runVerificationReportCommand } from './verification-dispatcher.js';
+export { runWorkflowExecuteCommand, runWorkflowPreviewCommand, runWorkflowRunCommand } from './workflow-dispatcher.js';

package/dist/interfaces/cli/commands/interactive-entrypoint-dispatcher.js

@@ -0,0 +1,14 @@
+import { okText } from '../cli-help.js';
+function defaultNoArgsGuidance() {
+    return ([
+        'VGXNESS no-args entrypoint is safe and deterministic; no local DB was opened and no provider config was written.',
+        'In a real terminal, `vgxness` opens the read-only Home TUI. In non-TTY contexts, use explicit CLI commands.',
+        'Next: use `vgxness setup plan`, `vgxness init --plan`, `vgxness status`, `vgxness next`, or `vgxness --help`.',
+    ].join('\n') + '\n');
+}
+export async function runDefaultInteractiveEntrypoint(environment) {
+    void environment;
+    return okText(defaultNoArgsGuidance());
+}
+// Re-export helper for focused CLI tests.
+export { defaultNoArgsGuidance };

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

@@ -0,0 +1,252 @@
+import { resolveClaudeCodeScope } from '../../../adapters/claude/install/claude-code-scope.js';
+import { installClaudeCodeMcpClient } from '../../../adapters/claude/install/client-install-claude-code.js';
+import { planClaudeCodeMcpInstall } from '../../../adapters/claude/install/client-install-claude-code-contract.js';
+import { installOpenCodeMcpClient } from '../../../adapters/opencode/install/client-install-opencode.js';
+import { planOpenCodeMcpInstall } from '../../../adapters/opencode/install/client-install-opencode-contract.js';
+import { createOpenCodeMcpVisibilityReport } from '../../../adapters/opencode/install/opencode-visibility.js';
+import { computeEffectiveManagerInstructions } from '../../../agents/manager-profile-overlay-service.js';
+import { createMcpClientSetupPreview, isMcpClientSetupProvider } from '../../../mcp/client-setup-preview.js';
+import { createMcpDoctorReport } from '../../../mcp/doctor.js';
+import { RunService } from '../../../runs/run-service.js';
+import { isTerminalRunStatus } from '../../../runs/schema.js';
+import { databasePathFor, databasePathSelectionFor, opencodeDiagnosticScopeFlag, opencodeInstallScopeFlag, optionalNumberFlag, optionalStringFlag, providerUserGlobalOnlyMigrationMessage, } from '../cli-flags.js';
+import { usageFailure, validationFailure } from '../cli-help.js';
+import { jsonResult, openCliDatabase, resultFailure } from '../cli-helpers.js';
+import { renderDoctorReport } from '../doctor-renderer.js';
+export function runMcpInstallCommand(parsed, environment) {
+    return (async () => {
+        const client = parsed.positionals[2];
+        if (client !== 'opencode' && client !== 'claude')
+            return usageFailure('mcp install requires client opencode or claude');
+        const databasePath = databasePathSelectionFor(parsed.flags, environment);
+        if (!databasePath.ok)
+            return resultFailure(databasePath);
+        const scope = opencodeInstallScopeFlag(parsed.flags, 'scope');
+        if (!scope.ok)
+            return resultFailure(scope);
+        const mcpOnly = parsed.flags['mcp-only'] === true || parsed.flags['no-agents'] === true;
+        const overwriteVgxness = parsed.flags['overwrite-vgxness'] === true || parsed.flags.reinstall === true;
+        if (client === 'claude') {
+            const claudeScope = claudeInstallScopeFlag(parsed.flags);
+            if (!claudeScope.ok)
+                return resultFailure(claudeScope);
+            if (parsed.flags.plan === true) {
+                return jsonResult({
+                    ok: true,
+                    value: planClaudeCodeMcpInstall({
+                        cwd: environment.cwd,
+                        databasePath: databasePath.value.path,
+                        databasePathSource: databasePath.value.source,
+                        overwriteVgxness,
+                        scope: claudeScope.value,
+                    }),
+                });
+            }
+            if (parsed.flags.yes !== true) {
+                return resultFailure({
+                    ok: false,
+                    error: { code: 'validation_failed', message: 'confirmation_required: `mcp install claude` requires explicit --yes before any project config write.' },
+                });
+            }
+            if (optionalStringFlag(parsed.flags, 'run-id') === undefined) {
+                return resultFailure({
+                    ok: false,
+                    error: {
+                        code: 'validation_failed',
+                        message: 'preflight_failed: Claude Code provider config writes require VGXNESS preflight; pass --run-id for an existing VGXNESS run before using --yes.',
+                    },
+                });
+            }
+            const opened = openCliDatabase(databasePath.value.path);
+            if (!opened.ok)
+                return resultFailure(opened);
+            try {
+                const preflight = createClaudeCodeInstallPreflight(parsed, opened.value, environment);
+                const effectiveManagerInstructions = computeEffectiveManagerInstructions(opened.value);
+                const result = await installClaudeCodeMcpClient({
+                    cwd: environment.cwd,
+                    databasePath: databasePath.value.path,
+                    databasePathSource: databasePath.value.source,
+                    confirmed: true,
+                    overwriteVgxness,
+                    scope: claudeScope.value,
+                    preflight,
+                    ...(effectiveManagerInstructions === undefined ? {} : { effectiveManagerInstructions }),
+                });
+                return result.status === 'installed'
+                    ? jsonResult({ ok: true, value: result })
+                    : resultFailure({ ok: false, error: { code: 'validation_failed', message: `${result.reason}: ${result.message}` } });
+            }
+            finally {
+                opened.value.close();
+            }
+        }
+        if (parsed.flags.plan === true) {
+            return jsonResult({
+                ok: true,
+                value: planOpenCodeMcpInstall({
+                    cwd: environment.cwd,
+                    databasePath: databasePath.value.path,
+                    databasePathSource: databasePath.value.source,
+                    scope: scope.value,
+                    env: environment.env,
+                    mcpOnly,
+                    overwriteVgxness,
+                }),
+            });
+        }
+        if (parsed.flags.yes !== true) {
+            const result = await installOpenCodeMcpClient({
+                cwd: environment.cwd,
+                databasePath: databasePath.value.path,
+                databasePathSource: databasePath.value.source,
+                scope: scope.value,
+                env: environment.env,
+                confirmed: false,
+                mcpOnly,
+                overwriteVgxness,
+            });
+            return result.status === 'installed'
+                ? jsonResult({ ok: true, value: result })
+                : resultFailure({
+                    ok: false,
+                    error: {
+                        code: 'validation_failed',
+                        message: `${result.reason}: ${result.message} Manual doctor command: ${result.manualTest.doctorCommand.join(' ')}`,
+                    },
+                });
+        }
+        const opened = openCliDatabase(databasePath.value.path);
+        if (!opened.ok)
+            return resultFailure(opened);
+        try {
+            const effectiveManagerInstructions = computeEffectiveManagerInstructions(opened.value);
+            const result = await installOpenCodeMcpClient({
+                cwd: environment.cwd,
+                databasePath: databasePath.value.path,
+                databasePathSource: databasePath.value.source,
+                scope: scope.value,
+                env: environment.env,
+                confirmed: true,
+                mcpOnly,
+                overwriteVgxness,
+                ...(effectiveManagerInstructions === undefined ? {} : { effectiveManagerInstructions }),
+            });
+            return result.status === 'installed'
+                ? jsonResult({ ok: true, value: result })
+                : resultFailure({
+                    ok: false,
+                    error: {
+                        code: 'validation_failed',
+                        message: `${result.reason}: ${result.message} Manual doctor command: ${result.manualTest.doctorCommand.join(' ')}`,
+                    },
+                });
+        }
+        finally {
+            opened.value.close();
+        }
+    })();
+}
+function claudeInstallScopeFlag(flags) {
+    const value = optionalStringFlag(flags, 'scope');
+    const resolved = resolveClaudeCodeScope(value, 'user');
+    if (!resolved.ok)
+        return validationFailure(resolved.error.message);
+    if (resolved.value.canonical === 'project' || resolved.value.canonical === 'local')
+        return validationFailure(providerUserGlobalOnlyMigrationMessage);
+    return { ok: true, value: resolved.value.canonical };
+}
+function createClaudeCodeInstallPreflight(parsed, database, environment) {
+    return (request) => {
+        const runId = optionalStringFlag(parsed.flags, 'run-id');
+        if (runId === undefined) {
+            return validationFailure('Claude Code provider config writes require VGXNESS preflight; pass --run-id for an existing VGXNESS run before using --yes.');
+        }
+        const service = new RunService(database);
+        const details = service.getRun(runId);
+        if (!details.ok)
+            return details;
+        if (isTerminalRunStatus(details.value.status)) {
+            return validationFailure(`VGXNESS run ${runId} is in terminal state '${details.value.status}'; Claude Code provider config writes require a live run (created/planned/running/needs-human). Start a new run with \`vgxness run start\` and pass its --run-id.`);
+        }
+        const phase = optionalStringFlag(parsed.flags, 'phase') ?? details.value.phase;
+        const agentId = optionalStringFlag(parsed.flags, 'agent-id') ?? details.value.selectedAgentId;
+        const preflight = service.preflightOperation({
+            runId,
+            category: request.category,
+            operation: request.operation,
+            workspaceRoot: environment.cwd,
+            targetPath: request.targetPath,
+            providerToolName: request.providerToolName,
+            phase,
+            agentId,
+        });
+        if (!preflight.ok)
+            return preflight;
+        if (preflight.value.outcome !== 'allowed') {
+            return validationFailure(`VGXNESS preflight ${preflight.value.outcome} for Claude Code provider config write: ${request.targetPath}`);
+        }
+        return { ok: true, value: preflight.value };
+    };
+}
+export function runMcpSetupCommand(parsed, environment) {
+    if (parsed.flags.preview !== true)
+        return usageFailure('mcp setup requires --preview; provider config installation is not supported');
+    const provider = optionalStringFlag(parsed.flags, 'provider') ?? 'opencode';
+    if (!isMcpClientSetupProvider(provider))
+        return resultFailure(validationFailure('--provider must be opencode or claude'));
+    const databasePath = databasePathSelectionFor(parsed.flags, environment);
+    if (!databasePath.ok)
+        return resultFailure(databasePath);
+    return jsonResult({
+        ok: true,
+        value: createMcpClientSetupPreview({ provider, databasePath: databasePath.value.path, databasePathSource: databasePath.value.source }),
+    });
+}
+export function runMcpDoctorCommand(parsed, environment, output = 'json') {
+    return (async () => {
+        if (parsed.positionals[2] === 'opencode')
+            return runMcpDoctorOpenCodeCommand(parsed, environment);
+        const timeoutMs = optionalNumberFlag(parsed.flags, 'timeout-ms');
+        if (!timeoutMs.ok)
+            return resultFailure(timeoutMs);
+        const databasePath = databasePathFor(parsed.flags, environment);
+        if (!databasePath.ok)
+            return resultFailure(databasePath);
+        const report = await createMcpDoctorReport({
+            cwd: environment.cwd,
+            databasePath: databasePath.value,
+            project: optionalStringFlag(parsed.flags, 'project') ?? 'vgxness',
+            change: optionalStringFlag(parsed.flags, 'change') ?? 'doctor-smoke',
+            timeoutMs: timeoutMs.value ?? 5_000,
+            env: environment.env,
+        });
+        if (output === 'json')
+            return { exitCode: report.ready ? 0 : 1, stdout: `${JSON.stringify(report, null, 2)}\n`, stderr: '' };
+        return {
+            exitCode: report.ready ? 0 : 1,
+            stdout: renderDoctorReport({
+                report,
+                project: optionalStringFlag(parsed.flags, 'project') ?? 'vgxness',
+                change: optionalStringFlag(parsed.flags, 'change') ?? 'doctor-smoke',
+            }),
+            stderr: '',
+        };
+    })();
+}
+export function runMcpDoctorOpenCodeCommand(parsed, environment) {
+    const scope = opencodeDiagnosticScopeFlag(parsed.flags, 'scope');
+    if (!scope.ok)
+        return resultFailure(scope);
+    const projectRoot = optionalStringFlag(parsed.flags, 'project-root');
+    const report = createOpenCodeMcpVisibilityReport({
+        cwd: environment.cwd,
+        env: environment.env,
+        scope: scope.value,
+        ...(projectRoot !== undefined ? { projectRoot } : {}),
+    });
+    return { exitCode: report.ready ? 0 : 1, stdout: `${JSON.stringify(report, null, 2)}\n`, stderr: '' };
+}
+export function runDoctorAliasCommand(parsed, environment) {
+    return runMcpDoctorCommand({ ...parsed, positionals: ['mcp', 'doctor', ...parsed.positionals.slice(1)] }, environment, parsed.flags.json === true ? 'json' : 'human');
+}

package/dist/interfaces/cli/commands/memory-sdd-dispatcher.js

@@ -0,0 +1,367 @@
+import { AgentRegistryService } from '../../../agents/agent-registry-service.js';
+import { ManagerProfileOverlayService } from '../../../agents/manager-profile-overlay-service.js';
+import { ManagerProfileOverlayRepository } from '../../../agents/repositories/manager-profile-overlays.js';
+import { createMemoryToolHandlers } from '../../../harness/tools/memory.js';
+import { planMemoryImportDryRun, validateMemoryImportPackage, writeMemoryImportObservations } from '../../../memory/import/index.js';
+import { MemoryService } from '../../../memory/memory-service.js';
+import { createNaturalLanguagePlan } from '../../../orchestrator/natural-language-planner.js';
+import { OpenCodeInjectionPreviewService } from '../../../providers/opencode/injection-preview.js';
+import { RunService } from '../../../runs/run-service.js';
+import { ArtifactPortabilityService } from '../../../sdd/artifact-portability-service.js';
+import { buildSddCockpitSurfaceResponse } from '../../../sdd/cockpit-read-model.js';
+import { normalizeSddArtifact, normalizeSddPhaseInput, sddPhases } from '../../../sdd/schema.js';
+import { SddWorkflowService } from '../../../sdd/sdd-workflow-service.js';
+import { SkillRegistryService } from '../../../skills/skill-registry-service.js';
+import { acceptedAtFlag, databasePathSelectionFor, optionalNumberFlag, optionalScopeFlag, optionalStringFlag, optionalTrimmedFlag, requiredFlag, requiredTrimmedFlag, scopeFlag, } from '../cli-flags.js';
+import { okText, usageFailure, validationFailure } from '../cli-help.js';
+import { formatMemoryImportValidationErrors, jsonResult, openCliDatabase, readJsonFile, resultFailure, validateMemoryImportMode, writeJsonFile, } from '../cli-helpers.js';
+import { renderSddArtifactAccepted, renderSddArtifactDetail, renderSddArtifactList, renderSddArtifactReopened, renderSddCockpit, renderSddContinuationPlan, renderSddNext, renderSddStatus, sddContinuationPlanFrom, } from '../sdd-renderer.js';
+export function runMemoryCommand(command, parsed, database) {
+    const handlers = createMemoryToolHandlers({ service: new MemoryService(database), config: { localMemoryEnabled: true } });
+    const context = { actor: 'cli' };
+    if (command === 'save') {
+        const project = requiredFlag(parsed.flags, 'project');
+        const scope = scopeFlag(parsed.flags, 'scope', 'project');
+        const type = requiredFlag(parsed.flags, 'type');
+        const title = requiredFlag(parsed.flags, 'title');
+        const content = requiredFlag(parsed.flags, 'content');
+        if (!project.ok)
+            return resultFailure(project);
+        if (!scope.ok)
+            return resultFailure(scope);
+        if (!type.ok)
+            return resultFailure(type);
+        if (!title.ok)
+            return resultFailure(title);
+        if (!content.ok)
+            return resultFailure(content);
+        const topicKey = optionalStringFlag(parsed.flags, 'topic-key');
+        return jsonResult(handlers.saveObservation({
+            project: project.value,
+            scope: scope.value,
+            type: type.value,
+            title: title.value,
+            content: content.value,
+            ...(topicKey !== undefined ? { topicKey } : {}),
+        }, context));
+    }
+    if (command === 'search') {
+        const scope = optionalScopeFlag(parsed.flags, 'scope');
+        if (!scope.ok)
+            return resultFailure(scope);
+        const limit = optionalNumberFlag(parsed.flags, 'limit');
+        if (!limit.ok)
+            return resultFailure(limit);
+        const filters = {};
+        const query = optionalStringFlag(parsed.flags, 'query');
+        if (query !== undefined)
+            filters.query = query;
+        const project = optionalStringFlag(parsed.flags, 'project');
+        if (project !== undefined)
+            filters.project = project;
+        if (scope.value !== undefined)
+            filters.scope = scope.value;
+        const type = optionalStringFlag(parsed.flags, 'type');
+        if (type !== undefined)
+            filters.type = type;
+        if (limit.value !== undefined)
+            filters.limit = limit.value;
+        return jsonResult(handlers.searchObservations(filters, context));
+    }
+    return usageFailure(`Unknown memory command: ${command}`);
+}
+export function runMemoryImportCommand(parsed, environment) {
+    const mode = validateMemoryImportMode(parsed.flags);
+    if (!mode.ok)
+        return resultFailure(mode);
+    const file = requiredFlag(parsed.flags, 'file');
+    if (!file.ok)
+        return resultFailure(file);
+    const importPackage = readJsonFile(file.value, environment);
+    if (!importPackage.ok)
+        return resultFailure(importPackage);
+    const databasePath = databasePathSelectionFor(parsed.flags, environment);
+    if (!databasePath.ok)
+        return resultFailure(databasePath);
+    if (mode.value === 'dry-run')
+        return jsonResult(planMemoryImportDryRun({ packageJson: importPackage.value, targetDatabase: databasePath.value }));
+    const packageValidation = validateMemoryImportPackage(importPackage.value);
+    if (!packageValidation.ok)
+        return resultFailure(validationFailure(`Invalid memory import package: ${formatMemoryImportValidationErrors(packageValidation.errors)}`));
+    const opened = openCliDatabase(databasePath.value.path);
+    if (!opened.ok)
+        return resultFailure(opened);
+    try {
+        return jsonResult(writeMemoryImportObservations({
+            packageJson: importPackage.value,
+            targetDatabase: databasePath.value,
+            service: new MemoryService(opened.value),
+            duplicatePolicy: mode.value,
+        }));
+    }
+    finally {
+        opened.value.close();
+    }
+}
+export function runSddCommand(command, parsed, database, environment) {
+    const memory = new MemoryService(database);
+    const service = new SddWorkflowService(memory);
+    const project = requiredFlag(parsed.flags, 'project');
+    const change = requiredFlag(parsed.flags, 'change');
+    if (!project.ok)
+        return resultFailure(project);
+    if (!change.ok)
+        return resultFailure(change);
+    if (command === 'status') {
+        const status = service.getStatus({ project: project.value, change: change.value });
+        if (!status.ok || parsed.flags.json === true)
+            return jsonResult(status);
+        return okText(renderSddStatus({ project: project.value, status: status.value }));
+    }
+    if (command === 'next') {
+        const next = service.getNext({ project: project.value, change: change.value });
+        if (!next.ok || parsed.flags.json === true)
+            return jsonResult(next);
+        return okText(renderSddNext({ project: project.value, decision: next.value }));
+    }
+    if (command === 'continue') {
+        const next = service.getNext({ project: project.value, change: change.value });
+        if (!next.ok)
+            return jsonResult(next);
+        const cockpit = service.getCockpit({ project: project.value, change: change.value });
+        if (!cockpit.ok)
+            return jsonResult(cockpit);
+        const explicitDatabasePath = optionalStringFlag(parsed.flags, 'db');
+        const relatedRun = new RunService(database).findRelatedInterruptedSddRun({ project: project.value, change: change.value });
+        if (!relatedRun.ok)
+            return jsonResult(relatedRun);
+        const plan = sddContinuationPlanFrom({
+            project: project.value,
+            next: next.value,
+            cockpit: cockpit.value,
+            ...(relatedRun.value === undefined ? {} : { relatedRunContext: relatedRun.value }),
+            ...(explicitDatabasePath === undefined ? {} : { explicitDatabasePath }),
+        });
+        return parsed.flags.json === true ? jsonResult({ ok: true, value: plan }) : okText(renderSddContinuationPlan(plan));
+    }
+    if (command === 'cockpit') {
+        const cockpit = service.getCockpit({ project: project.value, change: change.value });
+        if (!cockpit.ok)
+            return jsonResult(cockpit);
+        const surface = buildSddCockpitSurfaceResponse(cockpit.value);
+        if (parsed.flags.json === true)
+            return jsonResult({ ok: true, value: surface });
+        return okText(renderSddCockpit(surface));
+    }
+    if (command === 'ready') {
+        const phase = requiredFlag(parsed.flags, 'phase');
+        if (!phase.ok)
+            return resultFailure(phase);
+        return jsonResult(service.getReady({ project: project.value, change: change.value, phase: phase.value }));
+    }
+    if (command === 'save-artifact') {
+        const phase = requiredFlag(parsed.flags, 'phase');
+        const content = requiredFlag(parsed.flags, 'content');
+        if (!phase.ok)
+            return resultFailure(phase);
+        if (!content.ok)
+            return resultFailure(content);
+        return jsonResult(service.saveArtifact({ project: project.value, change: change.value, phase: phase.value, content: content.value }));
+    }
+    if (command === 'accept-artifact') {
+        const phase = requiredTrimmedFlag(parsed.flags, 'phase');
+        const actor = requiredTrimmedFlag(parsed.flags, 'actor');
+        const displayName = optionalTrimmedFlag(parsed.flags, 'display-name');
+        const note = optionalTrimmedFlag(parsed.flags, 'note');
+        const acceptedAt = acceptedAtFlag(parsed.flags);
+        if (!phase.ok)
+            return resultFailure(phase);
+        if (!actor.ok)
+            return resultFailure(actor);
+        if (!displayName.ok)
+            return resultFailure(displayName);
+        if (!note.ok)
+            return resultFailure(note);
+        if (!acceptedAt.ok)
+            return resultFailure(acceptedAt);
+        const canonicalPhase = normalizeSddPhaseInput(phase.value);
+        if (canonicalPhase === undefined)
+            return resultFailure(validationFailure(`Unknown SDD phase: ${phase.value}. Expected one of: ${sddPhases.join(', ')}`));
+        const acceptedBy = {
+            type: 'human',
+            id: actor.value,
+            displayName: displayName.value ?? actor.value,
+        };
+        const accepted = service.acceptArtifact({
+            project: project.value,
+            change: change.value,
+            phase: canonicalPhase,
+            acceptedBy,
+            acceptedAt: acceptedAt.value,
+            ...(note.value === undefined ? {} : { note: note.value }),
+        });
+        if (!accepted.ok)
+            return resultFailure(accepted);
+        const view = {
+            project: accepted.value.project,
+            change: change.value,
+            phase: canonicalPhase,
+            topicKey: accepted.value.topicKey,
+            artifactId: accepted.value.id,
+            status: 'accepted',
+            acceptedBy,
+            acceptedAt: acceptedAt.value,
+            ...(note.value === undefined ? {} : { note: note.value }),
+        };
+        return parsed.flags.json === true ? jsonResult({ ok: true, value: view }) : okText(renderSddArtifactAccepted(view));
+    }
+    if (command === 'reopen-artifact') {
+        const phase = requiredTrimmedFlag(parsed.flags, 'phase');
+        const actor = requiredTrimmedFlag(parsed.flags, 'actor');
+        const displayName = optionalTrimmedFlag(parsed.flags, 'display-name');
+        const note = optionalTrimmedFlag(parsed.flags, 'note');
+        if (!phase.ok)
+            return resultFailure(phase);
+        if (!actor.ok)
+            return resultFailure(actor);
+        if (!displayName.ok)
+            return resultFailure(displayName);
+        if (!note.ok)
+            return resultFailure(note);
+        const canonicalPhase = normalizeSddPhaseInput(phase.value);
+        if (canonicalPhase === undefined)
+            return resultFailure(validationFailure(`Unknown SDD phase: ${phase.value}. Expected one of: ${sddPhases.join(', ')}`));
+        const reopenedBy = {
+            type: 'human',
+            id: actor.value,
+            displayName: displayName.value ?? actor.value,
+        };
+        const reopened = service.reopenArtifact({
+            project: project.value,
+            change: change.value,
+            phase: canonicalPhase,
+            reopenedBy,
+            ...(note.value === undefined ? {} : { note: note.value }),
+        });
+        if (!reopened.ok)
+            return resultFailure(reopened);
+        const normalized = normalizeSddArtifact(reopened.value);
+        const view = {
+            project: reopened.value.project,
+            change: change.value,
+            phase: canonicalPhase,
+            topicKey: reopened.value.topicKey,
+            artifactId: reopened.value.id,
+            status: normalized.metadata.status,
+            reopenedBy,
+            reopenedAt: normalized.metadata.reopen?.reopenedAt ?? normalized.metadata.updatedAt ?? reopened.value.updatedAt,
+            ...(note.value === undefined ? {} : { note: note.value }),
+        };
+        return parsed.flags.json === true ? jsonResult({ ok: true, value: view }) : okText(renderSddArtifactReopened(view));
+    }
+    if (command === 'get-artifact') {
+        const phase = requiredFlag(parsed.flags, 'phase');
+        if (!phase.ok)
+            return resultFailure(phase);
+        const result = service.getArtifact({ project: project.value, change: change.value, phase: phase.value });
+        if (!result.ok || parsed.flags.json === true)
+            return jsonResult(result);
+        return okText(renderSddArtifactDetail({ project: project.value, change: change.value, phase: phase.value, artifact: result.value }));
+    }
+    if (command === 'list-artifacts') {
+        if (parsed.flags.json === true)
+            return jsonResult(service.listArtifacts({ project: project.value, change: change.value }));
+        const result = service.listArtifacts({ project: project.value, change: change.value, payloadMode: 'compact' });
+        if (!result.ok)
+            return jsonResult(result);
+        return okText(renderSddArtifactList({ project: project.value, change: change.value, artifacts: result.value.artifacts }));
+    }
+    if (command === 'export') {
+        const portability = new ArtifactPortabilityService(memory, service);
+        const exported = portability.exportPackage({ project: project.value, change: change.value });
+        if (!exported.ok)
+            return resultFailure(exported);
+        const file = optionalStringFlag(parsed.flags, 'file');
+        if (file !== undefined) {
+            const written = writeJsonFile(file, exported.value, environment);
+            if (!written.ok)
+                return resultFailure(written);
+        }
+        return jsonResult(exported);
+    }
+    if (command === 'import') {
+        const file = requiredFlag(parsed.flags, 'file');
+        if (!file.ok)
+            return resultFailure(file);
+        const artifactPackage = readJsonFile(file.value, environment);
+        if (!artifactPackage.ok)
+            return resultFailure(artifactPackage);
+        const portability = new ArtifactPortabilityService(memory, service);
+        const input = { project: project.value, change: change.value, package: artifactPackage.value, overwrite: parsed.flags.overwrite === true };
+        return jsonResult(parsed.flags.write === true ? portability.importPackage(input) : portability.planImport(input));
+    }
+    return usageFailure(`Unknown sdd command: ${command}`);
+}
+export function runOrchestratorCommand(command, parsed, database) {
+    if (command !== 'preview')
+        return usageFailure(`Unknown orchestrator command: ${command}`);
+    const project = requiredFlag(parsed.flags, 'project');
+    const intent = requiredFlag(parsed.flags, 'intent');
+    if (!project.ok)
+        return resultFailure(project);
+    if (!intent.ok)
+        return resultFailure(intent);
+    const change = optionalStringFlag(parsed.flags, 'change');
+    const sdd = new SddWorkflowService(new MemoryService(database));
+    const sddContext = {};
+    if (change !== undefined) {
+        const status = sdd.getStatus({ project: project.value, change });
+        if (!status.ok)
+            return resultFailure(status);
+        const next = sdd.getNext({ project: project.value, change });
+        if (!next.ok)
+            return resultFailure(next);
+        sddContext.status = status.value;
+        sddContext.next = next.value;
+    }
+    return jsonResult({
+        ok: true,
+        value: createNaturalLanguagePlan({
+            project: project.value,
+            intent: intent.value,
+            ...(change !== undefined ? { change } : {}),
+            ...(change !== undefined ? { sdd: sddContext } : {}),
+        }),
+    });
+}
+export function runOpenCodeCommand(command, parsed, database, environment) {
+    if (command !== 'preview')
+        return usageFailure(`Unknown opencode command: ${command}`);
+    const scope = optionalScopeFlag(parsed.flags, 'scope');
+    if (!scope.ok)
+        return resultFailure(scope);
+    const agents = new AgentRegistryService(database);
+    const managerProfiles = new ManagerProfileOverlayService({ agents, overlays: new ManagerProfileOverlayRepository(database) });
+    const service = new OpenCodeInjectionPreviewService({
+        agents,
+        managerProfiles,
+        skills: new SkillRegistryService(database),
+        sdd: new SddWorkflowService(new MemoryService(database)),
+    });
+    const provider = optionalStringFlag(parsed.flags, 'provider');
+    const project = optionalStringFlag(parsed.flags, 'project');
+    const change = optionalStringFlag(parsed.flags, 'change');
+    const phase = optionalStringFlag(parsed.flags, 'phase');
+    const agentId = optionalStringFlag(parsed.flags, 'agent-id');
+    const agentName = optionalStringFlag(parsed.flags, 'agent');
+    return jsonResult(service.preview({
+        ...(provider !== undefined ? { provider } : {}),
+        ...(project !== undefined ? { project } : {}),
+        ...(change !== undefined ? { change } : {}),
+        ...(phase !== undefined ? { phase } : {}),
+        ...(agentId !== undefined ? { agentId } : {}),
+        ...(agentName !== undefined ? { agentName } : {}),
+        ...(scope.value !== undefined ? { scope: scope.value } : {}),
+        workspaceRoot: environment.cwd,
+    }));
+}