agent-sdd 1.0.3

package/dist/shared/domain/SpecRecord.js

@@ -0,0 +1,208 @@
+import { parseAllDocuments, parseDocument } from "yaml";
+export const NORMATIVE_TEMPLATES = new Set([
+    "Behavior",
+    "Invariant",
+    "Contract",
+    "Scenario",
+    "NFR",
+    "Constraint",
+    "Policy",
+    "Migration",
+    "Delta",
+    "GeneratedArtifact",
+    "ExternalDependency",
+    "LocalizationContract",
+    "Surface",
+]);
+export const VALID_LIFECYCLE_STATUS = new Set([
+    "draft",
+    "proposed",
+    "approved",
+    "deprecated",
+    "removed",
+]);
+const ALIAS_FIELDS = [
+    "negative_test_obligations",
+    "tests_pre",
+    "tests_during",
+    "tests_post",
+    "tests_old_behavior",
+    "tests_new_behavior",
+];
+export function lintRecordsFromMarkdown(file, markdown) {
+    const out = [];
+    for (const fence of yamlFences(markdown)) {
+        out.push(...lintRecordsFromFence(file, fence));
+    }
+    return out;
+}
+function yamlFences(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const fences = [];
+    let inFence = false;
+    let buffer = [];
+    let startLine = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!inFence && /^```yaml\s*$/.test(line)) {
+            inFence = true;
+            buffer = [];
+            startLine = i + 2;
+            continue;
+        }
+        if (inFence && /^```\s*$/.test(line)) {
+            fences.push({ raw: buffer.join("\n"), startLine });
+            inFence = false;
+            continue;
+        }
+        if (inFence) {
+            buffer.push(line);
+        }
+    }
+    return fences;
+}
+function lintRecordsFromFence(file, fence) {
+    const hasSeparator = fence.raw.split(/\r?\n/).some((l) => l === "---");
+    if (hasSeparator) {
+        const docs = parseAllDocuments(fence.raw, { prettyErrors: false });
+        const out = [];
+        for (const doc of docs) {
+            if (doc.errors.length > 0) {
+                continue;
+            }
+            const value = doc.toJS();
+            if (!isObject(value)) {
+                continue;
+            }
+            const rec = recordFromObject(file, value, fence.startLine + (doc.range?.[0] ?? 0));
+            if (rec !== null) {
+                out.push(rec);
+            }
+        }
+        return out;
+    }
+    const doc = parseDocument(fence.raw, { prettyErrors: false });
+    if (doc.errors.length > 0) {
+        return [];
+    }
+    const value = doc.toJS();
+    if (Array.isArray(value)) {
+        const out = [];
+        const fenceLines = fence.raw.split(/\r?\n/);
+        let cursor = 0;
+        for (const item of value) {
+            if (!isObject(item)) {
+                continue;
+            }
+            const id = typeof item.id === "string" ? item.id : null;
+            let lineWithin = cursor;
+            if (id !== null) {
+                for (let j = cursor; j < fenceLines.length; j++) {
+                    if (new RegExp(`^-\\s+id:\\s*${escapeRe(id)}\\b`).test(fenceLines[j])) {
+                        lineWithin = j;
+                        cursor = j + 1;
+                        break;
+                    }
+                }
+            }
+            const rec = recordFromObject(file, item, fence.startLine + lineWithin);
+            if (rec !== null) {
+                out.push(rec);
+            }
+        }
+        return out;
+    }
+    if (isObject(value)) {
+        const rec = recordFromObject(file, value, fence.startLine);
+        return rec === null ? [] : [rec];
+    }
+    return [];
+}
+function recordFromObject(file, value, line) {
+    const id = typeof value.id === "string" ? value.id : null;
+    if (id === null) {
+        return null;
+    }
+    const template = pickTemplate(value);
+    const lifecycleStatus = pickLifecycleStatus(value);
+    const approvalRecord = pickApprovalRecord(value);
+    const testObligations = stringArray(value.test_obligations);
+    const hasAliasedObligations = ALIAS_FIELDS.some((k) => value[k] !== undefined) ||
+        hasSingularTestObligation(value);
+    return {
+        id,
+        template,
+        lifecycleStatus,
+        approvalRecord,
+        testObligations,
+        hasAliasedObligations,
+        parsed: value,
+        file,
+        line,
+        rawBlock: "",
+    };
+}
+function hasSingularTestObligation(value) {
+    const v = value.test_obligation;
+    if (isObject(v)) {
+        return true;
+    }
+    if (typeof v === "string" && v.startsWith("not_applicable")) {
+        return true;
+    }
+    return false;
+}
+function pickTemplate(value) {
+    const t = value.template ?? value.type;
+    return typeof t === "string" ? t : null;
+}
+function pickLifecycleStatus(value) {
+    const flat = value["lifecycle.status"];
+    if (typeof flat === "string") {
+        return flat;
+    }
+    const nested = value.lifecycle;
+    if (isObject(nested) && typeof nested.status === "string") {
+        return nested.status;
+    }
+    return null;
+}
+function pickApprovalRecord(value) {
+    const top = value.approval_record;
+    const fromTop = describeApprovalRecord(top);
+    if (fromTop !== null) {
+        return fromTop;
+    }
+    const lifecycle = value.lifecycle;
+    if (isObject(lifecycle)) {
+        return describeApprovalRecord(lifecycle.approval_record);
+    }
+    return null;
+}
+function describeApprovalRecord(v) {
+    if (v === undefined) {
+        return null;
+    }
+    if (typeof v === "string") {
+        return v;
+    }
+    if (isObject(v)) {
+        const tag = typeof v.approver_identity === "string"
+            ? `obj:${v.approver_identity}`
+            : "obj:unknown";
+        return tag;
+    }
+    return null;
+}
+function stringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter((v) => typeof v === "string");
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function escapeRe(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/shared/domain/TemplateFieldMetadata.d.ts

@@ -0,0 +1,2 @@
+export declare const IS_NORMATIVE: Readonly<Record<string, Readonly<Record<string, boolean>>>>;
+export declare function isFieldNormative(template: string | null | undefined, field: string): boolean;

package/dist/shared/domain/TemplateFieldMetadata.js

@@ -0,0 +1,177 @@
+/*
+ * IS_NORMATIVE table per typed normative template: which fields the
+ * field-aware weasel pass treats as normative (`true`). Structural,
+ * descriptive and test-design fields are `false`; unknown templates
+ * default `false` so modal weasel never blocks where we are not certain.
+ */
+export const IS_NORMATIVE = {
+    Behavior: {
+        title: false,
+        notes: false,
+        test_obligation: false,
+        given: true,
+        when: true,
+        then: true,
+        negative_cases: true,
+        out_of_scope: true,
+        applicability: true,
+        concurrency_model: true,
+        data_scope: true,
+        policy_refs: true,
+    },
+    Contract: {
+        title: false,
+        notes: false,
+        test_obligation: false,
+        test_obligations: false,
+        surface_ref: true,
+        schema: true,
+        preconditions: true,
+        postconditions: true,
+        external_identifiers: true,
+        compatibility_rules: true,
+        error_taxonomy: true,
+        applicability: true,
+        concurrency_model: true,
+        data_scope: true,
+        policy_refs: true,
+    },
+    Invariant: {
+        title: false,
+        notes: false,
+        test_obligation: false,
+        always: true,
+        never: true,
+        when: true,
+        then: true,
+        scope: true,
+        evidence: true,
+        stability: true,
+        negative_cases: true,
+        out_of_scope: true,
+        applicability: true,
+        concurrency_model: true,
+        data_scope: true,
+        policy_refs: true,
+    },
+    Scenario: {
+        title: false,
+        notes: false,
+        test_obligation: false,
+        given: true,
+        when: true,
+        then: true,
+        applicability: true,
+        data_scope: true,
+    },
+    NFR: {
+        title: false,
+        notes: false,
+        test_obligation: false,
+        metric: true,
+        target: true,
+        verification_obligation: true,
+        applicability: true,
+        data_scope: true,
+        policy_refs: true,
+    },
+    Constraint: {
+        title: false,
+        notes: false,
+        test_obligations: false,
+        rule: true,
+        rationale: true,
+        scope: true,
+        applicability: true,
+        data_scope: true,
+        policy_refs: true,
+    },
+    Policy: {
+        title: false,
+        notes: false,
+        test_obligation: false,
+        rule: true,
+        rationale: true,
+        scope: true,
+        applicability: true,
+        data_scope: true,
+    },
+    Migration: {
+        title: false,
+        notes: false,
+        test_obligation: false,
+        direction: true,
+        mode: true,
+        runtime_state: true,
+        enforcement_stage: true,
+        target_ids: true,
+        baseline_version: true,
+        partition_slice: true,
+        applicability: true,
+        data_scope: true,
+        policy_refs: true,
+    },
+    Delta: {
+        title: false,
+        notes: false,
+        test_obligation: false,
+        kind: true,
+        compatibility_action: true,
+        target_ids: true,
+        baseline_version: true,
+        tests_old_behavior: false,
+        tests_new_behavior: false,
+        applicability: true,
+        data_scope: true,
+    },
+    GeneratedArtifact: {
+        title: false,
+        notes: false,
+        test_obligation: false,
+        generator: true,
+        inputs: true,
+        outputs: true,
+        published_surface: true,
+        surface_ref: true,
+        applicability: true,
+        data_scope: true,
+    },
+    ExternalDependency: {
+        title: false,
+        notes: false,
+        test_obligation: false,
+        provider: true,
+        interface: true,
+        failure_modes: true,
+        fallback_policy: true,
+        applicability: true,
+        data_scope: true,
+        policy_refs: true,
+    },
+    LocalizationContract: {
+        title: false,
+        notes: false,
+        test_obligation: false,
+        text_id: true,
+        fallback_locale: true,
+        contract: true,
+        applicability: true,
+    },
+    Surface: {
+        name: false,
+        notes: false,
+        title: false,
+        test_obligation: false,
+        test_obligations: false,
+        version: true,
+        boundary_type: true,
+        members: true,
+        consumer_compat_policy: true,
+    },
+};
+export function isFieldNormative(template, field) {
+    if (template === null || template === undefined) {
+        return false;
+    }
+    return IS_NORMATIVE[template]?.[field] === true;
+}

package/dist/shared/domain/Token.d.ts

@@ -0,0 +1,2 @@
+export declare const TOKEN_MECHANISM = "git_tree_hash_v1";
+export declare function token(bytes: Uint8Array): string;

package/dist/shared/domain/Token.js

@@ -0,0 +1,5 @@
+import { createHash } from "node:crypto";
+export const TOKEN_MECHANISM = "git_tree_hash_v1";
+export function token(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}

package/dist/shared/domain/WeaselWords.d.ts

@@ -0,0 +1,3 @@
+export declare const WEASEL_ABSOLUTE: ReadonlyArray<string>;
+export declare const WEASEL_MODAL_IN_NORMATIVE: ReadonlyArray<string>;
+export declare const WEASEL_WORDS: ReadonlyArray<string>;

package/dist/shared/domain/WeaselWords.js

@@ -0,0 +1,32 @@
+/*
+ * Source of truth for SDD weasel-word detection (CTR-016 / SUR-009):
+ * `absolute` words trigger inside any normative section; `modal_in_normative`
+ * words only inside fields whose IS_NORMATIVE entry is `true`.
+ */
+export const WEASEL_ABSOLUTE = [
+    "возможно",
+    "вероятно",
+    "обычно",
+    "as a rule",
+    "etc.",
+    "and so on",
+    "should usually",
+    "similar to",
+    "approximately",
+    "best-effort",
+    "best effort",
+    "informally",
+];
+export const WEASEL_MODAL_IN_NORMATIVE = [
+    "may be",
+    "might be",
+];
+/*
+ * Backward-compatible aggregate used by the legacy single-pass weaselFindings
+ * caller. P0.5 splits this into two passes; the union is the conservative
+ * upper bound until field-aware detection lands.
+ */
+export const WEASEL_WORDS = [
+    ...WEASEL_ABSOLUTE,
+    ...WEASEL_MODAL_IN_NORMATIVE,
+];

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "agent-sdd",
+  "version": "1.0.3",
+  "description": "Spec-Driven Development helper CLI: freshness tokens, scope drift stubs, spec-lint, approval ceremony.",
+  "keywords": [
+    "spec-driven-development",
+    "sdd",
+    "cli",
+    "spec-lint",
+    "freshness-token",
+    "baseline"
+  ],
+  "license": "MIT",
+  "author": "cyberash <cyberash-dev@yandex.com>",
+  "homepage": "https://github.com/cyberash-dev/sdd-cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cyberash-dev/sdd-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cyberash-dev/sdd-cli/issues"
+  },
+  "type": "module",
+  "prettier": "@cyberash-dev/dev-tooling/prettier.base.json",
+  "bin": {
+    "sdd": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "schema",
+    "rules",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc && chmod +x dist/cli.js",
+    "test": "npm run test:unit && npm run test:integration",
+    "test:unit": "node --import tsx --test tests/unit/*.test.ts",
+    "test:integration": "node --import tsx --test tests/integration/*.test.ts",
+    "tsc": "tsc --noEmit",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\"",
+    "lint:spec": "node dist/cli.js lint",
+    "prepublishOnly": "npm run tsc && npm test && npm run build"
+  },
+  "dependencies": {
+    "yaml": "^2.7.0"
+  },
+  "devDependencies": {
+    "@cyberash-dev/dev-tooling": "^5.0.0",
+    "@types/node": "^22.10.5",
+    "eslint": "^9.39.4",
+    "prettier": "^3.8.3",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
+}

package/rules/enforcement_registry.md

@@ -0,0 +1,126 @@
+# SDD Enforcement Registry
+
+Single source of truth for «which SDD requirement is closed by which channel». Every MUST and every stop-condition from `spec-driven-development.md` and `SKILL.md` has exactly one row here. Adding a normative requirement without a row is invalid; adding a CLI diagnostic without a row is invalid.
+
+## Compatibility metadata
+
+| Field | Value |
+|---|---|
+| sdd_methodology_version | 1.0.0 |
+| compatible_sdd_cli | >=1.0 <2.0 |
+| diagnostic_surface | @cyberash/sdd-cli/diagnostics@1.0 |
+
+## Schema
+
+Each row carries:
+- `id` — `ENF-NNN[A-Z]?` (suffix letter when split via `parent_id`).
+- `parent_id` — optional; links rows that decompose one requirement.
+- `requirement` — short imperative statement (one sentence).
+- `enforcement_class` — one of 10 semantic classes (see below).
+- `executor` — one of `sdd lint | sdd check | sdd refresh | sdd ready | sdd finalize | sdd report | sdd doctor | agent | human`.
+- `gate` — `baseline-valid | spec-valid | implementation-valid` (omitted for process-class rows).
+- `diagnostic_id` — required for lint/ready/doctor rows with `maturity=implemented`. Contains the exact string the CLI emits and `sdd doctor` reconciles against `DiagnosticRegistry`: `sdd:*` for lint rules, snake-case for ready violation kinds, and the doctor drift kinds (`version_mismatch`/`missing_diagnostic`/`stale_diagnostic`). A single cell may list several ids separated by ` | ` (escaped `\|`). Set to `—` when the row is verified by another channel and emits no doctor-tracked diagnostic: `report-evidence` rows (verified by the report integration tests, e.g. BEH-044..048) and the finalize graph-violation reason `proposed-references` (an envelope reason, not a `DiagnosticRegistry` member).
+- `maturity` — `implemented | planned | out_of_scope` (omitted for process-class rows). Suffix `:hybrid` when the row mixes mechanical and human verdicts.
+- `process_owner` — required when `executor ∈ {agent, human}`.
+- `review_trigger` — required when `executor ∈ {agent, human}`; one of `PR merge | sprint close | release cut`.
+
+### Enforcement classes
+
+- `structural-lint` — single-record textual/typed check.
+- `graph-consistency` — cross-record reference validation.
+- `freshness` — comparison against recorded baseline.
+- `aggregate-gate` — composite check across multiple sub-rules.
+- `derived-versioning` — semver/diff classification computed from references.
+- `derived-artifact` — structural diff over emitted artefact.
+- `report-evidence` — produces machine-readable narrative for PR.
+- `agent-halt` — agent reflex on closed stop-condition (term not in Glossary → Open-Q).
+- `agent-judgment` — agent semantic classification (provider-owned → ExternalDependency).
+- `human-review` — human-only gate (test oracle quality, debt content).
+
+## Registry
+
+| id | parent_id | requirement | enforcement_class | executor | gate | diagnostic_id | maturity | process_owner | review_trigger |
+|----|-----------|-------------|-------------------|----------|------|---------------|----------|---------------|----------------|
+| ENF-001 | — | Weasel words banned in normative sections; modal phrases in `is_normative=true` fields | structural-lint | sdd lint | spec-valid | sdd:weasel-word | implemented | — | — |
+| ENF-002A | ENF-002 | Approved/deprecated/removed Surface referencing a non-approved member is flagged | graph-consistency | sdd ready | spec-valid | surface_unapproved_ref | implemented | — | — |
+| ENF-002B | ENF-002 | Materialising `lifecycle.status=approved` via finalize refuses when the plan references still-proposed IDs (envelope reason `proposed-references`) | graph-consistency | sdd finalize | spec-valid | — | implemented | — | — |
+| ENF-003 | — | Delta/Migration carries `baseline_version` | structural-lint | sdd lint | spec-valid | sdd:baseline-version-required | implemented | — | — |
+| ENF-004A | ENF-004 | Major Surface bump computed via semver cascade (Policy / Invariant(contractual) → referencing Surface) | derived-versioning | sdd ready | spec-valid | surface_semver_cascade | implemented | — | — |
+| ENF-004B | ENF-004 | Major-bump test oracle reviewed (input classes, negative oracle, assertion summary) | human-review | human | — | — | — | surface owner | PR merge |
+| ENF-005 | — | Unknown Glossary term → agent raises Open-Q | agent-halt | agent | — | — | — | PR author | PR merge |
+| ENF-006 | — | Provider-owned behavior → agent classifies as ExternalDependency | agent-judgment | agent | — | — | — | PR author | PR merge |
+| ENF-007A | ENF-007 | PR report lists closed Test obligations + tests | report-evidence | sdd report | implementation-valid | — | implemented | PR author | PR merge |
+| ENF-007B | ENF-007 | PR report lists internal decisions (candidates for new Constraint/Policy/ASSUMPTION) | report-evidence | sdd report | implementation-valid | — | implemented | PR author | PR merge |
+| ENF-007C | ENF-007 | PR report lists ASSUMPTIONs + `review_by` | report-evidence | sdd report | implementation-valid | — | implemented | PR author | PR merge |
+| ENF-007D | ENF-007 | PR report lists remaining Open-Qs + non-block reason | report-evidence | sdd report | implementation-valid | — | implemented | PR author | PR merge |
+| ENF-007E | ENF-007 | PR report shows debt budget delta vs previous PR | report-evidence | sdd report | implementation-valid | — | implemented:hybrid | PR author | PR merge |
+| ENF-008 | — | Diagnostic rule IDs are stable public Surface (drift kinds: `version_mismatch`, `missing_diagnostic`, `stale_diagnostic`) | graph-consistency | sdd doctor | — | version_mismatch \| missing_diagnostic \| stale_diagnostic | implemented | — | release cut |
+| ENF-009 | — | `deprecated` ⇒ `sunset_version` + `replacement_id` | structural-lint | sdd lint | spec-valid | sdd:deprecated-fields-required | implemented | — | — |
+| ENF-010 | — | ASSUMPTION downgrade `blocking → advisory` requires `approval_record` (≠ agent identity) | structural-lint | sdd lint | spec-valid | sdd:assumption-downgrade-approval | implemented | — | — |
+| ENF-011 | — | Partition declares `default_policy_set[]` (≥0, explicit) | structural-lint | sdd lint | spec-valid | sdd:partition-default-policy-set | implemented | — | — |
+| ENF-012 | — | `GeneratedArtifact.published_surface=yes` ⇒ Surface-ref | structural-lint | sdd lint | spec-valid | sdd:generated-artifact-surface-ref | implemented | — | — |
+| ENF-013 | — | Boundary Contract/Behavior references ≥1 Policy or carries explicit `Policy.override` | structural-lint | sdd lint | spec-valid | sdd:boundary-policy-ref | implemented | — | — |
+| ENF-014 | — | `concurrency_model` present on boundary elements with required sub-fields | structural-lint | sdd lint | spec-valid | sdd:boundary-concurrency-model | implemented | — | — |
+| ENF-015 | — | `applicability` present (or `invariant_to_all_axes: true`) | structural-lint | sdd lint | spec-valid | sdd:applicability-required | implemented | — | — |
+| ENF-016 | — | `data_scope` present on persistent-state elements | structural-lint | sdd lint | spec-valid | sdd:data-scope-required | implemented | — | — |
+| ENF-017 | — | Migration `runtime_state` ↔ `enforcement_stage` marker consistency | structural-lint | sdd lint | spec-valid | sdd:migration-enforcement-stage | implemented | — | — |
+| ENF-018 | — | Cross-partition Migration uses `partition_slice[]` + `coordinator_id` | structural-lint | sdd lint | spec-valid | sdd:migration-cross-partition | implemented | — | — |
+| ENF-019 | — | `GeneratedArtifact(published_surface=yes)` structural-breaking diff ⇒ major bump | derived-artifact | sdd ready | spec-valid | generated_artifact_structural_diff_unbumped | implemented | — | — |
+| ENF-020A | ENF-020 | Iterative debt budget per Partition — `unmodeled_budget` form/required-sub-fields check | structural-lint | sdd lint | spec-valid | sdd:debt-budget-form | implemented | — | — |
+| ENF-020B | ENF-020 | Iterative debt budget per Partition — monotonic non-increase vs recorded baseline | aggregate-gate | sdd ready | implementation-valid | debt_budget_increased | implemented:hybrid | partition owner | sprint close |
+| ENF-021 | — | Brownfield baseline `freshness_token` matches source tree | freshness | sdd check | baseline-valid | — | implemented | — | — |
+| ENF-022 | — | weasel-words list has single canonical source (drift detected by `sdd doctor`) | graph-consistency | sdd doctor | — | sdd:weasel-source-drift | planned | — | release cut |
+| ENF-023 | — | Code↔spec contradiction outside Delta → agent halts | agent-halt | agent | — | — | — | PR author | PR merge |
+| ENF-024 | — | Text-as-contract → agent classifies as LocalizationContract | agent-judgment | agent | — | — | — | PR author | PR merge |
+| ENF-025 | — | Generated output → agent classifies as GeneratedArtifact | agent-judgment | agent | — | — | — | PR author | PR merge |
+| ENF-026 | — | Removal without `compatibility_action` → agent halts | agent-halt | agent | — | — | — | PR author | PR merge |
+| ENF-027 | — | Missing `Policy`-ref on a boundary detected by agent → halt | agent-halt | agent | — | — | — | PR author | PR merge |
+| ENF-028 | — | Missing `applicability` when an axis variable is detectable in baseline → halt | agent-halt | agent | — | — | — | PR author | PR merge |
+| ENF-029 | — | Missing `concurrency_model` on a boundary → halt | agent-halt | agent | — | — | — | PR author | PR merge |
+| ENF-030 | — | Missing `data_scope` on persistent state → halt | agent-halt | agent | — | — | — | PR author | PR merge |
+| ENF-031 | — | Missing `baseline_version` on Delta/Migration → halt before relying on lint | agent-halt | agent | — | — | — | PR author | PR merge |
+| ENF-032 | — | `proposed → approved` Surface while referenced Policy/Contract not yet approved → halt before invoking finalize | agent-halt | agent | — | — | — | PR author | PR merge |
+| ENF-033 | — | Migration `runtime_state` change without updating dependent `enforcement_stage` → halt | agent-halt | agent | — | — | — | PR author | PR merge |
+| ENF-034 | — | Structural-breaking diff in `GeneratedArtifact(published_surface=yes)` without major bump → halt before commit | agent-halt | agent | — | — | — | PR author | PR merge |
+| ENF-035 | — | Spec document carries every required section (§2) | structural-lint | sdd lint | spec-valid | sdd:section-presence | implemented | — | — |
+| ENF-036 | — | Spec document sections appear in the required order (§2) | structural-lint | sdd lint | spec-valid | sdd:section-order | implemented | — | — |
+| ENF-037 | — | Every normative ID carries `lifecycle.status` (§7.2) | structural-lint | sdd lint | spec-valid | sdd:lifecycle-status-present | implemented | — | — |
+| ENF-038 | — | `lifecycle.status` is a valid enum value (§7.2) | structural-lint | sdd lint | spec-valid | sdd:lifecycle-status-valid | implemented | — | — |
+| ENF-039 | — | `approval_record` present for `approved`/`deprecated`/`removed` (§7.5) | structural-lint | sdd lint | spec-valid | sdd:approval-record-required | implemented | — | — |
+| ENF-040 | — | `approval_record` forbidden for `draft`/`proposed` (§7.5) | structural-lint | sdd lint | spec-valid | sdd:approval-record-forbidden | implemented | — | — |
+| ENF-041 | — | Every normative ID declares a `Test obligation` (§4) | structural-lint | sdd lint | spec-valid | sdd:test-obligation-required | implemented | — | — |
+| ENF-042 | — | `version` field is an integer where required (§1.5) | structural-lint | sdd lint | spec-valid | sdd:type-version-int | implemented | — | — |
+| ENF-043 | — | `Invariant.evidence` is a valid enum value (§1.5) | structural-lint | sdd lint | spec-valid | sdd:type-invariant-evidence | implemented | — | — |
+| ENF-044 | — | `Invariant.stability` is a valid enum value (§1.5) | structural-lint | sdd lint | spec-valid | sdd:type-invariant-stability | implemented | — | — |
+| ENF-045 | — | `data_scope` is a valid enum value (§1.5) | structural-lint | sdd lint | spec-valid | sdd:type-data-scope | implemented | — | — |
+| ENF-046 | — | `NFR.verification_stage` is a valid enum value (§1.5) | structural-lint | sdd lint | spec-valid | sdd:type-nfr-stage | implemented | — | — |
+| ENF-047 | — | `Migration.direction` is a valid enum value (§1.5) | structural-lint | sdd lint | spec-valid | sdd:type-migration-direction | implemented | — | — |
+| ENF-048 | — | `Migration.mode` is a valid enum value (§1.5) | structural-lint | sdd lint | spec-valid | sdd:type-migration-mode | implemented | — | — |
+| ENF-049 | — | `Migration.runtime_state` is a valid enum value (§1.5) | structural-lint | sdd lint | spec-valid | sdd:type-migration-runtime-state | implemented | — | — |
+| ENF-050 | — | `Surface.boundary_type` is a valid enum value (§1.5) | structural-lint | sdd lint | spec-valid | sdd:type-surface-boundary-type | implemented | — | — |
+| ENF-051 | — | `proposed`/`draft` ID outside a partition `sandbox_paths` is not mergeable | graph-consistency | sdd ready | implementation-valid | unapproved | implemented | — | — |
+| ENF-052 | — | Every `approved` ID is covered by ≥1 `@covers` marker | aggregate-gate | sdd ready | implementation-valid | uncovered | implemented | — | — |
+| ENF-053 | — | `removed` ID has a test for its `compatibility_action` | aggregate-gate | sdd ready | implementation-valid | removed_no_compat_test | implemented | — | — |
+| ENF-054 | — | `removed` ID test matches its declared `compatibility_action` | aggregate-gate | sdd ready | implementation-valid | removed_compat_action_mismatch | implemented | — | — |
+| ENF-055 | — | `@covers` marker references an existing normative ID | graph-consistency | sdd ready | implementation-valid | orphan_covers | implemented | — | — |
+| ENF-056 | — | `@covers` marker uses a declared partition prefix | graph-consistency | sdd ready | implementation-valid | unknown_partition_covers | implemented | — | — |
+| ENF-057 | — | `sdd ready` aggregates upstream `sdd lint` violations | aggregate-gate | sdd ready | implementation-valid | aggregated_lint | implemented | — | — |
+| ENF-058 | — | `sdd ready` aggregates baseline (`sdd check`) violations | aggregate-gate | sdd ready | implementation-valid | aggregated_check | implemented | — | — |
+| ENF-059 | — | Unresolved `Open-Q.blocking=yes` blocks spec-valid (§0) | structural-lint | sdd lint | spec-valid | sdd:open-q-blocking | implemented | — | — |
+| ENF-060 | — | Near-miss `@covers` markers surface as non-blocking `advisories[]` in the ready envelope (never affect exit code) | report-evidence | sdd ready | implementation-valid | — | implemented | — | — |
+
+## Maturity transitions
+
+- `planned` → `implemented`: requires CHANGELOG entry in `sdd-cli` with PR number and integration test; `compatible_sdd_cli` range in this registry must cover the implementing CLI version.
+- `implemented` → `deprecated`: alias period ≥1 minor on `Surface: diagnostics` (SUR-009 in `sdd-cli/spec/spec.md`); the alias is recorded in CLI's `DiagnosticRegistry.ts`.
+- `out_of_scope` → ничего: фиксирует, что это не будет автоматизировано в данной major-line.
+
+Many `agent-halt` rows duplicate mechanical lint coverage (e.g. ENF-027 vs ENF-013, ENF-031 vs ENF-003). The duplication is intentional — `sdd lint` catches the violation at gate-2 (`spec-valid`), but the agent must still raise it as `Open-Q` proactively rather than relying on the linter to find it. `enforcement_class: agent-halt` is the *behavior expected from the agent*; `structural-lint` is the *mechanical safety net*.
+
+## How to add a new requirement
+
+1. Сформулировать как одно предложение MUST.
+2. Выбрать `enforcement_class` (одно из 10) и `executor`.
+3. Если class mechanical и `maturity=implemented` — обязателен `diagnostic_id`. Если `executor ∈ {agent, human}` — обязательны `process_owner` и `review_trigger`.
+4. Добавить строку в Registry. Если требование декомпозируется (mechanical part + human-review part) — две строки с общим `parent_id`.
+5. В `rules/spec-driven-development.md` и/или `SKILL.md` сформулировать сам MUST и сослаться на ENF-id.

package/rules/hooks/sdd-lint-reminder.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+# Stdin: JSON с tool_name и tool_input.
+# Stdout: hookSpecificOutput c additionalContext: reminder запустить `sdd lint`
+input=$(cat)
+tool=$(printf '%s' "$input" | jq -r '.tool_name')
+path=$(printf '%s' "$input" | jq -r '.tool_input.path // .tool_input.file_path // empty')
+
+case "$path" in
+  */spec/*.md) ;;
+  *) exit 0 ;;
+esac
+
+config_dir="$(dirname "$path")"
+found_config=
+while [[ "$config_dir" != "/" && "$config_dir" != "." ]]; do
+  if [[ -f "$config_dir/.sdd/config.json" ]]; then
+    found_config=1
+    break
+  fi
+  config_dir="$(dirname "$config_dir")"
+done
+
+if [[ -z "$found_config" ]]; then
+  exit 0
+fi
+
+jq -n --arg tool "$tool" --arg path "$path" '{
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    permissionDecision: "allow",
+    additionalContext: ("Reminder: " + $path + " is a spec file in an SDD project (.sdd/config.json found). After this " + $tool + " completes, run `sdd lint` and do not proceed to Implement/Commit until exit 0. See @sdd/sdd-cli-usage.md for full phase-to-command mapping.")
+  }
+}'