@neuraloom/contracts 0.0.0-stage → 0.1.23

package/dist/schemas/ai/manuscript-checks.schema.js

@@ -0,0 +1,440 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManuscriptChecksPostResponseSchema = exports.AIManuscriptChecksInputSchema = exports.NonfictionManuscriptProofSnapshotSchema = exports.NonfictionManuscriptProofChapterRowSchema = exports.NonfictionManuscriptProofArtifactSchema = exports.NonfictionPeerReviewReleasePayloadSchema = exports.NonfictionPeerReviewComponentArtifactIdsSchema = exports.ManuscriptChecksReportSchema = exports.NonfictionManuscriptChecksReportSchema = exports.LegacyManuscriptChecksReportSchema = exports.NonfictionManuscriptChecksReportCheckSchema = exports.NonfictionManuscriptChecksIssueSchema = exports.NonfictionManuscriptChapterCoverageSchema = exports.NonfictionManuscriptTruthArtifactIdsSchema = exports.ManuscriptChecksReportCheckSchema = exports.ManuscriptChecksSliceResultSchema = exports.ManuscriptChecksIssueSchema = exports.ManuscriptChecksIssueSeveritySchema = exports.ManuscriptChecksCheckStatusSchema = exports.ManuscriptChecksCheckTypeSchema = void 0;
+const zod_1 = require("zod");
+exports.ManuscriptChecksCheckTypeSchema = zod_1.z.enum([
+    "spelling_consistency",
+    "citation_audit",
+    "definition_consistency",
+    "chapter_continuity",
+    "constitution_compliance",
+]);
+exports.ManuscriptChecksCheckStatusSchema = zod_1.z.enum(["pass", "warning", "fail"]);
+exports.ManuscriptChecksIssueSeveritySchema = zod_1.z.enum(["info", "warning", "error"]);
+function normalizeEnumToken(v) {
+    if (typeof v !== "string") {
+        return v;
+    }
+    return v.trim().toLowerCase().replace(/\s+/g, "_");
+}
+/** LLM row: extra keys allowed; required fields defaulted when missing. */
+exports.ManuscriptChecksIssueSchema = zod_1.z
+    .object({
+    chapterId: zod_1.z.preprocess((v) => {
+        if (v === null || v === undefined || v === "")
+            return undefined;
+        const s = String(v).trim();
+        return s.length > 0 ? s : undefined;
+    }, zod_1.z.string().min(1).optional()),
+    chapterIndex: zod_1.z.preprocess((v) => (v === null || v === undefined || v === "" ? undefined : v), zod_1.z.coerce.number().int().min(0).optional()),
+    severity: zod_1.z.preprocess(normalizeEnumToken, exports.ManuscriptChecksIssueSeveritySchema.catch("warning")),
+    message: zod_1.z.preprocess((v) => {
+        if (v === null || v === undefined) {
+            return "Issue noted";
+        }
+        const s = String(v).trim();
+        return s.length > 0 ? s : "Issue noted";
+    }, zod_1.z.string()),
+    evidence: zod_1.z.preprocess((v) => {
+        if (v === null || v === undefined || v === "")
+            return undefined;
+        const s = String(v).trim();
+        return s.length > 0 ? s : undefined;
+    }, zod_1.z.string().min(1).optional()),
+    suggestedFix: zod_1.z.preprocess((v) => {
+        if (v === null || v === undefined || v === "")
+            return undefined;
+        const s = String(v).trim();
+        return s.length > 0 ? s : undefined;
+    }, zod_1.z.string().min(1).optional()),
+})
+    .passthrough();
+exports.ManuscriptChecksSliceResultSchema = zod_1.z
+    .object({
+    checkType: exports.ManuscriptChecksCheckTypeSchema,
+    status: zod_1.z.preprocess(normalizeEnumToken, exports.ManuscriptChecksCheckStatusSchema.catch("warning")),
+    issueCount: zod_1.z.coerce.number().int().min(0).optional().catch(undefined),
+    issues: zod_1.z.preprocess((val) => (val === null || val === undefined ? [] : val), zod_1.z.array(exports.ManuscriptChecksIssueSchema).catch([])),
+})
+    .transform((row) => {
+    const issues = row.issues;
+    return {
+        checkType: row.checkType,
+        status: row.status,
+        issues,
+        issueCount: issues.length,
+    };
+});
+exports.ManuscriptChecksReportCheckSchema = zod_1.z
+    .object({
+    checkType: exports.ManuscriptChecksCheckTypeSchema,
+    status: zod_1.z.preprocess(normalizeEnumToken, exports.ManuscriptChecksCheckStatusSchema.catch("warning")),
+    issueCount: zod_1.z.coerce.number().int().min(0).optional().catch(undefined),
+    issues: zod_1.z.preprocess((val) => (val === null || val === undefined ? [] : val), zod_1.z.array(exports.ManuscriptChecksIssueSchema).catch([])),
+})
+    .transform((row) => ({
+    checkType: row.checkType,
+    status: row.status,
+    issues: row.issues,
+    issueCount: row.issues.length,
+}));
+const Sha256HexSchema = zod_1.z.string().regex(/^[a-f0-9]{64}$/);
+exports.NonfictionManuscriptTruthArtifactIdsSchema = zod_1.z
+    .object({
+    plan: zod_1.z.string().min(1).nullable(),
+    sourceRegistry: zod_1.z.string().min(1).nullable(),
+    researchTasks: zod_1.z.string().min(1).nullable(),
+    manuscriptRollup: zod_1.z.string().min(1).nullable(),
+})
+    .strict();
+exports.NonfictionManuscriptChapterCoverageSchema = zod_1.z
+    .object({
+    chapterId: zod_1.z.string().trim().min(1),
+    chapterNumber: zod_1.z.number().int().min(0),
+    title: zod_1.z.string().trim().min(1),
+    artifactId: zod_1.z.string().min(1).nullable(),
+    artifactStatus: zod_1.z.enum(["accepted", "superseded", "rejected", "missing"]),
+    proseHash: Sha256HexSchema.nullable(),
+    contractHash: Sha256HexSchema.nullable(),
+    authorizationHash: Sha256HexSchema.nullable(),
+    paragraphCount: zod_1.z.number().int().min(0),
+    sentenceCount: zod_1.z.number().int().min(0),
+    finalParagraphAuditId: zod_1.z.string().regex(/^p\d{4,}$/).nullable(),
+    finalSentenceAuditId: zod_1.z.string().regex(/^p\d{4,}\.s\d{4,}$/).nullable(),
+    auditComplete: zod_1.z.boolean(),
+    semanticStopSatisfied: zod_1.z.boolean(),
+    semanticPass: zod_1.z.boolean(),
+    printPass: zod_1.z.boolean(),
+    audioPass: zod_1.z.boolean(),
+    qualityFloorsPass: zod_1.z.boolean(),
+    evidenceComplete: zod_1.z.boolean(),
+    observedWordCount: zod_1.z.number().int().min(0),
+    citationReadySourceIds: zod_1.z.array(zod_1.z.string().trim().min(1)),
+})
+    .strict()
+    .superRefine((coverage, ctx) => {
+    if (new Set(coverage.citationReadySourceIds).size !== coverage.citationReadySourceIds.length) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["citationReadySourceIds"],
+            message: "Citation-ready source IDs must be unique",
+        });
+    }
+});
+/** Strict deterministic issue shape. LLM-tolerant coercion is legacy-only. */
+exports.NonfictionManuscriptChecksIssueSchema = zod_1.z
+    .object({
+    chapterId: zod_1.z.string().trim().min(1).optional(),
+    chapterIndex: zod_1.z.number().int().min(0).optional(),
+    severity: zod_1.z.literal("error"),
+    message: zod_1.z.string().trim().min(1),
+    evidence: zod_1.z.string().trim().min(1).optional(),
+    suggestedFix: zod_1.z.string().trim().min(1).optional(),
+})
+    .strict();
+exports.NonfictionManuscriptChecksReportCheckSchema = zod_1.z
+    .object({
+    checkType: exports.ManuscriptChecksCheckTypeSchema,
+    status: zod_1.z.enum(["pass", "fail"]),
+    issueCount: zod_1.z.number().int().min(0),
+    issues: zod_1.z.array(exports.NonfictionManuscriptChecksIssueSchema),
+})
+    .strict()
+    .superRefine((check, ctx) => {
+    if (check.issueCount !== check.issues.length) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["issueCount"],
+            message: "Issue count must equal the exact strict issue array length",
+        });
+    }
+    if ((check.status === "pass") !== (check.issues.length === 0)) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["status"],
+            message: "A deterministic check passes if and only if it has no issues",
+        });
+    }
+});
+/** Compatibility contract for fiction and historical writing reports. */
+exports.LegacyManuscriptChecksReportSchema = zod_1.z
+    .object({
+    projectId: zod_1.z.string().uuid(),
+    checkedAt: zod_1.z.string().datetime(),
+    chaptersChecked: zod_1.z.coerce.number().int().min(0),
+    checksPassed: zod_1.z.coerce.number().int().min(0),
+    checksFailed: zod_1.z.coerce.number().int().min(0),
+    checks: zod_1.z.preprocess((v) => (v === null || v === undefined ? [] : v), zod_1.z.array(exports.ManuscriptChecksReportCheckSchema).catch([])),
+    overallStatus: zod_1.z.preprocess(normalizeEnumToken, exports.ManuscriptChecksCheckStatusSchema.catch("warning")),
+    readyForPublication: zod_1.z.coerce.boolean().catch(false),
+    blockers: zod_1.z.preprocess((v) => (v === null || v === undefined ? [] : v), zod_1.z.array(zod_1.z.string().min(1)).catch([])),
+    warnings: zod_1.z.preprocess((v) => (v === null || v === undefined ? [] : v), zod_1.z.array(zod_1.z.string().min(1)).catch([])),
+})
+    .passthrough()
+    .superRefine((report, ctx) => {
+    if (report.version !== undefined) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["version"],
+            message: "A versioned nonfiction proof cannot fall back to the legacy report contract",
+        });
+    }
+});
+/** Strict, fail-closed contract for nonfiction full-manuscript release proof. */
+exports.NonfictionManuscriptChecksReportSchema = zod_1.z
+    .object({
+    version: zod_1.z.literal("nonfiction-manuscript-release-proof-v1"),
+    scope: zod_1.z.literal("full_manuscript"),
+    projectId: zod_1.z.string().uuid(),
+    checkedAt: zod_1.z.string().datetime(),
+    expectedChapters: zod_1.z.number().int().min(0),
+    chaptersChecked: zod_1.z.number().int().min(0),
+    fullCoverage: zod_1.z.boolean(),
+    manuscriptHash: Sha256HexSchema,
+    guardianScore: zod_1.z.number().int().min(0).max(100),
+    truthArtifactIds: exports.NonfictionManuscriptTruthArtifactIdsSchema,
+    chapterCoverage: zod_1.z.array(exports.NonfictionManuscriptChapterCoverageSchema),
+    checksPassed: zod_1.z.number().int().min(0),
+    checksFailed: zod_1.z.number().int().min(0),
+    checks: zod_1.z.array(exports.NonfictionManuscriptChecksReportCheckSchema),
+    overallStatus: zod_1.z.enum(["pass", "fail"]),
+    readyForPublication: zod_1.z.boolean(),
+    blockers: zod_1.z.array(zod_1.z.string().trim().min(1)),
+    warnings: zod_1.z.array(zod_1.z.string().trim().min(1)),
+})
+    .strict()
+    .superRefine((report, ctx) => {
+    const expectedCheckTypes = new Set(exports.ManuscriptChecksCheckTypeSchema.options);
+    const actualCheckTypes = new Set(report.checks.map((check) => check.checkType));
+    if (report.checks.length !== expectedCheckTypes.size
+        || actualCheckTypes.size !== expectedCheckTypes.size
+        || [...expectedCheckTypes].some((checkType) => !actualCheckTypes.has(checkType))) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["checks"],
+            message: "A full release proof requires exactly one result for every manuscript check",
+        });
+    }
+    const uniqueChapterNumbers = new Set(report.chapterCoverage.map((chapter) => chapter.chapterNumber));
+    const uniqueChapterIds = new Set(report.chapterCoverage.map((chapter) => chapter.chapterId));
+    const artifactIds = report.chapterCoverage.flatMap((chapter) => chapter.artifactId === null ? [] : [chapter.artifactId]);
+    const truthArtifactIds = Object.values(report.truthArtifactIds).flatMap((artifactId) => artifactId === null ? [] : [artifactId]);
+    const exactCoverageOrder = report.chapterCoverage.every((chapter, index, coverage) => index === 0 || coverage[index - 1].chapterNumber < chapter.chapterNumber);
+    if (uniqueChapterNumbers.size !== report.chapterCoverage.length
+        || uniqueChapterIds.size !== report.chapterCoverage.length
+        || new Set(artifactIds).size !== artifactIds.length) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["chapterCoverage"],
+            message: "Chapter numbers, Plan identities, and persisted artifact identities must be unique",
+        });
+    }
+    if (new Set(truthArtifactIds).size !== truthArtifactIds.length
+        || truthArtifactIds.some((artifactId) => artifactIds.includes(artifactId))) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["truthArtifactIds"],
+            message: "Deterministic truth and chapter artifact identities must form one unique lineage set",
+        });
+    }
+    const checkedCount = report.chapterCoverage.filter((chapter) => chapter.artifactId !== null).length;
+    if (report.chaptersChecked !== checkedCount) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["chaptersChecked"],
+            message: "chaptersChecked must equal the exact persisted chapter coverage count",
+        });
+    }
+    const truthComplete = Object.values(report.truthArtifactIds).every((id) => id !== null);
+    const chapterProofComplete = report.chapterCoverage.length === report.expectedChapters
+        && report.chapterCoverage.every((chapter) => chapter.artifactId !== null
+            && (chapter.artifactStatus === "accepted" || chapter.artifactStatus === "superseded")
+            && chapter.proseHash !== null
+            && chapter.contractHash !== null
+            && chapter.authorizationHash !== null
+            && chapter.paragraphCount > 0
+            && chapter.sentenceCount > 0
+            && chapter.observedWordCount > 0
+            && chapter.citationReadySourceIds.length > 0
+            && chapter.finalParagraphAuditId !== null
+            && chapter.finalSentenceAuditId !== null
+            && chapter.auditComplete
+            && chapter.semanticStopSatisfied
+            && chapter.semanticPass
+            && chapter.printPass
+            && chapter.audioPass
+            && chapter.qualityFloorsPass
+            && chapter.evidenceComplete);
+    const allChecksPass = report.checks.every((check) => check.status === "pass" && check.issueCount === 0);
+    const calculatedFullCoverage = report.expectedChapters > 0
+        && report.chaptersChecked === report.expectedChapters
+        && report.chapterCoverage.length === report.expectedChapters
+        && exactCoverageOrder
+        && report.chapterCoverage.every((chapter) => chapter.artifactId !== null
+            && (chapter.artifactStatus === "accepted" || chapter.artifactStatus === "superseded")
+            && chapter.paragraphCount > 0
+            && chapter.sentenceCount > 0
+            && chapter.observedWordCount > 0
+            && chapter.citationReadySourceIds.length > 0
+            && chapter.finalParagraphAuditId !== null
+            && chapter.finalSentenceAuditId !== null
+            && chapter.auditComplete);
+    if (report.fullCoverage !== calculatedFullCoverage) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["fullCoverage"],
+            message: "fullCoverage must be recomputed from exact ordered, persisted, positive audit coverage",
+        });
+    }
+    const calculatedChecksPassed = report.checks.filter((check) => check.status === "pass").length;
+    const calculatedChecksFailed = report.checks.length - calculatedChecksPassed;
+    if (report.checksPassed !== calculatedChecksPassed
+        || report.checksFailed !== calculatedChecksFailed) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["checksPassed"],
+            message: "Check totals must equal the exact strict check results",
+        });
+    }
+    const calculatedReady = report.expectedChapters === 0
+        ? false
+        : report.fullCoverage
+            && truthComplete
+            && chapterProofComplete
+            && allChecksPass
+            && report.checksPassed === expectedCheckTypes.size
+            && report.checksFailed === 0
+            && report.blockers.length === 0
+            && report.warnings.length === 0
+            && report.guardianScore >= 65;
+    if (report.readyForPublication !== calculatedReady) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["readyForPublication"],
+            message: "Publication readiness requires complete exact coverage and every non-compensating check to pass",
+        });
+    }
+    if (report.overallStatus !== (calculatedReady ? "pass" : "fail")) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["overallStatus"],
+            message: "Overall status must match the non-compensating publication decision",
+        });
+    }
+    if (!calculatedReady && report.guardianScore !== 0) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["guardianScore"],
+            message: "Any failed nonfiction release invariant forces the aggregate Guardian score to zero",
+        });
+    }
+});
+/** Nonfiction-first preserves its proof fields; legacy remains valid for other writing families. */
+exports.ManuscriptChecksReportSchema = zod_1.z.union([
+    exports.NonfictionManuscriptChecksReportSchema,
+    exports.LegacyManuscriptChecksReportSchema,
+]);
+exports.NonfictionPeerReviewComponentArtifactIdsSchema = zod_1.z
+    .object({
+    sourceQualityAudit: zod_1.z.string().min(1),
+    contradictionAnalysis: zod_1.z.string().min(1),
+    hallucinationCheck: zod_1.z.string().min(1),
+    rhetoricalBalanceReview: zod_1.z.string().min(1),
+})
+    .strict()
+    .superRefine((ids, ctx) => {
+    if (new Set(Object.values(ids)).size !== Object.keys(ids).length) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: [],
+            message: "Peer-review component artifact IDs must be unique",
+        });
+    }
+});
+/**
+ * The peer-review payload may retain its full editorial ledgers, but this
+ * authorization subset is mandatory and strictly typed. A report by itself is
+ * never a release decision.
+ */
+exports.NonfictionPeerReviewReleasePayloadSchema = zod_1.z
+    .object({
+    reviewContractVersion: zod_1.z.literal("full-manuscript-v1"),
+    reviewRunState: zod_1.z.literal("completed"),
+    releaseReady: zod_1.z.literal(true),
+    editorialBlockers: zod_1.z.tuple([]),
+    editorialFindings: zod_1.z.tuple([]),
+    componentArtifactIds: exports.NonfictionPeerReviewComponentArtifactIdsSchema,
+    manuscriptChecksReport: exports.NonfictionManuscriptChecksReportSchema,
+    contextHash: Sha256HexSchema,
+    projectAuthorityHash: Sha256HexSchema,
+    projectAuthorityUpdatedAt: zod_1.z.string().datetime({ offset: true }),
+    manuscriptFingerprint: Sha256HexSchema,
+})
+    // Named release-authority fields above are literal/strict and never coerced.
+    // Additional keys are the already-produced editorial ledgers; retain them so
+    // validating authorization never destroys the useful full review payload.
+    .catchall(zod_1.z.unknown())
+    .superRefine((payload, ctx) => {
+    if (!payload.manuscriptChecksReport.readyForPublication) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["manuscriptChecksReport", "readyForPublication"],
+            message: "Peer review cannot authorize release with a red deterministic manuscript proof",
+        });
+    }
+});
+exports.NonfictionManuscriptProofArtifactSchema = zod_1.z
+    .object({
+    id: zod_1.z.string().min(1),
+    payload: zod_1.z.record(zod_1.z.unknown()),
+    sourceArtifactIds: zod_1.z.array(zod_1.z.string().min(1)),
+})
+    .strict();
+exports.NonfictionManuscriptProofChapterRowSchema = zod_1.z
+    .object({
+    id: zod_1.z.string().min(1),
+    status: zod_1.z.enum(["accepted", "superseded", "rejected"]),
+    createdAt: zod_1.z.string().datetime(),
+    sourceArtifactIds: zod_1.z.array(zod_1.z.string().min(1)),
+    guardianScore: zod_1.z.number().nullable(),
+    payload: zod_1.z.record(zod_1.z.unknown()),
+})
+    .strict();
+exports.NonfictionManuscriptProofSnapshotSchema = zod_1.z
+    .object({
+    projectId: zod_1.z.string().uuid(),
+    checkedAt: zod_1.z.string().datetime(),
+    planGate: zod_1.z
+        .object({
+        status: zod_1.z.string().nullable(),
+        planArtifactId: zod_1.z.string().nullable(),
+    })
+        .strict(),
+    planArtifact: exports.NonfictionManuscriptProofArtifactSchema.nullable(),
+    sourceRegistryArtifact: exports.NonfictionManuscriptProofArtifactSchema.nullable(),
+    researchTasksArtifact: exports.NonfictionManuscriptProofArtifactSchema.nullable(),
+    manuscriptRollupArtifact: exports.NonfictionManuscriptProofArtifactSchema.nullable(),
+    chapterRows: zod_1.z.array(exports.NonfictionManuscriptProofChapterRowSchema),
+    chapterTasks: zod_1.z.array(zod_1.z.record(zod_1.z.unknown())),
+    truthLoadIssues: zod_1.z.array(zod_1.z.string().trim().min(1)),
+})
+    .strict();
+exports.AIManuscriptChecksInputSchema = zod_1.z
+    .object({
+    projectId: zod_1.z.string().uuid(),
+    chapterIndexes: zod_1.z.array(zod_1.z.number().int().min(0)).optional(),
+})
+    .passthrough()
+    .superRefine((input, ctx) => {
+    if (input.chapterIndexes !== undefined && input.chapterIndexes.length > 0) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            path: ["chapterIndexes"],
+            message: "Partial chapter audits cannot establish manuscript publication readiness",
+        });
+    }
+});
+exports.ManuscriptChecksPostResponseSchema = zod_1.z.object({
+    artifactId: zod_1.z.string().uuid(),
+    report: exports.ManuscriptChecksReportSchema,
+});

package/dist/schemas/ai/model-policy/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./model-modes.schema";
+export * from "./model-mode-preset.schema";
+export * from "./workflow-step-ids.schema";
+export * from "./workflow-step-model-override.schema";
+export * from "./workflow-phase-model-override.schema";
+export * from "./project-model-policy.schema";
+export * from "./model-usage-summary.schema";
+export * from "./model-quality-summary.schema";
+export * from "./model-policy-resolved.schema";

package/dist/schemas/ai/model-policy/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./model-modes.schema"), exports);
+__exportStar(require("./model-mode-preset.schema"), exports);
+__exportStar(require("./workflow-step-ids.schema"), exports);
+__exportStar(require("./workflow-step-model-override.schema"), exports);
+__exportStar(require("./workflow-phase-model-override.schema"), exports);
+__exportStar(require("./project-model-policy.schema"), exports);
+__exportStar(require("./model-usage-summary.schema"), exports);
+__exportStar(require("./model-quality-summary.schema"), exports);
+__exportStar(require("./model-policy-resolved.schema"), exports);

package/dist/schemas/ai/model-policy/model-mode-preset.schema.d.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const ModelModePresetSchema: z.ZodObject<{
+    mode: z.ZodEnum<["testing", "balanced", "production", "custom"]>;
+    provider: z.ZodString;
+    modelId: z.ZodString;
+    reasoningEffort: z.ZodEnum<["minimal", "low", "medium", "high"]>;
+    verbosity: z.ZodEnum<["low", "medium", "high"]>;
+    maxOutputTokens: z.ZodNumber;
+    maxContextItems: z.ZodNumber;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    qualityGate: z.ZodEnum<["low", "medium", "high", "critical"]>;
+    guardianThreshold: z.ZodNumber;
+    costLimitUsdPerRun: z.ZodNullable<z.ZodNumber>;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    mode: "custom" | "testing" | "balanced" | "production";
+    guardianThreshold: number;
+    modelId: string;
+    provider: string;
+    reasoningEffort: "low" | "medium" | "high" | "minimal";
+    verbosity: "low" | "medium" | "high";
+    maxOutputTokens: number;
+    maxContextItems: number;
+    temperature: number;
+    qualityGate: "critical" | "low" | "medium" | "high";
+    costLimitUsdPerRun: number | null;
+}, {
+    description: string;
+    mode: "custom" | "testing" | "balanced" | "production";
+    guardianThreshold: number;
+    modelId: string;
+    provider: string;
+    reasoningEffort: "low" | "medium" | "high" | "minimal";
+    verbosity: "low" | "medium" | "high";
+    maxOutputTokens: number;
+    maxContextItems: number;
+    qualityGate: "critical" | "low" | "medium" | "high";
+    costLimitUsdPerRun: number | null;
+    temperature?: number | undefined;
+}>;
+export type ModelModePreset = z.infer<typeof ModelModePresetSchema>;
+export declare const ModelModePresetMapSchema: z.ZodRecord<z.ZodEnum<["testing", "balanced", "production", "custom"]>, z.ZodObject<{
+    mode: z.ZodEnum<["testing", "balanced", "production", "custom"]>;
+    provider: z.ZodString;
+    modelId: z.ZodString;
+    reasoningEffort: z.ZodEnum<["minimal", "low", "medium", "high"]>;
+    verbosity: z.ZodEnum<["low", "medium", "high"]>;
+    maxOutputTokens: z.ZodNumber;
+    maxContextItems: z.ZodNumber;
+    temperature: z.ZodDefault<z.ZodNumber>;
+    qualityGate: z.ZodEnum<["low", "medium", "high", "critical"]>;
+    guardianThreshold: z.ZodNumber;
+    costLimitUsdPerRun: z.ZodNullable<z.ZodNumber>;
+    description: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    mode: "custom" | "testing" | "balanced" | "production";
+    guardianThreshold: number;
+    modelId: string;
+    provider: string;
+    reasoningEffort: "low" | "medium" | "high" | "minimal";
+    verbosity: "low" | "medium" | "high";
+    maxOutputTokens: number;
+    maxContextItems: number;
+    temperature: number;
+    qualityGate: "critical" | "low" | "medium" | "high";
+    costLimitUsdPerRun: number | null;
+}, {
+    description: string;
+    mode: "custom" | "testing" | "balanced" | "production";
+    guardianThreshold: number;
+    modelId: string;
+    provider: string;
+    reasoningEffort: "low" | "medium" | "high" | "minimal";
+    verbosity: "low" | "medium" | "high";
+    maxOutputTokens: number;
+    maxContextItems: number;
+    qualityGate: "critical" | "low" | "medium" | "high";
+    costLimitUsdPerRun: number | null;
+    temperature?: number | undefined;
+}>>;
+export type ModelModePresetMap = z.infer<typeof ModelModePresetMapSchema>;

package/dist/schemas/ai/model-policy/model-mode-preset.schema.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelModePresetMapSchema = exports.ModelModePresetSchema = void 0;
+const zod_1 = require("zod");
+const model_modes_schema_1 = require("./model-modes.schema");
+exports.ModelModePresetSchema = zod_1.z.object({
+    mode: model_modes_schema_1.ModelModeSchema,
+    provider: zod_1.z.string().min(1),
+    modelId: zod_1.z.string().min(1),
+    reasoningEffort: model_modes_schema_1.ModelReasoningLevelSchema,
+    verbosity: model_modes_schema_1.ModelVerbosityLevelSchema,
+    maxOutputTokens: zod_1.z.number().int().positive().max(200_000),
+    maxContextItems: zod_1.z.number().int().positive().max(2000),
+    temperature: zod_1.z.number().min(0).max(2).default(0),
+    qualityGate: model_modes_schema_1.ModelQualityGateSchema,
+    guardianThreshold: zod_1.z.number().int().min(0).max(100),
+    costLimitUsdPerRun: zod_1.z.number().nonnegative().nullable(),
+    description: zod_1.z.string().min(1),
+});
+exports.ModelModePresetMapSchema = zod_1.z.record(model_modes_schema_1.ModelModeSchema, exports.ModelModePresetSchema);

package/dist/schemas/ai/model-policy/model-modes.schema.d.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export declare const MODEL_MODES: readonly ["testing", "balanced", "production", "custom"];
+export type ModelMode = (typeof MODEL_MODES)[number];
+export declare const ModelModeSchema: z.ZodEnum<["testing", "balanced", "production", "custom"]>;
+export declare const MODEL_REASONING_LEVELS: readonly ["minimal", "low", "medium", "high"];
+export type ModelReasoningLevel = (typeof MODEL_REASONING_LEVELS)[number];
+export declare const ModelReasoningLevelSchema: z.ZodEnum<["minimal", "low", "medium", "high"]>;
+export declare const MODEL_QUALITY_GATES: readonly ["low", "medium", "high", "critical"];
+export type ModelQualityGate = (typeof MODEL_QUALITY_GATES)[number];
+export declare const ModelQualityGateSchema: z.ZodEnum<["low", "medium", "high", "critical"]>;
+export declare const MODEL_VERBOSITY_LEVELS: readonly ["low", "medium", "high"];
+export type ModelVerbosityLevel = (typeof MODEL_VERBOSITY_LEVELS)[number];
+export declare const ModelVerbosityLevelSchema: z.ZodEnum<["low", "medium", "high"]>;

package/dist/schemas/ai/model-policy/model-modes.schema.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelVerbosityLevelSchema = exports.MODEL_VERBOSITY_LEVELS = exports.ModelQualityGateSchema = exports.MODEL_QUALITY_GATES = exports.ModelReasoningLevelSchema = exports.MODEL_REASONING_LEVELS = exports.ModelModeSchema = exports.MODEL_MODES = void 0;
+const zod_1 = require("zod");
+exports.MODEL_MODES = [
+    "testing",
+    "balanced",
+    "production",
+    "custom",
+];
+exports.ModelModeSchema = zod_1.z.enum(exports.MODEL_MODES);
+exports.MODEL_REASONING_LEVELS = [
+    "minimal",
+    "low",
+    "medium",
+    "high",
+];
+exports.ModelReasoningLevelSchema = zod_1.z.enum(exports.MODEL_REASONING_LEVELS);
+exports.MODEL_QUALITY_GATES = [
+    "low",
+    "medium",
+    "high",
+    "critical",
+];
+exports.ModelQualityGateSchema = zod_1.z.enum(exports.MODEL_QUALITY_GATES);
+exports.MODEL_VERBOSITY_LEVELS = ["low", "medium", "high"];
+exports.ModelVerbosityLevelSchema = zod_1.z.enum(exports.MODEL_VERBOSITY_LEVELS);

package/dist/schemas/ai/model-policy/model-policy-resolved.schema.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export declare const RESOLVED_POLICY_SOURCE: readonly ["preset", "phase_override", "step_override", "request_override", "execution_mode", "default"];
+export type ResolvedPolicySource = (typeof RESOLVED_POLICY_SOURCE)[number];
+export declare const ResolvedModelPolicySchema: z.ZodObject<{
+    provider: z.ZodString;
+    modelId: z.ZodString;
+    mode: z.ZodEnum<["testing", "balanced", "production", "custom"]>;
+    reasoningEffort: z.ZodEnum<["minimal", "low", "medium", "high"]>;
+    verbosity: z.ZodEnum<["low", "medium", "high"]>;
+    maxOutputTokens: z.ZodNumber;
+    maxContextItems: z.ZodNumber;
+    temperature: z.ZodNumber;
+    qualityGate: z.ZodEnum<["low", "medium", "high", "critical"]>;
+    guardianThreshold: z.ZodNumber;
+    costLimitUsdPerRun: z.ZodNullable<z.ZodNumber>;
+    source: z.ZodEnum<["preset", "phase_override", "step_override", "request_override", "execution_mode", "default"]>;
+}, "strip", z.ZodTypeAny, {
+    source: "default" | "preset" | "phase_override" | "step_override" | "request_override" | "execution_mode";
+    mode: "custom" | "testing" | "balanced" | "production";
+    guardianThreshold: number;
+    modelId: string;
+    provider: string;
+    reasoningEffort: "low" | "medium" | "high" | "minimal";
+    verbosity: "low" | "medium" | "high";
+    maxOutputTokens: number;
+    maxContextItems: number;
+    temperature: number;
+    qualityGate: "critical" | "low" | "medium" | "high";
+    costLimitUsdPerRun: number | null;
+}, {
+    source: "default" | "preset" | "phase_override" | "step_override" | "request_override" | "execution_mode";
+    mode: "custom" | "testing" | "balanced" | "production";
+    guardianThreshold: number;
+    modelId: string;
+    provider: string;
+    reasoningEffort: "low" | "medium" | "high" | "minimal";
+    verbosity: "low" | "medium" | "high";
+    maxOutputTokens: number;
+    maxContextItems: number;
+    temperature: number;
+    qualityGate: "critical" | "low" | "medium" | "high";
+    costLimitUsdPerRun: number | null;
+}>;
+export type ResolvedModelPolicy = z.infer<typeof ResolvedModelPolicySchema>;