@devtrack-solution/codesdd 1.2.3 → 1.2.4

package/dist/core/sdd/foundation-layer-manifest.js

@@ -0,0 +1,117 @@
+export const CODESDD_FOUNDATION_LAYER_IDS = [
+    'domains',
+    'applications',
+    'infrastructures',
+    'presentations',
+    'shared',
+];
+export const CODESDD_FOUNDATION_LAYER_MANIFEST = [
+    {
+        layer: 'domains',
+        root: 'src/domains',
+        entrypoint: 'src/domains/sdd/index.ts',
+        legacy_roots: ['src/core/sdd/domain'],
+        role: 'Pure CodeSDD lifecycle, traceability, title, transition, and guardrail domain rules.',
+        migration_status: 'active-facade',
+    },
+    {
+        layer: 'applications',
+        root: 'src/applications',
+        entrypoint: 'src/applications/sdd/index.ts',
+        legacy_roots: ['src/core/sdd/services'],
+        role: 'Use-case and orchestration services for CodeSDD lifecycle and command workflows.',
+        migration_status: 'active-facade',
+    },
+    {
+        layer: 'infrastructures',
+        root: 'src/infrastructures',
+        entrypoint: 'src/infrastructures/sdd/index.ts',
+        legacy_roots: ['src/core/sdd/store', 'src/core/sdd/coordination'],
+        role: 'Filesystem, YAML state, Redis, cache, lock, queue, and event adapters.',
+        migration_status: 'active-facade',
+    },
+    {
+        layer: 'presentations',
+        root: 'src/presentations',
+        entrypoint: 'src/presentations/cli/sdd/index.ts',
+        legacy_roots: ['src/commands', 'src/cli'],
+        role: 'CLI and operator-facing command surfaces.',
+        migration_status: 'active-facade',
+    },
+    {
+        layer: 'shared',
+        root: 'src/shared',
+        entrypoint: 'src/shared/sdd/index.ts',
+        legacy_roots: ['src/core/sdd/types.ts', 'src/core/sdd/workspace-schemas.ts', 'src/core/shared'],
+        role: 'Shared contracts, schema documents, and reusable utility boundaries.',
+        migration_status: 'active-facade',
+    },
+];
+export function listCodesddFoundationLayerRoots(manifest = CODESDD_FOUNDATION_LAYER_MANIFEST) {
+    return manifest.map((entry) => entry.root);
+}
+export function validateCodesddFoundationLayerManifest(manifest = CODESDD_FOUNDATION_LAYER_MANIFEST) {
+    const findings = [];
+    const seenLayers = new Set();
+    const seenRoots = new Set();
+    for (const layer of CODESDD_FOUNDATION_LAYER_IDS) {
+        if (!manifest.some((entry) => entry.layer === layer)) {
+            findings.push({
+                code: 'FOUNDATION_LAYER_MISSING',
+                layer,
+                message: `Foundation-like layer ${layer} must be declared.`,
+            });
+        }
+    }
+    for (const entry of manifest) {
+        if (seenLayers.has(entry.layer)) {
+            findings.push({
+                code: 'FOUNDATION_LAYER_DUPLICATE',
+                layer: entry.layer,
+                message: `Foundation-like layer ${entry.layer} is declared more than once.`,
+            });
+        }
+        seenLayers.add(entry.layer);
+        if (seenRoots.has(entry.root)) {
+            findings.push({
+                code: 'FOUNDATION_LAYER_DUPLICATE',
+                layer: entry.layer,
+                path: entry.root,
+                message: `Foundation-like root ${entry.root} is declared more than once.`,
+            });
+        }
+        seenRoots.add(entry.root);
+        const expectedRoot = `src/${entry.layer}`;
+        if (entry.root !== expectedRoot) {
+            findings.push({
+                code: 'FOUNDATION_LAYER_ROOT_MISMATCH',
+                layer: entry.layer,
+                path: entry.root,
+                message: `Layer ${entry.layer} must use plural root ${expectedRoot}.`,
+            });
+        }
+        if (!entry.entrypoint.startsWith(`${entry.root}/`)) {
+            findings.push({
+                code: 'FOUNDATION_LAYER_ENTRYPOINT_MISMATCH',
+                layer: entry.layer,
+                path: entry.entrypoint,
+                message: `Layer ${entry.layer} entrypoint must live under ${entry.root}.`,
+            });
+        }
+        for (const legacyRoot of entry.legacy_roots) {
+            if (legacyRoot.includes('/.codesdd') || legacyRoot.startsWith('.codesdd')) {
+                findings.push({
+                    code: 'FOUNDATION_LAYER_FORBIDDEN_PROJECT_RUNTIME',
+                    layer: entry.layer,
+                    path: legacyRoot,
+                    message: 'Foundation-like layer mappings must not use project-local .codesdd runtime paths.',
+                });
+            }
+        }
+    }
+    return {
+        valid: findings.length === 0,
+        findings,
+    };
+}
+//# sourceMappingURL=foundation-layer-manifest.js.map

package/dist/core/sdd/governance-schemas.d.ts

@@ -91,10 +91,10 @@ export declare const debateFrontmatterSchema: z.ZodObject<{
         mediator: z.ZodObject<{
             choice: z.ZodString;
             rationale: z.ZodString;
-            accepted_risks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            accepted_risks: z.ZodDefault<z.ZodArray<z.ZodPreprocess<z.ZodObject<{
                 risk: z.ZodString;
                 mitigation: z.ZodString;
-            }, z.core.$strict>>>;
+            }, z.core.$strict>>>>;
             reversal_conditions: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>;
         output: z.ZodEnum<{

package/dist/core/sdd/governance-schemas.js

@@ -59,12 +59,21 @@ const debateScoringSchema = z
     scores: z.record(z.string().regex(/^[A-Z]$/), z.number()),
 })
     .strict();
-const debateAcceptedRiskSchema = z
+const DEFAULT_ACCEPTED_RISK_MITIGATION = 'Mitigation not provided by the source artifact; preserve this risk and require explicit mitigation before finalize.';
+const debateAcceptedRiskSchema = z.preprocess((value) => {
+    if (typeof value !== 'string')
+        return value;
+    const risk = value.trim();
+    return {
+        risk,
+        mitigation: DEFAULT_ACCEPTED_RISK_MITIGATION,
+    };
+}, z
     .object({
     risk: z.string().min(1),
     mitigation: z.string().min(1),
 })
-    .strict();
+    .strict());
 const debateDecisionSchema = z
     .object({
     question: z.string().min(1),

package/dist/core/sdd/intent-guard.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const sddIntentGuardInputSchema: z.ZodObject<{
+    request: z.ZodString;
+    featureRef: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const sddIntentGuardResultSchema: z.ZodObject<{
+    request: z.ZodString;
+    classification: z.ZodEnum<{
+        change_request: "change_request";
+        read_only: "read_only";
+        outside_codesdd: "outside_codesdd";
+    }>;
+    requires_codesdd_planning: z.ZodBoolean;
+    feature_ref: z.ZodOptional<z.ZodString>;
+    reason: z.ZodString;
+    required_commands: z.ZodArray<z.ZodString>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type SddIntentGuardInput = z.input<typeof sddIntentGuardInputSchema>;
+export type SddIntentGuardResult = z.infer<typeof sddIntentGuardResultSchema>;
+export declare function evaluateSddIntentGuard(input: SddIntentGuardInput): SddIntentGuardResult;
+//# sourceMappingURL=intent-guard.d.ts.map

package/dist/core/sdd/intent-guard.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { CLI_NAME } from '../branding.js';
+const FEATURE_REF_PATTERN = /^FEAT-\d{4}$/;
+const changeIntentPattern = /\b(add|alter|apply|build|change|code|commit|create|delete|edit|execute|fix|generate|implement|install|move|refactor|remove|rename|resolve|run|scaffold|update|write|ajust|altere|aplique|corrija|crie|edite|execute|faca|faça|gere|implemente|mova|remova|renomeie|resolva|rode|atualize)\b/i;
+const readOnlyPattern = /\b(read-only|readonly|no edit|no edits|sem editar|somente leitura|apenas leia|apenas leitura|explique|explique-me|analise|review|status|estado atual|listar|list|show|mostrar)\b/i;
+const outsideSddPattern = /\b(skip codesdd|sem codesdd|fora do codesdd|outside codesdd|do not use codesdd|nao use codesdd|não use codesdd)\b/i;
+export const sddIntentGuardInputSchema = z.object({
+    request: z.string().min(1),
+    featureRef: z.string().regex(FEATURE_REF_PATTERN).optional(),
+});
+export const sddIntentGuardResultSchema = z.object({
+    request: z.string(),
+    classification: z.enum(['change_request', 'read_only', 'outside_codesdd']),
+    requires_codesdd_planning: z.boolean(),
+    feature_ref: z.string().regex(FEATURE_REF_PATTERN).optional(),
+    reason: z.string(),
+    required_commands: z.array(z.string()),
+    warnings: z.array(z.string()),
+});
+export function evaluateSddIntentGuard(input) {
+    const parsed = sddIntentGuardInputSchema.parse(input);
+    const request = parsed.request.trim();
+    const explicitlyOutside = outsideSddPattern.test(request);
+    const readOnly = readOnlyPattern.test(request) && !changeIntentPattern.test(request);
+    const changeRequest = changeIntentPattern.test(request) && !explicitlyOutside;
+    if (explicitlyOutside) {
+        return sddIntentGuardResultSchema.parse({
+            request,
+            classification: 'outside_codesdd',
+            requires_codesdd_planning: false,
+            feature_ref: parsed.featureRef,
+            reason: 'The request explicitly opts out of CodeSDD handling.',
+            required_commands: [],
+            warnings: ['Only honor this opt-out when it does not conflict with repository governance policy.'],
+        });
+    }
+    if (!changeRequest || readOnly) {
+        return sddIntentGuardResultSchema.parse({
+            request,
+            classification: 'read_only',
+            requires_codesdd_planning: false,
+            feature_ref: parsed.featureRef,
+            reason: 'The request is read-only and does not imply implementation, edits, validation, execution, or finalize.',
+            required_commands: [],
+            warnings: [],
+        });
+    }
+    const featureCommand = parsed.featureRef
+        ? `${CLI_NAME} sdd context ${parsed.featureRef}`
+        : `${CLI_NAME} sdd context <FEAT-ID>`;
+    return sddIntentGuardResultSchema.parse({
+        request,
+        classification: 'change_request',
+        requires_codesdd_planning: true,
+        feature_ref: parsed.featureRef,
+        reason: 'The request implies implementation, edits, validation, execution, or finalize in an initialized CodeSDD repository.',
+        required_commands: [
+            `${CLI_NAME} sdd onboard system`,
+            `${CLI_NAME} sdd next`,
+            featureCommand,
+        ],
+        warnings: parsed.featureRef
+            ? []
+            : ['Bind this request to the active or ready FEAT returned by CodeSDD before coding.'],
+    });
+}
+//# sourceMappingURL=intent-guard.js.map

package/dist/core/sdd/json-schema.js

@@ -6,11 +6,15 @@ import { pluginArtifactManifestSchema, pluginDryRunExecutionPlanSchema, pluginRo
 import { pluginPolicyEvaluationSchema } from './plugin-policy.js';
 import { pluginPolicyPackEvaluationSchema, pluginPolicyPackSchema } from './plugin-policy-pack.js';
 import { pluginComplianceIndexSchema, pluginEvidenceManifestSchema, pluginValidationManifestSchema, } from './plugin-evidence.js';
+import { buildPluginSdkJsonSchemas } from './plugin-sdk-contract.js';
 import { pluginSkillBindingResolutionSchema, pluginSkillBindingSchema, } from './plugin-skill-binding.js';
 import { agentBindingAdapterSchema, agentBindingResolutionSchema, } from './agent-binding.js';
-import { parallelFeatAutomationPlanSchema, parallelFeatAutomationRequestSchema, } from './parallel-feat-automation.js';
+import { buildAgentRuntimeJsonSchemas } from './agent-runtime-contract.js';
+import { parallelFeatAutomationPlanSchema, parallelFeatAutomationRequestSchema, parallelFeatSchedulerRequestSchema, parallelFeatSchedulerResultSchema, } from './parallel-feat-automation.js';
 import { backlogProjectionPlanSchema, backlogProviderContractSchema, } from './backlog-provider-contract.js';
 import { qualityArchitectureSchema, qualityEvidenceBundleSchema, qualityRunSchema, qualityScenarioSchema, } from './quality-validation.js';
+import { reversaEvidenceBundleSchema } from './reversa-evidence.js';
+import { buildSdkAgentPluginQualityGateJsonSchemas } from './sdk-agent-plugin-quality-gates.js';
 import { deepagentDecisionEvidenceSchema, deepagentEnvContractSchema, deepagentQualityEvidenceSchema, deepagentRunEvidenceSchema, deepagentRunPlanSchema, deepagentRunRequestSchema, deepagentSubagentEvidenceSchema, deepagentToolCallEvidenceSchema, } from './deepagent-contracts.js';
 import { adrFrontmatterSchema, debateFrontmatterSchema, discardedFrontmatterSchema, epicFrontmatterSchema, insightFrontmatterSchema, } from './governance-schemas.js';
 const JSON_SCHEMA_DRAFT = 'https://json-schema.org/draft/2020-12/schema';
@@ -70,6 +74,7 @@ export function buildWorkspaceJsonSchemaCatalog() {
         plugin_manifests: {
             'codesdd-plugin.yaml': buildPluginManifestJsonSchema(),
         },
+        plugin_sdk_contracts: buildPluginSdkJsonSchemas(),
         plugin_registries: {
             'plugin-registry.yaml': normalizeJsonSchemaDocument(toJSONSchema(pluginRegistryStateSchema), 'CodeSDD Plugin Registry State', 'Machine-readable state contract for registered CodeSDD enterprise plugins.'),
         },
@@ -115,9 +120,12 @@ export function buildWorkspaceJsonSchemaCatalog() {
         agent_binding_resolutions: {
             'agent-binding-resolution.yaml': normalizeJsonSchemaDocument(toJSONSchema(agentBindingResolutionSchema), 'CodeSDD Agent Binding Resolution', 'Machine-readable resolution result for selecting a compatible coding-agent adapter for a FEAT task.'),
         },
+        agent_runtime_contracts: buildAgentRuntimeJsonSchemas(),
         parallel_feat_automation: {
             'parallel-feat-automation-request.yaml': normalizeJsonSchemaDocument(toJSONSchema(parallelFeatAutomationRequestSchema), 'CodeSDD Parallel FEAT Automation Request', 'Machine-readable input contract for planning safe parallel FEAT execution waves.'),
             'parallel-feat-automation-plan.yaml': normalizeJsonSchemaDocument(toJSONSchema(parallelFeatAutomationPlanSchema), 'CodeSDD Parallel FEAT Automation Plan', 'Machine-readable execution plan for safe parallel FEAT waves, quality gates, and commit boundaries.'),
+            'parallel-feat-scheduler-request.yaml': normalizeJsonSchemaDocument(toJSONSchema(parallelFeatSchedulerRequestSchema), 'CodeSDD Parallel FEAT Scheduler Request', 'Machine-readable input contract for dependency-aware chained FEAT wave scheduling.'),
+            'parallel-feat-scheduler-result.yaml': normalizeJsonSchemaDocument(toJSONSchema(parallelFeatSchedulerResultSchema), 'CodeSDD Parallel FEAT Scheduler Result', 'Machine-readable scheduler result linking chained FEAT waves, blocked dependencies, and the execution plan.'),
         },
         backlog_integrations: {
             'backlog-provider-contract.yaml': normalizeJsonSchemaDocument(toJSONSchema(backlogProviderContractSchema), 'CodeSDD Backlog Provider Contract', 'Machine-readable provider contract for projecting canonical CodeSDD backlog state to external planning tools.'),
@@ -128,6 +136,10 @@ export function buildWorkspaceJsonSchemaCatalog() {
             'quality-run.yaml': normalizeJsonSchemaDocument(toJSONSchema(qualityRunSchema), 'CodeSDD Quality Run', 'Machine-readable execution record for a CodeSDD quality validation scenario.'),
             'quality-architecture-schema.yaml': normalizeJsonSchemaDocument(toJSONSchema(qualityArchitectureSchema), 'CodeSDD Quality Architecture Schema', 'Machine-readable architecture gateway contract for generated product validation.'),
             'quality-evidence-bundle.yaml': normalizeJsonSchemaDocument(toJSONSchema(qualityEvidenceBundleSchema), 'CodeSDD Quality Evidence Bundle', 'Machine-readable evidence bundle contract tying scenario, run, artifacts, checksums, findings, and exceptions together.'),
+            ...buildSdkAgentPluginQualityGateJsonSchemas(),
+        },
+        reversa_contracts: {
+            'reversa-evidence-bundle.yaml': normalizeJsonSchemaDocument(toJSONSchema(reversaEvidenceBundleSchema), 'CodeSDD Reversa Evidence Bundle', 'Machine-readable evidence bundle contract for Reversa intake, extraction, generation, migration, reconstruction, and equivalence phases.'),
         },
         deepagent_execution: {
             'deepagent-run-request.yaml': normalizeJsonSchemaDocument(toJSONSchema(deepagentRunRequestSchema), 'CodeSDD DeepAgent Run Request', 'Machine-readable request contract for governed DeepAgents execution with scoped tools, write policy, env contract, and expected evidence.'),

package/dist/core/sdd/legacy-operations.js

@@ -136,16 +136,19 @@ Decide ____ instead of ____ to solve ____.
 
 ## 3) Options Considered (Minimum 2)
 ### Option A
+- Status (selected/discarded):
 - Proposal:
 - Pros:
 - Cons:
 
 ### Option B
+- Status (selected/discarded):
 - Proposal:
 - Pros:
 - Cons:
 
 ### Option C (Optional)
+- Status (selected/discarded):
 - Proposal:
 - Pros:
 - Cons:
@@ -194,7 +197,15 @@ Decide ____ instead of ____ to solve ____.
 - APPROVED -> EPIC-####
 - DISCARDED -> Record in discarded
 
-## Metadata
+## 10) Planning Completeness Gate (Required before promotion)
+- Measurable acceptance:
+- Non-scope:
+- Definition of Done:
+- Validation commands:
+  -
+- Residual risk:
+
+## 11) Metadata
 - Source insight: ${insight.id}
 - Insight title: ${insight.title}
 - Created at: ${insight.created_at || now}
@@ -745,19 +756,92 @@ export async function findDebateFile(paths, debateId) {
         return null;
     return path.join(debateDir, found.name);
 }
+const GENERIC_DECISION_QUESTION_PATTERNS = [
+    /^decide\s+____\s+instead\s+of\s+____\s+to\s+solve\s+____\.?$/i,
+    /^decidir\s+____\s+em\s+vez\s+de\s+____\s+para\s+resolver\s+____\.?$/i,
+    /which option should we choose\??$/i,
+    /qual opcao devemos escolher\??$/i,
+    /decide between option [a-z] and option [a-z]\.?$/i,
+    /decidir entre opcao [a-z] e opcao [a-z]\.?$/i,
+];
+function isPlaceholderLike(value) {
+    const normalized = value.trim().toLowerCase();
+    if (!normalized)
+        return true;
+    const placeholderTokens = ['____', '(fill in', '(preencher', 'todo', 'tbd', 'n/a'];
+    return placeholderTokens.some((token) => normalized.includes(token));
+}
+function isGenericDecisionQuestion(question) {
+    const normalized = question.trim().replace(/\s+/g, ' ').toLowerCase();
+    if (normalized.length < 30)
+        return true;
+    return GENERIC_DECISION_QUESTION_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function extractNamedListValue(content, labels) {
+    const escaped = labels.map((label) => label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
+    const match = content.match(new RegExp(`-\\s*(?:${escaped}):\\s*(.+)`, 'i'));
+    if (!match)
+        return '';
+    return match[1].trim();
+}
+function hasValidationCommand(content) {
+    const sectionMatch = content.match(/-\s*Validation commands:\s*([\s\S]*?)(?=\n-\s*Residual risk:|\n##\s+\d+\)|$)/i);
+    if (!sectionMatch)
+        return false;
+    const lines = sectionMatch[1]
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('-'))
+        .map((line) => line.replace(/^-\s*/, '').replace(/`/g, '').trim())
+        .filter((line) => line.length > 0);
+    if (lines.length === 0)
+        return false;
+    return lines.some((line) => line.includes('pnpm') || line.includes('npm') || line.includes('vitest'));
+}
+function collectPlanningGateMissing(content, selectedOption, optionIds) {
+    const missing = [];
+    const nonSelectedOptionIds = optionIds.filter((optionId) => optionId !== selectedOption);
+    if (nonSelectedOptionIds.length === 0) {
+        missing.push('Provide at least one discarded alternative option different from mediator choice');
+    }
+    const measurableAcceptance = extractNamedListValue(content, ['Measurable acceptance']);
+    if (isPlaceholderLike(measurableAcceptance) || !/\d|%|<=|>=|\bwithin\b|\bunder\b|\bmax\b/i.test(measurableAcceptance)) {
+        missing.push('Define measurable acceptance criteria in the planning completeness gate');
+    }
+    const nonScope = extractNamedListValue(content, ['Non-scope', 'Nao-escopo']);
+    if (isPlaceholderLike(nonScope)) {
+        missing.push('Document non-scope in the planning completeness gate');
+    }
+    const definitionOfDone = extractNamedListValue(content, ['Definition of Done', 'DoD']);
+    if (isPlaceholderLike(definitionOfDone)) {
+        missing.push('Document Definition of Done (DoD) in the planning completeness gate');
+    }
+    if (!hasValidationCommand(content)) {
+        missing.push('Document executable validation commands in the planning completeness gate');
+    }
+    const residualRisk = extractNamedListValue(content, ['Residual risk', 'Risco residual']);
+    if (isPlaceholderLike(residualRisk)) {
+        missing.push('Document residual risk in the planning completeness gate');
+    }
+    return missing;
+}
 export function validateDebateDocument(content) {
     try {
         const parsed = parseGovernanceFile('inline-content', content, debateFrontmatterSchema);
         if (parsed.hasFrontmatter && parsed.frontmatter) {
             const missing = [];
             const question = parsed.frontmatter.decision.question.trim().toLowerCase();
-            if (!question || question.includes('____')) {
+            if (isGenericDecisionQuestion(question) || question.includes('____')) {
                 missing.push('Fill the decision question with real context');
             }
+            if (parsed.frontmatter.decision.options.length < 2) {
+                missing.push('Provide at least two options in the decision matrix');
+            }
             const rationale = parsed.frontmatter.decision.mediator.rationale.trim().toLowerCase();
             if (!rationale || rationale.includes('____') || rationale.includes('(fill in') || rationale.includes('(preencher')) {
                 missing.push('Inform the mediator decision rationale');
             }
+            missing.push(...collectPlanningGateMissing(parsed.body, parsed.frontmatter.decision.mediator.choice.trim().toUpperCase(), parsed.frontmatter.decision.options.map((option) => option.id.trim().toUpperCase())));
             if (/\- Unit coverage:\s*$/m.test(parsed.body)) {
                 missing.push('Inform required unit coverage evidence in the quality contract');
             }
@@ -770,7 +854,7 @@ export function validateDebateDocument(content) {
             if (/\- Exceptions:\s*\n\s+- None, or formal exception/m.test(parsed.body)) {
                 missing.push('Confirm there is no quality exception or document the formal exception');
             }
-            return missing;
+            return Array.from(new Set(missing));
         }
     }
     catch (error) {
@@ -782,6 +866,11 @@ export function validateDebateDocument(content) {
         content.includes('Decide ____ instead of ____ to solve ____.')) {
         missing.push('Fill the decision question with real context');
     }
+    const selectedChoice = content.match(/-\s+(?:Escolha|Choice)(?:\s+\(A\/B\/C\))?:\s*(?:op(?:c|ç)[aã]o\s*)?([ABC])\b/i)?.[1] ||
+        content.match(/-\s+Op(?:c|ç)[aã]o\s+escolhida:\s*([ABC])\b/i)?.[1] ||
+        'A';
+    const optionIds = Array.from(content.matchAll(/###\s+Option\s+([A-Z])/gi)).map((match) => match[1]);
+    missing.push(...collectPlanningGateMissing(content, selectedChoice.toUpperCase(), optionIds));
     if (/\- (?:Escolha|Choice) \(A\/B\/C\):\s*$/m.test(content)) {
         missing.push('Inform the mediator choice in "Choice (A/B/C)"');
     }
@@ -800,7 +889,7 @@ export function validateDebateDocument(content) {
     if (/\- Exceptions:\s*\n\s+- None, or formal exception/m.test(content)) {
         missing.push('Confirm there is no quality exception or document the formal exception');
     }
-    return missing;
+    return Array.from(new Set(missing));
 }
 export function pickTopSkills(catalogSkills, ids, max = 3) {
     if (!ids || ids.length === 0)
@@ -1028,6 +1117,74 @@ export function buildActivePlanDoc(feature, recommendedBundles) {
     const baseDocument = {
         schema_version: 1,
         feature_id: feature.id,
+        governance: {
+            state_boundary: 'codesdd-canonical-sdd-state',
+            planning_artifacts: [
+                '.sdd/state/backlog.yaml',
+                `.sdd/${feature.status === 'IN_PROGRESS' ? 'active' : 'planned'}/${feature.id}/1-spec.yaml`,
+                `.sdd/${feature.status === 'IN_PROGRESS' ? 'active' : 'planned'}/${feature.id}/2-plan.yaml`,
+                `.sdd/${feature.status === 'IN_PROGRESS' ? 'active' : 'planned'}/${feature.id}/5-quality.yaml`,
+            ],
+            decision_refs: Array.from(new Set([feature.origin_ref, ...feature.acceptance_refs].filter(Boolean))),
+            planned_state_writes: [
+                '.sdd/state/backlog.yaml',
+                '.sdd/state/transition-log.yaml',
+            ],
+            rollback_plan: 'If validation fails, revert only the scoped feature workspace/state entries and regenerate CodeSDD views from canonical state.',
+            validation_gates: [
+                {
+                    name: 'SDD diagnose',
+                    command: `${CLI_NAME} sdd diagnose`,
+                    expected: 'Structural CodeSDD health has no blockers or errors.',
+                },
+                {
+                    name: 'SDD check render',
+                    command: `${CLI_NAME} sdd check --render`,
+                    expected: 'Canonical state validates and generated views are synchronized.',
+                },
+            ],
+        },
+        execution_plan: {
+            mode: 'single-feature',
+            state_boundary_ref: 'codesdd-canonical-sdd-state',
+            command_sequence: [
+                {
+                    name: 'Load CodeSDD context',
+                    command: `${CLI_NAME} sdd context ${feature.id}`,
+                    writes_state: false,
+                    expected_state_writes: [],
+                },
+                {
+                    name: 'Declare frontend impact',
+                    command: `${CLI_NAME} sdd frontend-impact ${feature.id} --status required|none --reason "..."`,
+                    writes_state: true,
+                    expected_state_writes: ['.sdd/state/backlog.yaml', '.sdd/state/transition-log.yaml'],
+                },
+                {
+                    name: 'Finalize feature',
+                    command: `${CLI_NAME} sdd finalize --ref ${feature.id}`,
+                    writes_state: true,
+                    expected_state_writes: [
+                        '.sdd/state/backlog.yaml',
+                        '.sdd/state/finalize-queue.yaml',
+                        '.sdd/state/transition-log.yaml',
+                        `.sdd/archived/${feature.id}/`,
+                    ],
+                },
+            ],
+            allowed_state_writes: [
+                `.sdd/active/${feature.id}/`,
+                `.sdd/archived/${feature.id}/`,
+                '.sdd/state/backlog.yaml',
+                '.sdd/state/finalize-queue.yaml',
+                '.sdd/state/transition-log.yaml',
+            ],
+            forbidden_state_writes: ['.codesdd/**', 'external-context/**'],
+            handoff_artifacts: [
+                `.sdd/active/${feature.id}/5-quality.yaml`,
+                `.sdd/archived/${feature.id}/`,
+            ],
+        },
         architectural_impact: {
             description: `Touches ${feature.touches.join(', ') || 'the active SDD workspace'} with lock domains ${feature.lock_domains.join(', ') || 'none declared'}.`,
             affected_modules: feature.touches,
@@ -1136,6 +1293,11 @@ export function buildActiveQualityDoc(feature) {
             },
             requirements: [],
         },
+        runtime_quality_gates: {
+            mode: 'observe',
+            performance: [],
+            flakiness: [],
+        },
         q95_ledger: {
             threshold: 95,
             score: 0,
@@ -2016,7 +2178,9 @@ export function inferOriginType(input) {
     return 'direct';
 }
 export async function buildFinalizeQueue(paths, backlogItems, queueItems) {
-    const queueByFeature = new Map(queueItems.map((item) => [item.feature_id, item]));
+    const queueByFeature = new Map(queueItems
+        .filter((item) => item.status === 'PENDING')
+        .map((item) => [item.feature_id, item]));
     const archiveRoot = resolveLegacySpecSubpath(paths.projectRoot, 'changes', 'archive');
     for (const item of backlogItems) {
         if (!item.change_name)

package/dist/core/sdd/migrate-workspace.js

@@ -198,6 +198,35 @@ function migratePlan(featureId, parsed) {
     const doc = {
         schema_version: 1,
         feature_id: featureId,
+        governance: {
+            state_boundary: 'codesdd-canonical-sdd-state',
+            planning_artifacts: [`.sdd/active/${featureId}/2-plan.yaml`],
+            decision_refs: [featureId],
+            planned_state_writes: [],
+            rollback_plan: 'Review the migrated workspace plan and revert only the scoped migration files if validation fails.',
+            validation_gates: [
+                {
+                    name: 'Workspace schema validation',
+                    command: `codesdd sdd migrate-workspace --feat ${featureId}`,
+                    expected: 'Migrated plan document validates against the canonical workspace schema.',
+                },
+            ],
+        },
+        execution_plan: {
+            mode: 'single-feature',
+            state_boundary_ref: 'codesdd-canonical-sdd-state',
+            command_sequence: [
+                {
+                    name: 'Validate migrated workspace',
+                    command: `codesdd sdd migrate-workspace --feat ${featureId}`,
+                    writes_state: true,
+                    expected_state_writes: [`.sdd/active/${featureId}/2-plan.yaml`],
+                },
+            ],
+            allowed_state_writes: [`.sdd/active/${featureId}/`],
+            forbidden_state_writes: ['.codesdd/**', 'external-context/**'],
+            handoff_artifacts: [`.sdd/active/${featureId}/5-quality.yaml`],
+        },
         architectural_impact: {
             description: ensureText(featureId, 'architectural_impact.description', section(parsed, ['architectural impact', 'impacto arquitetural', 'plan', 'plano']), 1, missing),
             affected_modules: affected,
@@ -304,6 +333,16 @@ function migrateQuality(featureId, parsed) {
             },
             requirements: [],
         },
+        token_budget_gates: {
+            require_numeric_efficiency: true,
+            fail_below_percent: 95,
+            telemetry: [],
+        },
+        runtime_quality_gates: {
+            mode: 'observe',
+            performance: [],
+            flakiness: [],
+        },
         q95_ledger: {
             threshold: 95,
             score: 0,

package/dist/core/sdd/package-security-gates.d.ts

@@ -0,0 +1,21 @@
+export interface PackageSecurityIssue {
+    code: string;
+    path: string;
+    message: string;
+}
+export interface PackageSecurityGateReport {
+    status: 'pass' | 'fail';
+    package_allowlist: {
+        status: 'pass' | 'fail';
+        allowed_files: string[];
+        issues: PackageSecurityIssue[];
+    };
+    secret_scan: {
+        status: 'pass' | 'fail';
+        scanned_files: number;
+        issues: PackageSecurityIssue[];
+    };
+}
+export declare function evaluatePackageSecurityGates(projectRoot: string): Promise<PackageSecurityGateReport>;
+export declare function evaluatePackageFileAllowlist(files: string[]): PackageSecurityIssue[];
+//# sourceMappingURL=package-security-gates.d.ts.map