@claudexor/schema 1.0.0

package/dist/spec.d.ts

@@ -0,0 +1,561 @@
+import { z } from "zod";
+/**
+ * SpecPack — the frozen, versioned, diffable specification produced by the
+ * spec interview (the hierarchical clarify-quiz). It is the SSOT a run is held
+ * to: a SpecPack maps deterministically into a TaskContract. Unlike spec-first
+ * tools that regenerate an opaque blob, this is spec-anchored: versioned with
+ * section-level diffs across revisions.
+ */
+export declare const InterviewQuestionKind: z.ZodEnum<["single", "multi", "text"]>;
+export type InterviewQuestionKind = z.infer<typeof InterviewQuestionKind>;
+export declare const InterviewOption: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    label: string;
+}, {
+    id: string;
+    label: string;
+}>;
+export type InterviewOption = z.infer<typeof InterviewOption>;
+/** One quiz card. `tier` expresses the hierarchical depth (0 = foundational). */
+export declare const InterviewQuestion: z.ZodObject<{
+    id: z.ZodString;
+    tier: z.ZodDefault<z.ZodNumber>;
+    prompt: z.ZodString;
+    kind: z.ZodDefault<z.ZodEnum<["single", "multi", "text"]>>;
+    options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        label: string;
+    }, {
+        id: string;
+        label: string;
+    }>, "many">>;
+    /** Whether free-text is accepted in addition to / instead of options. */
+    allow_text: z.ZodDefault<z.ZodBoolean>;
+    rationale: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        id: string;
+        label: string;
+    }[];
+    id: string;
+    kind: "text" | "single" | "multi";
+    prompt: string;
+    tier: number;
+    allow_text: boolean;
+    rationale?: string | undefined;
+}, {
+    id: string;
+    prompt: string;
+    options?: {
+        id: string;
+        label: string;
+    }[] | undefined;
+    kind?: "text" | "single" | "multi" | undefined;
+    tier?: number | undefined;
+    allow_text?: boolean | undefined;
+    rationale?: string | undefined;
+}>;
+export type InterviewQuestion = z.infer<typeof InterviewQuestion>;
+export declare const InterviewAnswer: z.ZodObject<{
+    question_id: z.ZodString;
+    option_ids: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    text: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    question_id: string;
+    text: string | null;
+    option_ids: string[];
+}, {
+    question_id: string;
+    text?: string | null | undefined;
+    option_ids?: string[] | undefined;
+}>;
+export type InterviewAnswer = z.infer<typeof InterviewAnswer>;
+/**
+ * An explicit unresolved ambiguity (NEEDS_CLARIFICATION). The interview refuses
+ * to freeze while any of these are `open` — nothing is silently guessed.
+ */
+export declare const ClarificationItem: z.ZodObject<{
+    id: z.ZodString;
+    claim: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<["open", "resolved"]>>;
+    resolution: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    status: "open" | "resolved";
+    id: string;
+    claim: string;
+    resolution: string | null;
+}, {
+    id: string;
+    claim: string;
+    status?: "open" | "resolved" | undefined;
+    resolution?: string | null | undefined;
+}>;
+export type ClarificationItem = z.infer<typeof ClarificationItem>;
+/** Acceptance criterion in EARS style ("WHEN <cond>, THE SYSTEM SHALL <behavior>"). */
+export declare const SpecAcceptanceCriterion: z.ZodObject<{
+    id: z.ZodString;
+    behavior: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    required: boolean;
+    behavior: string;
+}, {
+    id: string;
+    behavior: string;
+    required?: boolean | undefined;
+}>;
+export type SpecAcceptanceCriterion = z.infer<typeof SpecAcceptanceCriterion>;
+/** A dependency-ordered task in the implementation checklist. */
+export declare const SpecTask: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    done: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    title: string;
+    done: boolean;
+    depends_on: string[];
+}, {
+    id: string;
+    title: string;
+    done?: boolean | undefined;
+    depends_on?: string[] | undefined;
+}>;
+export type SpecTask = z.infer<typeof SpecTask>;
+export declare const SpecConstraints: z.ZodObject<{
+    /** Spec-owned protected paths can raise review risk; per-run approvals cannot be frozen into a spec. */
+    protected_paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    protected_paths: string[];
+}, {
+    protected_paths?: string[] | undefined;
+}>;
+export type SpecConstraints = z.infer<typeof SpecConstraints>;
+/**
+ * Schema-level invariants (SSOT, enforced on every parse — even when loaded from
+ * disk, not just via the engine): a frozen spec cannot carry open clarifications,
+ * and a "resolved" clarification must record a non-empty resolution. This makes a
+ * frozen-but-ambiguous SpecPack unrepresentable — no silent guessing.
+ */
+export declare const SpecPack: z.ZodEffects<z.ZodObject<{
+    schema_version: z.ZodLiteral<2>;
+    id: z.ZodString;
+    created_at: z.ZodString;
+    /** Monotonic revision; each freeze increments it (spec-anchored history). */
+    version: z.ZodDefault<z.ZodNumber>;
+    frozen: z.ZodDefault<z.ZodBoolean>;
+    intent: z.ZodObject<{
+        raw: z.ZodString;
+        normalized: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        raw: string;
+        normalized?: string | undefined;
+    }, {
+        raw: string;
+        normalized?: string | undefined;
+    }>;
+    summary: z.ZodDefault<z.ZodString>;
+    success_criteria: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        behavior: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        required: boolean;
+        behavior: string;
+    }, {
+        id: string;
+        behavior: string;
+        required?: boolean | undefined;
+    }>, "many">>;
+    non_goals: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    forbidden_approaches: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    decided_tradeoffs: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    constraints: z.ZodDefault<z.ZodObject<{
+        /** Spec-owned protected paths can raise review risk; per-run approvals cannot be frozen into a spec. */
+        protected_paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        protected_paths: string[];
+    }, {
+        protected_paths?: string[] | undefined;
+    }>>;
+    tests: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        command: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        command: string;
+        required: boolean;
+    }, {
+        id: string;
+        command: string;
+        required?: boolean | undefined;
+    }>, "many">>;
+    tasks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        done: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        title: string;
+        done: boolean;
+        depends_on: string[];
+    }, {
+        id: string;
+        title: string;
+        done?: boolean | undefined;
+        depends_on?: string[] | undefined;
+    }>, "many">>;
+    open_questions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        claim: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<["open", "resolved"]>>;
+        resolution: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        status: "open" | "resolved";
+        id: string;
+        claim: string;
+        resolution: string | null;
+    }, {
+        id: string;
+        claim: string;
+        status?: "open" | "resolved" | undefined;
+        resolution?: string | null | undefined;
+    }>, "many">>;
+    interview: z.ZodDefault<z.ZodObject<{
+        questions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            tier: z.ZodDefault<z.ZodNumber>;
+            prompt: z.ZodString;
+            kind: z.ZodDefault<z.ZodEnum<["single", "multi", "text"]>>;
+            options: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                label: string;
+            }, {
+                id: string;
+                label: string;
+            }>, "many">>;
+            /** Whether free-text is accepted in addition to / instead of options. */
+            allow_text: z.ZodDefault<z.ZodBoolean>;
+            rationale: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            options: {
+                id: string;
+                label: string;
+            }[];
+            id: string;
+            kind: "text" | "single" | "multi";
+            prompt: string;
+            tier: number;
+            allow_text: boolean;
+            rationale?: string | undefined;
+        }, {
+            id: string;
+            prompt: string;
+            options?: {
+                id: string;
+                label: string;
+            }[] | undefined;
+            kind?: "text" | "single" | "multi" | undefined;
+            tier?: number | undefined;
+            allow_text?: boolean | undefined;
+            rationale?: string | undefined;
+        }>, "many">>;
+        answers: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            question_id: z.ZodString;
+            option_ids: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            text: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        }, "strip", z.ZodTypeAny, {
+            question_id: string;
+            text: string | null;
+            option_ids: string[];
+        }, {
+            question_id: string;
+            text?: string | null | undefined;
+            option_ids?: string[] | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        questions: {
+            options: {
+                id: string;
+                label: string;
+            }[];
+            id: string;
+            kind: "text" | "single" | "multi";
+            prompt: string;
+            tier: number;
+            allow_text: boolean;
+            rationale?: string | undefined;
+        }[];
+        answers: {
+            question_id: string;
+            text: string | null;
+            option_ids: string[];
+        }[];
+    }, {
+        questions?: {
+            id: string;
+            prompt: string;
+            options?: {
+                id: string;
+                label: string;
+            }[] | undefined;
+            kind?: "text" | "single" | "multi" | undefined;
+            tier?: number | undefined;
+            allow_text?: boolean | undefined;
+            rationale?: string | undefined;
+        }[] | undefined;
+        answers?: {
+            question_id: string;
+            text?: string | null | undefined;
+            option_ids?: string[] | undefined;
+        }[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    version: number;
+    intent: {
+        raw: string;
+        normalized?: string | undefined;
+    };
+    schema_version: 2;
+    created_at: string;
+    summary: string;
+    tests: {
+        id: string;
+        command: string;
+        required: boolean;
+    }[];
+    success_criteria: {
+        id: string;
+        required: boolean;
+        behavior: string;
+    }[];
+    non_goals: string[];
+    forbidden_approaches: string[];
+    decided_tradeoffs: string[];
+    constraints: {
+        protected_paths: string[];
+    };
+    frozen: boolean;
+    tasks: {
+        id: string;
+        title: string;
+        done: boolean;
+        depends_on: string[];
+    }[];
+    open_questions: {
+        status: "open" | "resolved";
+        id: string;
+        claim: string;
+        resolution: string | null;
+    }[];
+    interview: {
+        questions: {
+            options: {
+                id: string;
+                label: string;
+            }[];
+            id: string;
+            kind: "text" | "single" | "multi";
+            prompt: string;
+            tier: number;
+            allow_text: boolean;
+            rationale?: string | undefined;
+        }[];
+        answers: {
+            question_id: string;
+            text: string | null;
+            option_ids: string[];
+        }[];
+    };
+}, {
+    id: string;
+    intent: {
+        raw: string;
+        normalized?: string | undefined;
+    };
+    schema_version: 2;
+    created_at: string;
+    version?: number | undefined;
+    summary?: string | undefined;
+    tests?: {
+        id: string;
+        command: string;
+        required?: boolean | undefined;
+    }[] | undefined;
+    success_criteria?: {
+        id: string;
+        behavior: string;
+        required?: boolean | undefined;
+    }[] | undefined;
+    non_goals?: string[] | undefined;
+    forbidden_approaches?: string[] | undefined;
+    decided_tradeoffs?: string[] | undefined;
+    constraints?: {
+        protected_paths?: string[] | undefined;
+    } | undefined;
+    frozen?: boolean | undefined;
+    tasks?: {
+        id: string;
+        title: string;
+        done?: boolean | undefined;
+        depends_on?: string[] | undefined;
+    }[] | undefined;
+    open_questions?: {
+        id: string;
+        claim: string;
+        status?: "open" | "resolved" | undefined;
+        resolution?: string | null | undefined;
+    }[] | undefined;
+    interview?: {
+        questions?: {
+            id: string;
+            prompt: string;
+            options?: {
+                id: string;
+                label: string;
+            }[] | undefined;
+            kind?: "text" | "single" | "multi" | undefined;
+            tier?: number | undefined;
+            allow_text?: boolean | undefined;
+            rationale?: string | undefined;
+        }[] | undefined;
+        answers?: {
+            question_id: string;
+            text?: string | null | undefined;
+            option_ids?: string[] | undefined;
+        }[] | undefined;
+    } | undefined;
+}>, {
+    id: string;
+    version: number;
+    intent: {
+        raw: string;
+        normalized?: string | undefined;
+    };
+    schema_version: 2;
+    created_at: string;
+    summary: string;
+    tests: {
+        id: string;
+        command: string;
+        required: boolean;
+    }[];
+    success_criteria: {
+        id: string;
+        required: boolean;
+        behavior: string;
+    }[];
+    non_goals: string[];
+    forbidden_approaches: string[];
+    decided_tradeoffs: string[];
+    constraints: {
+        protected_paths: string[];
+    };
+    frozen: boolean;
+    tasks: {
+        id: string;
+        title: string;
+        done: boolean;
+        depends_on: string[];
+    }[];
+    open_questions: {
+        status: "open" | "resolved";
+        id: string;
+        claim: string;
+        resolution: string | null;
+    }[];
+    interview: {
+        questions: {
+            options: {
+                id: string;
+                label: string;
+            }[];
+            id: string;
+            kind: "text" | "single" | "multi";
+            prompt: string;
+            tier: number;
+            allow_text: boolean;
+            rationale?: string | undefined;
+        }[];
+        answers: {
+            question_id: string;
+            text: string | null;
+            option_ids: string[];
+        }[];
+    };
+}, {
+    id: string;
+    intent: {
+        raw: string;
+        normalized?: string | undefined;
+    };
+    schema_version: 2;
+    created_at: string;
+    version?: number | undefined;
+    summary?: string | undefined;
+    tests?: {
+        id: string;
+        command: string;
+        required?: boolean | undefined;
+    }[] | undefined;
+    success_criteria?: {
+        id: string;
+        behavior: string;
+        required?: boolean | undefined;
+    }[] | undefined;
+    non_goals?: string[] | undefined;
+    forbidden_approaches?: string[] | undefined;
+    decided_tradeoffs?: string[] | undefined;
+    constraints?: {
+        protected_paths?: string[] | undefined;
+    } | undefined;
+    frozen?: boolean | undefined;
+    tasks?: {
+        id: string;
+        title: string;
+        done?: boolean | undefined;
+        depends_on?: string[] | undefined;
+    }[] | undefined;
+    open_questions?: {
+        id: string;
+        claim: string;
+        status?: "open" | "resolved" | undefined;
+        resolution?: string | null | undefined;
+    }[] | undefined;
+    interview?: {
+        questions?: {
+            id: string;
+            prompt: string;
+            options?: {
+                id: string;
+                label: string;
+            }[] | undefined;
+            kind?: "text" | "single" | "multi" | undefined;
+            tier?: number | undefined;
+            allow_text?: boolean | undefined;
+            rationale?: string | undefined;
+        }[] | undefined;
+        answers?: {
+            question_id: string;
+            text?: string | null | undefined;
+            option_ids?: string[] | undefined;
+        }[] | undefined;
+    } | undefined;
+}>;
+export type SpecPack = z.infer<typeof SpecPack>;
+//# sourceMappingURL=spec.d.ts.map

package/dist/spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../src/spec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;GAMG;AAEH,eAAO,MAAM,qBAAqB,wCAEiE,CAAC;AACpG,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,eAAO,MAAM,eAAe;;;;;;;;;EAKkC,CAAC;AAC/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,iFAAiF;AACjF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;IAO1B,yEAAyE;;;;;;;;;;;;;;;;;;;;;;;;;EAI1B,CAAC;AACpD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,eAAe;;;;;;;;;;;;EAM+B,CAAC;AAC5D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;EAO2F,CAAC;AAC1H,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,uFAAuF;AACvF,eAAO,MAAM,uBAAuB;;;;;;;;;;;;EAMc,CAAC;AACnD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,iEAAiE;AACjE,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;EAOoD,CAAC;AAC1E,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,eAAe;IAExB,wGAAwG;;;;;;EAO5D,CAAC;AACjD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAiC9D;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;;IAjCnB,6EAA6E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAd3E,wGAAwG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YArDxG,yEAAyE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuH5E,CAAC;AACF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC"}

package/dist/spec.js

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import { Id, IsoTimestamp, SchemaVersion } from "./primitives.js";
+import { TestCommand } from "./task.js";
+/**
+ * SpecPack — the frozen, versioned, diffable specification produced by the
+ * spec interview (the hierarchical clarify-quiz). It is the SSOT a run is held
+ * to: a SpecPack maps deterministically into a TaskContract. Unlike spec-first
+ * tools that regenerate an opaque blob, this is spec-anchored: versioned with
+ * section-level diffs across revisions.
+ */
+export const InterviewQuestionKind = z
+    .enum(["single", "multi", "text"])
+    .describe("Answer shape of an interview question: single choice, multiple choice, or free text.");
+export const InterviewOption = z
+    .object({
+    id: Id.describe("Option id."),
+    label: z.string().describe("Human-readable option label."),
+})
+    .describe("One selectable option of an interview question.");
+/** One quiz card. `tier` expresses the hierarchical depth (0 = foundational). */
+export const InterviewQuestion = z
+    .object({
+    id: Id.describe("Question id."),
+    tier: z.number().int().nonnegative().default(0).describe("Hierarchical depth of the question (0 = foundational)."),
+    prompt: z.string().describe("The question text shown to the user."),
+    kind: InterviewQuestionKind.default("single"),
+    options: z.array(InterviewOption).default([]).describe("Selectable options; empty for pure free-text questions."),
+    /** Whether free-text is accepted in addition to / instead of options. */
+    allow_text: z.boolean().default(false).describe("Whether free-text is accepted in addition to or instead of options."),
+    rationale: z.string().optional().describe("Why this question matters for the spec."),
+})
+    .describe("One quiz card of the spec interview.");
+export const InterviewAnswer = z
+    .object({
+    question_id: Id.describe("Id of the question being answered."),
+    option_ids: z.array(Id).default([]).describe("Ids of the selected options."),
+    text: z.string().nullable().default(null).describe("Free-text answer; null when only options were selected."),
+})
+    .describe("The user's answer to one interview question.");
+/**
+ * An explicit unresolved ambiguity (NEEDS_CLARIFICATION). The interview refuses
+ * to freeze while any of these are `open` — nothing is silently guessed.
+ */
+export const ClarificationItem = z
+    .object({
+    id: Id.describe("Clarification id."),
+    claim: z.string().describe("The ambiguous claim or open question that needs resolution."),
+    status: z.enum(["open", "resolved"]).default("open").describe("Whether the ambiguity is still open or has been resolved."),
+    resolution: z.string().nullable().default(null).describe("How the ambiguity was resolved; null while open."),
+})
+    .describe("An explicit unresolved ambiguity (NEEDS_CLARIFICATION); the interview refuses to freeze while any is open.");
+/** Acceptance criterion in EARS style ("WHEN <cond>, THE SYSTEM SHALL <behavior>"). */
+export const SpecAcceptanceCriterion = z
+    .object({
+    id: Id.describe("Criterion id."),
+    behavior: z.string().describe("Required behavior, EARS style (WHEN <condition>, THE SYSTEM SHALL <behavior>)."),
+    required: z.boolean().default(true).describe("Whether this criterion is required (vs advisory)."),
+})
+    .describe("Acceptance criterion in EARS style.");
+/** A dependency-ordered task in the implementation checklist. */
+export const SpecTask = z
+    .object({
+    id: Id.describe("Task id."),
+    title: z.string().describe("Human-readable task title."),
+    depends_on: z.array(Id).default([]).describe("Ids of tasks that must complete first."),
+    done: z.boolean().default(false).describe("Whether the task has been completed."),
+})
+    .describe("A dependency-ordered task in the implementation checklist.");
+export const SpecConstraints = z
+    .object({
+    /** Spec-owned protected paths can raise review risk; per-run approvals cannot be frozen into a spec. */
+    protected_paths: z
+        .array(z.string())
+        .default([])
+        .describe("Spec-owned protected path globs that raise review risk; per-run approvals cannot be frozen into a spec."),
+})
+    .strict()
+    .describe("Constraints frozen into the spec.");
+const SpecPackBase = z.object({
+    schema_version: SchemaVersion,
+    id: Id.describe("SpecPack id."),
+    created_at: IsoTimestamp.describe("When this SpecPack revision was created."),
+    /** Monotonic revision; each freeze increments it (spec-anchored history). */
+    version: z.number().int().positive().default(1).describe("Monotonic revision; each freeze increments it."),
+    frozen: z.boolean().default(false).describe("Whether the spec is frozen (immutable and runnable)."),
+    intent: z
+        .object({
+        raw: z.string().describe("The user's original request, verbatim."),
+        normalized: z.string().optional().describe("Optional normalized restatement of the request."),
+    })
+        .describe("The user intent this spec captures."),
+    summary: z.string().default("").describe("Short human-readable summary of the spec."),
+    success_criteria: z.array(SpecAcceptanceCriterion).default([]).describe("Acceptance criteria the implementation is held to."),
+    non_goals: z.array(z.string()).default([]).describe("Explicitly out-of-scope outcomes."),
+    forbidden_approaches: z.array(z.string()).default([]).describe("Approaches the implementation must not take."),
+    decided_tradeoffs: z.array(z.string()).default([]).describe("Tradeoffs already decided during the interview."),
+    constraints: SpecConstraints.default({}),
+    tests: z.array(TestCommand).default([]).describe("Deterministic test commands frozen into the spec."),
+    tasks: z.array(SpecTask).default([]).describe("Dependency-ordered implementation checklist."),
+    open_questions: z.array(ClarificationItem).default([]).describe("Unresolved ambiguities; must all be resolved before freezing."),
+    interview: z
+        .object({
+        questions: z.array(InterviewQuestion).default([]).describe("Questions asked during the interview."),
+        answers: z.array(InterviewAnswer).default([]).describe("The user's answers."),
+    })
+        .default({ questions: [], answers: [] })
+        .describe("The clarify-quiz transcript this spec was built from."),
+});
+/**
+ * Schema-level invariants (SSOT, enforced on every parse — even when loaded from
+ * disk, not just via the engine): a frozen spec cannot carry open clarifications,
+ * and a "resolved" clarification must record a non-empty resolution. This makes a
+ * frozen-but-ambiguous SpecPack unrepresentable — no silent guessing.
+ */
+export const SpecPack = SpecPackBase.superRefine((data, ctx) => {
+    if (data.frozen && data.open_questions.some((q) => q.status === "open")) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["open_questions"],
+            message: "a frozen SpecPack cannot have open clarifications",
+        });
+    }
+    data.open_questions.forEach((q, i) => {
+        if (q.status === "resolved" && (q.resolution === null || q.resolution.trim() === "")) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["open_questions", i, "resolution"],
+                message: "a resolved clarification must have a non-empty resolution",
+            });
+        }
+    });
+}).describe("The frozen, versioned, diffable specification produced by the spec interview; the SSOT a run is held to, mapping deterministically into a TaskContract.");
+//# sourceMappingURL=spec.js.map