@sigloch/contracts 0.7.0

package/dist/se/ontology.d.ts

@@ -0,0 +1,327 @@
+/**
+ * SE Ontology as Zod (version: see ONTOLOGY_VERSION in ./index.ts).
+ * Element + Trace types per INCOSE/SysML 2.0.
+ * @sigloch/contracts/se — single source of truth for SE ontology schemas.
+ */
+import { z } from 'zod/v4';
+/**
+ * Element (Node) types — matches GraphEngine ontology.
+ * SYS=System, UC=UseCase, ACTOR=Actor, FCHAIN=FunctionChain,
+ * FUNC=Function, FLOW=DataFlow, REQ=Requirement, TEST=TestCase,
+ * MOD=Module, SCHEMA=Contract/Interface (Zod schemas).
+ */
+export declare const ElementType: z.ZodEnum<{
+    SYS: "SYS";
+    UC: "UC";
+    ACTOR: "ACTOR";
+    FCHAIN: "FCHAIN";
+    FUNC: "FUNC";
+    FLOW: "FLOW";
+    REQ: "REQ";
+    TEST: "TEST";
+    MOD: "MOD";
+    SCHEMA: "SCHEMA";
+    SESSION: "SESSION";
+    CR: "CR";
+    MS: "MS";
+}>;
+export type ElementType = z.infer<typeof ElementType>;
+/**
+ * Trace (Edge) types — matches GraphEngine ontology.
+ * compose=parent-child, io=data flow, satisfy=REQ satisfaction,
+ * verify=test coverage, allocate=function-to-module, relation=generic link.
+ */
+export declare const TraceType: z.ZodEnum<{
+    compose: "compose";
+    io: "io";
+    satisfy: "satisfy";
+    verify: "verify";
+    allocate: "allocate";
+    relation: "relation";
+    produces: "produces";
+}>;
+export type TraceType = z.infer<typeof TraceType>;
+/** REQ kind — 7 values aligned with SysML 2.0 + FMEA (CR-180). */
+export declare const ReqKind: z.ZodEnum<{
+    functional: "functional";
+    "non-functional": "non-functional";
+    risk: "risk";
+    negative: "negative";
+    mitigation: "mitigation";
+    precondition: "precondition";
+    postcondition: "postcondition";
+}>;
+export type ReqKind = z.infer<typeof ReqKind>;
+export declare const AsilLevel: z.ZodEnum<{
+    QM: "QM";
+    A: "A";
+    B: "B";
+    C: "C";
+    D: "D";
+}>;
+export type AsilLevel = z.infer<typeof AsilLevel>;
+/** INCOSE TIAD verification method (only relevant for type=TEST). */
+export declare const VerificationMethod: z.ZodEnum<{
+    test: "test";
+    inspection: "inspection";
+    analysis: "analysis";
+    demonstration: "demonstration";
+}>;
+export type VerificationMethod = z.infer<typeof VerificationMethod>;
+/** Test execution result (only relevant for type=TEST). */
+export declare const TestResult: z.ZodEnum<{
+    passed: "passed";
+    failed: "failed";
+    skipped: "skipped";
+    pending: "pending";
+}>;
+export type TestResult = z.infer<typeof TestResult>;
+/**
+ * A repo-relative source path (CR-GC-255, ontology bump 3.8.0) — the path format every
+ * `*Ref.file` binding must use, so a graph-supplied path can never resolve outside the
+ * repo root a consumer joins it onto.
+ *
+ * Pure Zod, deliberately NO `node:path`/`node:fs`: contracts stays I/O-free and
+ * browser-bundlable (CR-GC-253 §2). Rejected:
+ *   - absolute POSIX (`/x`), home-relative (`~/x`), Windows drive (`C:/x`) and UNC (`\\srv`)
+ *   - any `..` path segment (traversal)
+ *   - backslashes (a `..\` escape must not slip past a POSIX-only segment check)
+ *   - the empty string
+ * Accepted: `tests/foo.test.ts`, `src/a/b.ts`, `a..b/c.ts` (`..` only as a full segment).
+ */
+export declare const RepoRelativePathSchema: z.ZodString;
+export type RepoRelativePath = z.infer<typeof RepoRelativePathSchema>;
+/**
+ * Runnable binding for a TEST element (CR-GC-134, ontology bump 3.4.0).
+ * Resolves a TEST node to the concrete artefact a runner can execute, enabling
+ * bottom-up selective test deduction (`graph_tests`): change → impacted TESTs →
+ * `testRef` → minimal selective run command.
+ *   - `file`  : test file path, e.g. `tests/foo.test.ts` (the runner target).
+ *   - `case`  : optional named case/`describe`/`it` block within the file.
+ *   - `tool`  : the runner, e.g. `vitest`, `playwright`, `pytest`.
+ *   - `level` : optional level, e.g. `unit`, `integration`, `validation`.
+ * Stored under `OntologyElement.attributes.testRef` (additive, opt-in validation).
+ */
+export declare const TestRefSchema: z.ZodObject<{
+    file: z.ZodString;
+    case: z.ZodOptional<z.ZodString>;
+    tool: z.ZodString;
+    level: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TestRef = z.infer<typeof TestRefSchema>;
+/**
+ * Code binding for a FUNC element (CR-GC-205 Item 5, ontology bump 3.6.0).
+ * Resolves a FUNC node to the concrete code symbol that realizes it, enabling
+ * graph<->code conformance: every non-concept/non-external FUNC must resolve to a
+ * real symbol in its allocated MOD's file, and (via the consumer's LSP-backed
+ * check) every cross-module-called symbol must itself be a FUNC node.
+ *   - `file`   : implementation file path, e.g. `src/harness.ts` (the symbol's home).
+ *   - `symbol` : the exported symbol (function/method/class) name realizing the FUNC.
+ *   - `lang`   : optional language id (default `ts`) — selects the LSP/engine the
+ *               conformance check drives, so the binding is language-agnostic.
+ * Stored under `OntologyElement.attributes.codeRef` (additive, opt-in validation).
+ */
+export declare const CodeRefSchema: z.ZodObject<{
+    file: z.ZodString;
+    symbol: z.ZodString;
+    lang: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CodeRef = z.infer<typeof CodeRefSchema>;
+/**
+ * Binding of a SCHEMA node to the Zod schema that defines it (CR-211), analogous
+ * to CodeRefSchema for FUNC:
+ *   - `file`   : the source file declaring the Zod schema, e.g. `src/se/ontology.ts`.
+ *   - `symbol` : the exported schema symbol, e.g. `CodeRefSchema`.
+ *   - `lang`   : optional language id (default `ts`).
+ * Stored under `OntologyElement.attributes.schemaRef`. The free-text `contract`
+ * attribute stays as a human description but is no longer the conformance basis:
+ * RC-03 resolves this binding to a declared export, RC-04 checks it is parsed at
+ * the modelled interface.
+ */
+export declare const SchemaRefSchema: z.ZodObject<{
+    file: z.ZodString;
+    symbol: z.ZodString;
+    lang: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SchemaRef = z.infer<typeof SchemaRefSchema>;
+/**
+ * An element (node) in the SE ontology graph.
+ * `attributes` holds type-specific properties (e.g. FUNC.safety_relevant).
+ */
+export declare const OntologyElement: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodEnum<{
+        SYS: "SYS";
+        UC: "UC";
+        ACTOR: "ACTOR";
+        FCHAIN: "FCHAIN";
+        FUNC: "FUNC";
+        FLOW: "FLOW";
+        REQ: "REQ";
+        TEST: "TEST";
+        MOD: "MOD";
+        SCHEMA: "SCHEMA";
+        SESSION: "SESSION";
+        CR: "CR";
+        MS: "MS";
+    }>;
+    name: z.ZodString;
+    description: z.ZodString;
+    asil: z.ZodOptional<z.ZodEnum<{
+        QM: "QM";
+        A: "A";
+        B: "B";
+        C: "C";
+        D: "D";
+    }>>;
+    method: z.ZodOptional<z.ZodEnum<{
+        test: "test";
+        inspection: "inspection";
+        analysis: "analysis";
+        demonstration: "demonstration";
+    }>>;
+    kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        functional: "functional";
+        "non-functional": "non-functional";
+        risk: "risk";
+        negative: "negative";
+        mitigation: "mitigation";
+        precondition: "precondition";
+        postcondition: "postcondition";
+    }>>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    status: z.ZodDefault<z.ZodEnum<{
+        draft: "draft";
+        reviewed: "reviewed";
+        open: "open";
+        done: "done";
+    }>>;
+    created_at: z.ZodString;
+    updated_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type OntologyElement = z.infer<typeof OntologyElement>;
+/**
+ * A trace (edge) in the SE ontology graph.
+ * `label` provides semantic context for 'relation' edges (e.g. 'derives', 'depends-on').
+ */
+/** Trace category: modeling traces are user-visible, audit traces are internal. */
+export declare const TraceCategory: z.ZodEnum<{
+    modeling: "modeling";
+    audit: "audit";
+}>;
+export type TraceCategory = z.infer<typeof TraceCategory>;
+export declare const Trace: z.ZodObject<{
+    source: z.ZodString;
+    target: z.ZodString;
+    type: z.ZodEnum<{
+        compose: "compose";
+        io: "io";
+        satisfy: "satisfy";
+        verify: "verify";
+        allocate: "allocate";
+        relation: "relation";
+        produces: "produces";
+    }>;
+    category: z.ZodOptional<z.ZodEnum<{
+        modeling: "modeling";
+        audit: "audit";
+    }>>;
+    label: z.ZodOptional<z.ZodString>;
+    weight: z.ZodDefault<z.ZodNumber>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    created_at: z.ZodString;
+    verified_at: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type Trace = z.infer<typeof Trace>;
+export declare const OntologyGraph: z.ZodObject<{
+    elements: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<{
+            SYS: "SYS";
+            UC: "UC";
+            ACTOR: "ACTOR";
+            FCHAIN: "FCHAIN";
+            FUNC: "FUNC";
+            FLOW: "FLOW";
+            REQ: "REQ";
+            TEST: "TEST";
+            MOD: "MOD";
+            SCHEMA: "SCHEMA";
+            SESSION: "SESSION";
+            CR: "CR";
+            MS: "MS";
+        }>;
+        name: z.ZodString;
+        description: z.ZodString;
+        asil: z.ZodOptional<z.ZodEnum<{
+            QM: "QM";
+            A: "A";
+            B: "B";
+            C: "C";
+            D: "D";
+        }>>;
+        method: z.ZodOptional<z.ZodEnum<{
+            test: "test";
+            inspection: "inspection";
+            analysis: "analysis";
+            demonstration: "demonstration";
+        }>>;
+        kinds: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+            functional: "functional";
+            "non-functional": "non-functional";
+            risk: "risk";
+            negative: "negative";
+            mitigation: "mitigation";
+            precondition: "precondition";
+            postcondition: "postcondition";
+        }>>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        status: z.ZodDefault<z.ZodEnum<{
+            draft: "draft";
+            reviewed: "reviewed";
+            open: "open";
+            done: "done";
+        }>>;
+        created_at: z.ZodString;
+        updated_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    traces: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        target: z.ZodString;
+        type: z.ZodEnum<{
+            compose: "compose";
+            io: "io";
+            satisfy: "satisfy";
+            verify: "verify";
+            allocate: "allocate";
+            relation: "relation";
+            produces: "produces";
+        }>;
+        category: z.ZodOptional<z.ZodEnum<{
+            modeling: "modeling";
+            audit: "audit";
+        }>>;
+        label: z.ZodOptional<z.ZodString>;
+        weight: z.ZodDefault<z.ZodNumber>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        created_at: z.ZodString;
+        verified_at: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type OntologyGraph = z.infer<typeof OntologyGraph>;
+/** Human-readable descriptions for each ElementType. */
+export declare const ELEMENT_DESCRIPTIONS: Record<ElementType, string>;
+/** Element types used in modeling (user-visible). Excludes audit types (SESSION, CR). */
+export declare const MODELING_ELEMENT_TYPES: ElementType[];
+export interface AttributeSpec {
+    key: string;
+    type: 'string' | 'number' | 'boolean' | 'enum' | 'object';
+    enumValues?: readonly string[];
+    description: string;
+}
+/**
+ * Documented attributes per ElementType.
+ * `attributes` is Record<string,unknown> on the schema level, but these are
+ * the prescribed keys that rules, views, and extractors rely on.
+ */
+export declare const ELEMENT_ATTRIBUTES: Partial<Record<ElementType, AttributeSpec[]>>;

package/dist/se/ontology.js

@@ -0,0 +1,216 @@
+/**
+ * SE Ontology as Zod (version: see ONTOLOGY_VERSION in ./index.ts).
+ * Element + Trace types per INCOSE/SysML 2.0.
+ * @sigloch/contracts/se — single source of truth for SE ontology schemas.
+ */
+import { z } from 'zod/v4';
+/**
+ * Element (Node) types — matches GraphEngine ontology.
+ * SYS=System, UC=UseCase, ACTOR=Actor, FCHAIN=FunctionChain,
+ * FUNC=Function, FLOW=DataFlow, REQ=Requirement, TEST=TestCase,
+ * MOD=Module, SCHEMA=Contract/Interface (Zod schemas).
+ */
+export const ElementType = z.enum([
+    'SYS', 'UC', 'ACTOR', 'FCHAIN',
+    'FUNC', 'FLOW', 'REQ', 'TEST',
+    'MOD', 'SCHEMA', 'SESSION', 'CR',
+    'MS',
+]);
+/**
+ * Trace (Edge) types — matches GraphEngine ontology.
+ * compose=parent-child, io=data flow, satisfy=REQ satisfaction,
+ * verify=test coverage, allocate=function-to-module, relation=generic link.
+ */
+export const TraceType = z.enum([
+    'compose', 'io', 'satisfy', 'verify', 'allocate', 'relation', 'produces',
+]);
+/** REQ kind — 7 values aligned with SysML 2.0 + FMEA (CR-180). */
+export const ReqKind = z.enum([
+    'functional', 'non-functional', 'risk', 'negative',
+    'mitigation', 'precondition', 'postcondition',
+]);
+export const AsilLevel = z.enum(['QM', 'A', 'B', 'C', 'D']);
+/** INCOSE TIAD verification method (only relevant for type=TEST). */
+export const VerificationMethod = z.enum(['test', 'inspection', 'analysis', 'demonstration']);
+/** Test execution result (only relevant for type=TEST). */
+export const TestResult = z.enum(['passed', 'failed', 'skipped', 'pending']);
+/**
+ * A repo-relative source path (CR-GC-255, ontology bump 3.8.0) — the path format every
+ * `*Ref.file` binding must use, so a graph-supplied path can never resolve outside the
+ * repo root a consumer joins it onto.
+ *
+ * Pure Zod, deliberately NO `node:path`/`node:fs`: contracts stays I/O-free and
+ * browser-bundlable (CR-GC-253 §2). Rejected:
+ *   - absolute POSIX (`/x`), home-relative (`~/x`), Windows drive (`C:/x`) and UNC (`\\srv`)
+ *   - any `..` path segment (traversal)
+ *   - backslashes (a `..\` escape must not slip past a POSIX-only segment check)
+ *   - the empty string
+ * Accepted: `tests/foo.test.ts`, `src/a/b.ts`, `a..b/c.ts` (`..` only as a full segment).
+ */
+export const RepoRelativePathSchema = z
+    .string()
+    .min(1, 'path must not be empty')
+    .refine((p) => !p.includes('\\'), { message: 'path must not contain backslashes (use POSIX separators)' })
+    .refine((p) => !p.startsWith('/') && !p.startsWith('~'), { message: 'path must be repo-relative, not absolute' })
+    .refine((p) => !/^[A-Za-z]:/.test(p), { message: 'path must be repo-relative, not a Windows drive path' })
+    .refine((p) => !p.split('/').includes('..'), { message: "path must not contain a '..' segment" });
+/**
+ * Runnable binding for a TEST element (CR-GC-134, ontology bump 3.4.0).
+ * Resolves a TEST node to the concrete artefact a runner can execute, enabling
+ * bottom-up selective test deduction (`graph_tests`): change → impacted TESTs →
+ * `testRef` → minimal selective run command.
+ *   - `file`  : test file path, e.g. `tests/foo.test.ts` (the runner target).
+ *   - `case`  : optional named case/`describe`/`it` block within the file.
+ *   - `tool`  : the runner, e.g. `vitest`, `playwright`, `pytest`.
+ *   - `level` : optional level, e.g. `unit`, `integration`, `validation`.
+ * Stored under `OntologyElement.attributes.testRef` (additive, opt-in validation).
+ */
+export const TestRefSchema = z.object({
+    file: RepoRelativePathSchema,
+    case: z.string().optional(),
+    tool: z.string(),
+    level: z.string().optional(),
+});
+/**
+ * Code binding for a FUNC element (CR-GC-205 Item 5, ontology bump 3.6.0).
+ * Resolves a FUNC node to the concrete code symbol that realizes it, enabling
+ * graph<->code conformance: every non-concept/non-external FUNC must resolve to a
+ * real symbol in its allocated MOD's file, and (via the consumer's LSP-backed
+ * check) every cross-module-called symbol must itself be a FUNC node.
+ *   - `file`   : implementation file path, e.g. `src/harness.ts` (the symbol's home).
+ *   - `symbol` : the exported symbol (function/method/class) name realizing the FUNC.
+ *   - `lang`   : optional language id (default `ts`) — selects the LSP/engine the
+ *               conformance check drives, so the binding is language-agnostic.
+ * Stored under `OntologyElement.attributes.codeRef` (additive, opt-in validation).
+ */
+export const CodeRefSchema = z.object({
+    file: RepoRelativePathSchema,
+    symbol: z.string(),
+    lang: z.string().optional(),
+});
+/**
+ * Binding of a SCHEMA node to the Zod schema that defines it (CR-211), analogous
+ * to CodeRefSchema for FUNC:
+ *   - `file`   : the source file declaring the Zod schema, e.g. `src/se/ontology.ts`.
+ *   - `symbol` : the exported schema symbol, e.g. `CodeRefSchema`.
+ *   - `lang`   : optional language id (default `ts`).
+ * Stored under `OntologyElement.attributes.schemaRef`. The free-text `contract`
+ * attribute stays as a human description but is no longer the conformance basis:
+ * RC-03 resolves this binding to a declared export, RC-04 checks it is parsed at
+ * the modelled interface.
+ */
+export const SchemaRefSchema = z.object({
+    file: RepoRelativePathSchema,
+    symbol: z.string(),
+    lang: z.string().optional(),
+});
+/**
+ * An element (node) in the SE ontology graph.
+ * `attributes` holds type-specific properties (e.g. FUNC.safety_relevant).
+ */
+export const OntologyElement = z.object({
+    id: z.string(),
+    type: ElementType,
+    name: z.string(),
+    description: z.string(),
+    asil: AsilLevel.optional(),
+    /** INCOSE TIAD verification method — only for TEST elements (CR-057). */
+    method: VerificationMethod.optional(),
+    /** REQ kinds: multi-valued classification (CR-180). Only for REQ elements. */
+    kinds: z.array(ReqKind).optional(),
+    attributes: z.record(z.string(), z.unknown()).optional(),
+    status: z.enum(['draft', 'reviewed', 'open', 'done']).default('draft'),
+    created_at: z.string(),
+    updated_at: z.string().optional(),
+});
+/**
+ * A trace (edge) in the SE ontology graph.
+ * `label` provides semantic context for 'relation' edges (e.g. 'derives', 'depends-on').
+ */
+/** Trace category: modeling traces are user-visible, audit traces are internal. */
+export const TraceCategory = z.enum(['modeling', 'audit']);
+export const Trace = z.object({
+    source: z.string(),
+    target: z.string(),
+    type: TraceType,
+    /** 'modeling' (default, user-visible) or 'audit' (internal, e.g. produces traces). Absent = modeling. */
+    category: TraceCategory.optional(),
+    label: z.string().optional(),
+    weight: z.number().default(1),
+    attributes: z.record(z.string(), z.unknown()).optional(),
+    created_at: z.string(),
+    verified_at: z.string().optional(),
+});
+export const OntologyGraph = z.object({
+    elements: z.array(OntologyElement),
+    traces: z.array(Trace),
+});
+// ---------------------------------------------------------------------------
+// Ontology metadata — single source of truth for plugin generators (CR-190)
+// ---------------------------------------------------------------------------
+/** Human-readable descriptions for each ElementType. */
+export const ELEMENT_DESCRIPTIONS = {
+    SYS: 'System (Wurzel)',
+    UC: 'Use Case',
+    ACTOR: 'Akteur (Mensch, System, Geraet)',
+    FCHAIN: 'Funktionskette (UC->FN Verknuepfung)',
+    FUNC: 'Funktion (implementierbare Einheit)',
+    FLOW: 'Datenfluss / Zustandsuebergang',
+    REQ: 'Requirement (funktional oder nicht-funktional)',
+    TEST: 'Testfall',
+    MOD: 'Modul (SW-Paket oder HW-Baugruppe)',
+    SCHEMA: 'Datenschema (Zod)',
+    SESSION: 'Audit-Session',
+    CR: 'Change Request',
+    MS: 'Meilenstein',
+};
+/** Element types used in modeling (user-visible). Excludes audit types (SESSION, CR). */
+export const MODELING_ELEMENT_TYPES = ElementType.options.filter(t => t !== 'SESSION' && t !== 'CR');
+/**
+ * Documented attributes per ElementType.
+ * `attributes` is Record<string,unknown> on the schema level, but these are
+ * the prescribed keys that rules, views, and extractors rely on.
+ */
+export const ELEMENT_ATTRIBUTES = {
+    TEST: [
+        { key: 'testResult', type: 'enum', enumValues: TestResult.options, description: 'Test execution outcome' },
+        { key: 'sourceFile', type: 'string', description: 'Test file path (e.g. tests/foo.test.ts)' },
+        { key: 'testRef', type: 'object', description: 'Runnable binding {file, case?, tool, level?} — see TestRefSchema (CR-GC-134)' },
+        { key: 'concept', type: 'boolean', description: 'Concept-only TEST: no run artifact yet; exempt from the R-19 testRef-binding requirement (CR-GC-205)' },
+    ],
+    REQ: [
+        { key: 'severity', type: 'number', description: 'FMEA severity (1-10)' },
+        { key: 'occurrence', type: 'number', description: 'FMEA occurrence (1-10)' },
+        { key: 'detection', type: 'number', description: 'FMEA detection (1-10)' },
+    ],
+    FUNC: [
+        { key: 'safety_relevant', type: 'boolean', description: 'Function is safety-relevant' },
+        { key: 'timingBudgetMs', type: 'number', description: 'NFR timing budget in ms' },
+        { key: 'measuredMs', type: 'number', description: 'Measured execution time in ms' },
+        { key: 'sourceFile', type: 'string', description: 'Implementation source file' },
+        { key: 'codeRef', type: 'object', description: 'Code binding {file, symbol, lang?} — the symbol that realizes this FUNC; see CodeRefSchema (CR-GC-205)' },
+        { key: 'external', type: 'boolean', description: 'Externally-realized FUNC (e.g. a renderer in another package): exempt from the R-20 codeRef-binding requirement (CR-GC-205)' },
+        { key: 'concept', type: 'boolean', description: 'Concept-only FUNC: specified, no implementation yet; exempt from R-20 (CR-GC-205)' },
+    ],
+    UC: [
+        { key: 'operatingMode', type: 'string', description: 'ConOps operating mode' },
+    ],
+    CR: [
+        { key: 'status', type: 'enum', enumValues: ['open', 'done'], description: 'CR completion status' },
+        { key: 'rationale', type: 'string', description: 'Reason for the change' },
+        { key: 'spike', type: 'boolean', description: 'CR is a spike/exploration' },
+    ],
+    FLOW: [
+        { key: 'protocol', type: 'string', description: 'ICD protocol (e.g. REST, gRPC)' },
+        { key: 'qos', type: 'string', description: 'Quality of Service level' },
+    ],
+    MOD: [
+        { key: 'path', type: 'string', description: 'Source file or glob the module owns, e.g. src/harness.ts — anchors the MOD<->file mapping for graph<->code conformance (CR-GC-205)' },
+    ],
+    SCHEMA: [
+        { key: 'contract', type: 'string', description: 'Free-text contract description, e.g. "@sigloch/contracts LiveUpdateEventSchema" — human hint only, not the conformance basis (CR-211)' },
+        { key: 'schemaRef', type: 'object', description: 'Schema binding {file, symbol, lang?} — the Zod export defining this SCHEMA; see SchemaRefSchema (CR-211)' },
+        { key: 'external', type: 'boolean', description: 'Externally-defined SCHEMA (e.g. a foreign-API contract): exempt from the schemaRef-presence requirement (CR-211)' },
+        { key: 'concept', type: 'boolean', description: 'Concept-only SCHEMA: modelled, no Zod export yet; exempt from the schemaRef-presence requirement (CR-211)' },
+    ],
+};

package/dist/se/quality-rules.d.ts

@@ -0,0 +1,28 @@
+/**
+ * BQ-01 through BQ-07 — Base Quality rules for artefact descriptions.
+ * Complement the structural V3 rules (R-01..R-12) with content-level checks
+ * on REQ element descriptions (weasel words, verifiability, atomicity, etc.).
+ */
+import type { OntologyGraph } from './ontology.js';
+import type { RuleDefinition, RuleViolation } from './rules.js';
+export declare function bq01Unambiguous(graph: OntologyGraph): RuleViolation[];
+export declare function bq02Verifiable(graph: OntologyGraph): RuleViolation[];
+/**
+ * Inject a pre-computed similarity matrix for BQ-04.
+ * Call this before evaluateBQRules() when embeddings are available.
+ * Pass null to clear.
+ */
+export declare function setBQ04SimilarityMatrix(data: {
+    reqIds: string[];
+    matrix: number[][];
+} | null): void;
+/**
+ * BQ-04 checks for duplicate / near-duplicate requirements using
+ * pre-computed embedding similarity. Returns [] when no matrix is set.
+ */
+export declare function bq04Necessary(graph: OntologyGraph): RuleViolation[];
+export declare function bq06Conforming(graph: OntologyGraph): RuleViolation[];
+export declare function bq07Complete(graph: OntologyGraph): RuleViolation[];
+export declare const BQ_RULES: RuleDefinition[];
+/** Run all BQ rules against a graph, returning combined violations. */
+export declare function evaluateBQRules(graph: OntologyGraph): RuleViolation[];