@neuraloom/contracts 0.0.0-stage → 0.1.23

package/dist/schemas/review/review-coverage.schema.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewExportResponseSchema = exports.ReviewExportRequestSchema = exports.ReviewExportFormatSchema = exports.ReviewApprovalResponseSchema = exports.ReviewApprovalRequestSchema = exports.ReviewDecisionApiResponseSchema = exports.ReviewCoverageQuerySchema = exports.ReviewCoverageSchema = exports.ReviewReleaseDecisionSchema = exports.RequirementCoverageItemSchema = exports.ReviewReleaseBlockerCodeSchema = exports.REVIEW_MS03_RUNTIME_PROBE_PASS_RATE_THRESHOLD = exports.REVIEW_MS03_COVERAGE_SHIP_THRESHOLD_PCT = void 0;
+const zod_1 = require("zod");
+const probe_schema_1 = require("../runtime/probe.schema");
+exports.REVIEW_MS03_COVERAGE_SHIP_THRESHOLD_PCT = 95;
+exports.REVIEW_MS03_RUNTIME_PROBE_PASS_RATE_THRESHOLD = 0.95;
+const RequirementCoverageStatusSchema = zod_1.z.enum([
+    "covered",
+    "partial",
+    "uncovered",
+]);
+exports.ReviewReleaseBlockerCodeSchema = zod_1.z.enum([
+    "coverage_below_threshold",
+    "unmet_acceptance_criteria",
+    "blocking_security_findings",
+    "blocking_drift_findings",
+    "runtime_probe_failed",
+    "runtime_probe_missing",
+    "human_approval_missing",
+    "graph_evidence_missing",
+    "release_decision_missing",
+    "deployment_verification_failed",
+    "deployment_not_verified",
+]);
+const ReviewReleaseBlockerSchema = zod_1.z
+    .object({
+    code: exports.ReviewReleaseBlockerCodeSchema,
+    detail: zod_1.z.string().min(1),
+    evidenceNodeIds: zod_1.z.array(zod_1.z.string().min(1)),
+})
+    .strict();
+const ReviewUnmetCriterionSchema = zod_1.z
+    .object({
+    blockerCode: exports.ReviewReleaseBlockerCodeSchema,
+    detail: zod_1.z.string().min(1),
+    evidenceNodeIds: zod_1.z.array(zod_1.z.string().min(1)),
+})
+    .strict();
+const RequirementCoverageMissingCategorySchema = zod_1.z.enum([
+    "file",
+    "test",
+    "probe",
+    "pr",
+    "deployment",
+    "approval",
+]);
+const RequirementEvidenceBucketSchema = zod_1.z
+    .object({
+    present: zod_1.z.boolean(),
+    nodeIds: zod_1.z.array(zod_1.z.string().min(1)),
+    passing: zod_1.z.boolean().optional(),
+})
+    .strict();
+const RequirementEvidenceBucketsSchema = zod_1.z
+    .object({
+    files: RequirementEvidenceBucketSchema,
+    tests: RequirementEvidenceBucketSchema,
+    prs: RequirementEvidenceBucketSchema,
+    deployments: RequirementEvidenceBucketSchema,
+    probes: RequirementEvidenceBucketSchema,
+    approvals: RequirementEvidenceBucketSchema,
+})
+    .strict();
+exports.RequirementCoverageItemSchema = zod_1.z
+    .object({
+    requirementId: zod_1.z.string().min(1),
+    title: zod_1.z.string(),
+    status: RequirementCoverageStatusSchema,
+    missing: zod_1.z.array(RequirementCoverageMissingCategorySchema),
+    evidence: RequirementEvidenceBucketsSchema,
+    graphPathsTruncated: zod_1.z.boolean().optional(),
+})
+    .strict();
+const ReviewGateSecurityCountsSchema = zod_1.z
+    .object({
+    critical: zod_1.z.number().int().min(0),
+    high: zod_1.z.number().int().min(0),
+    medium: zod_1.z.number().int().min(0),
+    low: zod_1.z.number().int().min(0),
+})
+    .strict();
+const ReviewGateDriftCountsSchema = zod_1.z
+    .object({
+    blocking: zod_1.z.number().int().min(0),
+    warning: zod_1.z.number().int().min(0),
+})
+    .strict();
+const ReviewGateSecurityDriftRollupSchema = zod_1.z
+    .object({
+    security: ReviewGateSecurityCountsSchema,
+    drift: ReviewGateDriftCountsSchema,
+})
+    .strict();
+const ReviewGateFindingsSchema = ReviewGateSecurityDriftRollupSchema.extend({
+    blockingSecurityNodeIds: zod_1.z.array(zod_1.z.string().min(1)),
+    blockingDriftNodeIds: zod_1.z.array(zod_1.z.string().min(1)),
+    securityGraphEvidencePresent: zod_1.z.boolean(),
+    driftGraphEvidencePresent: zod_1.z.boolean(),
+}).strict();
+const ReviewHumanApprovalStateSchema = zod_1.z
+    .object({
+    guardianReviewGateApproved: zod_1.z.boolean(),
+    graphAcceptedByEdgeCount: zod_1.z.number().int().min(0),
+    satisfied: zod_1.z.boolean(),
+})
+    .strict();
+const ReviewReleaseStatusSchema = zod_1.z.enum(["ship", "block"]);
+exports.ReviewReleaseDecisionSchema = zod_1.z
+    .object({
+    projectId: zod_1.z.string().uuid(),
+    workflowRunId: zod_1.z.string().uuid().optional(),
+    coveragePct: zod_1.z.number().min(0).max(100),
+    unmetCriteria: zod_1.z.array(ReviewUnmetCriterionSchema),
+    findings: ReviewGateFindingsSchema,
+    runtimeProbePassRate: zod_1.z.number().min(0).max(1).nullable(),
+    /** Canonical per-probe summaries for MS-03 surfaces (#732). */
+    runtimeProbeEvidenceSummaries: zod_1.z
+        .array(probe_schema_1.RuntimeProbeEvidenceSummarySchema)
+        .optional(),
+    humanApproval: ReviewHumanApprovalStateSchema,
+    status: ReviewReleaseStatusSchema,
+    blockers: zod_1.z.array(ReviewReleaseBlockerSchema),
+    computedAt: zod_1.z.string().datetime(),
+})
+    .strict();
+exports.ReviewCoverageSchema = zod_1.z
+    .object({
+    projectId: zod_1.z.string().uuid(),
+    workflowRunId: zod_1.z.string().uuid().optional(),
+    totalRequirements: zod_1.z.number().int().min(0),
+    covered: zod_1.z.number().int().min(0),
+    partial: zod_1.z.number().int().min(0),
+    uncovered: zod_1.z.number().int().min(0),
+    coveragePct: zod_1.z.number().min(0).max(100),
+    requirements: zod_1.z.array(exports.RequirementCoverageItemSchema),
+    unmetCriteria: zod_1.z.array(ReviewUnmetCriterionSchema),
+    findingSummary: ReviewGateSecurityDriftRollupSchema,
+    releaseDecision: exports.ReviewReleaseDecisionSchema,
+    generatedAt: zod_1.z.string().datetime(),
+})
+    .strict();
+exports.ReviewCoverageQuerySchema = zod_1.z
+    .object({
+    requirementNodeIds: zod_1.z.array(zod_1.z.string().min(1)).max(500).optional(),
+})
+    .strict();
+exports.ReviewDecisionApiResponseSchema = zod_1.z
+    .object({
+    decision: exports.ReviewReleaseDecisionSchema,
+})
+    .strict();
+exports.ReviewApprovalRequestSchema = zod_1.z
+    .object({
+    requirementNodeIds: zod_1.z.array(zod_1.z.string().min(1)).max(500).optional(),
+    note: zod_1.z.string().max(2000).optional(),
+})
+    .strict();
+exports.ReviewApprovalResponseSchema = zod_1.z
+    .object({
+    approvalNodeId: zod_1.z.string().min(1),
+    approvedRequirementNodeIds: zod_1.z.array(zod_1.z.string().min(1)),
+    decision: exports.ReviewReleaseDecisionSchema,
+})
+    .strict();
+exports.ReviewExportFormatSchema = zod_1.z.enum(["markdown", "pdf"]);
+exports.ReviewExportRequestSchema = zod_1.z
+    .object({
+    format: exports.ReviewExportFormatSchema.default("markdown"),
+})
+    .strict();
+exports.ReviewExportResponseSchema = zod_1.z
+    .object({
+    status: zod_1.z.enum(["ready", "unsupported"]),
+    format: exports.ReviewExportFormatSchema,
+    fileName: zod_1.z.string().min(1),
+    content: zod_1.z.string().nullable(),
+    mimeType: zod_1.z.string().min(1).optional(),
+    generatedAt: zod_1.z.string().datetime(),
+    decision: exports.ReviewReleaseDecisionSchema,
+})
+    .strict();

package/dist/schemas/review/review-policy.schema.d.ts

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+/** Matches `reviewAggregatePayloadSchema.releaseDecision` / contract SSOT — do not widen. */
+export declare const ReleaseDecisionSchema: z.ZodEnum<["release", "block", "needs_fixes"]>;
+export declare const ReviewBlockReasonSchema: z.ZodEnum<["IMPLEMENTATION_ARTIFACT_MISSING", "CRITICAL_FINDINGS_PRESENT", "RUNTIME_DOMAIN_MISSING", "SCAFFOLD_ONLY_RUNTIME"]>;
+/** Unified severity vocabulary for deterministic review policy aggregation. */
+export declare const ReviewSeveritySchema: z.ZodEnum<["info", "low", "medium", "high", "critical"]>;
+export declare const ReviewPolicyFindingSchema: z.ZodObject<{
+    severity: z.ZodEnum<["info", "low", "medium", "high", "critical"]>;
+    code: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    /** Optional bridge to canonical `SecurityFindingRuleId` (#770). */
+    securityRuleId: z.ZodOptional<z.ZodEnum<["MISSING_RLS_ON_PUBLIC_TABLE", "SERVICE_ROLE_IN_BROWSER", "RAW_FETCH_BYPASSING_APICLIENT", "UNSIGNED_WEBHOOK", "PII_TABLE_PUBLIC_ROUTE", "CRITICAL_DEP_VULN", "ENV_FALLBACK_OPERATOR", "DUPLICATE_ROUTE", "SECURITY_DEFINER_VIEW_RISK", "RLS_POLICY_ALWAYS_TRUE", "EXTENSION_IN_PUBLIC_SCHEMA", "AUTH_LEAKED_PASSWORD_PROTECTION_OFF"]>>;
+}, "strict", z.ZodTypeAny, {
+    severity: "info" | "critical" | "low" | "medium" | "high";
+    code?: string | undefined;
+    message?: string | undefined;
+    securityRuleId?: "MISSING_RLS_ON_PUBLIC_TABLE" | "RLS_POLICY_ALWAYS_TRUE" | "SECURITY_DEFINER_VIEW_RISK" | "EXTENSION_IN_PUBLIC_SCHEMA" | "SERVICE_ROLE_IN_BROWSER" | "RAW_FETCH_BYPASSING_APICLIENT" | "UNSIGNED_WEBHOOK" | "PII_TABLE_PUBLIC_ROUTE" | "CRITICAL_DEP_VULN" | "ENV_FALLBACK_OPERATOR" | "DUPLICATE_ROUTE" | "AUTH_LEAKED_PASSWORD_PROTECTION_OFF" | undefined;
+}, {
+    severity: "info" | "critical" | "low" | "medium" | "high";
+    code?: string | undefined;
+    message?: string | undefined;
+    securityRuleId?: "MISSING_RLS_ON_PUBLIC_TABLE" | "RLS_POLICY_ALWAYS_TRUE" | "SECURITY_DEFINER_VIEW_RISK" | "EXTENSION_IN_PUBLIC_SCHEMA" | "SERVICE_ROLE_IN_BROWSER" | "RAW_FETCH_BYPASSING_APICLIENT" | "UNSIGNED_WEBHOOK" | "PII_TABLE_PUBLIC_ROUTE" | "CRITICAL_DEP_VULN" | "ENV_FALLBACK_OPERATOR" | "DUPLICATE_ROUTE" | "AUTH_LEAKED_PASSWORD_PROTECTION_OFF" | undefined;
+}>;
+export declare const ReviewPolicyInputSchema: z.ZodObject<{
+    findings: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<["info", "low", "medium", "high", "critical"]>;
+        code: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+        /** Optional bridge to canonical `SecurityFindingRuleId` (#770). */
+        securityRuleId: z.ZodOptional<z.ZodEnum<["MISSING_RLS_ON_PUBLIC_TABLE", "SERVICE_ROLE_IN_BROWSER", "RAW_FETCH_BYPASSING_APICLIENT", "UNSIGNED_WEBHOOK", "PII_TABLE_PUBLIC_ROUTE", "CRITICAL_DEP_VULN", "ENV_FALLBACK_OPERATOR", "DUPLICATE_ROUTE", "SECURITY_DEFINER_VIEW_RISK", "RLS_POLICY_ALWAYS_TRUE", "EXTENSION_IN_PUBLIC_SCHEMA", "AUTH_LEAKED_PASSWORD_PROTECTION_OFF"]>>;
+    }, "strict", z.ZodTypeAny, {
+        severity: "info" | "critical" | "low" | "medium" | "high";
+        code?: string | undefined;
+        message?: string | undefined;
+        securityRuleId?: "MISSING_RLS_ON_PUBLIC_TABLE" | "RLS_POLICY_ALWAYS_TRUE" | "SECURITY_DEFINER_VIEW_RISK" | "EXTENSION_IN_PUBLIC_SCHEMA" | "SERVICE_ROLE_IN_BROWSER" | "RAW_FETCH_BYPASSING_APICLIENT" | "UNSIGNED_WEBHOOK" | "PII_TABLE_PUBLIC_ROUTE" | "CRITICAL_DEP_VULN" | "ENV_FALLBACK_OPERATOR" | "DUPLICATE_ROUTE" | "AUTH_LEAKED_PASSWORD_PROTECTION_OFF" | undefined;
+    }, {
+        severity: "info" | "critical" | "low" | "medium" | "high";
+        code?: string | undefined;
+        message?: string | undefined;
+        securityRuleId?: "MISSING_RLS_ON_PUBLIC_TABLE" | "RLS_POLICY_ALWAYS_TRUE" | "SECURITY_DEFINER_VIEW_RISK" | "EXTENSION_IN_PUBLIC_SCHEMA" | "SERVICE_ROLE_IN_BROWSER" | "RAW_FETCH_BYPASSING_APICLIENT" | "UNSIGNED_WEBHOOK" | "PII_TABLE_PUBLIC_ROUTE" | "CRITICAL_DEP_VULN" | "ENV_FALLBACK_OPERATOR" | "DUPLICATE_ROUTE" | "AUTH_LEAKED_PASSWORD_PROTECTION_OFF" | undefined;
+    }>, "many">;
+    hasImplementCodeGenArtifact: z.ZodBoolean;
+    hasScaffoldOnlyRuntime: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    baseScore: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    findings: {
+        severity: "info" | "critical" | "low" | "medium" | "high";
+        code?: string | undefined;
+        message?: string | undefined;
+        securityRuleId?: "MISSING_RLS_ON_PUBLIC_TABLE" | "RLS_POLICY_ALWAYS_TRUE" | "SECURITY_DEFINER_VIEW_RISK" | "EXTENSION_IN_PUBLIC_SCHEMA" | "SERVICE_ROLE_IN_BROWSER" | "RAW_FETCH_BYPASSING_APICLIENT" | "UNSIGNED_WEBHOOK" | "PII_TABLE_PUBLIC_ROUTE" | "CRITICAL_DEP_VULN" | "ENV_FALLBACK_OPERATOR" | "DUPLICATE_ROUTE" | "AUTH_LEAKED_PASSWORD_PROTECTION_OFF" | undefined;
+    }[];
+    hasImplementCodeGenArtifact: boolean;
+    hasScaffoldOnlyRuntime: boolean;
+    baseScore: number;
+}, {
+    findings: {
+        severity: "info" | "critical" | "low" | "medium" | "high";
+        code?: string | undefined;
+        message?: string | undefined;
+        securityRuleId?: "MISSING_RLS_ON_PUBLIC_TABLE" | "RLS_POLICY_ALWAYS_TRUE" | "SECURITY_DEFINER_VIEW_RISK" | "EXTENSION_IN_PUBLIC_SCHEMA" | "SERVICE_ROLE_IN_BROWSER" | "RAW_FETCH_BYPASSING_APICLIENT" | "UNSIGNED_WEBHOOK" | "PII_TABLE_PUBLIC_ROUTE" | "CRITICAL_DEP_VULN" | "ENV_FALLBACK_OPERATOR" | "DUPLICATE_ROUTE" | "AUTH_LEAKED_PASSWORD_PROTECTION_OFF" | undefined;
+    }[];
+    hasImplementCodeGenArtifact: boolean;
+    baseScore: number;
+    hasScaffoldOnlyRuntime?: boolean | undefined;
+}>;
+export declare const ReviewPolicyOutputSchema: z.ZodObject<{
+    accepted: z.ZodBoolean;
+    releaseDecision: z.ZodEnum<["release", "block", "needs_fixes"]>;
+    finalScore: z.ZodNumber;
+    reasons: z.ZodArray<z.ZodEnum<["IMPLEMENTATION_ARTIFACT_MISSING", "CRITICAL_FINDINGS_PRESENT", "RUNTIME_DOMAIN_MISSING", "SCAFFOLD_ONLY_RUNTIME"]>, "many">;
+}, "strip", z.ZodTypeAny, {
+    accepted: boolean;
+    reasons: ("IMPLEMENTATION_ARTIFACT_MISSING" | "CRITICAL_FINDINGS_PRESENT" | "RUNTIME_DOMAIN_MISSING" | "SCAFFOLD_ONLY_RUNTIME")[];
+    releaseDecision: "release" | "block" | "needs_fixes";
+    finalScore: number;
+}, {
+    accepted: boolean;
+    reasons: ("IMPLEMENTATION_ARTIFACT_MISSING" | "CRITICAL_FINDINGS_PRESENT" | "RUNTIME_DOMAIN_MISSING" | "SCAFFOLD_ONLY_RUNTIME")[];
+    releaseDecision: "release" | "block" | "needs_fixes";
+    finalScore: number;
+}>;
+export type ReleaseDecision = z.infer<typeof ReleaseDecisionSchema>;
+export type ReviewBlockReason = z.infer<typeof ReviewBlockReasonSchema>;
+export type ReviewPolicyFinding = z.infer<typeof ReviewPolicyFindingSchema>;
+export type ReviewSeverity = z.infer<typeof ReviewSeveritySchema>;
+export type ReviewPolicyInput = z.infer<typeof ReviewPolicyInputSchema>;
+export type ReviewPolicyOutput = z.infer<typeof ReviewPolicyOutputSchema>;

package/dist/schemas/review/review-policy.schema.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReviewPolicyOutputSchema = exports.ReviewPolicyInputSchema = exports.ReviewPolicyFindingSchema = exports.ReviewSeveritySchema = exports.ReviewBlockReasonSchema = exports.ReleaseDecisionSchema = void 0;
+const zod_1 = require("zod");
+const security_finding_schema_1 = require("../security/security-finding.schema");
+/** Matches `reviewAggregatePayloadSchema.releaseDecision` / contract SSOT — do not widen. */
+exports.ReleaseDecisionSchema = zod_1.z.enum(['release', 'block', 'needs_fixes']);
+exports.ReviewBlockReasonSchema = zod_1.z.enum([
+    'IMPLEMENTATION_ARTIFACT_MISSING',
+    'CRITICAL_FINDINGS_PRESENT',
+    'RUNTIME_DOMAIN_MISSING',
+    'SCAFFOLD_ONLY_RUNTIME',
+]);
+/** Unified severity vocabulary for deterministic review policy aggregation. */
+exports.ReviewSeveritySchema = zod_1.z.enum([
+    'info',
+    'low',
+    'medium',
+    'high',
+    'critical',
+]);
+exports.ReviewPolicyFindingSchema = zod_1.z
+    .object({
+    severity: exports.ReviewSeveritySchema,
+    code: zod_1.z.string().optional(),
+    message: zod_1.z.string().optional(),
+    /** Optional bridge to canonical `SecurityFindingRuleId` (#770). */
+    securityRuleId: security_finding_schema_1.SecurityFindingRuleIdSchema.optional(),
+})
+    .strict();
+exports.ReviewPolicyInputSchema = zod_1.z.object({
+    findings: zod_1.z.array(exports.ReviewPolicyFindingSchema),
+    hasImplementCodeGenArtifact: zod_1.z.boolean(),
+    hasScaffoldOnlyRuntime: zod_1.z.boolean().optional().default(false),
+    baseScore: zod_1.z.number(),
+});
+exports.ReviewPolicyOutputSchema = zod_1.z.object({
+    accepted: zod_1.z.boolean(),
+    releaseDecision: exports.ReleaseDecisionSchema,
+    finalScore: zod_1.z.number(),
+    reasons: zod_1.z.array(exports.ReviewBlockReasonSchema),
+});

package/dist/schemas/runtime/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./probe.schema";
+export * from "./platform-health.schema";
+export * from "./probe-harness-gen.schema";
+export * from "./runtime-knowledge-node.schema";
+export * from "./runtime-run.schema";
+export * from "./runtime-loop.schema";

package/dist/schemas/runtime/index.js

@@ -0,0 +1,22 @@
+"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("./probe.schema"), exports);
+__exportStar(require("./platform-health.schema"), exports);
+__exportStar(require("./probe-harness-gen.schema"), exports);
+__exportStar(require("./runtime-knowledge-node.schema"), exports);
+__exportStar(require("./runtime-run.schema"), exports);
+__exportStar(require("./runtime-loop.schema"), exports);

package/dist/schemas/runtime/platform-health.schema.d.ts

@@ -0,0 +1,83 @@
+/**
+ * GET /api/health response — liveness probe for the operator app.
+ * Database is an optional bounded probe; the handler must return within a hard timeout.
+ */
+import { z } from "zod";
+export declare const PlatformHealthComponentSchema: z.ZodEnum<["up", "error", "timeout", "skipped", "unconfigured"]>;
+export type PlatformHealthComponent = z.infer<typeof PlatformHealthComponentSchema>;
+export declare const PlatformHealthDataSchema: z.ZodObject<{
+    database: z.ZodEnum<["up", "error", "timeout", "skipped", "unconfigured"]>;
+    auth: z.ZodEnum<["up", "error", "timeout", "skipped", "unconfigured"]>;
+    api: z.ZodLiteral<"up">;
+    aiRuns: z.ZodEnum<["up", "error", "timeout", "skipped", "unconfigured"]>;
+    rlsEnforced: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    api: "up";
+    aiRuns: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+    database: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+    auth: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+    rlsEnforced: boolean;
+}, {
+    api: "up";
+    aiRuns: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+    database: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+    auth: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+    rlsEnforced: boolean;
+}>;
+export type PlatformHealthData = z.infer<typeof PlatformHealthDataSchema>;
+export declare const PlatformHealthResponseSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    data: z.ZodObject<{
+        database: z.ZodEnum<["up", "error", "timeout", "skipped", "unconfigured"]>;
+        auth: z.ZodEnum<["up", "error", "timeout", "skipped", "unconfigured"]>;
+        api: z.ZodLiteral<"up">;
+        aiRuns: z.ZodEnum<["up", "error", "timeout", "skipped", "unconfigured"]>;
+        rlsEnforced: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        api: "up";
+        aiRuns: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        database: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        auth: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        rlsEnforced: boolean;
+    }, {
+        api: "up";
+        aiRuns: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        database: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        auth: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        rlsEnforced: boolean;
+    }>;
+    timestamp: z.ZodString;
+    responseTime: z.ZodString;
+    environment: z.ZodOptional<z.ZodString>;
+    node: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    data: {
+        api: "up";
+        aiRuns: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        database: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        auth: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        rlsEnforced: boolean;
+    };
+    timestamp: string;
+    ok: boolean;
+    responseTime: string;
+    version?: string | undefined;
+    environment?: string | undefined;
+    node?: string | undefined;
+}, {
+    data: {
+        api: "up";
+        aiRuns: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        database: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        auth: "up" | "error" | "skipped" | "timeout" | "unconfigured";
+        rlsEnforced: boolean;
+    };
+    timestamp: string;
+    ok: boolean;
+    responseTime: string;
+    version?: string | undefined;
+    environment?: string | undefined;
+    node?: string | undefined;
+}>;
+export type PlatformHealthResponse = z.infer<typeof PlatformHealthResponseSchema>;

package/dist/schemas/runtime/platform-health.schema.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * GET /api/health response — liveness probe for the operator app.
+ * Database is an optional bounded probe; the handler must return within a hard timeout.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatformHealthResponseSchema = exports.PlatformHealthDataSchema = exports.PlatformHealthComponentSchema = void 0;
+const zod_1 = require("zod");
+exports.PlatformHealthComponentSchema = zod_1.z.enum([
+    "up",
+    "error",
+    "timeout",
+    "skipped",
+    "unconfigured",
+]);
+exports.PlatformHealthDataSchema = zod_1.z.object({
+    database: exports.PlatformHealthComponentSchema,
+    auth: exports.PlatformHealthComponentSchema,
+    api: zod_1.z.literal("up"),
+    aiRuns: exports.PlatformHealthComponentSchema,
+    rlsEnforced: zod_1.z.boolean(),
+});
+exports.PlatformHealthResponseSchema = zod_1.z.object({
+    ok: zod_1.z.boolean(),
+    data: exports.PlatformHealthDataSchema,
+    timestamp: zod_1.z.string().datetime(),
+    responseTime: zod_1.z.string().min(1),
+    environment: zod_1.z.string().optional(),
+    node: zod_1.z.string().optional(),
+    version: zod_1.z.string().optional(),
+});