@devtrack-solution/codesdd 1.2.2 → 1.2.4-rc3

package/dist/core/sdd/services/frontend-gap.service.js

@@ -2,6 +2,12 @@ import { CLI_NAME } from "../../branding.js";
 import { allocateEntityId, loadStateSnapshot, nowIso, saveStateTransaction } from "../state.js";
 import { slugify, getRuntime, persistAndRender } from "../legacy-operations.js";
 import { withStateLock } from "../state-lock.js";
+function firstNonEmpty(values) {
+    return (values || []).map((value) => value.trim()).find(Boolean) || '';
+}
+function routeLabelFromGap(title, routePath) {
+    return title.trim() || routePath;
+}
 export class FrontendGapService {
     stores;
     constructor(stores) {
@@ -41,17 +47,20 @@ export class FrontendGapService {
             for (const routePath of options?.routes || []) {
                 const routeId = `route-${slugify(routePath) || 'root'}`;
                 const existing = snapshot.frontendMap.routes.find((route) => route.id === routeId);
+                const navSurface = firstNonEmpty(options?.menu);
                 if (existing) {
                     existing.ui_status = existing.ui_status === 'OK' ? 'PARTIAL' : existing.ui_status;
                     existing.source_gap_ids = Array.from(new Set([...existing.source_gap_ids, id]));
+                    existing.label = existing.label || routeLabelFromGap(title, routePath);
+                    existing.nav_surface = existing.nav_surface || navSurface;
                 }
                 else {
                     snapshot.frontendMap.routes.push({
                         id: routeId,
                         path: routePath,
                         parent_id: '',
-                        label: '',
-                        nav_surface: '',
+                        label: routeLabelFromGap(title, routePath),
+                        nav_surface: navSurface,
                         ui_status: 'GAP',
                         source_gap_ids: [id],
                         implemented_files: [],
@@ -83,17 +92,20 @@ export class FrontendGapService {
             gap.resolved_by_feature = options?.feature || '';
             gap.implemented_files = options?.files || [];
             gap.updated_at = now;
-            const routeTargets = new Set([...(gap.route_targets || []), ...(options?.routes || [])]);
+            const routeTargets = new Set([...gap.route_targets, ...(options?.routes || [])]);
+            const relatedRouteIds = new Set(gap.related_route_ids);
+            const navSurface = firstNonEmpty(gap.menu_targets);
             for (const routePath of routeTargets) {
                 const routeId = `route-${slugify(routePath) || 'root'}`;
+                relatedRouteIds.add(routeId);
                 const route = snapshot.frontendMap.routes.find((entry) => entry.id === routeId);
                 if (!route) {
                     snapshot.frontendMap.routes.push({
                         id: routeId,
                         path: routePath,
                         parent_id: '',
-                        label: '',
-                        nav_surface: '',
+                        label: routeLabelFromGap(gap.title, routePath),
+                        nav_surface: navSurface,
                         ui_status: 'OK',
                         source_gap_ids: [gap.id],
                         implemented_files: options?.files || [],
@@ -102,9 +114,12 @@ export class FrontendGapService {
                     continue;
                 }
                 route.ui_status = 'OK';
-                route.implemented_files = Array.from(new Set([...(route.implemented_files || []), ...(options?.files || [])]));
-                route.source_gap_ids = Array.from(new Set([...(route.source_gap_ids || []), gap.id]));
+                route.label = route.label || routeLabelFromGap(gap.title, routePath);
+                route.nav_surface = route.nav_surface || navSurface;
+                route.implemented_files = Array.from(new Set([...route.implemented_files, ...(options?.files || [])]));
+                route.source_gap_ids = Array.from(new Set([...route.source_gap_ids, gap.id]));
             }
+            gap.related_route_ids = Array.from(relatedRouteIds);
             await saveStateTransaction(paths, {
                 frontendGaps: snapshot.frontendGaps,
                 frontendMap: snapshot.frontendMap,

package/dist/core/sdd/services/frontend-impact.service.d.ts

@@ -10,7 +10,7 @@ export declare class FrontendImpactService {
         render?: boolean;
     }): Promise<{
         feature_id: string;
-        frontend_impact_status: "unknown" | "none" | "required";
+        frontend_impact_status: "none" | "unknown" | "required";
         frontend_impact_reason: string;
         frontend_impact_declared_at: string;
         frontend_surface_tokens: string[];

package/dist/core/sdd/services/governance-control-plane-runtime-adapters.d.ts

@@ -0,0 +1,17 @@
+export type GovernanceControlPlaneRuntimeMode = 'native' | 'contract';
+export type GovernanceControlPlaneRuntimeDependencyResolver = (packageName: string) => string;
+export interface GovernanceControlPlaneRuntimeAdapterStatus<TRuntime extends string = string> {
+    runtime: TRuntime;
+    package: string;
+    available: boolean;
+    mode: GovernanceControlPlaneRuntimeMode;
+    reason: string;
+}
+export interface GovernanceControlPlaneRuntimeAdapters {
+    ui_write_policy: 'cli-shell-out-only';
+    canonical_state: '.sdd/state/*.yaml';
+    frontend: GovernanceControlPlaneRuntimeAdapterStatus<'angular-spa'>;
+    realtime: GovernanceControlPlaneRuntimeAdapterStatus<'socket.io'>;
+}
+export declare function resolveGovernanceControlPlaneRuntimeAdapters(resolver?: GovernanceControlPlaneRuntimeDependencyResolver): GovernanceControlPlaneRuntimeAdapters;
+//# sourceMappingURL=governance-control-plane-runtime-adapters.d.ts.map

package/dist/core/sdd/services/governance-control-plane-runtime-adapters.js

@@ -0,0 +1,38 @@
+import { createRequire } from 'node:module';
+const FRONTEND_RUNTIME_PACKAGE = '@angular/core';
+const REALTIME_RUNTIME_PACKAGE = 'socket.io';
+export function resolveGovernanceControlPlaneRuntimeAdapters(resolver = defaultRuntimeDependencyResolver) {
+    return {
+        ui_write_policy: 'cli-shell-out-only',
+        canonical_state: '.sdd/state/*.yaml',
+        frontend: resolveAdapterStatus('angular-spa', FRONTEND_RUNTIME_PACKAGE, resolver),
+        realtime: resolveAdapterStatus('socket.io', REALTIME_RUNTIME_PACKAGE, resolver),
+    };
+}
+function resolveAdapterStatus(runtime, packageName, resolver) {
+    try {
+        resolver(packageName);
+        return {
+            runtime,
+            package: packageName,
+            available: true,
+            mode: 'native',
+            reason: `${packageName} resolved; native runtime adapter is available.`,
+        };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : `Unable to resolve ${packageName}`;
+        return {
+            runtime,
+            package: packageName,
+            available: true,
+            mode: 'contract',
+            reason: `${packageName} unresolved; using internal contract adapter (${detail}).`,
+        };
+    }
+}
+function defaultRuntimeDependencyResolver(packageName) {
+    const runtimeRequire = createRequire(import.meta.url);
+    return runtimeRequire.resolve(packageName);
+}
+//# sourceMappingURL=governance-control-plane-runtime-adapters.js.map

package/dist/core/sdd/services/governance-control-plane.service.d.ts

@@ -0,0 +1,66 @@
+import { type SddStateSnapshot } from '../state.js';
+export type ControlPlaneMutationAction = 'frontend-impact' | 'finalize';
+export interface GovernanceControlPlaneManifest {
+    protocol: 'codesdd-governance-control-plane/v1';
+    architecture: {
+        frontend: 'angular-spa';
+        api: 'rest';
+        realtime: 'socket.io';
+        ui_write_policy: 'cli-shell-out-only';
+        canonical_state: '.sdd/state/*.yaml';
+    };
+    rest: {
+        read_endpoints: Array<{
+            method: 'GET';
+            path: string;
+            description: string;
+        }>;
+        write_intent_endpoint: {
+            method: 'POST';
+            path: '/api/intents/cli-shell-out';
+            behavior: 'intent-only-by-default';
+            allowed_actions: ControlPlaneMutationAction[];
+        };
+    };
+    realtime: {
+        transport: 'socket.io';
+        available: boolean;
+        channel: 'codesdd.state.changed';
+        reason: string;
+    };
+    blockers: string[];
+}
+export interface GovernanceProjection {
+    generated_at: string;
+    backlog: SddStateSnapshot['backlog'];
+    finalize_queue: SddStateSnapshot['finalizeQueue'];
+    frontend_decisions: SddStateSnapshot['frontendDecisions'];
+}
+export interface GovernanceMutationIntent {
+    action: ControlPlaneMutationAction;
+    command: {
+        bin: string;
+        args: string[];
+        cwd: string;
+    };
+    gate: {
+        executes_immediately: false;
+        required_flag: '--allow-mutation-execution';
+        ui_can_write_state_directly: false;
+    };
+}
+export declare class GovernanceControlPlaneService {
+    manifest(projectRoot: string): Promise<GovernanceControlPlaneManifest>;
+    readProjection(projectRoot: string): Promise<GovernanceProjection>;
+    readBacklogFeature(projectRoot: string, featureId: string): Promise<Record<string, unknown>>;
+    planMutationIntent(projectRoot: string, action: ControlPlaneMutationAction, params: Record<string, string>): GovernanceMutationIntent;
+    executeMutationIntent(intent: GovernanceMutationIntent, options?: {
+        allowMutationExecution?: boolean;
+    }): Promise<{
+        executed: boolean;
+        stdout: string;
+        stderr: string;
+    }>;
+    private buildActionArgs;
+}
+//# sourceMappingURL=governance-control-plane.service.d.ts.map

package/dist/core/sdd/services/governance-control-plane.service.js

@@ -0,0 +1,134 @@
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { execFile } from 'node:child_process';
+import { loadProjectSddConfig, loadStateSnapshot, nowIso, resolveSddPaths, } from '../state.js';
+import { resolveGovernanceControlPlaneRuntimeAdapters } from './governance-control-plane-runtime-adapters.js';
+const execFileAsync = promisify(execFile);
+export class GovernanceControlPlaneService {
+    async manifest(projectRoot) {
+        const runtimeAdapters = resolveGovernanceControlPlaneRuntimeAdapters();
+        const { realtime, frontend } = runtimeAdapters;
+        const blockers = [];
+        if (!frontend.available) {
+            blockers.push(`Angular SPA runtime adapter is unavailable: ${frontend.reason}`);
+        }
+        if (!realtime.available) {
+            blockers.push(`Socket.io realtime runtime adapter is unavailable: ${realtime.reason}`);
+        }
+        return {
+            protocol: 'codesdd-governance-control-plane/v1',
+            architecture: {
+                frontend: frontend.runtime,
+                api: 'rest',
+                realtime: realtime.runtime,
+                ui_write_policy: runtimeAdapters.ui_write_policy,
+                canonical_state: runtimeAdapters.canonical_state,
+            },
+            rest: {
+                read_endpoints: [
+                    {
+                        method: 'GET',
+                        path: '/api/state/projection',
+                        description: 'Read-only projection generated from canonical CodeSDD state files.',
+                    },
+                    {
+                        method: 'GET',
+                        path: '/api/state/backlog/:featureId',
+                        description: 'Read-only backlog detail for one FEAT from canonical state.',
+                    },
+                ],
+                write_intent_endpoint: {
+                    method: 'POST',
+                    path: '/api/intents/cli-shell-out',
+                    behavior: 'intent-only-by-default',
+                    allowed_actions: ['frontend-impact', 'finalize'],
+                },
+            },
+            realtime: {
+                transport: realtime.runtime,
+                available: realtime.available,
+                channel: 'codesdd.state.changed',
+                reason: realtime.reason,
+            },
+            blockers,
+        };
+    }
+    async readProjection(projectRoot) {
+        const config = await loadProjectSddConfig(projectRoot);
+        const paths = resolveSddPaths(projectRoot, config);
+        const snapshot = await loadStateSnapshot(paths, config);
+        return {
+            generated_at: nowIso(),
+            backlog: snapshot.backlog,
+            finalize_queue: snapshot.finalizeQueue,
+            frontend_decisions: snapshot.frontendDecisions,
+        };
+    }
+    async readBacklogFeature(projectRoot, featureId) {
+        const projection = await this.readProjection(projectRoot);
+        const item = projection.backlog.items.find((entry) => entry.id === featureId);
+        if (!item) {
+            throw new Error(`Feature ${featureId} not found in canonical backlog state.`);
+        }
+        return {
+            generated_at: projection.generated_at,
+            feature: item,
+        };
+    }
+    planMutationIntent(projectRoot, action, params) {
+        const actionArgs = this.buildActionArgs(action, params);
+        return {
+            action,
+            command: {
+                bin: process.execPath,
+                args: [path.join(projectRoot, 'bin', 'codesdd.js'), ...actionArgs],
+                cwd: projectRoot,
+            },
+            gate: {
+                executes_immediately: false,
+                required_flag: '--allow-mutation-execution',
+                ui_can_write_state_directly: false,
+            },
+        };
+    }
+    async executeMutationIntent(intent, options) {
+        if (!options?.allowMutationExecution) {
+            throw new Error('Mutation execution is gated. Pass --allow-mutation-execution to proceed.');
+        }
+        const { stdout, stderr } = await execFileAsync(intent.command.bin, intent.command.args, {
+            cwd: intent.command.cwd,
+        });
+        return {
+            executed: true,
+            stdout,
+            stderr,
+        };
+    }
+    buildActionArgs(action, params) {
+        if (action === 'frontend-impact') {
+            const featureId = requiredParam(params, 'featureId');
+            const status = requiredParam(params, 'status');
+            const args = ['sdd', 'frontend-impact', featureId, '--status', status];
+            if (params.reason)
+                args.push('--reason', params.reason);
+            if (params.routes)
+                args.push('--routes', params.routes);
+            if (params.surfaces)
+                args.push('--surfaces', params.surfaces);
+            return args;
+        }
+        if (action === 'finalize') {
+            const featureId = requiredParam(params, 'featureId');
+            return ['sdd', 'finalize', '--ref', featureId];
+        }
+        throw new Error(`Unsupported control-plane action: ${action}`);
+    }
+}
+function requiredParam(params, key) {
+    const value = params[key];
+    if (!value || !value.trim()) {
+        throw new Error(`Missing required intent parameter: ${key}`);
+    }
+    return value.trim();
+}
+//# sourceMappingURL=governance-control-plane.service.js.map

package/dist/core/sdd/services/ingest-deposito.service.js

@@ -202,7 +202,7 @@ export class IngestDepositoService {
             }
             else {
                 startWarning =
-                    'Nenhuma FEAT pronta para iniciar automaticamente (dependencias/locks pendentes). Use "opensdd sdd next".';
+                    'Nenhuma FEAT pronta para iniciar automaticamente (dependencias/locks pendentes). Use "codesdd sdd next".';
             }
         }
         await persistAndRender(paths, config, options?.render);

package/dist/core/sdd/services/legacy-capability.service.d.ts

@@ -2,23 +2,26 @@ export interface LegacyCapabilityDefinition {
     id: string;
     displayName: string;
     liveRootDir: string;
+    deprecatedLiveRootSegments?: string[][];
     importedRootSegments: string[];
     importedDepositoSegments: string[];
     deprecatedImportedRootSegments?: string[][];
 }
-export declare const OPENSPEC_LEGACY_CAPABILITY: LegacyCapabilityDefinition;
-export declare const LEGACY_OPENSPEC_DIR: string;
-export declare const IMPORTED_OPENSPEC_DIR: string;
+export declare const LEGACY_SPEC_CAPABILITY: LegacyCapabilityDefinition;
+export declare const LEGACY_SPEC_DIR: string;
+export declare const IMPORTED_LEGACY_SPEC_DIR: string;
 export declare function resolveLegacyCapabilityLiveRoot(projectRoot: string, capability?: LegacyCapabilityDefinition): string;
 export declare function resolveLegacyCapabilityLiveSubpath(projectRoot: string, capability: LegacyCapabilityDefinition, ...segments: string[]): string;
 export declare function resolveLegacyCapabilityImportedRoot(projectRoot: string, capability?: LegacyCapabilityDefinition): string;
 export declare function resolveLegacyCapabilityDeprecatedImportedRoots(projectRoot: string, capability?: LegacyCapabilityDefinition): string[];
+export declare function resolveLegacyCapabilityDeprecatedLiveRoots(projectRoot: string, capability?: LegacyCapabilityDefinition): string[];
 export declare function resolveLegacyCapabilityImportedDepositoRoot(depositoDir: string, capability?: LegacyCapabilityDefinition): string;
 export declare function resolveLegacyCapabilityRoot(projectRoot?: string, capability?: LegacyCapabilityDefinition): string;
 export declare function resolveLegacyCapabilitySubpath(projectRoot: string, capability: LegacyCapabilityDefinition, ...segments: string[]): string;
 export declare function displayLegacyCapabilityPath(capability: LegacyCapabilityDefinition, ...segments: string[]): string;
-export declare function resolveOpenSpecRoot(projectRoot?: string): string;
-export declare function resolveOpenSpecSubpath(projectRoot: string, ...segments: string[]): string;
-export declare function resolveOpenSpecLiveSubpath(projectRoot: string, ...segments: string[]): string;
-export declare function displayLegacyOpenSpecPath(...segments: string[]): string;
+export declare function resolveLegacySpecRoot(projectRoot?: string): string;
+export declare function resolveLegacySpecLiveRoot(projectRoot?: string): string;
+export declare function resolveLegacySpecSubpath(projectRoot: string, ...segments: string[]): string;
+export declare function resolveLegacySpecLiveSubpath(projectRoot: string, ...segments: string[]): string;
+export declare function displayLegacySpecPath(...segments: string[]): string;
 //# sourceMappingURL=legacy-capability.service.d.ts.map

package/dist/core/sdd/services/legacy-capability.service.js

@@ -1,31 +1,45 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
-export const OPENSPEC_LEGACY_CAPABILITY = {
-    id: 'openspec',
-    displayName: 'OpenSpec',
-    liveRootDir: 'openspec',
+export const LEGACY_SPEC_CAPABILITY = {
+    id: 'legacy-spec',
+    displayName: 'Legacy spec corpus',
+    liveRootDir: 'legacy-spec',
+    deprecatedLiveRootSegments: [['codesdd']],
     importedRootSegments: ['.sdd', 'sources', 'legacy', 'spec-corpus'],
     importedDepositoSegments: ['legacy', 'spec-corpus'],
-    deprecatedImportedRootSegments: [['.sdd', 'sources', 'legado', 'openspec']],
+    deprecatedImportedRootSegments: [
+        ['.sdd', 'sources', 'legado', 'legacy-spec'],
+        ['.sdd', 'sources', 'legado', 'codesdd'],
+    ],
 };
-export const LEGACY_OPENSPEC_DIR = OPENSPEC_LEGACY_CAPABILITY.liveRootDir;
-export const IMPORTED_OPENSPEC_DIR = path.join(...OPENSPEC_LEGACY_CAPABILITY.importedRootSegments);
-export function resolveLegacyCapabilityLiveRoot(projectRoot, capability = OPENSPEC_LEGACY_CAPABILITY) {
-    return path.join(projectRoot, capability.liveRootDir);
+export const LEGACY_SPEC_DIR = LEGACY_SPEC_CAPABILITY.liveRootDir;
+export const IMPORTED_LEGACY_SPEC_DIR = path.join(...LEGACY_SPEC_CAPABILITY.importedRootSegments);
+export function resolveLegacyCapabilityLiveRoot(projectRoot, capability = LEGACY_SPEC_CAPABILITY) {
+    const canonicalRoot = path.join(projectRoot, capability.liveRootDir);
+    if (existsSync(canonicalRoot))
+        return canonicalRoot;
+    for (const deprecatedRoot of resolveLegacyCapabilityDeprecatedLiveRoots(projectRoot, capability)) {
+        if (existsSync(deprecatedRoot))
+            return deprecatedRoot;
+    }
+    return canonicalRoot;
 }
 export function resolveLegacyCapabilityLiveSubpath(projectRoot, capability, ...segments) {
     return path.join(resolveLegacyCapabilityLiveRoot(projectRoot, capability), ...segments);
 }
-export function resolveLegacyCapabilityImportedRoot(projectRoot, capability = OPENSPEC_LEGACY_CAPABILITY) {
+export function resolveLegacyCapabilityImportedRoot(projectRoot, capability = LEGACY_SPEC_CAPABILITY) {
     return path.join(projectRoot, ...capability.importedRootSegments);
 }
-export function resolveLegacyCapabilityDeprecatedImportedRoots(projectRoot, capability = OPENSPEC_LEGACY_CAPABILITY) {
+export function resolveLegacyCapabilityDeprecatedImportedRoots(projectRoot, capability = LEGACY_SPEC_CAPABILITY) {
     return (capability.deprecatedImportedRootSegments || []).map((segments) => path.join(projectRoot, ...segments));
 }
-export function resolveLegacyCapabilityImportedDepositoRoot(depositoDir, capability = OPENSPEC_LEGACY_CAPABILITY) {
+export function resolveLegacyCapabilityDeprecatedLiveRoots(projectRoot, capability = LEGACY_SPEC_CAPABILITY) {
+    return (capability.deprecatedLiveRootSegments || []).map((segments) => path.join(projectRoot, ...segments));
+}
+export function resolveLegacyCapabilityImportedDepositoRoot(depositoDir, capability = LEGACY_SPEC_CAPABILITY) {
     return path.join(depositoDir, ...capability.importedDepositoSegments);
 }
-export function resolveLegacyCapabilityRoot(projectRoot = process.cwd(), capability = OPENSPEC_LEGACY_CAPABILITY) {
+export function resolveLegacyCapabilityRoot(projectRoot = process.cwd(), capability = LEGACY_SPEC_CAPABILITY) {
     const liveRoot = resolveLegacyCapabilityLiveRoot(projectRoot, capability);
     if (existsSync(liveRoot))
         return liveRoot;
@@ -44,16 +58,19 @@ export function resolveLegacyCapabilitySubpath(projectRoot, capability, ...segme
 export function displayLegacyCapabilityPath(capability, ...segments) {
     return path.join(capability.liveRootDir, ...segments);
 }
-export function resolveOpenSpecRoot(projectRoot = process.cwd()) {
-    return resolveLegacyCapabilityRoot(projectRoot, OPENSPEC_LEGACY_CAPABILITY);
+export function resolveLegacySpecRoot(projectRoot = process.cwd()) {
+    return resolveLegacyCapabilityRoot(projectRoot, LEGACY_SPEC_CAPABILITY);
+}
+export function resolveLegacySpecLiveRoot(projectRoot = process.cwd()) {
+    return resolveLegacyCapabilityLiveRoot(projectRoot, LEGACY_SPEC_CAPABILITY);
 }
-export function resolveOpenSpecSubpath(projectRoot, ...segments) {
-    return resolveLegacyCapabilitySubpath(projectRoot, OPENSPEC_LEGACY_CAPABILITY, ...segments);
+export function resolveLegacySpecSubpath(projectRoot, ...segments) {
+    return resolveLegacyCapabilitySubpath(projectRoot, LEGACY_SPEC_CAPABILITY, ...segments);
 }
-export function resolveOpenSpecLiveSubpath(projectRoot, ...segments) {
-    return resolveLegacyCapabilityLiveSubpath(projectRoot, OPENSPEC_LEGACY_CAPABILITY, ...segments);
+export function resolveLegacySpecLiveSubpath(projectRoot, ...segments) {
+    return resolveLegacyCapabilityLiveSubpath(projectRoot, LEGACY_SPEC_CAPABILITY, ...segments);
 }
-export function displayLegacyOpenSpecPath(...segments) {
-    return displayLegacyCapabilityPath(OPENSPEC_LEGACY_CAPABILITY, ...segments);
+export function displayLegacySpecPath(...segments) {
+    return displayLegacyCapabilityPath(LEGACY_SPEC_CAPABILITY, ...segments);
 }
 //# sourceMappingURL=legacy-capability.service.js.map

package/dist/core/sdd/services/mcp-runtime.service.d.ts

@@ -1,11 +1,76 @@
 import type { SddStores } from '../store/sdd-stores.js';
-export type McpProviderId = 'codex' | 'claude-code' | 'kimmy-code' | 'kilo-code' | 'open-code' | 'generic';
-export type McpToolName = 'opensdd.next' | 'opensdd.context' | 'opensdd.finalize';
+export type McpProviderId = 'codex' | 'claude-code' | 'deepagents' | 'kimmy-code' | 'kilo-code' | 'open-code' | 'generic';
+export type CodeSddMcpToolName = 'codesdd.next' | 'codesdd.context' | 'codesdd.query' | 'codesdd.read' | 'codesdd.start' | 'codesdd.plugin.inspect' | 'codesdd.plugin.plan' | 'codesdd.plugin.apply_sandbox' | 'codesdd.quality.evidence' | 'codesdd.adr' | 'codesdd.check' | 'codesdd.diagnose' | 'codesdd.finalize_intent' | 'codesdd.frontend_impact' | 'codesdd.skill_prompt';
+export type McpCompatibilityAliasName = never;
+export type McpToolName = CodeSddMcpToolName | McpCompatibilityAliasName;
+export type McpRuntimeToolOperation = 'next' | 'context' | 'query' | 'read' | 'start' | 'plugin-inspect' | 'plugin-plan' | 'plugin-apply-sandbox' | 'quality-evidence' | 'adr' | 'check' | 'diagnose' | 'finalize-intent' | 'frontend-impact' | 'skill-prompt';
+export type McpRuntimeStateAccess = 'read' | 'read-write';
+export type McpRuntimePolicyGate = 'read-only' | 'intent-only';
+export type McpRuntimeRiskTier = 'low' | 'medium' | 'high' | 'critical';
+export type McpRuntimeServiceName = 'NextService' | 'ContextService' | 'StructuralQueryService' | 'WorkspaceReadService' | 'StartService' | 'PluginCliService' | 'QualityEvidenceService' | 'AdrIndexService' | 'SddCheckCommand' | 'SddDiagnoseCommand' | 'GovernanceControlPlaneService' | 'SkillsInvokeService';
 type JsonSchema = Record<string, unknown>;
+export type PlannedMcpToolName = 'codesdd.agent.run' | 'codesdd.agent.plan' | 'codesdd.agent.evidence' | 'codesdd.agent.status';
+export interface McpRuntimeStateBoundary {
+    id: 'codesdd-canonical-sdd-state';
+    canonical_state_root: '.sdd/state';
+    canonical_state_glob: '.sdd/state/*.yaml';
+    canonical_workspace_roots: ReadonlyArray<'.sdd/planned' | '.sdd/active' | '.sdd/archived'>;
+    adapter_boundary: 'SddStores';
+    runtime_persistence: 'delegated-to-codesdd-services';
+    hidden_state_allowed: false;
+    external_state_allowed: false;
+}
+export interface McpRuntimeToolRegistryEntry {
+    id: `runtime-tool:${CodeSddMcpToolName}`;
+    canonical_name: CodeSddMcpToolName;
+    operation: McpRuntimeToolOperation;
+    title: string;
+    description: string;
+    input_schema: JsonSchema;
+    output_schema: JsonSchema;
+    compatibility_aliases: ReadonlyArray<McpCompatibilityAliasName>;
+    governance: {
+        gate: McpRuntimePolicyGate;
+        risk_tier: McpRuntimeRiskTier;
+        evidence_behavior: string;
+        hitl_rule: string;
+    };
+    implementation: {
+        service: McpRuntimeServiceName;
+        state_access: McpRuntimeStateAccess;
+        reads: ReadonlyArray<string>;
+        writes: ReadonlyArray<string>;
+    };
+}
+export interface McpRuntimeRegistryManifest {
+    name: 'codesdd-runtime-tool-registry';
+    version: 1;
+    canonical_namespace: 'codesdd';
+    compatibility_namespaces: ReadonlyArray<string>;
+    state_boundary_ref: McpRuntimeStateBoundary['id'];
+    entries: Array<{
+        id: McpRuntimeToolRegistryEntry['id'];
+        canonical_name: CodeSddMcpToolName;
+        operation: McpRuntimeToolOperation;
+        governance: {
+            gate: McpRuntimePolicyGate;
+            risk_tier: McpRuntimeRiskTier;
+            evidence_behavior: string;
+            hitl_rule: string;
+        };
+        compatibility_aliases: McpCompatibilityAliasName[];
+        implementation: {
+            service: McpRuntimeServiceName;
+            state_access: McpRuntimeStateAccess;
+            reads: string[];
+            writes: string[];
+        };
+    }>;
+}
 export interface McpRuntimeManifest {
-    protocol: 'opensdd-mcp-bridge/v1';
+    protocol: 'codesdd-mcp-bridge/v1';
     server: {
-        name: 'opensdd';
+        name: 'codesdd';
         version: 1;
     };
     provider: {
@@ -15,28 +80,78 @@ export interface McpRuntimeManifest {
         session_contract: string;
     };
     tools: Array<{
-        name: McpToolName;
+        registry_entry_ref: McpRuntimeToolRegistryEntry['id'];
+        name: CodeSddMcpToolName;
         title: string;
         description: string;
         input_schema: JsonSchema;
+        output_schema: JsonSchema;
+        governance: {
+            gate: McpRuntimePolicyGate;
+            risk_tier: McpRuntimeRiskTier;
+            evidence_behavior: string;
+            hitl_rule: string;
+        };
+        compatibility_aliases: McpCompatibilityAliasName[];
     }>;
+    planned_tools: Array<{
+        name: PlannedMcpToolName;
+        status: 'planned';
+        title: string;
+        description: string;
+    }>;
+    registry: McpRuntimeRegistryManifest;
+    state_boundary: McpRuntimeStateBoundary;
 }
 export interface McpRuntimeInvocation {
-    protocol: 'opensdd-mcp-bridge/v1';
+    protocol: 'codesdd-mcp-bridge/v1';
     provider: McpProviderId;
-    tool: McpToolName;
+    tool: CodeSddMcpToolName;
+    requested_tool: McpToolName;
+    compatibility_alias_used: boolean;
+    registry_resolution: {
+        registry: McpRuntimeRegistryManifest['name'];
+        registry_entry_ref: McpRuntimeToolRegistryEntry['id'];
+        canonical_tool: CodeSddMcpToolName;
+        requested_tool: McpToolName;
+        compatibility_alias_used: boolean;
+        state_access: McpRuntimeStateAccess;
+    };
+    state_boundary: McpRuntimeStateBoundary;
     invoked_at: string;
     result: unknown;
 }
+export declare const MCP_RUNTIME_STATE_BOUNDARY: {
+    readonly id: "codesdd-canonical-sdd-state";
+    readonly canonical_state_root: ".sdd/state";
+    readonly canonical_state_glob: ".sdd/state/*.yaml";
+    readonly canonical_workspace_roots: readonly [".sdd/planned", ".sdd/active", ".sdd/archived"];
+    readonly adapter_boundary: "SddStores";
+    readonly runtime_persistence: "delegated-to-codesdd-services";
+    readonly hidden_state_allowed: false;
+    readonly external_state_allowed: false;
+};
+export declare const MCP_RUNTIME_TOOL_REGISTRY: ReadonlyArray<McpRuntimeToolRegistryEntry>;
+export declare const MCP_RUNTIME_SUPPORTED_TOOLS: ReadonlyArray<McpToolName>;
 export declare class McpRuntimeService {
     private readonly stores;
     constructor(stores: SddStores);
     manifest(provider?: string): McpRuntimeManifest;
     invoke(projectRoot: string, input: {
         provider?: string;
-        tool: McpToolName;
+        tool: string;
         args?: Record<string, unknown>;
     }): Promise<McpRuntimeInvocation>;
+    private queryState;
+    private readWorkspaceDocs;
+    private planStartIntent;
+    private inspectPlugin;
+    private planPlugin;
+    private readQualityEvidence;
+    private readAdrIndex;
+    private planFinalizeIntent;
+    private planFrontendImpactIntent;
+    private buildSkillPrompt;
 }
 export {};
 //# sourceMappingURL=mcp-runtime.service.d.ts.map