@devtrack-solution/codesdd 1.2.2

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

@@ -0,0 +1,42 @@
+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';
+type JsonSchema = Record<string, unknown>;
+export interface McpRuntimeManifest {
+    protocol: 'opensdd-mcp-bridge/v1';
+    server: {
+        name: 'opensdd';
+        version: 1;
+    };
+    provider: {
+        id: McpProviderId;
+        label: string;
+        transport: 'stdio';
+        session_contract: string;
+    };
+    tools: Array<{
+        name: McpToolName;
+        title: string;
+        description: string;
+        input_schema: JsonSchema;
+    }>;
+}
+export interface McpRuntimeInvocation {
+    protocol: 'opensdd-mcp-bridge/v1';
+    provider: McpProviderId;
+    tool: McpToolName;
+    invoked_at: string;
+    result: unknown;
+}
+export declare class McpRuntimeService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    manifest(provider?: string): McpRuntimeManifest;
+    invoke(projectRoot: string, input: {
+        provider?: string;
+        tool: McpToolName;
+        args?: Record<string, unknown>;
+    }): Promise<McpRuntimeInvocation>;
+}
+export {};
+//# sourceMappingURL=mcp-runtime.service.d.ts.map

package/dist/core/sdd/services/mcp-runtime.service.js

@@ -0,0 +1,144 @@
+import { nowIso } from '../state.js';
+import { ContextService } from './context.service.js';
+import { FinalizeService } from './finalize.service.js';
+import { NextService } from './next.service.js';
+const PROVIDER_PROFILES = {
+    codex: {
+        label: 'Codex',
+        session_contract: 'Use JSON tool payloads and preserve FEAT state transitions through next/context/finalize without hidden side channels.',
+    },
+    'claude-code': {
+        label: 'Claude Code',
+        session_contract: 'Use JSON tool payloads and treat OpenSDD as the canonical execution ledger for plan, context, and closure.',
+    },
+    'kimmy-code': {
+        label: 'Kimmy Code',
+        session_contract: 'Use the same stateless JSON envelopes and feed all execution evidence back into OpenSDD workspaces.',
+    },
+    'kilo-code': {
+        label: 'Kilo Code',
+        session_contract: 'Use OpenSDD tool envelopes as the source of truth for ready work, scoped context, and feature finalization.',
+    },
+    'open-code': {
+        label: 'Open Code',
+        session_contract: 'Use stateless OpenSDD tool calls and return evidence through workspace artifacts before finalize.',
+    },
+    generic: {
+        label: 'Generic MCP Client',
+        session_contract: 'Use the provider-agnostic JSON envelope and treat OpenSDD workspace/state files as the only canonical state system.',
+    },
+};
+const TOOL_DEFINITIONS = [
+    {
+        name: 'opensdd.next',
+        title: 'OpenSDD Next',
+        description: 'Return the next ready FEATs, blocked work, conflicts, and execution waves.',
+        input_schema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                rank: { type: 'string', enum: ['impact', 'criticality', 'fifo'] },
+                limit: { type: 'integer', minimum: 1 },
+                maxAgents: { type: 'integer', minimum: 1 },
+            },
+        },
+    },
+    {
+        name: 'opensdd.context',
+        title: 'OpenSDD Context',
+        description: 'Return the scoped execution context for a FEAT, EPIC, FGAP, or TD reference.',
+        input_schema: {
+            type: 'object',
+            additionalProperties: false,
+            required: ['ref'],
+            properties: {
+                ref: { type: 'string' },
+            },
+        },
+    },
+    {
+        name: 'opensdd.finalize',
+        title: 'OpenSDD Finalize',
+        description: 'Finalize a FEAT or all ready queue entries after quality and workflow guardrails pass.',
+        input_schema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                ref: { type: 'string' },
+                allReady: { type: 'boolean' },
+                forceFrontend: { type: 'boolean' },
+                forceTransition: { type: 'boolean' },
+            },
+        },
+    },
+];
+function resolveProvider(provider) {
+    if (!provider)
+        return 'generic';
+    if (provider in PROVIDER_PROFILES)
+        return provider;
+    throw new Error(`Unknown MCP provider "${provider}". Use one of: ${Object.keys(PROVIDER_PROFILES).join(', ')}`);
+}
+export class McpRuntimeService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    manifest(provider) {
+        const providerId = resolveProvider(provider);
+        return {
+            protocol: 'opensdd-mcp-bridge/v1',
+            server: {
+                name: 'opensdd',
+                version: 1,
+            },
+            provider: {
+                id: providerId,
+                label: PROVIDER_PROFILES[providerId].label,
+                transport: 'stdio',
+                session_contract: PROVIDER_PROFILES[providerId].session_contract,
+            },
+            tools: TOOL_DEFINITIONS,
+        };
+    }
+    async invoke(projectRoot, input) {
+        const providerId = resolveProvider(input.provider);
+        const args = input.args || {};
+        let result;
+        switch (input.tool) {
+            case 'opensdd.next':
+                result = await new NextService(this.stores).execute(projectRoot, {
+                    rank: typeof args.rank === 'string' ? args.rank : undefined,
+                    limit: typeof args.limit === 'number' ? args.limit : undefined,
+                    maxAgents: typeof args.maxAgents === 'number' ? args.maxAgents : undefined,
+                });
+                break;
+            case 'opensdd.context':
+                if (typeof args.ref !== 'string' || !args.ref.trim()) {
+                    throw new Error('opensdd.context requires args.ref');
+                }
+                result = await new ContextService(this.stores).execute(projectRoot, args.ref);
+                break;
+            case 'opensdd.finalize':
+                result = await new FinalizeService(this.stores).execute(projectRoot, {
+                    ref: typeof args.ref === 'string' ? args.ref : undefined,
+                    allReady: args.allReady === true,
+                    forceFrontend: args.forceFrontend === true,
+                    forceTransition: args.forceTransition === true,
+                    cwd: typeof args.cwd === 'string' ? args.cwd : undefined,
+                    render: false,
+                });
+                break;
+            default:
+                throw new Error(`Unsupported MCP tool "${input.tool}"`);
+        }
+        return {
+            protocol: 'opensdd-mcp-bridge/v1',
+            provider: providerId,
+            tool: input.tool,
+            invoked_at: nowIso(),
+            result,
+        };
+    }
+}
+//# sourceMappingURL=mcp-runtime.service.js.map

package/dist/core/sdd/services/metrics.service.d.ts

@@ -0,0 +1,49 @@
+export interface SddMetricsOptions {
+    since?: string;
+    now?: Date;
+}
+export interface SddDurationMetrics {
+    count: number;
+    average_hours: number;
+    median_hours: number;
+    p90_hours: number;
+    min_hours: number;
+    max_hours: number;
+}
+export interface SddAgingItem {
+    feature_id: string;
+    started_at: string;
+    age_hours: number;
+}
+export interface SddMetricsReport {
+    generated_at: string;
+    since: string;
+    until: string;
+    window_days: number;
+    transition_log_events: number;
+    features: {
+        completed: number;
+        completed_feature_ids: string[];
+        active: number;
+        active_feature_ids: string[];
+    };
+    lead_time: SddDurationMetrics;
+    aging: {
+        count: number;
+        average_hours: number;
+        max_hours: number;
+        items: SddAgingItem[];
+    };
+    throughput: {
+        done_count: number;
+        per_day: number;
+        by_day: Record<string, number>;
+    };
+    warnings: string[];
+}
+export declare function parseMetricsSince(value: string | undefined, now: Date): Date;
+export declare class SddMetricsService {
+    execute(projectRoot?: string, options?: SddMetricsOptions): Promise<SddMetricsReport>;
+}
+export declare function formatSddMetricsReport(report: SddMetricsReport): string;
+//# sourceMappingURL=metrics.service.d.ts.map

package/dist/core/sdd/services/metrics.service.js

@@ -0,0 +1,181 @@
+import { loadProjectSddConfig, loadStateSnapshot, resolveSddPaths, } from '../state.js';
+import { ensureMemoryInitialized } from '../legacy-operations.js';
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+function round(value) {
+    return Math.round(value * 100) / 100;
+}
+function parseTimestamp(value) {
+    const date = new Date(value);
+    if (Number.isNaN(date.getTime()))
+        return undefined;
+    return date;
+}
+export function parseMetricsSince(value, now) {
+    const raw = (value || '7d').trim();
+    const relative = /^(\d+)([hdw])$/i.exec(raw);
+    if (relative) {
+        const amount = Number(relative[1]);
+        const unit = relative[2].toLowerCase();
+        const multiplier = unit === 'h' ? HOUR_MS : unit === 'w' ? 7 * DAY_MS : DAY_MS;
+        return new Date(now.getTime() - amount * multiplier);
+    }
+    const parsed = parseTimestamp(raw);
+    if (!parsed) {
+        throw new Error('Invalid --since value. Use a relative window like 7d, 24h, 2w, or an ISO timestamp.');
+    }
+    return parsed;
+}
+function hoursBetween(start, end) {
+    return round((end.getTime() - start.getTime()) / HOUR_MS);
+}
+function durationMetrics(hours) {
+    if (hours.length === 0) {
+        return {
+            count: 0,
+            average_hours: 0,
+            median_hours: 0,
+            p90_hours: 0,
+            min_hours: 0,
+            max_hours: 0,
+        };
+    }
+    const sorted = [...hours].sort((left, right) => left - right);
+    const sum = sorted.reduce((total, value) => total + value, 0);
+    const midpoint = Math.floor(sorted.length / 2);
+    const median = sorted.length % 2 === 0
+        ? (sorted[midpoint - 1] + sorted[midpoint]) / 2
+        : sorted[midpoint];
+    const p90Index = Math.min(sorted.length - 1, Math.ceil(sorted.length * 0.9) - 1);
+    return {
+        count: sorted.length,
+        average_hours: round(sum / sorted.length),
+        median_hours: round(median),
+        p90_hours: round(sorted[p90Index]),
+        min_hours: round(sorted[0]),
+        max_hours: round(sorted[sorted.length - 1]),
+    };
+}
+function groupFeatureTransitions(events, warnings) {
+    const grouped = new Map();
+    const featureEvents = events
+        .filter((event) => event.entity_type === 'FEAT')
+        .map((event) => ({ event, timestamp: parseTimestamp(event.timestamp) }))
+        .filter((entry) => {
+        if (!entry.timestamp) {
+            warnings.push(`Ignoring FEAT transition with invalid timestamp: ${entry.event.entity_id}`);
+            return false;
+        }
+        return true;
+    })
+        .sort((left, right) => left.timestamp.getTime() - right.timestamp.getTime());
+    for (const entry of featureEvents) {
+        const event = entry.event;
+        const timestamp = entry.timestamp;
+        const summary = grouped.get(event.entity_id) ?? {
+            featureId: event.entity_id,
+        };
+        if (event.to === 'IN_PROGRESS') {
+            summary.startAt = timestamp;
+            summary.doneAt = undefined;
+        }
+        if (event.to === 'DONE' && summary.startAt && !summary.doneAt) {
+            summary.doneAt = timestamp;
+        }
+        summary.latestTo = event.to;
+        grouped.set(event.entity_id, summary);
+    }
+    return grouped;
+}
+function dayKey(date) {
+    return date.toISOString().slice(0, 10);
+}
+export class SddMetricsService {
+    async execute(projectRoot = '.', options = {}) {
+        const now = options.now ?? new Date();
+        const since = parseMetricsSince(options.since, now);
+        if (since.getTime() > now.getTime()) {
+            throw new Error('--since cannot be in the future.');
+        }
+        const config = await loadProjectSddConfig(projectRoot);
+        const paths = resolveSddPaths(projectRoot, config);
+        await ensureMemoryInitialized(paths);
+        const snapshot = await loadStateSnapshot(paths, config);
+        const warnings = [];
+        const grouped = groupFeatureTransitions(snapshot.transitionLog.events, warnings);
+        const completedIds = [];
+        const activeItems = [];
+        const leadTimes = [];
+        const byDay = {};
+        for (const summary of grouped.values()) {
+            if (summary.startAt && summary.doneAt && summary.doneAt >= since && summary.doneAt <= now) {
+                completedIds.push(summary.featureId);
+                leadTimes.push(hoursBetween(summary.startAt, summary.doneAt));
+                const key = dayKey(summary.doneAt);
+                byDay[key] = (byDay[key] ?? 0) + 1;
+            }
+            if (summary.startAt && !summary.doneAt && summary.latestTo === 'IN_PROGRESS') {
+                activeItems.push({
+                    feature_id: summary.featureId,
+                    started_at: summary.startAt.toISOString(),
+                    age_hours: hoursBetween(summary.startAt, now),
+                });
+            }
+        }
+        activeItems.sort((left, right) => right.age_hours - left.age_hours || left.feature_id.localeCompare(right.feature_id));
+        completedIds.sort((left, right) => left.localeCompare(right));
+        const agingHours = activeItems.map((item) => item.age_hours);
+        const windowDays = Math.max(1 / 24, (now.getTime() - since.getTime()) / DAY_MS);
+        return {
+            generated_at: now.toISOString(),
+            since: since.toISOString(),
+            until: now.toISOString(),
+            window_days: round(windowDays),
+            transition_log_events: snapshot.transitionLog.events.length,
+            features: {
+                completed: completedIds.length,
+                completed_feature_ids: completedIds,
+                active: activeItems.length,
+                active_feature_ids: activeItems.map((item) => item.feature_id),
+            },
+            lead_time: durationMetrics(leadTimes),
+            aging: {
+                count: activeItems.length,
+                average_hours: agingHours.length > 0 ? round(agingHours.reduce((sum, value) => sum + value, 0) / agingHours.length) : 0,
+                max_hours: agingHours.length > 0 ? Math.max(...agingHours) : 0,
+                items: activeItems,
+            },
+            throughput: {
+                done_count: completedIds.length,
+                per_day: round(completedIds.length / windowDays),
+                by_day: Object.fromEntries(Object.entries(byDay).sort(([left], [right]) => left.localeCompare(right))),
+            },
+            warnings,
+        };
+    }
+}
+export function formatSddMetricsReport(report) {
+    const lines = [
+        `Metrics window: ${report.since} -> ${report.until} (${report.window_days} days)`,
+        `Transition events: ${report.transition_log_events}`,
+        `Completed features: ${report.features.completed} (${report.features.completed_feature_ids.join(', ') || '-'})`,
+        `Active features: ${report.features.active} (${report.features.active_feature_ids.join(', ') || '-'})`,
+        `Lead time: avg=${report.lead_time.average_hours}h median=${report.lead_time.median_hours}h p90=${report.lead_time.p90_hours}h count=${report.lead_time.count}`,
+        `Aging: avg=${report.aging.average_hours}h max=${report.aging.max_hours}h count=${report.aging.count}`,
+        `Throughput: done=${report.throughput.done_count}, per_day=${report.throughput.per_day}`,
+    ];
+    if (Object.keys(report.throughput.by_day).length > 0) {
+        lines.push('Throughput by day:');
+        for (const [day, count] of Object.entries(report.throughput.by_day)) {
+            lines.push(`- ${day}: ${count}`);
+        }
+    }
+    if (report.warnings.length > 0) {
+        lines.push('Warnings:');
+        for (const warning of report.warnings) {
+            lines.push(`- ${warning}`);
+        }
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=metrics.service.js.map

package/dist/core/sdd/services/next.service.d.ts

@@ -0,0 +1,35 @@
+import { SddStores } from "../store/sdd-stores.js";
+export declare class NextService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, options?: {
+        rank?: any;
+        limit?: number;
+        maxAgents?: number;
+    }): Promise<{
+        rank: any;
+        ready: {
+            id: string;
+            title: string;
+            recommended_skills: string[];
+            score: number;
+            reasons: string[];
+        }[];
+        blocked: {
+            id: string;
+            title: string;
+            blocked_by: string[];
+        }[];
+        conflicts: {
+            id: string;
+            title: string;
+            lock_domains: string[];
+        }[];
+        waves: string[][];
+        deferred: {
+            id: string;
+            reasons: string[];
+        }[];
+    }>;
+}
+//# sourceMappingURL=next.service.d.ts.map

package/dist/core/sdd/services/next.service.js

@@ -0,0 +1,54 @@
+import { loadStateSnapshot } from "../state.js";
+import { getRuntime, computeReadyFeatures, extractFeatureNumber, buildDependentsMap, scoreReadyItem } from "../legacy-operations.js";
+export class NextService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, options) {
+        const { config, paths } = await getRuntime(projectRoot);
+        const snapshot = await loadStateSnapshot(paths, config);
+        const rank = options?.rank || 'impact';
+        const limit = options?.limit && options.limit > 0 ? Math.floor(options.limit) : 10;
+        const computed = computeReadyFeatures(snapshot.backlog.items, {
+            rank,
+            maxAgents: options?.maxAgents,
+        });
+        const { ready, blocked, conflicts, waves, deferred } = computed;
+        const dependentsMap = buildDependentsMap(snapshot.backlog.items);
+        const rankedReady = ready
+            .map((item) => {
+            const scored = scoreReadyItem(item, snapshot.backlog.items, dependentsMap, rank);
+            return {
+                id: item.id,
+                title: item.title,
+                recommended_skills: item.recommended_skills.slice(0, 3),
+                score: scored.score,
+                reasons: scored.reasons,
+            };
+        })
+            .sort((a, b) => {
+            if (b.score !== a.score)
+                return b.score - a.score;
+            return extractFeatureNumber(a.id) - extractFeatureNumber(b.id);
+        })
+            .slice(0, limit);
+        return {
+            rank,
+            ready: rankedReady,
+            blocked: blocked.map((item) => ({
+                id: item.id,
+                title: item.title,
+                blocked_by: item.blocked_by,
+            })),
+            conflicts: conflicts.map((item) => ({
+                id: item.id,
+                title: item.title,
+                lock_domains: item.lock_domains,
+            })),
+            waves,
+            deferred,
+        };
+    }
+}
+//# sourceMappingURL=next.service.js.map

package/dist/core/sdd/services/onboard.service.d.ts

@@ -0,0 +1,9 @@
+import { SddStores } from "../store/sdd-stores.js";
+export declare class OnboardService {
+    private readonly stores;
+    constructor(stores: SddStores);
+    execute(projectRoot: string, target?: string, options?: {
+        compact?: boolean;
+    }): Promise<Record<string, unknown>>;
+}
+//# sourceMappingURL=onboard.service.d.ts.map

package/dist/core/sdd/services/onboard.service.js

@@ -0,0 +1,165 @@
+import path from "node:path";
+import { CLI_NAME } from "../../branding.js";
+import { loadStateSnapshot } from "../state.js";
+import { bundlesForSkills, getRuntime, relProjectPath, coreDocRef, planningDocRef, resolveActiveDocRefs } from "../legacy-operations.js";
+import { ContextService } from "./context.service.js";
+import { NextService } from "./next.service.js";
+export class OnboardService {
+    stores;
+    constructor(stores) {
+        this.stores = stores;
+    }
+    async execute(projectRoot, target = 'system', options) {
+        const { config, paths } = await getRuntime(projectRoot);
+        const snapshot = await loadStateSnapshot(paths, config);
+        const normalized = (target || 'system').trim();
+        const contextCmd = new ContextService(this.stores);
+        const baseReadOrder = [
+            'README.md',
+            relProjectPath(paths, path.join(paths.memoryRoot, 'AGENT.md')),
+            coreDocRef(paths, 'index.md'),
+            coreDocRef(paths, 'arquitetura.md'),
+            coreDocRef(paths, 'servicos.md'),
+            coreDocRef(paths, 'spec-tecnologica.md'),
+            coreDocRef(paths, 'repo-map.md'),
+        ];
+        if (config.frontend.enabled) {
+            baseReadOrder.push(coreDocRef(paths, 'frontend-map.md'), coreDocRef(paths, 'frontend-decisions.md'));
+        }
+        const computeGuidedSystemSteps = (nextResult) => {
+            if (nextResult.ready.length > 0) {
+                return nextResult.ready.map((item) => item.id);
+            }
+            const inProgress = snapshot.backlog.items.find((item) => item.status === 'IN_PROGRESS');
+            if (inProgress) {
+                return [
+                    `${CLI_NAME} sdd context ${inProgress.id}`,
+                    `${CLI_NAME} archive ${inProgress.change_name || '<change-name>'}`,
+                    `${CLI_NAME} sdd finalize --ref ${inProgress.id}`,
+                    `${CLI_NAME} sdd next`,
+                ];
+            }
+            const openDebate = snapshot.discoveryIndex.records.find((record) => record.type === 'DEB' && record.status === 'OPEN');
+            if (openDebate) {
+                return [
+                    `${CLI_NAME} sdd decide ${openDebate.id} --outcome epic`,
+                    `${CLI_NAME} sdd breakdown EPIC-#### --mode graph --incremental`,
+                    `${CLI_NAME} sdd next`,
+                ];
+            }
+            const activeRadars = snapshot.discoveryIndex.records.filter((record) => (record.type === 'RAD' || record.type === 'EPIC') &&
+                ['READY', 'PLANNED', 'SPLIT', 'IN_PROGRESS'].includes(record.status));
+            const firstUnplannedRadar = activeRadars.find((radar) => !snapshot.backlog.items.some((item) => (item.origin_type === 'radar' || item.origin_type === 'epic') && item.origin_ref === radar.id));
+            if (firstUnplannedRadar) {
+                return [
+                    `${CLI_NAME} sdd breakdown ${firstUnplannedRadar.id} --mode graph --incremental`,
+                    `${CLI_NAME} sdd next`,
+                    `${CLI_NAME} sdd start FEAT-####`,
+                ];
+            }
+            const firstNewInsight = snapshot.discoveryIndex.records.find((record) => record.type === 'INS' && record.status === 'NEW');
+            if (firstNewInsight) {
+                return [
+                    `${CLI_NAME} sdd debate ${firstNewInsight.id}`,
+                    `${CLI_NAME} sdd decide DEB-#### --outcome epic`,
+                    `${CLI_NAME} sdd breakdown EPIC-#### --mode graph --incremental`,
+                    `${CLI_NAME} sdd next`,
+                ];
+            }
+            if (snapshot.discoveryIndex.records.length === 0) {
+                return [
+                    `${CLI_NAME} sdd insight "Descreva o primeiro objetivo do sistema"`,
+                    `${CLI_NAME} sdd debate INS-####`,
+                    `${CLI_NAME} sdd decide DEB-#### --outcome epic`,
+                    `${CLI_NAME} sdd breakdown EPIC-#### --mode graph --incremental`,
+                    `${CLI_NAME} sdd next`,
+                ];
+            }
+            return [
+                `${CLI_NAME} sdd insight "Novo ciclo de melhoria: descreva o objetivo"`,
+                `${CLI_NAME} sdd debate INS-####`,
+                `${CLI_NAME} sdd decide DEB-#### --outcome epic`,
+                `${CLI_NAME} sdd breakdown EPIC-#### --mode graph --incremental`,
+                `${CLI_NAME} sdd next`,
+            ];
+        };
+        if (normalized === 'system') {
+            const next = await new NextService(this.stores).execute(projectRoot, { rank: 'impact', limit: 5 });
+            const systemSkills = Array.from(new Set(next.ready.flatMap((item) => item.recommended_skills))).slice(0, 10);
+            const guidedSteps = computeGuidedSystemSteps(next);
+            const payload = {
+                target: 'system',
+                summary: 'Onboarding global do sistema',
+                read_order: baseReadOrder,
+                arquitetura_relevante: snapshot.architecture.nodes,
+                stack_relevante: snapshot.techStack.items,
+                servicos_afetados: snapshot.serviceCatalog.services,
+                contratos_afetados: snapshot.integrationContracts.contracts,
+                decisoes_frontend: snapshot.frontendDecisions?.items ?? [],
+                skills_bundles_recomendados: {
+                    skills: systemSkills,
+                    bundles: bundlesForSkills(snapshot.skillCatalog, systemSkills),
+                },
+                proximos_passos: guidedSteps,
+            };
+            if (options?.compact) {
+                return {
+                    target: payload.target,
+                    summary: payload.summary,
+                    read_order: payload.read_order,
+                    proximos_passos: payload.proximos_passos,
+                };
+            }
+            return payload;
+        }
+        if (/^RAD-\d{3,}$/.test(normalized)) {
+            const context = await contextCmd.execute(projectRoot, normalized);
+            const relatedFeatures = snapshot.backlog.items.filter((item) => item.origin_type === 'radar' && item.origin_ref === normalized);
+            const radarSkills = Array.from(new Set(relatedFeatures.flatMap((item) => item.recommended_skills))).slice(0, 10);
+            return {
+                target: normalized,
+                summary: `Onboarding da iniciativa ${normalized}`,
+                read_order: [
+                    ...baseReadOrder,
+                    planningDocRef(paths, 'backlog-graph.md'),
+                    ...(await Promise.all(relatedFeatures.map((item) => resolveActiveDocRefs(paths, item.id, config)))).flat(),
+                ],
+                sddo: context,
+                features_relacionadas: relatedFeatures.map((item) => ({
+                    id: item.id,
+                    status: item.status,
+                    title: item.title,
+                })),
+                skills_bundles_recomendados: {
+                    skills: radarSkills,
+                    bundles: bundlesForSkills(snapshot.skillCatalog, radarSkills),
+                },
+                proximos_passos: relatedFeatures
+                    .filter((item) => item.status === 'READY' || item.status === 'IN_PROGRESS')
+                    .map((item) => item.id),
+            };
+        }
+        if (/^FEAT-\d{3,}$/.test(normalized)) {
+            const context = await contextCmd.execute(projectRoot, normalized);
+            const contextSkills = context.recommended_skills;
+            const featSkills = contextSkills || [];
+            return {
+                target: normalized,
+                summary: `Onboarding de execucao ${normalized}`,
+                read_order: context.read_order || baseReadOrder,
+                sddo: context,
+                skills_bundles_recomendados: {
+                    skills: featSkills,
+                    bundles: bundlesForSkills(snapshot.skillCatalog, featSkills),
+                },
+                proximos_passos: [
+                    `${CLI_NAME} sdd start ${normalized}`,
+                    `${CLI_NAME} sdd context ${normalized}`,
+                    `${CLI_NAME} sdd finalize --ref ${normalized}`,
+                ],
+            };
+        }
+        throw new Error('Referencia invalida para onboard. Use system, RAD-### ou FEAT-###.');
+    }
+}
+//# sourceMappingURL=onboard.service.js.map