@devtrack-solution/codesdd 1.2.3 → 1.2.4-rc3

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

@@ -20,6 +20,65 @@ export const workspacePolicyInjectionSchema = z.object({
     generated_from: z.literal('recommended_skills'),
     required_policies: z.array(workspacePolicyRequirementSchema).default([]),
 });
+const workspacePercentSchema = z.number().min(0).max(100);
+export const workspaceValidationGateSchema = z.object({
+    name: z.string().min(1),
+    command: z.string().min(1),
+    expected: z.string().min(1),
+});
+export const workspaceExecutionStepSchema = z.object({
+    name: z.string().min(1),
+    command: z.string().min(1),
+    writes_state: z.boolean().default(false),
+    expected_state_writes: z.array(z.string().min(1)).default([]),
+});
+export const workspacePlanExecutionSchema = z
+    .object({
+    mode: z.enum(['single-feature', 'parallel-wave', 'chained-features']).default('single-feature'),
+    state_boundary_ref: z.literal('codesdd-canonical-sdd-state').default('codesdd-canonical-sdd-state'),
+    command_sequence: z.array(workspaceExecutionStepSchema).min(1),
+    allowed_state_writes: z.array(z.string().min(1)).default([]),
+    forbidden_state_writes: z.array(z.string().min(1)).default(['.codesdd/**', 'external-context/**']),
+    handoff_artifacts: z.array(z.string().min(1)).default([]),
+})
+    .default({
+    mode: 'single-feature',
+    state_boundary_ref: 'codesdd-canonical-sdd-state',
+    command_sequence: [
+        {
+            name: 'SDD check',
+            command: 'codesdd sdd check --render',
+            writes_state: false,
+            expected_state_writes: [],
+        },
+    ],
+    allowed_state_writes: [],
+    forbidden_state_writes: ['.codesdd/**', 'external-context/**'],
+    handoff_artifacts: [],
+});
+export const workspacePlanGovernanceSchema = z
+    .object({
+    state_boundary: z.literal('codesdd-canonical-sdd-state').default('codesdd-canonical-sdd-state'),
+    planning_artifacts: z.array(z.string().min(1)).min(1),
+    decision_refs: z.array(z.string().min(1)).default([]),
+    planned_state_writes: z.array(z.string().min(1)).default([]),
+    rollback_plan: z.string().min(20),
+    validation_gates: z.array(workspaceValidationGateSchema).min(1),
+})
+    .default({
+    state_boundary: 'codesdd-canonical-sdd-state',
+    planning_artifacts: ['.sdd/state/backlog.yaml'],
+    decision_refs: [],
+    planned_state_writes: [],
+    rollback_plan: 'Review and revert only the scoped CodeSDD feature workspace and state changes if validation fails.',
+    validation_gates: [
+        {
+            name: 'SDD check',
+            command: 'codesdd sdd check --render',
+            expected: 'CodeSDD state and generated views remain valid.',
+        },
+    ],
+});
 export const workspaceSpecSchema = z.object({
     schema_version: z.literal(1),
     feature_id: workspaceFeatureIdSchema,
@@ -52,6 +111,8 @@ export const workspaceSpecSchema = z.object({
 export const workspacePlanSchema = z.object({
     schema_version: z.literal(1),
     feature_id: workspaceFeatureIdSchema,
+    governance: workspacePlanGovernanceSchema,
+    execution_plan: workspacePlanExecutionSchema,
     architectural_impact: z.object({
         description: z.string(),
         affected_modules: z.array(z.string()),
@@ -65,8 +126,8 @@ export const workspacePlanSchema = z.object({
         change_type: z.string(),
     })),
     quality_strategy: z.object({
-        unit_target: z.number(),
-        integration_target: z.number(),
+        unit_target: workspacePercentSchema,
+        integration_target: workspacePercentSchema,
         approach: z.string(),
     }),
     suggested_skills: z.array(z.string()),
@@ -156,13 +217,132 @@ export const workspaceTraceabilitySchema = z.object({
     }),
     requirements: z.array(workspaceTraceabilityRequirementSchema).default([]),
 });
+export const workspaceQualityLedgerAxisSchema = z.object({
+    raw_score: workspacePercentSchema,
+    weighted_score: workspacePercentSchema,
+    rationale: z.string().min(1),
+});
+export const workspaceQualityLedgerWeightsSchema = z
+    .object({
+    coverage: workspacePercentSchema.default(30),
+    traceability: workspacePercentSchema.default(20),
+    integrity: workspacePercentSchema.default(20),
+    naming: workspacePercentSchema.default(10),
+    token: workspacePercentSchema.default(20),
+})
+    .superRefine((weights, ctx) => {
+    const total = weights.coverage + weights.traceability + weights.integrity + weights.naming + weights.token;
+    if (total !== 100) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `q95_ledger.weights must total 100, got ${total}.`,
+        });
+    }
+});
+export const workspaceQualityLedgerSchema = z
+    .object({
+    threshold: workspacePercentSchema.default(95),
+    score: workspacePercentSchema.default(0),
+    status: z.enum(['pass', 'fail', 'pending']).default('pending'),
+    computed_at: z.string().default(''),
+    weights: workspaceQualityLedgerWeightsSchema.default({
+        coverage: 30,
+        traceability: 20,
+        integrity: 20,
+        naming: 10,
+        token: 20,
+    }),
+    axes: z
+        .object({
+        coverage: workspaceQualityLedgerAxisSchema,
+        traceability: workspaceQualityLedgerAxisSchema,
+        integrity: workspaceQualityLedgerAxisSchema,
+        naming: workspaceQualityLedgerAxisSchema,
+        token: workspaceQualityLedgerAxisSchema,
+    })
+        .default({
+        coverage: {
+            raw_score: 0,
+            weighted_score: 0,
+            rationale: 'Computed during finalize.'
+        },
+        traceability: {
+            raw_score: 0,
+            weighted_score: 0,
+            rationale: 'Computed during finalize.'
+        },
+        integrity: {
+            raw_score: 0,
+            weighted_score: 0,
+            rationale: 'Computed during finalize.'
+        },
+        naming: {
+            raw_score: 0,
+            weighted_score: 0,
+            rationale: 'Computed during finalize.'
+        },
+        token: {
+            raw_score: 0,
+            weighted_score: 0,
+            rationale: 'Computed during finalize.'
+        },
+    }),
+    next_best_action: z.string().default('Record missing evidence to raise the lowest weighted axis.'),
+})
+    .superRefine((ledger, ctx) => {
+    if (ledger.status === 'pass' && ledger.score < ledger.threshold) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['status'],
+            message: 'q95_ledger.status cannot be pass when score is below threshold.',
+        });
+    }
+});
+export const workspaceTokenTelemetrySchema = z.object({
+    mode: z.enum(['compact', 'standard', 'full']).optional(),
+    budget_chars: z.number().int().positive().optional(),
+    actual_chars: z.number().int().nonnegative().optional(),
+    efficiency_percent: workspacePercentSchema.optional(),
+    gate: z.enum(['pass', 'warn', 'fail']).default('pass'),
+    evidence_ref: z.string().min(1).optional(),
+    notes: z.string().optional(),
+});
+export const workspaceTokenBudgetGatesSchema = z.object({
+    max_context_chars: z.number().int().positive().optional(),
+    require_numeric_efficiency: z.boolean().default(true),
+    fail_below_percent: workspacePercentSchema.default(95),
+    telemetry: z.array(workspaceTokenTelemetrySchema).default([]),
+});
+export const workspaceRuntimePerformanceTelemetrySchema = z.object({
+    command: z.string().min(1),
+    metric: z.enum(['duration_ms', 'p95_ms', 'memory_mb', 'cpu_percent']).default('duration_ms'),
+    threshold: z.number().nonnegative().optional(),
+    actual: z.number().nonnegative().optional(),
+    gate: z.enum(['pass', 'warn', 'fail']).default('pass'),
+    evidence_ref: z.string().min(1).optional(),
+    notes: z.string().optional(),
+});
+export const workspaceFlakinessTelemetrySchema = z.object({
+    command: z.string().min(1),
+    attempts: z.number().int().positive().optional(),
+    failures: z.number().int().nonnegative().optional(),
+    failure_rate_percent: workspacePercentSchema.optional(),
+    gate: z.enum(['pass', 'warn', 'fail']).default('pass'),
+    evidence_ref: z.string().min(1).optional(),
+    notes: z.string().optional(),
+});
+export const workspaceRuntimeQualityGatesSchema = z.object({
+    mode: z.enum(['observe', 'enforce']).default('observe'),
+    performance: z.array(workspaceRuntimePerformanceTelemetrySchema).default([]),
+    flakiness: z.array(workspaceFlakinessTelemetrySchema).default([]),
+});
 export const workspaceQualitySchema = z.object({
     schema_version: z.literal(1),
     feature_id: workspaceFeatureIdSchema,
     coverage_targets: z.object({
-        unit: z.number(),
-        integration: z.number(),
-        modules: z.record(z.string(), z.number()).optional(),
+        unit: workspacePercentSchema,
+        integration: workspacePercentSchema,
+        modules: z.record(z.string(), workspacePercentSchema).optional(),
     }),
     validation_strategies: z.array(z.object({
         name: z.string(),
@@ -234,65 +414,17 @@ export const workspaceQualitySchema = z.object({
         notes: z.string().optional(),
     })
         .optional(),
-    q95_ledger: z
-        .object({
-        threshold: z.number().default(95),
-        score: z.number().default(0),
-        status: z.enum(['pass', 'fail', 'pending']).default('pending'),
-        computed_at: z.string().default(''),
-        weights: z
-            .object({
-            coverage: z.number().default(30),
-            traceability: z.number().default(20),
-            integrity: z.number().default(20),
-            naming: z.number().default(10),
-            token: z.number().default(20),
-        })
-            .default({
-            coverage: 30,
-            traceability: 20,
-            integrity: 20,
-            naming: 10,
-            token: 20,
-        }),
-        axes: z
-            .object({
-            coverage: z.object({ raw_score: z.number(), weighted_score: z.number(), rationale: z.string() }),
-            traceability: z.object({ raw_score: z.number(), weighted_score: z.number(), rationale: z.string() }),
-            integrity: z.object({ raw_score: z.number(), weighted_score: z.number(), rationale: z.string() }),
-            naming: z.object({ raw_score: z.number(), weighted_score: z.number(), rationale: z.string() }),
-            token: z.object({ raw_score: z.number(), weighted_score: z.number(), rationale: z.string() }),
-        })
-            .default({
-            coverage: {
-                raw_score: 0,
-                weighted_score: 0,
-                rationale: 'Computed during finalize.'
-            },
-            traceability: {
-                raw_score: 0,
-                weighted_score: 0,
-                rationale: 'Computed during finalize.'
-            },
-            integrity: {
-                raw_score: 0,
-                weighted_score: 0,
-                rationale: 'Computed during finalize.'
-            },
-            naming: {
-                raw_score: 0,
-                weighted_score: 0,
-                rationale: 'Computed during finalize.'
-            },
-            token: {
-                raw_score: 0,
-                weighted_score: 0,
-                rationale: 'Computed during finalize.'
-            },
-        }),
-        next_best_action: z.string().default('Record missing evidence to raise the lowest weighted axis.'),
-    })
-        .default({
+    token_budget_gates: workspaceTokenBudgetGatesSchema.default({
+        require_numeric_efficiency: true,
+        fail_below_percent: 95,
+        telemetry: [],
+    }),
+    runtime_quality_gates: workspaceRuntimeQualityGatesSchema.default({
+        mode: 'observe',
+        performance: [],
+        flakiness: [],
+    }),
+    q95_ledger: workspaceQualityLedgerSchema.default({
         threshold: 95,
         score: 0,
         status: 'pending',

package/dist/domains/sdd/index.d.ts

@@ -0,0 +1,6 @@
+export { buildFeatureTitle, computeCanonicalTitle, markdownInsightTemplate, slugify, stripFunctionalTitlePrefixes, } from '../../core/sdd/domain/helpers.js';
+export { evaluateFeatureFinalizeGuardrails, evaluateFeatureStartGuardrails, type FeatureFinalizeGuardrails, type FeatureStartGuardrails, type LifecycleDependencyCheck, type LifecycleLockCheck, } from '../../core/sdd/domain/lifecycle-guardrails.js';
+export { clearLifecycleHooks, registerLifecycleHook, runLifecycleHooks, unregisterLifecycleHook, type LifecycleHook, type LifecycleHookContext, type LifecycleHookEvent, } from '../../core/sdd/domain/lifecycle-hooks.js';
+export { TransitionEngine, type EntityStatus } from '../../core/sdd/domain/transition-engine.js';
+export { evaluateWorkspaceTraceability } from '../../core/sdd/domain/traceability.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/domains/sdd/index.js

@@ -0,0 +1,6 @@
+export { buildFeatureTitle, computeCanonicalTitle, markdownInsightTemplate, slugify, stripFunctionalTitlePrefixes, } from '../../core/sdd/domain/helpers.js';
+export { evaluateFeatureFinalizeGuardrails, evaluateFeatureStartGuardrails, } from '../../core/sdd/domain/lifecycle-guardrails.js';
+export { clearLifecycleHooks, registerLifecycleHook, runLifecycleHooks, unregisterLifecycleHook, } from '../../core/sdd/domain/lifecycle-hooks.js';
+export { TransitionEngine } from '../../core/sdd/domain/transition-engine.js';
+export { evaluateWorkspaceTraceability } from '../../core/sdd/domain/traceability.js';
+//# sourceMappingURL=index.js.map

package/dist/infrastructures/sdd/index.d.ts

@@ -0,0 +1,7 @@
+export { FileSystemLockAdapter, InMemoryCoordinationCache, InMemoryCoordinationEventBus, InMemoryCoordinationQueue, MultiTierCoordinationCache, createFilesystemFirstCoordinationAdapters, type CoordinationCacheAdapter, type CoordinationEvent, type CoordinationEventBusAdapter, type CoordinationLockAdapter, type CoordinationQueueAdapter, type SddCoordinationAdapters, } from '../../core/sdd/coordination/coordination-adapters.js';
+export { RedisClientFactory, RedisCoordinationCache, RedisEventBusAdapter, RedisLockAdapter, RedisQueueAdapter, RedisWorkDeduper, buildRedisKey, hashRedisKey, redactRedisUrl, resolveRedisBoundaryConfig, resolveRedisRuntimeConfig, sanitizeRedisError, type RedisOperationalReport, type RedisRuntimeConfig, type RedisRuntimeStatus, } from '../../core/sdd/coordination/redis-runtime.js';
+export { InMemoryAdapter } from '../../core/sdd/store/in-memory-adapter.js';
+export { YamlFileAdapter } from '../../core/sdd/store/yaml-file-adapter.js';
+export { createInMemorySddStores, createSddStores, type SddStores } from '../../core/sdd/store/sdd-stores.js';
+export type { StateStore } from '../../core/sdd/store/state-store.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/infrastructures/sdd/index.js

@@ -0,0 +1,6 @@
+export { FileSystemLockAdapter, InMemoryCoordinationCache, InMemoryCoordinationEventBus, InMemoryCoordinationQueue, MultiTierCoordinationCache, createFilesystemFirstCoordinationAdapters, } from '../../core/sdd/coordination/coordination-adapters.js';
+export { RedisClientFactory, RedisCoordinationCache, RedisEventBusAdapter, RedisLockAdapter, RedisQueueAdapter, RedisWorkDeduper, buildRedisKey, hashRedisKey, redactRedisUrl, resolveRedisBoundaryConfig, resolveRedisRuntimeConfig, sanitizeRedisError, } from '../../core/sdd/coordination/redis-runtime.js';
+export { InMemoryAdapter } from '../../core/sdd/store/in-memory-adapter.js';
+export { YamlFileAdapter } from '../../core/sdd/store/yaml-file-adapter.js';
+export { createInMemorySddStores, createSddStores } from '../../core/sdd/store/sdd-stores.js';
+//# sourceMappingURL=index.js.map

package/dist/presentations/cli/sdd/index.d.ts

@@ -0,0 +1,3 @@
+export { registerSddCommand } from '../../../commands/sdd.js';
+export { registerPluginCommands } from '../../../commands/sdd/plugin.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/presentations/cli/sdd/index.js

@@ -0,0 +1,3 @@
+export { registerSddCommand } from '../../../commands/sdd.js';
+export { registerPluginCommands } from '../../../commands/sdd/plugin.js';
+//# sourceMappingURL=index.js.map

package/dist/shared/sdd/index.d.ts

@@ -0,0 +1,3 @@
+export type { BacklogItem, BacklogState, DiscoveryIndexState, DiscoveryRecord, FinalizeQueueState, FrontendGapsState, FrontendMapState, RepoMapState, ServiceCatalogState, TransitionLogState, } from '../../core/sdd/types.js';
+export { stringifyWorkspaceYamlDocument, workspaceDocumentSchemas, workspaceSchemaForFile, type WorkspaceChangelogDocument, type WorkspaceDocumentFileName, type WorkspacePlanDocument, type WorkspaceQualityDocument, type WorkspaceSpecDocument, type WorkspaceTasksDocument, } from '../../core/sdd/workspace-schemas.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/sdd/index.js

@@ -0,0 +1,2 @@
+export { stringifyWorkspaceYamlDocument, workspaceDocumentSchemas, workspaceSchemaForFile, } from '../../core/sdd/workspace-schemas.js';
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devtrack-solution/codesdd",
-  "version": "1.2.3",
+  "version": "1.2.4-rc3",
   "description": "AI-native system for spec-driven development",
   "keywords": [
     "codesdd",
@@ -22,7 +22,8 @@
   "type": "module",
   "packageManager": "pnpm@10.33.2",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
   },
   "pnpm": {
     "overrides": {
@@ -64,13 +65,13 @@
     "build": "node build.js",
     "dev": "tsc --watch",
     "dev:cli": "pnpm build && node bin/codesdd.js",
-    "test": "vitest run",
+    "test": "vitest run --silent=passed-only",
     "test:watch": "vitest",
-    "test:e2e": "vitest run test/e2e test/cli-e2e",
+    "test:e2e": "vitest run test/e2e test/cli-e2e --silent=passed-only",
     "test:deepagents-smoke": "vitest run test/e2e/deepagents-agent-run-smoke.test.ts",
     "test:ui": "vitest --ui",
-    "test:coverage": "vitest run --coverage",
-    "coverage": "vitest run --coverage",
+    "test:coverage": "vitest run --coverage --silent=passed-only",
+    "coverage": "vitest run --coverage --silent=passed-only",
     "quality": "pnpm run cleanup:install && pnpm run build && pnpm run lint && pnpm run test && pnpm run test:e2e && pnpm run coverage",
     "quality:review": "pnpm run build && pnpm run lint && pnpm run test && pnpm run test:e2e && pnpm run coverage && pnpm run sdd:validate && pnpm run check:pack-version",
     "prepublishOnly": "node build.js",
@@ -85,6 +86,7 @@
     "sdd:validate": "pnpm run build && pnpm run sdd:schema:check && pnpm run sdd:validate:no-build",
     "release": "pnpm run release:ci",
     "release:ci": "pnpm run check:pack-version && pnpm exec changeset publish",
+    "release:sbom": "npm sbom --sbom-format cyclonedx",
     "changeset": "changeset"
   },
   "engines": {
@@ -114,6 +116,7 @@
     "fast-glob": "^3.3.3",
     "ora": "^9.4.0",
     "posthog-node": "^5.35.1",
+    "redis": "^6.0.0",
     "typescript": "^6.0.3",
     "yaml": "^2.9.0",
     "zod": "^4.4.3"

package/schemas/sdd/2-plan.schema.json

@@ -10,6 +10,205 @@
       "type": "string",
       "pattern": "^FEAT-\\d{4}$"
     },
+    "governance": {
+      "default": {
+        "state_boundary": "codesdd-canonical-sdd-state",
+        "planning_artifacts": [
+          ".sdd/state/backlog.yaml"
+        ],
+        "decision_refs": [],
+        "planned_state_writes": [],
+        "rollback_plan": "Review and revert only the scoped CodeSDD feature workspace and state changes if validation fails.",
+        "validation_gates": [
+          {
+            "name": "SDD check",
+            "command": "codesdd sdd check --render",
+            "expected": "CodeSDD state and generated views remain valid."
+          }
+        ]
+      },
+      "type": "object",
+      "properties": {
+        "state_boundary": {
+          "default": "codesdd-canonical-sdd-state",
+          "type": "string",
+          "const": "codesdd-canonical-sdd-state"
+        },
+        "planning_artifacts": {
+          "minItems": 1,
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "decision_refs": {
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "planned_state_writes": {
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "rollback_plan": {
+          "type": "string",
+          "minLength": 20
+        },
+        "validation_gates": {
+          "minItems": 1,
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string",
+                "minLength": 1
+              },
+              "command": {
+                "type": "string",
+                "minLength": 1
+              },
+              "expected": {
+                "type": "string",
+                "minLength": 1
+              }
+            },
+            "required": [
+              "name",
+              "command",
+              "expected"
+            ],
+            "additionalProperties": false
+          }
+        }
+      },
+      "required": [
+        "state_boundary",
+        "planning_artifacts",
+        "decision_refs",
+        "planned_state_writes",
+        "rollback_plan",
+        "validation_gates"
+      ],
+      "additionalProperties": false
+    },
+    "execution_plan": {
+      "default": {
+        "mode": "single-feature",
+        "state_boundary_ref": "codesdd-canonical-sdd-state",
+        "command_sequence": [
+          {
+            "name": "SDD check",
+            "command": "codesdd sdd check --render",
+            "writes_state": false,
+            "expected_state_writes": []
+          }
+        ],
+        "allowed_state_writes": [],
+        "forbidden_state_writes": [
+          ".codesdd/**",
+          "external-context/**"
+        ],
+        "handoff_artifacts": []
+      },
+      "type": "object",
+      "properties": {
+        "mode": {
+          "default": "single-feature",
+          "type": "string",
+          "enum": [
+            "single-feature",
+            "parallel-wave",
+            "chained-features"
+          ]
+        },
+        "state_boundary_ref": {
+          "default": "codesdd-canonical-sdd-state",
+          "type": "string",
+          "const": "codesdd-canonical-sdd-state"
+        },
+        "command_sequence": {
+          "minItems": 1,
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "name": {
+                "type": "string",
+                "minLength": 1
+              },
+              "command": {
+                "type": "string",
+                "minLength": 1
+              },
+              "writes_state": {
+                "default": false,
+                "type": "boolean"
+              },
+              "expected_state_writes": {
+                "default": [],
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "minLength": 1
+                }
+              }
+            },
+            "required": [
+              "name",
+              "command",
+              "writes_state",
+              "expected_state_writes"
+            ],
+            "additionalProperties": false
+          }
+        },
+        "allowed_state_writes": {
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "forbidden_state_writes": {
+          "default": [
+            ".codesdd/**",
+            "external-context/**"
+          ],
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "handoff_artifacts": {
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        }
+      },
+      "required": [
+        "mode",
+        "state_boundary_ref",
+        "command_sequence",
+        "allowed_state_writes",
+        "forbidden_state_writes",
+        "handoff_artifacts"
+      ],
+      "additionalProperties": false
+    },
     "architectural_impact": {
       "type": "object",
       "properties": {
@@ -73,10 +272,14 @@
       "type": "object",
       "properties": {
         "unit_target": {
-          "type": "number"
+          "type": "number",
+          "minimum": 0,
+          "maximum": 100
         },
         "integration_target": {
-          "type": "number"
+          "type": "number",
+          "minimum": 0,
+          "maximum": 100
         },
         "approach": {
           "type": "string"
@@ -259,6 +462,8 @@
   "required": [
     "schema_version",
     "feature_id",
+    "governance",
+    "execution_plan",
     "architectural_impact",
     "frontend_impact",
     "affected_contracts",