open-wiki-spec 0.1.0

package/dist/core/schema/index.d.ts

@@ -0,0 +1,235 @@
+export declare const SCHEMA_REGISTRY: {
+    readonly feature: {
+        readonly frontmatter: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"feature">;
+            status: import("zod").ZodEnum<["active", "deprecated"]>;
+            systems: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            sources: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            decisions: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            changes: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"feature">;
+            status: import("zod").ZodEnum<["active", "deprecated"]>;
+            systems: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            sources: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            decisions: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            changes: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"feature">;
+            status: import("zod").ZodEnum<["active", "deprecated"]>;
+            systems: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            sources: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            decisions: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            changes: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        readonly requiredSections: readonly ["Purpose", "Current Behavior", "Constraints", "Known Gaps", "Requirements"];
+    };
+    readonly change: {
+        readonly frontmatter: import("zod").ZodEffects<import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"change">;
+            status: import("zod").ZodEnum<["proposed", "planned", "in_progress", "applied"]>;
+            created_at: import("zod").ZodString;
+            feature: import("zod").ZodOptional<import("zod").ZodString>;
+            features: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            depends_on: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            touches: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            systems: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            sources: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            decisions: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"change">;
+            status: import("zod").ZodEnum<["proposed", "planned", "in_progress", "applied"]>;
+            created_at: import("zod").ZodString;
+            feature: import("zod").ZodOptional<import("zod").ZodString>;
+            features: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            depends_on: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            touches: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            systems: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            sources: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            decisions: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"change">;
+            status: import("zod").ZodEnum<["proposed", "planned", "in_progress", "applied"]>;
+            created_at: import("zod").ZodString;
+            feature: import("zod").ZodOptional<import("zod").ZodString>;
+            features: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            depends_on: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            touches: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            systems: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            sources: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            decisions: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">>, import("zod").objectOutputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"change">;
+            status: import("zod").ZodEnum<["proposed", "planned", "in_progress", "applied"]>;
+            created_at: import("zod").ZodString;
+            feature: import("zod").ZodOptional<import("zod").ZodString>;
+            features: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            depends_on: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            touches: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            systems: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            sources: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            decisions: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"change">;
+            status: import("zod").ZodEnum<["proposed", "planned", "in_progress", "applied"]>;
+            created_at: import("zod").ZodString;
+            feature: import("zod").ZodOptional<import("zod").ZodString>;
+            features: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            depends_on: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            touches: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            systems: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            sources: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            decisions: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        readonly requiredSections: readonly ["Why", "Delta Summary", "Proposed Update", "Impact", "Tasks", "Validation"];
+    };
+    readonly system: {
+        readonly frontmatter: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"system">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"system">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"system">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        readonly requiredSections: readonly ["Overview", "Boundaries", "Key Components", "Interfaces"];
+    };
+    readonly decision: {
+        readonly frontmatter: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"decision">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+            features: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            changes: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"decision">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+            features: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            changes: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"decision">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+            features: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            changes: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        readonly requiredSections: readonly ["Context", "Options Considered", "Decision", "Consequences"];
+    };
+    readonly source: {
+        readonly frontmatter: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"source">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+            source_type: import("zod").ZodOptional<import("zod").ZodEnum<["prd", "issue", "meeting", "code_reading", "research", "other"]>>;
+            url: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"source">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+            source_type: import("zod").ZodOptional<import("zod").ZodEnum<["prd", "issue", "meeting", "code_reading", "research", "other"]>>;
+            url: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"source">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+            source_type: import("zod").ZodOptional<import("zod").ZodEnum<["prd", "issue", "meeting", "code_reading", "research", "other"]>>;
+            url: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        readonly requiredSections: readonly ["Summary", "Key Points"];
+    };
+    readonly query: {
+        readonly frontmatter: import("zod").ZodObject<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"query">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+            question: import("zod").ZodOptional<import("zod").ZodString>;
+            consulted: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            features: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            systems: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"query">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+            question: import("zod").ZodOptional<import("zod").ZodString>;
+            consulted: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            features: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            systems: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            id: import("zod").ZodString;
+            tags: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        } & {
+            type: import("zod").ZodLiteral<"query">;
+            status: import("zod").ZodEnum<["active", "draft", "archived"]>;
+            question: import("zod").ZodOptional<import("zod").ZodString>;
+            consulted: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            features: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            systems: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+        readonly requiredSections: readonly ["Question", "Findings", "Conclusion"];
+    };
+};
+export { BaseFrontmatterSchema, NoteTypeEnum, NoteStatusEnum, ChangeStatusEnum, FeatureStatusEnum, GeneralStatusEnum, WikilinkRefSchema, type NoteType, } from './base.schema.js';
+export { FrontmatterSchema, type Frontmatter } from './frontmatter.js';
+export { FeatureFrontmatterSchema, FEATURE_REQUIRED_SECTIONS, FEATURE_OPTIONAL_SECTIONS } from './feature.schema.js';
+export { ChangeFrontmatterSchema, CHANGE_REQUIRED_SECTIONS, CHANGE_SOFT_SECTIONS, CHANGE_OPTIONAL_SECTIONS, CHANGE_STATUS_TRANSITIONS, PLANNED_HARD_PREREQUISITES, PLANNED_SOFT_PREREQUISITES, } from './change.schema.js';
+export { SystemFrontmatterSchema, SYSTEM_REQUIRED_SECTIONS } from './system.schema.js';
+export { DecisionFrontmatterSchema, DECISION_REQUIRED_SECTIONS } from './decision.schema.js';
+export { SourceFrontmatterSchema, SOURCE_REQUIRED_SECTIONS } from './source.schema.js';
+export { QueryFrontmatterSchema, QUERY_REQUIRED_SECTIONS } from './query.schema.js';
+export { RequirementSchema, ScenarioSchema, type Requirement, type Scenario } from './requirement.js';
+export { DeltaSummaryEntrySchema, DeltaOpEnum, DeltaTargetTypeEnum, DELTA_APPLY_ORDER, DELTA_REQUIREMENT_PATTERN, DELTA_RENAMED_PATTERN, DELTA_SECTION_PATTERN, type DeltaOp, type DeltaTargetType, type DeltaSummaryEntry, } from './delta-summary.js';
+export { WHY_MIN_LENGTH, MAX_DELTAS_PER_CHANGE } from './validation-constants.js';
+export { scaffoldFeature, scaffoldChange, scaffoldSystem, scaffoldDecision, scaffoldSource, scaffoldQuery, SCAFFOLD_REGISTRY, } from './templates.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/schema/index.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBwE,CAAC;AAGrG,OAAO,EACL,qBAAqB,EACrB,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,EACjB,KAAK,QAAQ,GACd,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,iBAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAGvE,OAAO,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrH,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACvF,OAAO,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAC7F,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACvF,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAGpF,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAGtG,OAAO,EACL,uBAAuB,EACvB,WAAW,EACX,mBAAmB,EACnB,iBAAiB,EACjB,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,EACrB,KAAK,OAAO,EACZ,KAAK,eAAe,EACpB,KAAK,iBAAiB,GACvB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAGlF,OAAO,EACL,eAAe,EACf,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,iBAAiB,GAClB,MAAM,gBAAgB,CAAC"}

package/dist/core/schema/index.js

@@ -0,0 +1,52 @@
+import { FeatureFrontmatterSchema, FEATURE_REQUIRED_SECTIONS } from './feature.schema.js';
+import { ChangeFrontmatterSchema, CHANGE_REQUIRED_SECTIONS } from './change.schema.js';
+import { SystemFrontmatterSchema, SYSTEM_REQUIRED_SECTIONS } from './system.schema.js';
+import { DecisionFrontmatterSchema, DECISION_REQUIRED_SECTIONS } from './decision.schema.js';
+import { SourceFrontmatterSchema, SOURCE_REQUIRED_SECTIONS } from './source.schema.js';
+import { QueryFrontmatterSchema, QUERY_REQUIRED_SECTIONS } from './query.schema.js';
+export const SCHEMA_REGISTRY = {
+    feature: {
+        frontmatter: FeatureFrontmatterSchema,
+        requiredSections: FEATURE_REQUIRED_SECTIONS,
+    },
+    change: {
+        frontmatter: ChangeFrontmatterSchema,
+        requiredSections: CHANGE_REQUIRED_SECTIONS,
+    },
+    system: {
+        frontmatter: SystemFrontmatterSchema,
+        requiredSections: SYSTEM_REQUIRED_SECTIONS,
+    },
+    decision: {
+        frontmatter: DecisionFrontmatterSchema,
+        requiredSections: DECISION_REQUIRED_SECTIONS,
+    },
+    source: {
+        frontmatter: SourceFrontmatterSchema,
+        requiredSections: SOURCE_REQUIRED_SECTIONS,
+    },
+    query: {
+        frontmatter: QueryFrontmatterSchema,
+        requiredSections: QUERY_REQUIRED_SECTIONS,
+    },
+};
+// Base
+export { BaseFrontmatterSchema, NoteTypeEnum, NoteStatusEnum, ChangeStatusEnum, FeatureStatusEnum, GeneralStatusEnum, WikilinkRefSchema, } from './base.schema.js';
+// Frontmatter union
+export { FrontmatterSchema } from './frontmatter.js';
+// Per-type schemas
+export { FeatureFrontmatterSchema, FEATURE_REQUIRED_SECTIONS, FEATURE_OPTIONAL_SECTIONS } from './feature.schema.js';
+export { ChangeFrontmatterSchema, CHANGE_REQUIRED_SECTIONS, CHANGE_SOFT_SECTIONS, CHANGE_OPTIONAL_SECTIONS, CHANGE_STATUS_TRANSITIONS, PLANNED_HARD_PREREQUISITES, PLANNED_SOFT_PREREQUISITES, } from './change.schema.js';
+export { SystemFrontmatterSchema, SYSTEM_REQUIRED_SECTIONS } from './system.schema.js';
+export { DecisionFrontmatterSchema, DECISION_REQUIRED_SECTIONS } from './decision.schema.js';
+export { SourceFrontmatterSchema, SOURCE_REQUIRED_SECTIONS } from './source.schema.js';
+export { QueryFrontmatterSchema, QUERY_REQUIRED_SECTIONS } from './query.schema.js';
+// Requirement + Scenario
+export { RequirementSchema, ScenarioSchema } from './requirement.js';
+// Delta Summary
+export { DeltaSummaryEntrySchema, DeltaOpEnum, DeltaTargetTypeEnum, DELTA_APPLY_ORDER, DELTA_REQUIREMENT_PATTERN, DELTA_RENAMED_PATTERN, DELTA_SECTION_PATTERN, } from './delta-summary.js';
+// Validation constants
+export { WHY_MIN_LENGTH, MAX_DELTAS_PER_CHANGE } from './validation-constants.js';
+// Templates
+export { scaffoldFeature, scaffoldChange, scaffoldSystem, scaffoldDecision, scaffoldSource, scaffoldQuery, SCAFFOLD_REGISTRY, } from './templates.js';
+//# sourceMappingURL=index.js.map

package/dist/core/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/schema/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AAC1F,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACvF,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACvF,OAAO,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAC7F,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACvF,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAEpF,MAAM,CAAC,MAAM,eAAe,GAAG;IAC7B,OAAO,EAAE;QACP,WAAW,EAAE,wBAAwB;QACrC,gBAAgB,EAAE,yBAAyB;KAC5C;IACD,MAAM,EAAE;QACN,WAAW,EAAE,uBAAuB;QACpC,gBAAgB,EAAE,wBAAwB;KAC3C;IACD,MAAM,EAAE;QACN,WAAW,EAAE,uBAAuB;QACpC,gBAAgB,EAAE,wBAAwB;KAC3C;IACD,QAAQ,EAAE;QACR,WAAW,EAAE,yBAAyB;QACtC,gBAAgB,EAAE,0BAA0B;KAC7C;IACD,MAAM,EAAE;QACN,WAAW,EAAE,uBAAuB;QACpC,gBAAgB,EAAE,wBAAwB;KAC3C;IACD,KAAK,EAAE;QACL,WAAW,EAAE,sBAAsB;QACnC,gBAAgB,EAAE,uBAAuB;KAC1C;CACiG,CAAC;AAErG,OAAO;AACP,OAAO,EACL,qBAAqB,EACrB,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EACjB,iBAAiB,GAElB,MAAM,kBAAkB,CAAC;AAE1B,oBAAoB;AACpB,OAAO,EAAE,iBAAiB,EAAoB,MAAM,kBAAkB,CAAC;AAEvE,mBAAmB;AACnB,OAAO,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrH,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACvF,OAAO,EAAE,yBAAyB,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAC7F,OAAO,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AACvF,OAAO,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAC;AAEpF,yBAAyB;AACzB,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAmC,MAAM,kBAAkB,CAAC;AAEtG,gBAAgB;AAChB,OAAO,EACL,uBAAuB,EACvB,WAAW,EACX,mBAAmB,EACnB,iBAAiB,EACjB,yBAAyB,EACzB,qBAAqB,EACrB,qBAAqB,GAItB,MAAM,oBAAoB,CAAC;AAE5B,uBAAuB;AACvB,OAAO,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAElF,YAAY;AACZ,OAAO,EACL,eAAe,EACf,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,cAAc,EACd,aAAa,EACb,iBAAiB,GAClB,MAAM,gBAAgB,CAAC"}

package/dist/core/schema/query.schema.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+/**
+ * Query frontmatter schema.
+ * Follows 00-unified-types.md QueryFrontmatter.
+ */
+export declare const QueryFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    type: z.ZodLiteral<"query">;
+    status: z.ZodEnum<["active", "draft", "archived"]>;
+    question: z.ZodOptional<z.ZodString>;
+    consulted: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    systems: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    type: z.ZodLiteral<"query">;
+    status: z.ZodEnum<["active", "draft", "archived"]>;
+    question: z.ZodOptional<z.ZodString>;
+    consulted: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    systems: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    type: z.ZodLiteral<"query">;
+    status: z.ZodEnum<["active", "draft", "archived"]>;
+    question: z.ZodOptional<z.ZodString>;
+    consulted: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    systems: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, z.ZodTypeAny, "passthrough">>;
+export type QueryFrontmatter = z.infer<typeof QueryFrontmatterSchema>;
+export declare const QUERY_REQUIRED_SECTIONS: readonly ["Question", "Findings", "Conclusion"];
+//# sourceMappingURL=query.schema.d.ts.map

package/dist/core/schema/query.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.schema.d.ts","sourceRoot":"","sources":["../../../src/core/schema/query.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAOjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,uBAAuB,iDAI1B,CAAC"}

package/dist/core/schema/query.schema.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { BaseFrontmatterSchema, GeneralStatusEnum, WikilinkRefSchema } from './base.schema.js';
+/**
+ * Query frontmatter schema.
+ * Follows 00-unified-types.md QueryFrontmatter.
+ */
+export const QueryFrontmatterSchema = BaseFrontmatterSchema.extend({
+    type: z.literal('query'),
+    status: GeneralStatusEnum,
+    question: z.string().min(1, 'Query must state its question').optional(),
+    consulted: z.array(WikilinkRefSchema).optional(),
+    features: z.array(WikilinkRefSchema).optional(),
+    systems: z.array(WikilinkRefSchema).optional(),
+});
+export const QUERY_REQUIRED_SECTIONS = [
+    'Question',
+    'Findings',
+    'Conclusion',
+];
+//# sourceMappingURL=query.schema.js.map

package/dist/core/schema/query.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.schema.js","sourceRoot":"","sources":["../../../src/core/schema/query.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE/F;;;GAGG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,qBAAqB,CAAC,MAAM,CAAC;IACjE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC;IACxB,MAAM,EAAE,iBAAiB;IACzB,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,+BAA+B,CAAC,CAAC,QAAQ,EAAE;IACvE,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,QAAQ,EAAE;IAChD,QAAQ,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,QAAQ,EAAE;IAC/C,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC,QAAQ,EAAE;CAC/C,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,UAAU;IACV,UAAU;IACV,YAAY;CACJ,CAAC"}

package/dist/core/schema/requirement.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+/**
+ * Scenario schema.
+ * Follows 00-unified-types.md Scenario.
+ */
+export declare const ScenarioSchema: z.ZodObject<{
+    /** Name from `#### Scenario: <name>` header */
+    name: z.ZodString;
+    /** Raw text of the scenario (WHEN/THEN lines) */
+    raw_text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    raw_text: string;
+}, {
+    name: string;
+    raw_text: string;
+}>;
+export type Scenario = z.infer<typeof ScenarioSchema>;
+/**
+ * Requirement schema.
+ * Follows 00-unified-types.md Requirement.
+ *
+ * - Normative statement must contain SHALL or MUST
+ * - At least 1 scenario per requirement
+ * - Composite key: `${feature_id}::${name}`
+ */
+export declare const RequirementSchema: z.ZodObject<{
+    /** Stable name from `### Requirement: <name>` header */
+    name: z.ZodString;
+    /** Composite key: `${feature_id}::${name}` */
+    key: z.ZodString;
+    /** The normative statement containing SHALL or MUST */
+    normative: z.ZodEffects<z.ZodString, string, string>;
+    /** Array of scenario objects */
+    scenarios: z.ZodArray<z.ZodObject<{
+        /** Name from `#### Scenario: <name>` header */
+        name: z.ZodString;
+        /** Raw text of the scenario (WHEN/THEN lines) */
+        raw_text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        raw_text: string;
+    }, {
+        name: string;
+        raw_text: string;
+    }>, "many">;
+    /** SHA-256 of normalized content */
+    content_hash: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    content_hash: string;
+    key: string;
+    name: string;
+    normative: string;
+    scenarios: {
+        name: string;
+        raw_text: string;
+    }[];
+}, {
+    content_hash: string;
+    key: string;
+    name: string;
+    normative: string;
+    scenarios: {
+        name: string;
+        raw_text: string;
+    }[];
+}>;
+export type Requirement = z.infer<typeof RequirementSchema>;
+//# sourceMappingURL=requirement.d.ts.map

package/dist/core/schema/requirement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirement.d.ts","sourceRoot":"","sources":["../../../src/core/schema/requirement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,cAAc;IACzB,+CAA+C;;IAE/C,iDAAiD;;;;;;;;EAEjD,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAEtD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;IAC5B,wDAAwD;;IAExD,8CAA8C;;IAE9C,uDAAuD;;IAOvD,gCAAgC;;QA5BhC,+CAA+C;;QAE/C,iDAAiD;;;;;;;;;IA6BjD,oCAAoC;;;;;;;;;;;;;;;;;;;;EAEpC,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/core/schema/requirement.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+/**
+ * Scenario schema.
+ * Follows 00-unified-types.md Scenario.
+ */
+export const ScenarioSchema = z.object({
+    /** Name from `#### Scenario: <name>` header */
+    name: z.string().min(1),
+    /** Raw text of the scenario (WHEN/THEN lines) */
+    raw_text: z.string().min(1),
+});
+/**
+ * Requirement schema.
+ * Follows 00-unified-types.md Requirement.
+ *
+ * - Normative statement must contain SHALL or MUST
+ * - At least 1 scenario per requirement
+ * - Composite key: `${feature_id}::${name}`
+ */
+export const RequirementSchema = z.object({
+    /** Stable name from `### Requirement: <name>` header */
+    name: z.string().min(1),
+    /** Composite key: `${feature_id}::${name}` */
+    key: z.string().min(1),
+    /** The normative statement containing SHALL or MUST */
+    normative: z.string()
+        .min(1, 'Normative statement is required')
+        .refine((text) => text.includes('SHALL') || text.includes('MUST'), 'Normative statement must contain SHALL or MUST'),
+    /** Array of scenario objects */
+    scenarios: z.array(ScenarioSchema)
+        .min(1, 'At least one scenario is required'),
+    /** SHA-256 of normalized content */
+    content_hash: z.string(),
+});
+//# sourceMappingURL=requirement.js.map

package/dist/core/schema/requirement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirement.js","sourceRoot":"","sources":["../../../src/core/schema/requirement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC;IACrC,+CAA+C;IAC/C,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,iDAAiD;IACjD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CAC5B,CAAC,CAAC;AAIH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,wDAAwD;IACxD,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACvB,8CAA8C;IAC9C,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACtB,uDAAuD;IACvD,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;SAClB,GAAG,CAAC,CAAC,EAAE,iCAAiC,CAAC;SACzC,MAAM,CACL,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EACzD,gDAAgD,CACjD;IACH,gCAAgC;IAChC,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,cAAc,CAAC;SAC/B,GAAG,CAAC,CAAC,EAAE,mCAAmC,CAAC;IAC9C,oCAAoC;IACpC,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE;CACzB,CAAC,CAAC"}

package/dist/core/schema/source.schema.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+/**
+ * Source frontmatter schema.
+ * Follows 00-unified-types.md SourceFrontmatter.
+ */
+export declare const SourceFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    type: z.ZodLiteral<"source">;
+    status: z.ZodEnum<["active", "draft", "archived"]>;
+    source_type: z.ZodOptional<z.ZodEnum<["prd", "issue", "meeting", "code_reading", "research", "other"]>>;
+    url: z.ZodOptional<z.ZodString>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    type: z.ZodLiteral<"source">;
+    status: z.ZodEnum<["active", "draft", "archived"]>;
+    source_type: z.ZodOptional<z.ZodEnum<["prd", "issue", "meeting", "code_reading", "research", "other"]>>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    type: z.ZodLiteral<"source">;
+    status: z.ZodEnum<["active", "draft", "archived"]>;
+    source_type: z.ZodOptional<z.ZodEnum<["prd", "issue", "meeting", "code_reading", "research", "other"]>>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.ZodTypeAny, "passthrough">>;
+export type SourceFrontmatter = z.infer<typeof SourceFrontmatterSchema>;
+export declare const SOURCE_REQUIRED_SECTIONS: readonly ["Summary", "Key Points"];
+//# sourceMappingURL=source.schema.d.ts.map

package/dist/core/schema/source.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.schema.d.ts","sourceRoot":"","sources":["../../../src/core/schema/source.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;gCAYlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,wBAAwB,oCAG3B,CAAC"}

package/dist/core/schema/source.schema.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { BaseFrontmatterSchema, GeneralStatusEnum } from './base.schema.js';
+/**
+ * Source frontmatter schema.
+ * Follows 00-unified-types.md SourceFrontmatter.
+ */
+export const SourceFrontmatterSchema = BaseFrontmatterSchema.extend({
+    type: z.literal('source'),
+    status: GeneralStatusEnum,
+    source_type: z.enum([
+        'prd',
+        'issue',
+        'meeting',
+        'code_reading',
+        'research',
+        'other',
+    ]).optional(),
+    url: z.string().url().optional(),
+});
+export const SOURCE_REQUIRED_SECTIONS = [
+    'Summary',
+    'Key Points',
+];
+//# sourceMappingURL=source.schema.js.map

package/dist/core/schema/source.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.schema.js","sourceRoot":"","sources":["../../../src/core/schema/source.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE5E;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,qBAAqB,CAAC,MAAM,CAAC;IAClE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;IACzB,MAAM,EAAE,iBAAiB;IACzB,WAAW,EAAE,CAAC,CAAC,IAAI,CAAC;QAClB,KAAK;QACL,OAAO;QACP,SAAS;QACT,cAAc;QACd,UAAU;QACV,OAAO;KACR,CAAC,CAAC,QAAQ,EAAE;IACb,GAAG,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;CACjC,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,SAAS;IACT,YAAY;CACJ,CAAC"}

package/dist/core/schema/system.schema.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+/**
+ * System frontmatter schema.
+ * Follows 00-unified-types.md SystemFrontmatter.
+ */
+export declare const SystemFrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    type: z.ZodLiteral<"system">;
+    status: z.ZodEnum<["active", "draft", "archived"]>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    id: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    type: z.ZodLiteral<"system">;
+    status: z.ZodEnum<["active", "draft", "archived"]>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    id: z.ZodString;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    type: z.ZodLiteral<"system">;
+    status: z.ZodEnum<["active", "draft", "archived"]>;
+}, z.ZodTypeAny, "passthrough">>;
+export type SystemFrontmatter = z.infer<typeof SystemFrontmatterSchema>;
+export declare const SYSTEM_REQUIRED_SECTIONS: readonly ["Overview", "Boundaries", "Key Components", "Interfaces"];
+//# sourceMappingURL=system.schema.d.ts.map

package/dist/core/schema/system.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.schema.d.ts","sourceRoot":"","sources":["../../../src/core/schema/system.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;GAGG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;gCAGlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE,eAAO,MAAM,wBAAwB,qEAK3B,CAAC"}

package/dist/core/schema/system.schema.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { BaseFrontmatterSchema, GeneralStatusEnum } from './base.schema.js';
+/**
+ * System frontmatter schema.
+ * Follows 00-unified-types.md SystemFrontmatter.
+ */
+export const SystemFrontmatterSchema = BaseFrontmatterSchema.extend({
+    type: z.literal('system'),
+    status: GeneralStatusEnum,
+});
+export const SYSTEM_REQUIRED_SECTIONS = [
+    'Overview',
+    'Boundaries',
+    'Key Components',
+    'Interfaces',
+];
+//# sourceMappingURL=system.schema.js.map

package/dist/core/schema/system.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.schema.js","sourceRoot":"","sources":["../../../src/core/schema/system.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE5E;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,qBAAqB,CAAC,MAAM,CAAC;IAClE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;IACzB,MAAM,EAAE,iBAAiB;CAC1B,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,UAAU;IACV,YAAY;IACZ,gBAAgB;IAChB,YAAY;CACJ,CAAC"}

package/dist/core/schema/templates.d.ts

@@ -0,0 +1,14 @@
+import type { NoteType } from './base.schema.js';
+/**
+ * Scaffolding functions for creating new notes with proper structure.
+ * Used by init and workflow commands.
+ */
+export declare function scaffoldFeature(id: string, title: string, systemRef: string): string;
+export declare function scaffoldChange(id: string, title: string, featureRef: string, systemRef: string, createdAt: string): string;
+export declare function scaffoldSystem(id: string, title: string): string;
+export declare function scaffoldDecision(id: string, title: string): string;
+export declare function scaffoldSource(id: string, title: string): string;
+export declare function scaffoldQuery(id: string, title: string): string;
+/** Registry mapping note type to scaffolding function */
+export declare const SCAFFOLD_REGISTRY: Record<NoteType, (...args: string[]) => string>;
+//# sourceMappingURL=templates.d.ts.map